Changeset 246135 in webkit

Timestamp:

Jun 5, 2019 5:46:25 PM (5 years ago)

Author:

rmorisset@apple.com

Message:

[WHLSL] Parsing and lexing the standard library is slow
​https://bugs.webkit.org/show_bug.cgi?id=192890
<rdar://problem/50746335>

Reviewed by Myles Maxfield.

The main idea is to avoid backtracking by instead peeking at the next token (and occasionally at the one after that).
This implies a few things:

• We can replace the stack of tokens by a trivial ring buffer of size 2 (holding the next token and the one after, or WTF::nullopt if we are at the end of the file).
• We now have "completeFooExpression" functions, to avoid having to reparse the prefix of some expression, if we find half-way through what it is.

I also fixed the following parser bug:

• ​https://bugs.webkit.org/show_bug.cgi?id=198305 [WHLSL] Multiple variables with initializers in a declaration statement crashes the compiler

which was due to a mistake I made in the grammar

Finally I added two new macros: CONSUME_TYPE and PARSE to eliminate about 500 lines of error propagation boilerplate.

There are still lots of ways of improving the parser and lexer, such as:

• finishing the conversion of tokens in the lexer, not bothering with allocating string views
• make two special tokens Invalid and EOF, to remove the overhead of Optional
• make peekTypes and consumeTypes use templates to avoid constructing a Vector and calling find on it.
• Turn the entire lexer into a proper automata, not going through the same characters again and again (this is certainly the largest win by far)
• Remove the last few pieces of backtracking from the parser.

The current patch is already enough to make parsing the full standard library (something like 85k lines) approximately 260ms.
This is still longer than I would like, but nowhere near the bottleneck any longer because of some other parts of the compiler.

• Modules/webgpu/WHLSL/WHLSLLexer.h:

(WebCore::WHLSL::Lexer::Lexer):
(WebCore::WHLSL::Lexer::consumeToken):
(WebCore::WHLSL::Lexer::peek):
(WebCore::WHLSL::Lexer::peekFurther):
(WebCore::WHLSL::Lexer::state const):
(WebCore::WHLSL::Lexer::setState):
(WebCore::WHLSL::Lexer::unconsumeToken): Deleted.

• Modules/webgpu/WHLSL/WHLSLParser.cpp:

(WebCore::WHLSL::Parser::parse):
(WebCore::WHLSL::Parser::peek):
(WebCore::WHLSL::Parser::peekTypes):
(WebCore::WHLSL::Parser::tryType):
(WebCore::WHLSL::Parser::tryTypes):
(WebCore::WHLSL::Parser::consumeTypes):
(WebCore::WHLSL::Parser::parseConstantExpression):
(WebCore::WHLSL::Parser::parseTypeArgument):
(WebCore::WHLSL::Parser::parseTypeArguments):
(WebCore::WHLSL::Parser::parseTypeSuffixAbbreviated):
(WebCore::WHLSL::Parser::parseTypeSuffixNonAbbreviated):
(WebCore::WHLSL::Parser::parseType):
(WebCore::WHLSL::Parser::parseTypeDefinition):
(WebCore::WHLSL::Parser::parseResourceSemantic):
(WebCore::WHLSL::Parser::parseSpecializationConstantSemantic):
(WebCore::WHLSL::Parser::parseStageInOutSemantic):
(WebCore::WHLSL::Parser::parseSemantic):
(WebCore::WHLSL::Parser::parseQualifiers):
(WebCore::WHLSL::Parser::parseStructureElement):
(WebCore::WHLSL::Parser::parseStructureDefinition):
(WebCore::WHLSL::Parser::parseEnumerationDefinition):
(WebCore::WHLSL::Parser::parseEnumerationMember):
(WebCore::WHLSL::Parser::parseNativeTypeDeclaration):
(WebCore::WHLSL::Parser::parseNumThreadsFunctionAttribute):
(WebCore::WHLSL::Parser::parseAttributeBlock):
(WebCore::WHLSL::Parser::parseParameter):
(WebCore::WHLSL::Parser::parseParameters):
(WebCore::WHLSL::Parser::parseFunctionDefinition):
(WebCore::WHLSL::Parser::parseComputeFunctionDeclaration):
(WebCore::WHLSL::Parser::parseVertexFragmentFunctionDeclaration):
(WebCore::WHLSL::Parser::parseRegularFunctionDeclaration):
(WebCore::WHLSL::Parser::parseOperatorFunctionDeclaration):
(WebCore::WHLSL::Parser::parseFunctionDeclaration):
(WebCore::WHLSL::Parser::parseNativeFunctionDeclaration):
(WebCore::WHLSL::Parser::parseBlock):
(WebCore::WHLSL::Parser::parseBlockBody):
(WebCore::WHLSL::Parser::parseIfStatement):
(WebCore::WHLSL::Parser::parseSwitchStatement):
(WebCore::WHLSL::Parser::parseSwitchCase):
(WebCore::WHLSL::Parser::parseForLoop):
(WebCore::WHLSL::Parser::parseWhileLoop):
(WebCore::WHLSL::Parser::parseDoWhileLoop):
(WebCore::WHLSL::Parser::parseVariableDeclaration):
(WebCore::WHLSL::Parser::parseVariableDeclarations):
(WebCore::WHLSL::Parser::parseStatement):
(WebCore::WHLSL::Parser::parseEffectfulExpression):
(WebCore::WHLSL::Parser::parseEffectfulAssignment):
(WebCore::WHLSL::Parser::parseExpression):
(WebCore::WHLSL::Parser::parseTernaryConditional): Deleted.
(WebCore::WHLSL::Parser::completeTernaryConditional):
(WebCore::WHLSL::Parser::parseAssignment): Deleted.
(WebCore::WHLSL::Parser::completeAssignment):
(WebCore::WHLSL::Parser::parsePossibleTernaryConditional):
(WebCore::WHLSL::Parser::parsePossibleLogicalBinaryOperation):
(WebCore::WHLSL::Parser::completePossibleLogicalBinaryOperation):
(WebCore::WHLSL::Parser::parsePossibleRelationalBinaryOperation):
(WebCore::WHLSL::Parser::completePossibleRelationalBinaryOperation):
(WebCore::WHLSL::Parser::parsePossibleShift):
(WebCore::WHLSL::Parser::completePossibleShift):
(WebCore::WHLSL::Parser::parsePossibleAdd):
(WebCore::WHLSL::Parser::completePossibleAdd):
(WebCore::WHLSL::Parser::parsePossibleMultiply):
(WebCore::WHLSL::Parser::completePossibleMultiply):
(WebCore::WHLSL::Parser::parsePossiblePrefix):
(WebCore::WHLSL::Parser::parsePossibleSuffix):
(WebCore::WHLSL::Parser::parseCallExpression):
(WebCore::WHLSL::Parser::parseTerm):
(WebCore::WHLSL::Parser::parseAddressSpaceType): Deleted.
(WebCore::WHLSL::Parser::parseNonAddressSpaceType): Deleted.
(WebCore::WHLSL::Parser::parseEntryPointFunctionDeclaration): Deleted.
(WebCore::WHLSL::Parser::parseEffectfulPrefix): Deleted.
(WebCore::WHLSL::Parser::parseEffectfulSuffix): Deleted.

• Modules/webgpu/WHLSL/WHLSLParser.h:

(WebCore::WHLSL::Parser::Error::dump const):

Location:

trunk/Source/WebCore

Files:

• ChangeLog (modified) (1 diff)
• Modules/webgpu/WHLSL/WHLSLLexer.h (modified) (4 diffs)
• Modules/webgpu/WHLSL/WHLSLParser.cpp (modified) (68 diffs)
• Modules/webgpu/WHLSL/WHLSLParser.h (modified) (9 diffs)
• Modules/webgpu/WHLSL/WHLSLPrepare.cpp (modified) (2 diffs)

trunk/Source/WebCore/ChangeLog

@@ +1 @@
+2019-06-05  Robin Morisset  <rmorisset@apple.com>
+
+        [WHLSL] Parsing and lexing the standard library is slow
+        https://bugs.webkit.org/show_bug.cgi?id=192890
+        <rdar://problem/50746335>
+
+        Reviewed by Myles Maxfield.
+
+        The main idea is to avoid backtracking by instead peeking at the next token (and occasionally at the one after that).
+        This implies a few things:
+        - We can replace the stack of tokens by a trivial ring buffer of size 2 (holding the next token and the one after, or WTF::nullopt if we are at the end of the file).
+        - We now have "completeFooExpression" functions, to avoid having to reparse the prefix of some expression, if we find half-way through what it is.
+
+        I also fixed the following parser bug:
+        - https://bugs.webkit.org/show_bug.cgi?id=198305 [WHLSL] Multiple variables with initializers in a declaration statement crashes the compiler
+            which was due to a mistake I made in the grammar
+
+        Finally I added two new macros: CONSUME_TYPE and PARSE to eliminate about 500 lines of error propagation boilerplate.
+
+        There are still lots of ways of improving the parser and lexer, such as:
+        - finishing the conversion of tokens in the lexer, not bothering with allocating string views
+        - make two special tokens Invalid and EOF, to remove the overhead of Optional
+        - make peekTypes and consumeTypes use templates to avoid constructing a Vector and calling find on it.
+        - Turn the entire lexer into a proper automata, not going through the same characters again and again (this is certainly the largest win by far)
+        - Remove the last few pieces of backtracking from the parser.
+
+        The current patch is already enough to make parsing the full standard library (something like 85k lines) approximately 260ms.
+        This is still longer than I would like, but nowhere near the bottleneck any longer because of some other parts of the compiler.
+
+        * Modules/webgpu/WHLSL/WHLSLLexer.h:
+        (WebCore::WHLSL::Lexer::Lexer):
+        (WebCore::WHLSL::Lexer::consumeToken):
+        (WebCore::WHLSL::Lexer::peek):
+        (WebCore::WHLSL::Lexer::peekFurther):
+        (WebCore::WHLSL::Lexer::state const):
+        (WebCore::WHLSL::Lexer::setState):
+        (WebCore::WHLSL::Lexer::unconsumeToken): Deleted.
+        * Modules/webgpu/WHLSL/WHLSLParser.cpp:
+        (WebCore::WHLSL::Parser::parse):
+        (WebCore::WHLSL::Parser::peek):
+        (WebCore::WHLSL::Parser::peekTypes):
+        (WebCore::WHLSL::Parser::tryType):
+        (WebCore::WHLSL::Parser::tryTypes):
+        (WebCore::WHLSL::Parser::consumeTypes):
+        (WebCore::WHLSL::Parser::parseConstantExpression):
+        (WebCore::WHLSL::Parser::parseTypeArgument):
+        (WebCore::WHLSL::Parser::parseTypeArguments):
+        (WebCore::WHLSL::Parser::parseTypeSuffixAbbreviated):
+        (WebCore::WHLSL::Parser::parseTypeSuffixNonAbbreviated):
+        (WebCore::WHLSL::Parser::parseType):
+        (WebCore::WHLSL::Parser::parseTypeDefinition):
+        (WebCore::WHLSL::Parser::parseResourceSemantic):
+        (WebCore::WHLSL::Parser::parseSpecializationConstantSemantic):
+        (WebCore::WHLSL::Parser::parseStageInOutSemantic):
+        (WebCore::WHLSL::Parser::parseSemantic):
+        (WebCore::WHLSL::Parser::parseQualifiers):
+        (WebCore::WHLSL::Parser::parseStructureElement):
+        (WebCore::WHLSL::Parser::parseStructureDefinition):
+        (WebCore::WHLSL::Parser::parseEnumerationDefinition):
+        (WebCore::WHLSL::Parser::parseEnumerationMember):
+        (WebCore::WHLSL::Parser::parseNativeTypeDeclaration):
+        (WebCore::WHLSL::Parser::parseNumThreadsFunctionAttribute):
+        (WebCore::WHLSL::Parser::parseAttributeBlock):
+        (WebCore::WHLSL::Parser::parseParameter):
+        (WebCore::WHLSL::Parser::parseParameters):
+        (WebCore::WHLSL::Parser::parseFunctionDefinition):
+        (WebCore::WHLSL::Parser::parseComputeFunctionDeclaration):
+        (WebCore::WHLSL::Parser::parseVertexFragmentFunctionDeclaration):
+        (WebCore::WHLSL::Parser::parseRegularFunctionDeclaration):
+        (WebCore::WHLSL::Parser::parseOperatorFunctionDeclaration):
+        (WebCore::WHLSL::Parser::parseFunctionDeclaration):
+        (WebCore::WHLSL::Parser::parseNativeFunctionDeclaration):
+        (WebCore::WHLSL::Parser::parseBlock):
+        (WebCore::WHLSL::Parser::parseBlockBody):
+        (WebCore::WHLSL::Parser::parseIfStatement):
+        (WebCore::WHLSL::Parser::parseSwitchStatement):
+        (WebCore::WHLSL::Parser::parseSwitchCase):
+        (WebCore::WHLSL::Parser::parseForLoop):
+        (WebCore::WHLSL::Parser::parseWhileLoop):
+        (WebCore::WHLSL::Parser::parseDoWhileLoop):
+        (WebCore::WHLSL::Parser::parseVariableDeclaration):
+        (WebCore::WHLSL::Parser::parseVariableDeclarations):
+        (WebCore::WHLSL::Parser::parseStatement):
+        (WebCore::WHLSL::Parser::parseEffectfulExpression):
+        (WebCore::WHLSL::Parser::parseEffectfulAssignment):
+        (WebCore::WHLSL::Parser::parseExpression):
+        (WebCore::WHLSL::Parser::parseTernaryConditional): Deleted.
+        (WebCore::WHLSL::Parser::completeTernaryConditional):
+        (WebCore::WHLSL::Parser::parseAssignment): Deleted.
+        (WebCore::WHLSL::Parser::completeAssignment):
+        (WebCore::WHLSL::Parser::parsePossibleTernaryConditional):
+        (WebCore::WHLSL::Parser::parsePossibleLogicalBinaryOperation):
+        (WebCore::WHLSL::Parser::completePossibleLogicalBinaryOperation):
+        (WebCore::WHLSL::Parser::parsePossibleRelationalBinaryOperation):
+        (WebCore::WHLSL::Parser::completePossibleRelationalBinaryOperation):
+        (WebCore::WHLSL::Parser::parsePossibleShift):
+        (WebCore::WHLSL::Parser::completePossibleShift):
+        (WebCore::WHLSL::Parser::parsePossibleAdd):
+        (WebCore::WHLSL::Parser::completePossibleAdd):
+        (WebCore::WHLSL::Parser::parsePossibleMultiply):
+        (WebCore::WHLSL::Parser::completePossibleMultiply):
+        (WebCore::WHLSL::Parser::parsePossiblePrefix):
+        (WebCore::WHLSL::Parser::parsePossibleSuffix):
+        (WebCore::WHLSL::Parser::parseCallExpression):
+        (WebCore::WHLSL::Parser::parseTerm):
+        (WebCore::WHLSL::Parser::parseAddressSpaceType): Deleted.
+        (WebCore::WHLSL::Parser::parseNonAddressSpaceType): Deleted.
+        (WebCore::WHLSL::Parser::parseEntryPointFunctionDeclaration): Deleted.
+        (WebCore::WHLSL::Parser::parseEffectfulPrefix): Deleted.
+        (WebCore::WHLSL::Parser::parseEffectfulSuffix): Deleted.
+        * Modules/webgpu/WHLSL/WHLSLParser.h:
+        (WebCore::WHLSL::Parser::Error::dump const):
+
 2019-06-05  Alex Christensen  <achristensen@webkit.org>
 

trunk/Source/WebCore/Modules/webgpu/WHLSL/WHLSLLexer.h

@@ -47 +47 @@
     {
         skipWhitespaceAndComments();
+        m_ringBuffer[0] = consumeTokenFromStream();
+        m_ringBuffer[1] = consumeTokenFromStream();
     }
 
@@ -178 +180 @@
     Optional<Token> consumeToken()
     {
-        if (!m_stack.isEmpty())
-            return m_stack.takeLast();
-        return consumeTokenFromStream();
-    }
-
-    void unconsumeToken(Token&& token)
-    {
-        m_stack.append(WTFMove(token));
-    }
-
+        auto result = m_ringBuffer[m_ringBufferIndex];
+        m_ringBuffer[m_ringBufferIndex] = consumeTokenFromStream();
+        m_ringBufferIndex = (m_ringBufferIndex + 1) % 2;
+        return result;
+    }
+
+    Optional<Token> peek()
+    {
+        return m_ringBuffer[m_ringBufferIndex];
+    }
+
+    Optional<Token> peekFurther()
+    {
+        return m_ringBuffer[(m_ringBufferIndex + 1) % 2];
+    }
+
+    // FIXME: We should not need this
+    // https://bugs.webkit.org/show_bug.cgi?id=198357
     struct State {
-        Vector<Token> stack;
+        Optional<Token> ringBuffer[2];
+        unsigned ringBufferIndex;
         unsigned offset;
         unsigned lineNumber;
@@ -196 +207 @@
     State state() const
     {
-        return { m_stack, m_offset, m_lineNumber };
+        State state;
+        state.ringBuffer[0] = m_ringBuffer[0];
+        state.ringBuffer[1] = m_ringBuffer[1];
+        state.ringBufferIndex = m_ringBufferIndex;
+        state.offset = m_offset;
+        state.lineNumber = m_lineNumber;
+        return state;
     }
 
     void setState(const State& state)
     {
-        m_stack = state.stack;
+        m_ringBuffer[0] = state.ringBuffer[0];
+        m_ringBuffer[1] = state.ringBuffer[1];
+        m_ringBufferIndex = state.ringBufferIndex;
         m_offset = state.offset;
         m_lineNumber = state.lineNumber;
+
     }
 
     void setState(State&& state)
     {
-        m_stack = WTFMove(state.stack);
+        m_ringBuffer[0] = WTFMove(state.ringBuffer[0]);
+        m_ringBuffer[1] = WTFMove(state.ringBuffer[1]);
+        m_ringBufferIndex = WTFMove(state.ringBufferIndex);
         m_offset = WTFMove(state.offset);
         m_lineNumber = WTFMove(state.lineNumber);
@@ -254 +276 @@
 
     StringView m_stringView;
-    Vector<Token> m_stack;
+    Optional<Token> m_ringBuffer[2];
+    unsigned m_ringBufferIndex { 0 };
     unsigned m_offset { 0 };
     unsigned m_lineNumber { 0 };

trunk/Source/WebCore/Modules/webgpu/WHLSL/WHLSLParser.cpp

@@ -39 +39 @@
 namespace WHLSL {
 
+#define PARSE(name, element, ...) \
+    auto name = parse##element(__VA_ARGS__); \
+    if (!name) \
+        return Unexpected<Error>(name.error());
+
+#define CONSUME_TYPE(name, type) \
+    auto name = consumeType(Lexer::Token::Type::type); \
+    if (!name) \
+        return Unexpected<Error>(name.error());
+
+#define PEEK(name) \
+    auto name = peek(); \
+    if (!name) \
+        return Unexpected<Error>(name.error());
+
+#define PEEK_FURTHER(name) \
+    auto name = peekFurther(); \
+    if (!name) \
+        return Unexpected<Error>(name.error());
+
 // FIXME: https://bugs.webkit.org/show_bug.cgi?id=195682 Return a better error code from this, and report it to JavaScript.
 auto Parser::parse(Program& program, StringView stringView, Mode mode) -> Optional<Error>
@@ -46 +66 @@
 
     while (!m_lexer.isFullyConsumed()) {
-        if (tryType(Lexer::Token::Type::Semicolon)) {
+        auto token = m_lexer.peek();
+        if (!token)
+            break;
+        switch (token->type) {
+        case Lexer::Token::Type::Semicolon:
             m_lexer.consumeToken();
             continue;
-        }
-
-        {
-            auto typeDefinition = backtrackingScope<Expected<AST::TypeDefinition, Error>>([&]() {
-                return parseTypeDefinition();
-            });
-            if (typeDefinition) {
-                auto success = program.append(WTFMove(*typeDefinition));
-                if (!success)
-                    return WTF::nullopt;
+        case Lexer::Token::Type::Typedef: {
+            auto typeDefinition = parseTypeDefinition();
+            if (!typeDefinition)
+                return typeDefinition.error();
+            program.append(WTFMove(*typeDefinition));
+            continue;
+        }
+        case Lexer::Token::Type::Struct: {
+            auto structureDefinition = parseStructureDefinition();
+            if (!structureDefinition)
+                return structureDefinition.error();
+            program.append(WTFMove(*structureDefinition));
+            continue;
+        }
+        case Lexer::Token::Type::Enum: {
+            auto enumerationDefinition = parseEnumerationDefinition();
+            if (!enumerationDefinition)
+                return enumerationDefinition.error();
+            program.append(WTFMove(*enumerationDefinition));
+            continue;
+        }
+        case Lexer::Token::Type::Native: {
+            ASSERT(m_mode == Mode::StandardLibrary);
+            auto furtherToken = peekFurther();
+            if (!furtherToken)
+                return WTF::nullopt;
+            if (furtherToken->type == Lexer::Token::Type::Typedef) {
+                auto nativeTypeDeclaration = parseNativeTypeDeclaration();
+                if (!nativeTypeDeclaration)
+                    return nativeTypeDeclaration.error();
+                program.append(WTFMove(*nativeTypeDeclaration));
                 continue;
             }
-        }
-
-        {
-            auto structureDefinition = backtrackingScope<Expected<AST::StructureDefinition, Error>>([&]() {
-                return parseStructureDefinition();
-            });
-            if (structureDefinition) {
-                auto success = program.append(WTFMove(*structureDefinition));
-                if (!success)
-                    return WTF::nullopt;
-                continue;
-            }
-        }
-
-        {
-            auto enumerationDefinition = backtrackingScope<Expected<AST::EnumerationDefinition, Error>>([&]() {
-                return parseEnumerationDefinition();
-            });
-            if (enumerationDefinition) {
-                auto success = program.append(WTFMove(*enumerationDefinition));
-                if (!success)
-                    return WTF::nullopt;
-                continue;
-            }
-        }
-
-        Optional<Error> error;
-        {
-            auto functionDefinition = backtrackingScope<Expected<AST::FunctionDefinition, Error>>([&]() {
-                return parseFunctionDefinition();
-            });
-            if (functionDefinition) {
-                auto success = program.append(WTFMove(*functionDefinition));
-                if (!success)
-                    return WTF::nullopt;
-                continue;
-            }
-            error = functionDefinition.error();
-        }
-
-        if (m_mode == Mode::StandardLibrary) {
-            auto nativeFunctionDeclaration = backtrackingScope<Expected<AST::NativeFunctionDeclaration, Error>>([&]() {
-                return parseNativeFunctionDeclaration();
-            });
-            if (nativeFunctionDeclaration) {
-                auto success = program.append(WTFMove(*nativeFunctionDeclaration));
-                if (!success)
-                    return WTF::nullopt;
-                continue;
-            }
-        }
-
-        if (m_mode == Mode::StandardLibrary) {
-            auto nativeTypeDeclaration = backtrackingScope<Expected<AST::NativeTypeDeclaration, Error>>([&]() {
-                return parseNativeTypeDeclaration();
-            });
-            if (nativeTypeDeclaration) {
-                auto success = program.append(WTFMove(*nativeTypeDeclaration));
-                if (!success)
-                    return WTF::nullopt;
-                continue;
-            }
-        }
-
-        return WTFMove(*error);
-    }
+            auto nativeFunctionDeclaration = parseNativeFunctionDeclaration();
+            if (!nativeFunctionDeclaration)
+                return nativeFunctionDeclaration.error();
+            program.append(WTFMove(*nativeFunctionDeclaration));
+            continue;
+        }
+        default: {
+            auto functionDefinition = parseFunctionDefinition();
+            if (!functionDefinition)
+                return functionDefinition.error();
+            program.append(WTFMove(*functionDefinition));
+            continue;
+        }
+        }
+    }
+
     return WTF::nullopt;
 }
@@ -141 +136 @@
 auto Parser::peek() -> Expected<Lexer::Token, Error>
 {
-    if (auto token = m_lexer.consumeToken()) {
-        m_lexer.unconsumeToken(Lexer::Token(*token));
+    if (auto token = m_lexer.peek()) {
         return *token;
     }
@@ -148 +142 @@
 }
 
+auto Parser::peekFurther() -> Expected<Lexer::Token, Error>
+{
+    if (auto token = m_lexer.peekFurther()) {
+        return *token;
+    }
+    return fail("Cannot consume two tokens"_str, TryToPeek::No);
+}
+
+bool Parser::peekTypes(const Vector<Lexer::Token::Type>& types)
+{
+    if (auto token = m_lexer.peek())
+        return std::find(types.begin(), types.end(), token->type) != types.end();
+    return false;
+}
+
 Optional<Lexer::Token> Parser::tryType(Lexer::Token::Type type)
 {
-    if (auto token = m_lexer.consumeToken()) {
+    if (auto token = m_lexer.peek()) {
         if (token->type == type)
-            return token;
-        m_lexer.unconsumeToken(Lexer::Token(*token));
+            return m_lexer.consumeToken();
     }
     return WTF::nullopt;
 }
 
-Optional<Lexer::Token> Parser::tryTypes(Vector<Lexer::Token::Type> types)
-{
-    if (auto token = m_lexer.consumeToken()) {
+Optional<Lexer::Token> Parser::tryTypes(const Vector<Lexer::Token::Type>& types)
+{
+    if (auto token = m_lexer.peek()) {
         if (std::find(types.begin(), types.end(), token->type) != types.end())
-            return token;
-        m_lexer.unconsumeToken(Lexer::Token(*token));
+            return m_lexer.consumeToken();
     }
     return WTF::nullopt;
@@ -178 +185 @@
 }
 
-auto Parser::consumeTypes(Vector<Lexer::Token::Type> types) -> Expected<Lexer::Token, Error>
+auto Parser::consumeTypes(const Vector<Lexer::Token::Type>& types) -> Expected<Lexer::Token, Error>
 {
     auto buildExpectedString = [&]() -> String {
@@ -368 +375 @@
     default: {
         ASSERT(type->type == Lexer::Token::Type::Identifier);
-        auto origin = consumeType(Lexer::Token::Type::FullStop);
-        if (!origin)
-            return Unexpected<Error>(origin.error());
-        auto next = consumeType(Lexer::Token::Type::Identifier);
-        if (!next)
-            return Unexpected<Error>(next.error());
+        CONSUME_TYPE(origin, FullStop);
+        CONSUME_TYPE(next, Identifier);
         return { AST::EnumerationMemberLiteral(WTFMove(*origin), type->stringView.toString(), next->stringView.toString()) };
     }
@@ -381 +384 @@
 auto Parser::parseTypeArgument() -> Expected<AST::TypeArgument, Error>
 {
-    auto constantExpression = backtrackingScope<Expected<AST::ConstantExpression, Error>>([&]() {
-        return parseConstantExpression();
-    });
-    if (constantExpression)
+    PEEK(nextToken);
+    PEEK_FURTHER(furtherToken);
+    if (nextToken->type != Lexer::Token::Type::Identifier || furtherToken->type == Lexer::Token::Type::FullStop) {
+        PARSE(constantExpression, ConstantExpression);
         return AST::TypeArgument(WTFMove(*constantExpression));
-    auto result = consumeType(Lexer::Token::Type::Identifier);
-    if (!result)
-        return Unexpected<Error>(result.error());
+    }
+    CONSUME_TYPE(result, Identifier);
     return AST::TypeArgument(makeUniqueRef<AST::TypeReference>(Lexer::Token(*result), result->stringView.toString(), AST::TypeArguments()));
 }
@@ -394 +396 @@
 auto Parser::parseTypeArguments() -> Expected<AST::TypeArguments, Error>
 {
-    auto typeArguments = backtrackingScope<Optional<AST::TypeArguments>>([&]() -> Optional<AST::TypeArguments> {
-        auto lessThanSign = consumeType(Lexer::Token::Type::LessThanSign);
-        if (!lessThanSign)
-            return WTF::nullopt;
-        AST::TypeArguments typeArguments;
-        auto typeArgument = parseTypeArgument();
-        if (!typeArgument)
-            return WTF::nullopt;
+    AST::TypeArguments typeArguments;
+    auto lessThanSign = tryType(Lexer::Token::Type::LessThanSign);
+    if (!lessThanSign)
+        return typeArguments;
+
+    auto greaterThanSign = tryType(Lexer::Token::Type::GreaterThanSign);
+    if (greaterThanSign)
+        return typeArguments;
+
+    PARSE(typeArgument, TypeArgument);
+    typeArguments.append(WTFMove(*typeArgument));
+
+    while (true) {
+        auto greaterThanSign = tryType(Lexer::Token::Type::GreaterThanSign);
+        if (greaterThanSign)
+            break;
+
+        CONSUME_TYPE(comma, Comma);
+        PARSE(typeArgument, TypeArgument);
         typeArguments.append(WTFMove(*typeArgument));
-        while (tryType(Lexer::Token::Type::Comma)) {
-            auto typeArgument = parseTypeArgument();
-            if (!typeArgument)
-                return WTF::nullopt;
-            typeArguments.append(WTFMove(*typeArgument));
-        }
-        auto greaterThanSign = consumeType(Lexer::Token::Type::GreaterThanSign);
-        if (!greaterThanSign)
-            return WTF::nullopt;
-        return typeArguments;
-    });
-    if (typeArguments)
-        return WTFMove(*typeArguments);
-
-    typeArguments = backtrackingScope<Optional<AST::TypeArguments>>([&]() -> Optional<AST::TypeArguments> {
-        auto lessThanSign = consumeType(Lexer::Token::Type::LessThanSign);
-        if (!lessThanSign)
-            return WTF::nullopt;
-        auto greaterThanSign = consumeType(Lexer::Token::Type::GreaterThanSign);
-        if (!greaterThanSign)
-            return WTF::nullopt;
-        return {{ }};
-    });
-    if (typeArguments)
-        return WTFMove(*typeArguments);
-
-    return AST::TypeArguments();
+    }
+
+    return typeArguments;
 }
 
@@ -441 +430 @@
         if (!numElements)
             return Unexpected<Error>(numElements.error());
-        auto rightSquareBracket = consumeType(Lexer::Token::Type::RightSquareBracket);
-        if (!rightSquareBracket)
-            return Unexpected<Error>(rightSquareBracket.error());
+        CONSUME_TYPE(rightSquareBracket, RightSquareBracket);
         return {{ *token, *numElements }};
     }
@@ -458 +445 @@
         if (!numElements)
             return Unexpected<Error>(numElements.error());
-        auto rightSquareBracket = consumeType(Lexer::Token::Type::RightSquareBracket);
-        if (!rightSquareBracket)
-            return Unexpected<Error>(rightSquareBracket.error());
+        CONSUME_TYPE(rightSquareBracket, RightSquareBracket);
         return {{ *token, WTF::nullopt, *numElements }};
     }
@@ -485 +470 @@
 }
 
-auto Parser::parseAddressSpaceType() -> Expected<UniqueRef<AST::UnnamedType>, Error>
-{
-    auto addressSpaceToken = consumeTypes({ Lexer::Token::Type::Constant, Lexer::Token::Type::Device, Lexer::Token::Type::Threadgroup, Lexer::Token::Type::Thread});
-    if (!addressSpaceToken)
-        return Unexpected<Error>(addressSpaceToken.error());
-    AST::AddressSpace addressSpace;
-    switch (addressSpaceToken->type) {
-    case Lexer::Token::Type::Constant:
-        addressSpace = AST::AddressSpace::Constant;
-        break;
-    case Lexer::Token::Type::Device:
-        addressSpace = AST::AddressSpace::Device;
-        break;
-    case Lexer::Token::Type::Threadgroup:
-        addressSpace = AST::AddressSpace::Threadgroup;
-        break;
-    default:
-        ASSERT(addressSpaceToken->type == Lexer::Token::Type::Thread);
-        addressSpace = AST::AddressSpace::Thread;
-        break;
-    }
-    auto name = consumeType(Lexer::Token::Type::Identifier);
-    if (!name)
-        return Unexpected<Error>(name.error());
-    auto typeArguments = parseTypeArguments();
-    if (!typeArguments)
-        return Unexpected<Error>(typeArguments.error());
-
-    auto constructTypeFromSuffixAbbreviated = [&](const TypeSuffixAbbreviated& typeSuffixAbbreviated, UniqueRef<AST::UnnamedType>&& previous) -> UniqueRef<AST::UnnamedType> {
-        switch (typeSuffixAbbreviated.token.type) {
-        case Lexer::Token::Type::Star:
-            return { makeUniqueRef<AST::PointerType>(Lexer::Token(typeSuffixAbbreviated.token), addressSpace, WTFMove(previous)) };
-        case Lexer::Token::Type::SquareBracketPair:
-            return { makeUniqueRef<AST::ArrayReferenceType>(Lexer::Token(typeSuffixAbbreviated.token), addressSpace, WTFMove(previous)) };
+auto Parser::parseType() -> Expected<UniqueRef<AST::UnnamedType>, Error>
+{
+    auto addressSpaceToken = tryTypes({ Lexer::Token::Type::Constant, Lexer::Token::Type::Device, Lexer::Token::Type::Threadgroup, Lexer::Token::Type::Thread});
+
+    CONSUME_TYPE(name, Identifier);
+    PARSE(typeArguments, TypeArguments);
+
+    if (addressSpaceToken) {
+        AST::AddressSpace addressSpace;
+        switch (addressSpaceToken->type) {
+        case Lexer::Token::Type::Constant:
+            addressSpace = AST::AddressSpace::Constant;
+            break;
+        case Lexer::Token::Type::Device:
+            addressSpace = AST::AddressSpace::Device;
+            break;
+        case Lexer::Token::Type::Threadgroup:
+            addressSpace = AST::AddressSpace::Threadgroup;
+            break;
         default:
-            ASSERT(typeSuffixAbbreviated.token.type == Lexer::Token::Type::LeftSquareBracket);
-            return { makeUniqueRef<AST::ArrayType>(Lexer::Token(typeSuffixAbbreviated.token), WTFMove(previous), *typeSuffixAbbreviated.numElements) };
-        }
-    };
-
-    auto firstTypeSuffixAbbreviated = parseTypeSuffixAbbreviated();
-    if (!firstTypeSuffixAbbreviated)
-        return Unexpected<Error>(firstTypeSuffixAbbreviated.error());
-    UniqueRef<AST::UnnamedType> result = makeUniqueRef<AST::TypeReference>(WTFMove(*addressSpaceToken), name->stringView.toString(), WTFMove(*typeArguments));
-    auto next = constructTypeFromSuffixAbbreviated(*firstTypeSuffixAbbreviated, WTFMove(result));
-    result = WTFMove(next);
-    while (true) {
-        auto typeSuffixAbbreviated = backtrackingScope<Expected<TypeSuffixAbbreviated, Error>>([&]() {
-            return parseTypeSuffixAbbreviated();
-        });
-        if (!typeSuffixAbbreviated)
-            break;
-        // FIXME: The nesting here might be in the wrong order.
-        next = constructTypeFromSuffixAbbreviated(*typeSuffixAbbreviated, WTFMove(result));
+            ASSERT(addressSpaceToken->type == Lexer::Token::Type::Thread);
+            addressSpace = AST::AddressSpace::Thread;
+            break;
+        }
+        auto constructTypeFromSuffixAbbreviated = [&](const TypeSuffixAbbreviated& typeSuffixAbbreviated, UniqueRef<AST::UnnamedType>&& previous) -> UniqueRef<AST::UnnamedType> {
+            switch (typeSuffixAbbreviated.token.type) {
+            case Lexer::Token::Type::Star:
+                return { makeUniqueRef<AST::PointerType>(Lexer::Token(typeSuffixAbbreviated.token), addressSpace, WTFMove(previous)) };
+            case Lexer::Token::Type::SquareBracketPair:
+                return { makeUniqueRef<AST::ArrayReferenceType>(Lexer::Token(typeSuffixAbbreviated.token), addressSpace, WTFMove(previous)) };
+            default:
+                ASSERT(typeSuffixAbbreviated.token.type == Lexer::Token::Type::LeftSquareBracket);
+                return { makeUniqueRef<AST::ArrayType>(Lexer::Token(typeSuffixAbbreviated.token), WTFMove(previous), *typeSuffixAbbreviated.numElements) };
+            }
+        };
+        PARSE(firstTypeSuffixAbbreviated, TypeSuffixAbbreviated);
+        UniqueRef<AST::UnnamedType> result = makeUniqueRef<AST::TypeReference>(WTFMove(*addressSpaceToken), name->stringView.toString(), WTFMove(*typeArguments));
+        auto next = constructTypeFromSuffixAbbreviated(*firstTypeSuffixAbbreviated, WTFMove(result));
         result = WTFMove(next);
-    }
-
-    return WTFMove(result);
-}
-
-auto Parser::parseNonAddressSpaceType() -> Expected<UniqueRef<AST::UnnamedType>, Error>
-{
-    auto origin = peek();
-    if (!origin)
-        return Unexpected<Error>(origin.error());
-    auto name = consumeType(Lexer::Token::Type::Identifier);
-    if (!name)
-        return Unexpected<Error>(name.error());
-    auto typeArguments = parseTypeArguments();
-    if (!typeArguments)
-        return Unexpected<Error>(typeArguments.error());
+        while (true) {
+            PEEK(nextToken);
+            if (nextToken->type != Lexer::Token::Type::Star
+                && nextToken->type != Lexer::Token::Type::SquareBracketPair
+                && nextToken->type != Lexer::Token::Type::LeftSquareBracket) {
+                break;
+            }
+            PARSE(typeSuffixAbbreviated, TypeSuffixAbbreviated);
+            // FIXME: The nesting here might be in the wrong order.
+            next = constructTypeFromSuffixAbbreviated(*typeSuffixAbbreviated, WTFMove(result));
+            result = WTFMove(next);
+        }
+        return WTFMove(result);
+    }
 
     auto constructTypeFromSuffixNonAbbreviated = [&](const TypeSuffixNonAbbreviated& typeSuffixNonAbbreviated, UniqueRef<AST::UnnamedType>&& previous) -> UniqueRef<AST::UnnamedType> {
@@ -568 +535 @@
         }
     };
-
-    UniqueRef<AST::UnnamedType> result = makeUniqueRef<AST::TypeReference>(WTFMove(*origin), name->stringView.toString(), WTFMove(*typeArguments));
+    UniqueRef<AST::UnnamedType> result = makeUniqueRef<AST::TypeReference>(WTFMove(*name), name->stringView.toString(), WTFMove(*typeArguments));
     while (true) {
-        auto typeSuffixNonAbbreviated = backtrackingScope<Expected<TypeSuffixNonAbbreviated, Error>>([&]() {
-            return parseTypeSuffixNonAbbreviated();
-        });
-        if (!typeSuffixNonAbbreviated)
-            break;
+        PEEK(nextToken);
+        if (nextToken->type != Lexer::Token::Type::Star
+            && nextToken->type != Lexer::Token::Type::SquareBracketPair
+            && nextToken->type != Lexer::Token::Type::LeftSquareBracket) {
+            break;
+        }
+        PARSE(typeSuffixNonAbbreviated, TypeSuffixNonAbbreviated);
         // FIXME: The nesting here might be in the wrong order.
         auto next = constructTypeFromSuffixNonAbbreviated(*typeSuffixNonAbbreviated, WTFMove(result));
         result = WTFMove(next);
     }
-
     return WTFMove(result);
 }
 
-auto Parser::parseType() -> Expected<UniqueRef<AST::UnnamedType>, Error>
-{
-    {
-        auto type = backtrackingScope<Expected<UniqueRef<AST::UnnamedType>, Error>>([&]() {
-            return parseAddressSpaceType();
-        });
-        if (type)
-            return type;
-    }
-
-    auto type = backtrackingScope<Expected<UniqueRef<AST::UnnamedType>, Error>>([&]() {
-        return parseNonAddressSpaceType();
-    });
-    if (type)
-        return type;
-
-    return Unexpected<Error>(type.error());
-}
-
 auto Parser::parseTypeDefinition() -> Expected<AST::TypeDefinition, Error>
 {
-    auto origin = consumeType(Lexer::Token::Type::Typedef);
-    if (!origin)
-        return Unexpected<Error>(origin.error());
-    auto name = consumeType(Lexer::Token::Type::Identifier);
-    if (!name)
-        return Unexpected<Error>(name.error());
-    auto equals = consumeType(Lexer::Token::Type::EqualsSign);
-    if (!equals)
-        return Unexpected<Error>(equals.error());
-    auto type = parseType();
-    if (!type)
-        return Unexpected<Error>(type.error());
-    auto semicolon = consumeType(Lexer::Token::Type::Semicolon);
-    if (!semicolon)
-        return Unexpected<Error>(semicolon.error());
+    CONSUME_TYPE(origin, Typedef);
+    CONSUME_TYPE(name, Identifier);
+    CONSUME_TYPE(equals, EqualsSign);
+    PARSE(type, Type);
+    CONSUME_TYPE(semicolon, Semicolon);
     return AST::TypeDefinition(WTFMove(*origin), name->stringView.toString(), WTFMove(*type));
 }
@@ -682 +620 @@
 auto Parser::parseResourceSemantic() -> Expected<AST::ResourceSemantic, Error>
 {
-    auto origin = consumeType(Lexer::Token::Type::Register);
-    if (!origin)
-        return Unexpected<Error>(origin.error());
-
-    auto leftParenthesis = consumeType(Lexer::Token::Type::LeftParenthesis);
-    if (!leftParenthesis)
-        return Unexpected<Error>(leftParenthesis.error());
-
-    auto info = consumeType(Lexer::Token::Type::Identifier);
-    if (!info)
-        return Unexpected<Error>(info.error());
+    CONSUME_TYPE(origin, Register);
+    CONSUME_TYPE(leftParenthesis, LeftParenthesis);
+
+    CONSUME_TYPE(info, Identifier);
     if (info->stringView.length() < 2 || (info->stringView[0] != 'u'
         && info->stringView[0] != 't'
@@ -721 +652 @@
     unsigned space = 0;
     if (tryType(Lexer::Token::Type::Comma)) {
-        auto spaceToken = consumeType(Lexer::Token::Type::Identifier);
-        if (!spaceToken)
-            return Unexpected<Error>(spaceToken.error());
+        CONSUME_TYPE(spaceToken, Identifier);
         auto prefix = "space"_str;
         if (!spaceToken->stringView.startsWith(StringView(prefix)))
@@ -735 +664 @@
     }
 
-    auto rightParenthesis = consumeType(Lexer::Token::Type::RightParenthesis);
-    if (!rightParenthesis)
-        return Unexpected<Error>(rightParenthesis.error());
+    CONSUME_TYPE(rightParenthesis, RightParenthesis);
 
     return AST::ResourceSemantic(WTFMove(*origin), mode, *index, space);
@@ -744 +671 @@
 auto Parser::parseSpecializationConstantSemantic() -> Expected<AST::SpecializationConstantSemantic, Error>
 {
-    auto origin = consumeType(Lexer::Token::Type::Specialized);
-    if (!origin)
-        return Unexpected<Error>(origin.error());
+    CONSUME_TYPE(origin, Specialized);
     return AST::SpecializationConstantSemantic(WTFMove(*origin));
 }
@@ -752 +677 @@
 auto Parser::parseStageInOutSemantic() -> Expected<AST::StageInOutSemantic, Error>
 {
-    auto origin = consumeType(Lexer::Token::Type::Attribute);
-    if (!origin)
-        return Unexpected<Error>(origin.error());
-
-    auto leftParenthesis = consumeType(Lexer::Token::Type::LeftParenthesis);
-    if (!leftParenthesis)
-        return Unexpected<Error>(leftParenthesis.error());
+    CONSUME_TYPE(origin, Attribute);
+    CONSUME_TYPE(leftParenthesis, LeftParenthesis);
 
     auto index = consumeNonNegativeIntegralLiteral();
@@ -764 +684 @@
         return Unexpected<Error>(index.error());
 
-    auto rightParenthesis = consumeType(Lexer::Token::Type::RightParenthesis);
-    if (!rightParenthesis)
-        return Unexpected<Error>(rightParenthesis.error());
+    CONSUME_TYPE(rightParenthesis, RightParenthesis);
 
     return AST::StageInOutSemantic(WTFMove(*origin), *index);
 }
 
-auto Parser::parseSemantic() -> Expected<AST::Semantic, Error>
-{
-    auto builtInSemantic = backtrackingScope<Expected<AST::BuiltInSemantic, Error>>([&]() {
-        return parseBuiltInSemantic();
-    });
-    if (builtInSemantic)
-        return AST::Semantic(WTFMove(*builtInSemantic));
-
-    auto resourceSemantic = backtrackingScope<Expected<AST::ResourceSemantic, Error>>([&]() {
-        return parseResourceSemantic();
-    });
-    if (resourceSemantic)
-        return AST::Semantic(WTFMove(*resourceSemantic));
-
-    auto specializationConstantSemantic = backtrackingScope<Expected<AST::SpecializationConstantSemantic, Error>>([&]() {
-        return parseSpecializationConstantSemantic();
-    });
-    if (specializationConstantSemantic)
-        return AST::Semantic(WTFMove(*specializationConstantSemantic));
-
-    auto stageInOutSemantic = backtrackingScope<Expected<AST::StageInOutSemantic, Error>>([&]() {
-        return parseStageInOutSemantic();
-    });
-    if (stageInOutSemantic)
-        return AST::Semantic(WTFMove(*stageInOutSemantic));
-
-    return Unexpected<Error>(stageInOutSemantic.error());
+auto Parser::parseSemantic() -> Expected<Optional<AST::Semantic>, Error>
+{
+    if (!tryType(Lexer::Token::Type::Colon))
+        return { WTF::nullopt };
+
+    PEEK(token);
+    switch (token->type) {
+    case Lexer::Token::Type::Attribute: {
+        PARSE(result, StageInOutSemantic);
+        return { AST::Semantic(WTFMove(*result)) };
+    }
+    case Lexer::Token::Type::Specialized:  {
+        PARSE(result, SpecializationConstantSemantic);
+        return { AST::Semantic(WTFMove(*result)) };
+    }
+    case Lexer::Token::Type::Register:  {
+        PARSE(result, ResourceSemantic);
+        return { AST::Semantic(WTFMove(*result)) };
+    }
+    default:  {
+        PARSE(result, BuiltInSemantic);
+        return { AST::Semantic(WTFMove(*result)) };
+    }
+    }
 }
 AST::Qualifiers Parser::parseQualifiers()
 {
     AST::Qualifiers qualifiers;
-    while (true) {
-        if (auto next = tryType(Lexer::Token::Type::Qualifier)) {
-            if ("nointerpolation" == next->stringView)
-                qualifiers.append(AST::Qualifier::Nointerpolation);
-            else if ("noperspective" == next->stringView)
-                qualifiers.append(AST::Qualifier::Noperspective);
-            else if ("uniform" == next->stringView)
-                qualifiers.append(AST::Qualifier::Uniform);
-            else if ("centroid" == next->stringView)
-                qualifiers.append(AST::Qualifier::Centroid);
-            else {
-                ASSERT("sample" == next->stringView);
-                qualifiers.append(AST::Qualifier::Sample);
-            }
-        } else
-            break;
+    while (auto next = tryType(Lexer::Token::Type::Qualifier)) {
+        if ("nointerpolation" == next->stringView)
+            qualifiers.append(AST::Qualifier::Nointerpolation);
+        else if ("noperspective" == next->stringView)
+            qualifiers.append(AST::Qualifier::Noperspective);
+        else if ("uniform" == next->stringView)
+            qualifiers.append(AST::Qualifier::Uniform);
+        else if ("centroid" == next->stringView)
+            qualifiers.append(AST::Qualifier::Centroid);
+        else {
+            ASSERT("sample" == next->stringView);
+            qualifiers.append(AST::Qualifier::Sample);
+        }
     }
     return qualifiers;
@@ -824 +736 @@
 auto Parser::parseStructureElement() -> Expected<AST::StructureElement, Error>
 {
-    auto origin = peek();
-    if (!origin)
-        return Unexpected<Error>(origin.error());
+    PEEK(origin);
 
     AST::Qualifiers qualifiers = parseQualifiers();
 
-    auto type = parseType();
-    if (!type)
-        return Unexpected<Error>(type.error());
-
-    auto name = consumeType(Lexer::Token::Type::Identifier);
-    if (!name)
-        return Unexpected<Error>(name.error());
-
-    if (tryType(Lexer::Token::Type::Colon)) {
-        auto semantic = parseSemantic();
-        if (!semantic)
-            return Unexpected<Error>(semantic.error());
-
-        auto semicolon = consumeType(Lexer::Token::Type::Semicolon);
-        if (!semicolon)
-            return Unexpected<Error>(semicolon.error());
-
-        return AST::StructureElement(WTFMove(*origin), WTFMove(qualifiers), WTFMove(*type), name->stringView.toString(), WTFMove(*semantic));
-    }
-
-    auto semicolon = consumeType(Lexer::Token::Type::Semicolon);
-    if (!semicolon)
-        return Unexpected<Error>(semicolon.error());
-
-    return AST::StructureElement(WTFMove(*origin), WTFMove(qualifiers), WTFMove(*type), name->stringView.toString(), WTF::nullopt);
+    PARSE(type, Type);
+    CONSUME_TYPE(name, Identifier);
+    PARSE(semantic, Semantic);
+    CONSUME_TYPE(semicolon, Semicolon);
+
+    return AST::StructureElement(WTFMove(*origin), WTFMove(qualifiers), WTFMove(*type), name->stringView.toString(), WTFMove(*semantic));
 }
 
 auto Parser::parseStructureDefinition() -> Expected<AST::StructureDefinition, Error>
 {
-    auto origin = consumeType(Lexer::Token::Type::Struct);
-    if (!origin)
-        return Unexpected<Error>(origin.error());
-
-    auto name = consumeType(Lexer::Token::Type::Identifier);
-    if (!name)
-        return Unexpected<Error>(name.error());
-
-    auto leftCurlyBracket = consumeType(Lexer::Token::Type::LeftCurlyBracket);
-    if (!leftCurlyBracket)
-        return Unexpected<Error>(leftCurlyBracket.error());
+    CONSUME_TYPE(origin, Struct);
+    CONSUME_TYPE(name, Identifier);
+    CONSUME_TYPE(leftCurlyBracket, LeftCurlyBracket);
 
     AST::StructureElements structureElements;
-    while (true) {
-        auto structureElement = backtrackingScope<Expected<AST::StructureElement, Error>>([&]() {
-            return parseStructureElement();
-        });
-        if (structureElement)
-            structureElements.append(WTFMove(*structureElement));
-        else
-            break;
-    }
-
-    auto rightCurlyBracket = consumeType(Lexer::Token::Type::RightCurlyBracket);
-    if (!rightCurlyBracket)
-        return Unexpected<Error>(rightCurlyBracket.error());
+    while (!tryType(Lexer::Token::Type::RightCurlyBracket)) {
+        PARSE(structureElement, StructureElement);
+        structureElements.append(WTFMove(*structureElement));
+    }
 
     return AST::StructureDefinition(WTFMove(*origin), name->stringView.toString(), WTFMove(structureElements));
@@ -891 +765 @@
 auto Parser::parseEnumerationDefinition() -> Expected<AST::EnumerationDefinition, Error>
 {
-    auto origin = consumeType(Lexer::Token::Type::Enum);
-    if (!origin)
-        return Unexpected<Error>(origin.error());
-
-    auto name = consumeType(Lexer::Token::Type::Identifier);
-    if (!name)
-        return Unexpected<Error>(name.error());
+    CONSUME_TYPE(origin, Enum);
+    CONSUME_TYPE(name, Identifier);
 
     auto type = ([&]() -> Expected<UniqueRef<AST::UnnamedType>, Error> {
         if (tryType(Lexer::Token::Type::Colon)) {
-            auto parsedType = parseType();
-            if (!parsedType)
-                return Unexpected<Error>(parsedType.error());
+            PARSE(parsedType, Type);
             return WTFMove(*parsedType);
         }
@@ -911 +778 @@
         return Unexpected<Error>(type.error());
 
-    auto leftCurlyBracket = consumeType(Lexer::Token::Type::LeftCurlyBracket);
-    if (!leftCurlyBracket)
-        return Unexpected<Error>(leftCurlyBracket.error());
-
-    auto firstEnumerationMember = parseEnumerationMember();
-    if (!firstEnumerationMember)
-        return Unexpected<Error>(firstEnumerationMember.error());
+    CONSUME_TYPE(leftCurlyBracket, LeftCurlyBracket);
+
+    PARSE(firstEnumerationMember, EnumerationMember);
 
     AST::EnumerationDefinition result(WTFMove(*origin), name->stringView.toString(), WTFMove(*type));
@@ -925 +788 @@
 
     while (tryType(Lexer::Token::Type::Comma)) {
-        auto member = parseEnumerationMember();
-        if (!member)
-            return Unexpected<Error>(member.error());
+        PARSE(member, EnumerationMember);
         success = result.add(WTFMove(*member));
         if (!success)
@@ -933 +794 @@
     }
 
-    auto rightCurlyBracket = consumeType(Lexer::Token::Type::RightCurlyBracket);
-    if (!rightCurlyBracket)
-        return Unexpected<Error>(rightCurlyBracket.error());
+    CONSUME_TYPE(rightCurlyBracket, RightCurlyBracket);
 
     return WTFMove(result);
@@ -942 +801 @@
 auto Parser::parseEnumerationMember() -> Expected<AST::EnumerationMember, Error>
 {
-    auto identifier = consumeType(Lexer::Token::Type::Identifier);
-    if (!identifier)
-        return Unexpected<Error>(identifier.error());
+    CONSUME_TYPE(identifier, Identifier);
     auto name = identifier->stringView.toString();
 
     if (tryType(Lexer::Token::Type::EqualsSign)) {
-        auto constantExpression = parseConstantExpression();
-        if (!constantExpression)
-            return Unexpected<Error>(constantExpression.error());
+        PARSE(constantExpression, ConstantExpression);
         return AST::EnumerationMember(Lexer::Token(*identifier), WTFMove(name), WTFMove(*constantExpression));
     }
@@ -958 +813 @@
 auto Parser::parseNativeTypeDeclaration() -> Expected<AST::NativeTypeDeclaration, Error>
 {
-    auto origin = consumeType(Lexer::Token::Type::Native);
-    if (!origin)
-        return Unexpected<Error>(origin.error());
-
-    auto parsedTypedef = consumeType(Lexer::Token::Type::Typedef);
-    if (!parsedTypedef)
-        return Unexpected<Error>(parsedTypedef.error());
-
-    auto name = consumeType(Lexer::Token::Type::Identifier);
-    if (!name)
-        return Unexpected<Error>(name.error());
-
-    auto typeArguments = parseTypeArguments();
-    if (!typeArguments)
-        return Unexpected<Error>(typeArguments.error());
-
-    auto semicolon = consumeType(Lexer::Token::Type::Semicolon);
-    if (!semicolon)
-        return Unexpected<Error>(semicolon.error());
+    CONSUME_TYPE(origin, Native);
+    CONSUME_TYPE(parsedTypedef, Typedef);
+    CONSUME_TYPE(name, Identifier);
+    PARSE(typeArguments, TypeArguments);
+    CONSUME_TYPE(semicolon, Semicolon);
 
     return AST::NativeTypeDeclaration(WTFMove(*origin), name->stringView.toString(), WTFMove(*typeArguments));
@@ -983 +824 @@
 auto Parser::parseNumThreadsFunctionAttribute() -> Expected<AST::NumThreadsFunctionAttribute, Error>
 {
-    auto origin = consumeType(Lexer::Token::Type::NumThreads);
-    if (!origin)
-        return Unexpected<Error>(origin.error());
-
-    auto leftParenthesis = consumeType(Lexer::Token::Type::LeftParenthesis);
-    if (!leftParenthesis)
-        return Unexpected<Error>(leftParenthesis.error());
+    CONSUME_TYPE(origin, NumThreads);
+    CONSUME_TYPE(leftParenthesis, LeftParenthesis);
 
     auto width = consumeNonNegativeIntegralLiteral();
@@ -995 +831 @@
         return Unexpected<Error>(width.error());
 
-    auto comma = consumeType(Lexer::Token::Type::Comma);
-    if (!comma)
-        return Unexpected<Error>(comma.error());
+    CONSUME_TYPE(comma, Comma);
 
     auto height = consumeNonNegativeIntegralLiteral();
@@ -1003 +837 @@
         return Unexpected<Error>(height.error());
 
-    comma = consumeType(Lexer::Token::Type::Comma);
-    if (!comma)
-        return Unexpected<Error>(comma.error());
+    CONSUME_TYPE(secondComma, Comma);
 
     auto depth = consumeNonNegativeIntegralLiteral();
@@ -1011 +843 @@
         return Unexpected<Error>(depth.error());
 
-    auto rightParenthesis = consumeType(Lexer::Token::Type::RightParenthesis);
-    if (!rightParenthesis)
-        return Unexpected<Error>(rightParenthesis.error());
+    CONSUME_TYPE(rightParenthesis, RightParenthesis);
 
     return AST::NumThreadsFunctionAttribute(WTFMove(*origin), *width, *height, *depth);
@@ -1020 +850 @@
 auto Parser::parseAttributeBlock() -> Expected<AST::AttributeBlock, Error>
 {
-    auto leftSquareBracket = consumeType(Lexer::Token::Type::LeftSquareBracket);
-    if (!leftSquareBracket)
-        return Unexpected<Error>(leftSquareBracket.error());
+    CONSUME_TYPE(leftSquareBracket, LeftSquareBracket);
 
     AST::AttributeBlock result;
@@ -1038 +866 @@
     }
 
-    auto rightSquareBracket = consumeType(Lexer::Token::Type::RightSquareBracket);
-    if (!rightSquareBracket)
-        return Unexpected<Error>(rightSquareBracket.error());
+    CONSUME_TYPE(rightSquareBracket, RightSquareBracket);
 
     return WTFMove(result);
@@ -1047 +873 @@
 auto Parser::parseParameter() -> Expected<AST::VariableDeclaration, Error>
 {
-    auto origin = peek();
-    if (!origin)
-        return Unexpected<Error>(origin.error());
+    PEEK(origin);
 
     AST::Qualifiers qualifiers = parseQualifiers();
 
-    auto type = parseType();
-    if (!type)
-        return Unexpected<Error>(type.error());
+    PARSE(type, Type);
 
     String name;
@@ -1061 +883 @@
         name = token->stringView.toString();
 
-    if (tryType(Lexer::Token::Type::Colon)) {
-        auto semantic = parseSemantic();
-        if (!semantic)
-            return Unexpected<Error>(semantic.error());
-        return AST::VariableDeclaration(WTFMove(*origin), WTFMove(qualifiers), Optional<UniqueRef<AST::UnnamedType>>(WTFMove(*type)), WTFMove(name), WTFMove(*semantic), WTF::nullopt);
-    }
-
-    return AST::VariableDeclaration(WTFMove(*origin), WTFMove(qualifiers), { WTFMove(*type) }, WTFMove(name), WTF::nullopt, WTF::nullopt);
+    PARSE(semantic, Semantic);
+
+    return AST::VariableDeclaration(WTFMove(*origin), WTFMove(qualifiers), { WTFMove(*type) }, WTFMove(name), WTFMove(*semantic), WTF::nullopt);
 }
 
 auto Parser::parseParameters() -> Expected<AST::VariableDeclarations, Error>
 {
-    auto leftParenthesis = consumeType(Lexer::Token::Type::LeftParenthesis);
-    if (!leftParenthesis)
-        return Unexpected<Error>(leftParenthesis.error());
-
     AST::VariableDeclarations parameters;
+
+    CONSUME_TYPE(leftParenthesis, LeftParenthesis);
+
     if (tryType(Lexer::Token::Type::RightParenthesis))
         return WTFMove(parameters);
 
-    auto firstParameter = parseParameter();
-    if (!firstParameter)
-        return Unexpected<Error>(firstParameter.error());
+    PARSE(firstParameter, Parameter);
     parameters.append(makeUniqueRef<AST::VariableDeclaration>(WTFMove(*firstParameter)));
 
     while (tryType(Lexer::Token::Type::Comma)) {
-        auto parameter = parseParameter();
-        if (!parameter)
-            return Unexpected<Error>(parameter.error());
+        PARSE(parameter, Parameter);
         parameters.append(makeUniqueRef<AST::VariableDeclaration>(WTFMove(*parameter)));
     }
 
-    auto rightParenthesis = consumeType(Lexer::Token::Type::RightParenthesis);
-    if (!rightParenthesis)
-        return Unexpected<Error>(rightParenthesis.error());
+    CONSUME_TYPE(rightParenthesis, RightParenthesis);
 
     return WTFMove(parameters);
@@ -1102 +912 @@
 auto Parser::parseFunctionDefinition() -> Expected<AST::FunctionDefinition, Error>
 {
-    auto functionDeclaration = parseFunctionDeclaration();
-    if (!functionDeclaration)
-        return Unexpected<Error>(functionDeclaration.error());
-
-    auto block = parseBlock();
-    if (!block)
-        return Unexpected<Error>(block.error());
-
+    PARSE(functionDeclaration, FunctionDeclaration);
+    PARSE(block, Block);
     return AST::FunctionDefinition(WTFMove(*functionDeclaration), WTFMove(*block));
 }
 
-auto Parser::parseEntryPointFunctionDeclaration() -> Expected<AST::FunctionDeclaration, Error>
-{
-    auto origin = peek();
-    if (!origin)
-        return Unexpected<Error>(origin.error());
-
-    AST::AttributeBlock attributeBlock;
-    AST::EntryPointType entryPointType;
-
-    auto parsedAttributeBlock = backtrackingScope<Expected<AST::AttributeBlock, Error>>([&]() {
-        return parseAttributeBlock();
-    });
-    if (parsedAttributeBlock) {
-        auto compute = consumeType(Lexer::Token::Type::Compute);
-        if (!compute)
-            return Unexpected<Error>(compute.error());
-        attributeBlock = WTFMove(*parsedAttributeBlock);
-        entryPointType = AST::EntryPointType::Compute;
-    } else {
-        auto type = consumeTypes({ Lexer::Token::Type::Vertex, Lexer::Token::Type::Fragment });
-        if (!type)
-            return Unexpected<Error>(type.error());
-
-        switch (origin->type) {
-        case Lexer::Token::Type::Vertex:
-            entryPointType = AST::EntryPointType::Vertex;
-            break;
-        default:
-            ASSERT(origin->type == Lexer::Token::Type::Fragment);
-            entryPointType = AST::EntryPointType::Fragment;
-            break;
-        }
-    }
-
-    auto type = parseType();
-    if (!type)
-        return Unexpected<Error>(type.error());
-
-    auto name = consumeType(Lexer::Token::Type::Identifier);
-    if (!name)
-        return Unexpected<Error>(name.error());
-
-    auto parameters = parseParameters();
-    if (!parameters)
-        return Unexpected<Error>(parameters.error());
-
+auto Parser::parseComputeFunctionDeclaration() -> Expected<AST::FunctionDeclaration, Error>
+{
+    PEEK(origin);
+
+    PARSE(attributeBlock, AttributeBlock);
+    CONSUME_TYPE(compute, Compute);
+    PARSE(type, Type);
+    CONSUME_TYPE(name, Identifier);
+    PARSE(parameters, Parameters);
+    PARSE(semantic, Semantic);
     bool isOperator = false;
-
-    if (tryType(Lexer::Token::Type::Colon)) {
-        auto semantic = parseSemantic();
-        if (!semantic)
-            return Unexpected<Error>(semantic.error());
-        return AST::FunctionDeclaration(WTFMove(*origin), WTFMove(attributeBlock), entryPointType, WTFMove(*type), name->stringView.toString(), WTFMove(*parameters), WTFMove(*semantic), isOperator);
-    }
-
-    return AST::FunctionDeclaration(WTFMove(*origin), WTFMove(attributeBlock), entryPointType, WTFMove(*type), name->stringView.toString(), WTFMove(*parameters), WTF::nullopt, isOperator);
+    return AST::FunctionDeclaration(WTFMove(*origin), WTFMove(*attributeBlock), AST::EntryPointType::Compute, WTFMove(*type), name->stringView.toString(), WTFMove(*parameters), WTFMove(*semantic), isOperator);
+}
+
+auto Parser::parseVertexOrFragmentFunctionDeclaration() -> Expected<AST::FunctionDeclaration, Error>
+{
+    auto entryPoint = consumeTypes({ Lexer::Token::Type::Vertex, Lexer::Token::Type::Fragment });
+    if (!entryPoint)
+        return Unexpected<Error>(entryPoint.error());
+    auto entryPointType = (entryPoint->type == Lexer::Token::Type::Vertex) ? AST::EntryPointType::Vertex : AST::EntryPointType::Fragment;
+
+    PARSE(type, Type);
+    CONSUME_TYPE(name, Identifier);
+    PARSE(parameters, Parameters);
+    PARSE(semantic, Semantic);
+
+    bool isOperator = false;
+    return AST::FunctionDeclaration(WTFMove(*entryPoint), { }, entryPointType, WTFMove(*type), name->stringView.toString(), WTFMove(*parameters), WTFMove(*semantic), isOperator);
 }
 
 auto Parser::parseRegularFunctionDeclaration() -> Expected<AST::FunctionDeclaration, Error>
 {
-    auto origin = peek();
-    if (!origin)
-        return Unexpected<Error>(origin.error());
-
-    auto type = parseType();
-    if (!type)
-        return Unexpected<Error>(type.error());
+    PEEK(origin);
+
+    PARSE(type, Type);
 
     auto name = consumeTypes({ Lexer::Token::Type::Identifier, Lexer::Token::Type::OperatorName });
@@ -1186 +958 @@
     auto isOperator = name->type == Lexer::Token::Type::OperatorName;
 
-    auto parameters = parseParameters();
-    if (!parameters)
-        return Unexpected<Error>(parameters.error());
-
-    if (tryType(Lexer::Token::Type::Colon)) {
-        auto semantic = parseSemantic();
-        if (!semantic)
-            return Unexpected<Error>(semantic.error());
-        return AST::FunctionDeclaration(WTFMove(*origin), { }, WTF::nullopt, WTFMove(*type), name->stringView.toString(), WTFMove(*parameters), WTFMove(*semantic), isOperator);
-    }
-
-    return AST::FunctionDeclaration(WTFMove(*origin), { }, WTF::nullopt, WTFMove(*type), name->stringView.toString(), WTFMove(*parameters), WTF::nullopt, isOperator);
+    PARSE(parameters, Parameters);
+    PARSE(semantic, Semantic);
+
+    return AST::FunctionDeclaration(WTFMove(*origin), { }, WTF::nullopt, WTFMove(*type), name->stringView.toString(), WTFMove(*parameters), WTFMove(*semantic), isOperator);
 }
 
 auto Parser::parseOperatorFunctionDeclaration() -> Expected<AST::FunctionDeclaration, Error>
 {
-    auto origin = consumeType(Lexer::Token::Type::Operator);
-    if (!origin)
-        return Unexpected<Error>(origin.error());
-
-    auto type = parseType();
-    if (!type)
-        return Unexpected<Error>(type.error());
-
-    auto parameters = parseParameters();
-    if (!parameters)
-        return Unexpected<Error>(parameters.error());
+    CONSUME_TYPE(origin, Operator);
+    PARSE(type, Type);
+    PARSE(parameters, Parameters);
+    PARSE(semantic, Semantic);
 
     bool isOperator = true;
-
-    if (tryType(Lexer::Token::Type::Colon)) {
-        auto semantic = parseSemantic();
-        if (!semantic)
-            return Unexpected<Error>(semantic.error());
-        return AST::FunctionDeclaration(WTFMove(*origin), { }, WTF::nullopt, WTFMove(*type), "operator cast"_str, WTFMove(*parameters), WTFMove(*semantic), isOperator);
-    }
-
-    return AST::FunctionDeclaration(WTFMove(*origin), { }, WTF::nullopt, WTFMove(*type), "operator cast"_str, WTFMove(*parameters), WTF::nullopt, isOperator);
+    return AST::FunctionDeclaration(WTFMove(*origin), { }, WTF::nullopt, WTFMove(*type), "operator cast"_str, WTFMove(*parameters), WTFMove(*semantic), isOperator);
 }
 
 auto Parser::parseFunctionDeclaration() -> Expected<AST::FunctionDeclaration, Error>
 {
-    auto entryPointFunctionDeclaration = backtrackingScope<Expected<AST::FunctionDeclaration, Error>>([&]() {
-        return parseEntryPointFunctionDeclaration();
-    });
-    if (entryPointFunctionDeclaration)
-        return WTFMove(*entryPointFunctionDeclaration);
-
-    auto regularFunctionDeclaration = backtrackingScope<Expected<AST::FunctionDeclaration, Error>>([&]() {
+    PEEK(token);
+    switch (token->type) {
+    case Lexer::Token::Type::Operator:
+        return parseOperatorFunctionDeclaration();
+    case Lexer::Token::Type::Vertex:
+    case Lexer::Token::Type::Fragment:
+        return parseVertexOrFragmentFunctionDeclaration();
+    case Lexer::Token::Type::LeftSquareBracket:
+        return parseComputeFunctionDeclaration();
+    default:
         return parseRegularFunctionDeclaration();
-    });
-    if (regularFunctionDeclaration)
-        return WTFMove(*regularFunctionDeclaration);
-
-    auto operatorFunctionDeclaration = backtrackingScope<Expected<AST::FunctionDeclaration, Error>>([&]() {
-        return parseOperatorFunctionDeclaration();
-    });
-    if (operatorFunctionDeclaration)
-        return WTFMove(*operatorFunctionDeclaration);
-
-    return Unexpected<Error>(operatorFunctionDeclaration.error());
+    }
 }
 
 auto Parser::parseNativeFunctionDeclaration() -> Expected<AST::NativeFunctionDeclaration, Error>
 {
-    Optional<Lexer::Token> origin;
-
-    auto native = consumeType(Lexer::Token::Type::Native);
-    if (!native)
-        return Unexpected<Error>(native.error());
-    if (!origin)
-        origin = *native;
-
-    auto functionDeclaration = parseFunctionDeclaration();
-    if (!functionDeclaration)
-        return Unexpected<Error>(functionDeclaration.error());
-
-    auto semicolon = consumeType(Lexer::Token::Type::Semicolon);
-    if (!semicolon)
-        return Unexpected<Error>(semicolon.error());
+    CONSUME_TYPE(native, Native);
+    PARSE(functionDeclaration, FunctionDeclaration);
+    CONSUME_TYPE(semicolon, Semicolon);
 
     return AST::NativeFunctionDeclaration(WTFMove(*functionDeclaration));
@@ -1272 +1002 @@
 auto Parser::parseBlock() -> Expected<AST::Block, Error>
 {
-    auto origin = consumeType(Lexer::Token::Type::LeftCurlyBracket);
-    if (!origin)
-        return Unexpected<Error>(origin.error());
-
-    auto result = parseBlockBody(WTFMove(*origin));
-
-    auto rightCurlyBracket = consumeType(Lexer::Token::Type::RightCurlyBracket);
-    if (!rightCurlyBracket)
-        return Unexpected<Error>(rightCurlyBracket.error());
-
-    return WTFMove(result);
-}
-
-AST::Block Parser::parseBlockBody(Lexer::Token&& origin)
+    CONSUME_TYPE(origin, LeftCurlyBracket);
+    PARSE(result, BlockBody, WTFMove(*origin));
+    CONSUME_TYPE(rightCurlyBracket, RightCurlyBracket);
+    return WTFMove(*result);
+}
+
+auto Parser::parseBlockBody(Lexer::Token&& origin) -> Expected<AST::Block, Error>
 {
     AST::Statements statements;
-    while (true) {
-        auto statement = backtrackingScope<Expected<UniqueRef<AST::Statement>, Error>>([&]() {
-            return parseStatement();
-        });
-        if (statement)
-            statements.append(WTFMove(*statement));
-        else
-            break;
+    while (!peekTypes({Lexer::Token::Type::RightCurlyBracket, Lexer::Token::Type::Case, Lexer::Token::Type::Default})) {
+        PARSE(statement, Statement);
+        statements.append(WTFMove(*statement));
     }
     return AST::Block(WTFMove(origin), WTFMove(statements));
@@ -1302 +1020 @@
 auto Parser::parseIfStatement() -> Expected<AST::IfStatement, Error>
 {
-    auto origin = consumeType(Lexer::Token::Type::If);
-    if (!origin)
-        return Unexpected<Error>(origin.error());
-
-    auto leftParenthesis = consumeType(Lexer::Token::Type::LeftParenthesis);
-    if (!leftParenthesis)
-        return Unexpected<Error>(leftParenthesis.error());
-
-    auto conditional = parseExpression();
-    if (!conditional)
-        return Unexpected<Error>(conditional.error());
-
-    auto rightParenthesis = consumeType(Lexer::Token::Type::RightParenthesis);
-    if (!rightParenthesis)
-        return Unexpected<Error>(rightParenthesis.error());
-
-    auto body = parseStatement();
-    if (!body)
-        return Unexpected<Error>(body.error());
+    CONSUME_TYPE(origin, If);
+    CONSUME_TYPE(leftParenthesis, LeftParenthesis);
+    PARSE(conditional, Expression);
+    CONSUME_TYPE(rightParenthesis, RightParenthesis);
+    PARSE(body, Statement);
 
     Optional<UniqueRef<AST::Statement>> elseBody;
     if (tryType(Lexer::Token::Type::Else)) {
-        auto parsedElseBody = parseStatement();
-        if (!parsedElseBody)
-            return Unexpected<Error>(parsedElseBody.error());
+        PARSE(parsedElseBody, Statement);
         elseBody = WTFMove(*parsedElseBody);
     }
@@ -1338 +1040 @@
 auto Parser::parseSwitchStatement() -> Expected<AST::SwitchStatement, Error>
 {
-    auto origin = consumeType(Lexer::Token::Type::Switch);
-    if (!origin)
-        return Unexpected<Error>(origin.error());
-
-    auto leftParenthesis = consumeType(Lexer::Token::Type::LeftParenthesis);
-    if (!leftParenthesis)
-        return Unexpected<Error>(leftParenthesis.error());
-
-    auto value = parseExpression();
-    if (!value)
-        return Unexpected<Error>(value.error());
-
-    auto rightParenthesis = consumeType(Lexer::Token::Type::RightParenthesis);
-    if (!rightParenthesis)
-        return Unexpected<Error>(rightParenthesis.error());
-
-    auto leftCurlyBracket = consumeType(Lexer::Token::Type::LeftCurlyBracket);
-    if (!leftCurlyBracket)
-        return Unexpected<Error>(leftCurlyBracket.error());
+    CONSUME_TYPE(origin, Switch);
+    CONSUME_TYPE(leftParenthesis, LeftParenthesis);
+    PARSE(value, Expression);
+    CONSUME_TYPE(rightParenthesis, RightParenthesis);
+    CONSUME_TYPE(leftCurlyBracket, LeftCurlyBracket);
 
     Vector<AST::SwitchCase> switchCases;
-    while (true) {
-        auto switchCase = backtrackingScope<Expected<AST::SwitchCase, Error>>([&]() {
-            return parseSwitchCase();
-        });
-        if (switchCase)
-            switchCases.append(WTFMove(*switchCase));
-        else
-            break;
-    }
-
-    auto rightCurlyBracket = consumeType(Lexer::Token::Type::RightCurlyBracket);
-    if (!rightCurlyBracket)
-        return Unexpected<Error>(rightCurlyBracket.error());
+    PEEK(nextToken);
+    while (nextToken->type != Lexer::Token::Type::RightCurlyBracket) {
+        PARSE(switchCase, SwitchCase);
+        switchCases.append(WTFMove(*switchCase));
+        PEEK(nextTokenInLoop);
+        nextToken = nextTokenInLoop;
+    }
+
+    m_lexer.consumeToken();
 
     return AST::SwitchStatement(WTFMove(*origin), WTFMove(*value), WTFMove(switchCases));
@@ -1384 +1068 @@
     switch (origin->type) {
     case Lexer::Token::Type::Case: {
-        auto value = parseConstantExpression();
-        if (!value)
-            return Unexpected<Error>(value.error());
-
-        auto origin = consumeType(Lexer::Token::Type::Colon);
-        if (!origin)
-            return Unexpected<Error>(origin.error());
-
-        auto block = parseBlockBody(Lexer::Token(*origin));
-
-        return AST::SwitchCase(WTFMove(*origin), WTFMove(*value), WTFMove(block));
+        PARSE(value, ConstantExpression);
+        CONSUME_TYPE(colon, Colon);
+
+        PARSE(block, BlockBody, Lexer::Token(*origin));
+
+        return AST::SwitchCase(WTFMove(*origin), WTFMove(*value), WTFMove(*block));
     }
     default: {
         ASSERT(origin->type == Lexer::Token::Type::Default);
-        auto origin = consumeType(Lexer::Token::Type::Colon);
-        if (!origin)
-            return Unexpected<Error>(origin.error());
-
-        auto block = parseBlockBody(Lexer::Token(*origin));
-
-        return AST::SwitchCase(WTFMove(*origin), WTF::nullopt, WTFMove(block));
+        CONSUME_TYPE(colon, Colon);
+
+        PARSE(block, BlockBody, Lexer::Token(*origin));
+
+        return AST::SwitchCase(WTFMove(*origin), WTF::nullopt, WTFMove(*block));
     }
     }
@@ -1411 +1088 @@
 auto Parser::parseForLoop() -> Expected<AST::ForLoop, Error>
 {
-    auto origin = consumeType(Lexer::Token::Type::For);
-    if (!origin)
-        return Unexpected<Error>(origin.error());
+    CONSUME_TYPE(origin, For);
+    CONSUME_TYPE(leftParenthesis, LeftParenthesis);
 
     auto parseRemainder = [&](Variant<UniqueRef<AST::Statement>, UniqueRef<AST::Expression>>&& initialization) -> Expected<AST::ForLoop, Error> {
-        auto semicolon = consumeType(Lexer::Token::Type::Semicolon);
-        if (!semicolon)
-            return Unexpected<Error>(semicolon.error());
-
-        auto condition = backtrackingScope<Optional<UniqueRef<AST::Expression>>>([&]() -> Optional<UniqueRef<AST::Expression>> {
+        CONSUME_TYPE(semicolon, Semicolon);
+
+        Optional<UniqueRef<AST::Expression>> condition = WTF::nullopt;
+        if (!tryType(Lexer::Token::Type::Semicolon)) {
             if (auto expression = parseExpression())
-                return { WTFMove(*expression) };
-            return WTF::nullopt;
-        });
-
-        semicolon = consumeType(Lexer::Token::Type::Semicolon);
-        if (!semicolon)
-            return Unexpected<Error>(semicolon.error());
-
-        auto increment = backtrackingScope<Optional<UniqueRef<AST::Expression>>>([&]() -> Optional<UniqueRef<AST::Expression>> {
+                condition = { WTFMove(*expression) };
+            else
+                return Unexpected<Error>(expression.error());
+            CONSUME_TYPE(secondSemicolon, Semicolon);
+        }
+
+        Optional<UniqueRef<AST::Expression>> increment = WTF::nullopt;
+        if (!tryType(Lexer::Token::Type::RightParenthesis)) {
             if (auto expression = parseExpression())
-                return { WTFMove(*expression) };
-            return WTF::nullopt;
-        });
-
-        auto rightParenthesis = consumeType(Lexer::Token::Type::RightParenthesis);
-        if (!rightParenthesis)
-            return Unexpected<Error>(rightParenthesis.error());
-
-        auto body = parseStatement();
-        if (!body)
-            return Unexpected<Error>(body.error());
+                increment = { WTFMove(*expression) };
+            else
+                return Unexpected<Error>(expression.error());
+            CONSUME_TYPE(rightParenthesis, RightParenthesis);
+        }
+
+        PARSE(body, Statement);
 
         return AST::ForLoop(WTFMove(*origin), WTFMove(initialization), WTFMove(condition), WTFMove(increment), WTFMove(*body));
     };
-
-    auto leftParenthesis = consumeType(Lexer::Token::Type::LeftParenthesis);
-    if (!leftParenthesis)
-        return Unexpected<Error>(leftParenthesis.error());
 
     auto variableDeclarations = backtrackingScope<Expected<AST::VariableDeclarationsStatement, Error>>([&]() {
@@ -1459 +1125 @@
     }
 
-    auto effectfulExpression = parseEffectfulExpression();
-    if (!effectfulExpression)
-        return Unexpected<Error>(effectfulExpression.error());
+    PARSE(effectfulExpression, EffectfulExpression);
 
     return parseRemainder(WTFMove(*effectfulExpression));
@@ -1468 +1132 @@
 auto Parser::parseWhileLoop() -> Expected<AST::WhileLoop, Error>
 {
-    auto origin = consumeType(Lexer::Token::Type::While);
-    if (!origin)
-        return Unexpected<Error>(origin.error());
-
-    auto leftParenthesis = consumeType(Lexer::Token::Type::LeftParenthesis);
-    if (!leftParenthesis)
-        return Unexpected<Error>(leftParenthesis.error());
-
-    auto conditional = parseExpression();
-    if (!conditional)
-        return Unexpected<Error>(conditional.error());
-
-    auto rightParenthesis = consumeType(Lexer::Token::Type::RightParenthesis);
-    if (!rightParenthesis)
-        return Unexpected<Error>(rightParenthesis.error());
-
-    auto body = parseStatement();
-    if (!body)
-        return Unexpected<Error>(body.error());
+    CONSUME_TYPE(origin, While);
+    CONSUME_TYPE(leftParenthesis, LeftParenthesis);
+    PARSE(conditional, Expression);
+    CONSUME_TYPE(rightParenthesis, RightParenthesis);
+    PARSE(body, Statement);
 
     return AST::WhileLoop(WTFMove(*origin), WTFMove(*conditional), WTFMove(*body));
@@ -1493 +1143 @@
 auto Parser::parseDoWhileLoop() -> Expected<AST::DoWhileLoop, Error>
 {
-    auto origin = consumeType(Lexer::Token::Type::Do);
-    if (!origin)
-        return Unexpected<Error>(origin.error());
-
-    auto body = parseStatement();
-    if (!body)
-        return Unexpected<Error>(body.error());
-
-    auto whileKeyword = consumeType(Lexer::Token::Type::While);
-    if (!whileKeyword)
-        return Unexpected<Error>(whileKeyword.error());
-
-    auto leftParenthesis = consumeType(Lexer::Token::Type::LeftParenthesis);
-    if (!leftParenthesis)
-        return Unexpected<Error>(leftParenthesis.error());
-
-    auto conditional = parseExpression();
-    if (!conditional)
-        return Unexpected<Error>(conditional.error());
-
-    auto rightParenthesis = consumeType(Lexer::Token::Type::RightParenthesis);
-    if (!rightParenthesis)
-        return Unexpected<Error>(rightParenthesis.error());
+    CONSUME_TYPE(origin, Do);
+    PARSE(body, Statement);
+    CONSUME_TYPE(whileKeyword, While);
+    CONSUME_TYPE(leftParenthesis, LeftParenthesis);
+    PARSE(conditional, Expression);
+    CONSUME_TYPE(rightParenthesis, RightParenthesis);
+    CONSUME_TYPE(semicolon, Semicolon);
 
     return AST::DoWhileLoop(WTFMove(*origin), WTFMove(*body), WTFMove(*conditional));
@@ -1522 +1156 @@
 auto Parser::parseVariableDeclaration(UniqueRef<AST::UnnamedType>&& type) -> Expected<AST::VariableDeclaration, Error>
 {
-    auto origin = peek();
-    if (!origin)
-        return Unexpected<Error>(origin.error());
+    PEEK(origin);
 
     auto qualifiers = parseQualifiers();
 
-    auto name = consumeType(Lexer::Token::Type::Identifier);
-    if (!name)
-        return Unexpected<Error>(name.error());
-
-    if (tryType(Lexer::Token::Type::Colon)) {
-        auto semantic = parseSemantic();
-        if (!semantic)
-            return Unexpected<Error>(semantic.error());
-
-        if (tryType(Lexer::Token::Type::EqualsSign)) {
-            auto initializer = parseExpression();
-            if (!initializer)
-                return Unexpected<Error>(initializer.error());
-            return AST::VariableDeclaration(WTFMove(*origin), WTFMove(qualifiers), { WTFMove(type) }, name->stringView.toString(), WTFMove(*semantic), WTFMove(*initializer));
-        }
-
-        return AST::VariableDeclaration(WTFMove(*origin), WTFMove(qualifiers), { WTFMove(type) }, name->stringView.toString(), WTFMove(*semantic), WTF::nullopt);
-    }
+    CONSUME_TYPE(name, Identifier);
+    PARSE(semantic, Semantic);
 
     if (tryType(Lexer::Token::Type::EqualsSign)) {
-        auto initializer = parseExpression();
-        if (!initializer)
-            return Unexpected<Error>(initializer.error());
-        return AST::VariableDeclaration(WTFMove(*origin), WTFMove(qualifiers), { WTFMove(type) }, name->stringView.toString(), WTF::nullopt, WTFMove(*initializer));
-    }
-
-    return AST::VariableDeclaration(WTFMove(*origin), WTFMove(qualifiers), { WTFMove(type) }, name->stringView.toString(), WTF::nullopt, WTF::nullopt);
+        PARSE(initializer, PossibleTernaryConditional);
+        return AST::VariableDeclaration(WTFMove(*origin), WTFMove(qualifiers), { WTFMove(type) }, name->stringView.toString(), WTFMove(*semantic), WTFMove(*initializer));
+    }
+
+    return AST::VariableDeclaration(WTFMove(*origin), WTFMove(qualifiers), { WTFMove(type) }, name->stringView.toString(), WTFMove(*semantic), WTF::nullopt);
 }
 
 auto Parser::parseVariableDeclarations() -> Expected<AST::VariableDeclarationsStatement, Error>
 {
-    auto origin = peek();
-    if (!origin)
-        return Unexpected<Error>(origin.error());
-
-    auto type = parseType();
-    if (!type)
-        return Unexpected<Error>(type.error());
+    PEEK(origin);
+
+    PARSE(type, Type);
 
     auto firstVariableDeclaration = parseVariableDeclaration((*type)->clone());
@@ -1586 +1196 @@
 auto Parser::parseStatement() -> Expected<UniqueRef<AST::Statement>, Error>
 {
+    PEEK(token);
+    switch (token->type) {
+    case Lexer::Token::Type::LeftCurlyBracket: {
+        PARSE(block, Block);
+        return { makeUniqueRef<AST::Block>(WTFMove(*block)) };
+    }
+    case Lexer::Token::Type::If: {
+        PARSE(ifStatement, IfStatement);
+        return { makeUniqueRef<AST::IfStatement>(WTFMove(*ifStatement)) };
+    }
+    case Lexer::Token::Type::Switch: {
+        PARSE(switchStatement, SwitchStatement);
+        return { makeUniqueRef<AST::SwitchStatement>(WTFMove(*switchStatement)) };
+    }
+    case Lexer::Token::Type::For: {
+        PARSE(forLoop, ForLoop);
+        return { makeUniqueRef<AST::ForLoop>(WTFMove(*forLoop)) };
+    }
+    case Lexer::Token::Type::While: {
+        PARSE(whileLoop, WhileLoop);
+        return { makeUniqueRef<AST::WhileLoop>(WTFMove(*whileLoop)) };
+    }
+    case Lexer::Token::Type::Do: {
+        PARSE(doWhileLoop, DoWhileLoop);
+        return { makeUniqueRef<AST::DoWhileLoop>(WTFMove(*doWhileLoop)) };
+    }
+    case Lexer::Token::Type::Break: {
+        auto breakToken = m_lexer.consumeToken();
+        CONSUME_TYPE(semicolon, Semicolon);
+        auto breakObject = AST::Break(WTFMove(*breakToken));
+        return { makeUniqueRef<AST::Break>(WTFMove(breakObject)) };
+    }
+    case Lexer::Token::Type::Continue: {
+        auto continueToken = m_lexer.consumeToken();
+        CONSUME_TYPE(semicolon, Semicolon);
+        auto continueObject = AST::Continue(WTFMove(*continueToken));
+        return { makeUniqueRef<AST::Continue>(WTFMove(continueObject)) };
+    }
+    case Lexer::Token::Type::Fallthrough: {
+        auto fallthroughToken = m_lexer.consumeToken();
+        CONSUME_TYPE(semicolon, Semicolon);
+        auto fallthroughObject = AST::Fallthrough(WTFMove(*fallthroughToken));
+        return { makeUniqueRef<AST::Fallthrough>(WTFMove(fallthroughObject)) };
+    }
+    case Lexer::Token::Type::Trap: {
+        auto trapToken = m_lexer.consumeToken();
+        CONSUME_TYPE(semicolon, Semicolon);
+        auto trapObject = AST::Trap(WTFMove(*trapToken));
+        return { makeUniqueRef<AST::Trap>(WTFMove(trapObject)) };
+    }
+    case Lexer::Token::Type::Return: {
+        auto returnToken = m_lexer.consumeToken();
+        if (auto semicolon = tryType(Lexer::Token::Type::Semicolon)) {
+            auto returnObject = AST::Return(WTFMove(*returnToken), WTF::nullopt);
+            return { makeUniqueRef<AST::Return>(WTFMove(returnObject)) };
+        }
+        PARSE(expression, Expression);
+        CONSUME_TYPE(finalSemicolon, Semicolon);
+        auto returnObject = AST::Return(WTFMove(*returnToken), { WTFMove(*expression) });
+        return { makeUniqueRef<AST::Return>(WTFMove(returnObject)) };
+    }
+    case Lexer::Token::Type::Constant:
+    case Lexer::Token::Type::Device:
+    case Lexer::Token::Type::Threadgroup:
+    case Lexer::Token::Type::Thread: {
+        PARSE(variableDeclarations, VariableDeclarations);
+        CONSUME_TYPE(semicolon, Semicolon);
+        return { makeUniqueRef<AST::VariableDeclarationsStatement>(WTFMove(*variableDeclarations)) };
+    }
+    case Lexer::Token::Type::Identifier: {
+        PEEK_FURTHER(nextToken);
+        switch (nextToken->type) {
+        case Lexer::Token::Type::Identifier:
+        case Lexer::Token::Type::LessThanSign:
+        case Lexer::Token::Type::Star:
+        case Lexer::Token::Type::Qualifier: {
+            PARSE(variableDeclarations, VariableDeclarations);
+            CONSUME_TYPE(semicolon, Semicolon);
+            return { makeUniqueRef<AST::VariableDeclarationsStatement>(WTFMove(*variableDeclarations)) };
+        }
+        default:
+            break;
+        }
+        break;
+    }
+    default:
+        break;
+    }
+
     {
-        auto block = backtrackingScope<Expected<AST::Block, Error>>([&]() {
-            return parseBlock();
-        });
-        if (block)
-            return { makeUniqueRef<AST::Block>(WTFMove(*block)) };
-    }
-
-    {
-        auto ifStatement = backtrackingScope<Expected<AST::IfStatement, Error>>([&]() {
-            return parseIfStatement();
-        });
-        if (ifStatement)
-            return { makeUniqueRef<AST::IfStatement>(WTFMove(*ifStatement)) };
-    }
-
-    {
-        auto switchStatement = backtrackingScope<Expected<AST::SwitchStatement, Error>>([&]() {
-            return parseSwitchStatement();
-        });
-        if (switchStatement)
-            return { makeUniqueRef<AST::SwitchStatement>(WTFMove(*switchStatement)) };
-    }
-
-    {
-        auto forLoop = backtrackingScope<Expected<AST::ForLoop, Error>>([&]() {
-            return parseForLoop();
-        });
-        if (forLoop)
-            return { makeUniqueRef<AST::ForLoop>(WTFMove(*forLoop)) };
-    }
-
-    {
-        auto whileLoop = backtrackingScope<Expected<AST::WhileLoop, Error>>([&]() {
-            return parseWhileLoop();
-        });
-        if (whileLoop)
-            return { makeUniqueRef<AST::WhileLoop>(WTFMove(*whileLoop)) };
-    }
-
-    {
-        auto doWhileLoop = backtrackingScope<Expected<AST::DoWhileLoop, Error>>([&]() -> Expected<AST::DoWhileLoop, Error> {
-            auto result = parseDoWhileLoop();
-            if (!result)
-                return Unexpected<Error>(result.error());
-
-            auto semicolon = consumeType(Lexer::Token::Type::Semicolon);
-            if (!semicolon)
-                return Unexpected<Error>(semicolon.error());
-
+        auto effectfulExpression = backtrackingScope<Expected<UniqueRef<AST::Expression>, Error>>([&]() -> Expected<UniqueRef<AST::Expression>, Error> {
+            PARSE(result, EffectfulExpression);
+            CONSUME_TYPE(semicolon, Semicolon);
             return result;
         });
-        if (doWhileLoop)
-            return { makeUniqueRef<AST::DoWhileLoop>(WTFMove(*doWhileLoop)) };
-    }
-
-    {
-        auto breakObject = backtrackingScope<Expected<AST::Break, Error>>([&]() -> Expected<AST::Break, Error> {
-            auto origin = consumeType(Lexer::Token::Type::Break);
-            if (!origin)
-                return Unexpected<Error>(origin.error());
-
-            auto semicolon = consumeType(Lexer::Token::Type::Semicolon);
-            if (!semicolon)
-                return Unexpected<Error>(semicolon.error());
-
-            return AST::Break(WTFMove(*origin));
-        });
-        if (breakObject)
-            return { makeUniqueRef<AST::Break>(WTFMove(*breakObject)) };
-    }
-
-    {
-        auto continueObject = backtrackingScope<Expected<AST::Continue, Error>>([&]() -> Expected<AST::Continue, Error> {
-            auto origin = consumeType(Lexer::Token::Type::Continue);
-            if (!origin)
-                return Unexpected<Error>(origin.error());
-
-            auto semicolon = consumeType(Lexer::Token::Type::Semicolon);
-            if (!semicolon)
-                return Unexpected<Error>(semicolon.error());
-
-            return AST::Continue(WTFMove(*origin));
-        });
-        if (continueObject)
-            return { makeUniqueRef<AST::Continue>(WTFMove(*continueObject)) };
-    }
-
-    {
-        auto fallthroughObject = backtrackingScope<Expected<AST::Fallthrough, Error>>([&]() -> Expected<AST::Fallthrough, Error> {
-            auto origin = consumeType(Lexer::Token::Type::Fallthrough);
-            if (!origin)
-                return Unexpected<Error>(origin.error());
-
-            auto semicolon = consumeType(Lexer::Token::Type::Semicolon);
-            if (!semicolon)
-                return Unexpected<Error>(semicolon.error());
-
-            return AST::Fallthrough(WTFMove(*origin));
-        });
-        if (fallthroughObject)
-            return { makeUniqueRef<AST::Fallthrough>(WTFMove(*fallthroughObject)) };
-    }
-
-    {
-        auto trapObject = backtrackingScope<Expected<AST::Trap, Error>>([&]() -> Expected<AST::Trap, Error> {
-            auto origin = consumeType(Lexer::Token::Type::Trap);
-            if (!origin)
-                return Unexpected<Error>(origin.error());
-
-            auto semicolon = consumeType(Lexer::Token::Type::Semicolon);
-            if (!semicolon)
-                return Unexpected<Error>(semicolon.error());
-
-            return AST::Trap(WTFMove(*origin));
-        });
-        if (trapObject)
-            return { makeUniqueRef<AST::Trap>(WTFMove(*trapObject)) };
-    }
-
-    {
-        auto returnObject = backtrackingScope<Expected<AST::Return, Error>>([&]() -> Expected<AST::Return, Error> {
-            auto origin = consumeType(Lexer::Token::Type::Return);
-            if (!origin)
-                return Unexpected<Error>(origin.error());
-
-            if (auto semicolon = tryType(Lexer::Token::Type::Semicolon))
-                return AST::Return(WTFMove(*origin), WTF::nullopt);
-
-            auto expression = parseExpression();
-            if (!expression)
-                return Unexpected<Error>(expression.error());
-
-            auto semicolon = consumeType(Lexer::Token::Type::Semicolon);
-            if (!semicolon)
-                return Unexpected<Error>(semicolon.error());
-
-            return AST::Return(WTFMove(*origin), { WTFMove(*expression) });
-        });
-        if (returnObject)
-            return { makeUniqueRef<AST::Return>(WTFMove(*returnObject)) };
-    }
-
-    {
-        auto variableDeclarations = backtrackingScope<Expected<AST::VariableDeclarationsStatement, Error>>([&]() -> Expected<AST::VariableDeclarationsStatement, Error> {
-            auto result = parseVariableDeclarations();
-            if (!result)
-                return Unexpected<Error>(result.error());
-
-            auto semicolon = consumeType(Lexer::Token::Type::Semicolon);
-            if (!semicolon)
-                return Unexpected<Error>(semicolon.error());
-
-            return result;
-        });
-        if (variableDeclarations)
-            return { makeUniqueRef<AST::VariableDeclarationsStatement>(WTFMove(*variableDeclarations)) };
-    }
-
-    auto effectfulExpression = backtrackingScope<Expected<UniqueRef<AST::Expression>, Error>>([&]() -> Expected<UniqueRef<AST::Expression>, Error> {
-        auto result = parseEffectfulExpression();
-        if (!result)
-            return Unexpected<Error>(result.error());
-
-        auto semicolon = consumeType(Lexer::Token::Type::Semicolon);
-        if (!semicolon)
-            return Unexpected<Error>(semicolon.error());
-
-        return result;
-    });
-    if (effectfulExpression)
-        return { makeUniqueRef<AST::EffectfulExpressionStatement>(WTFMove(*effectfulExpression)) };
-
-    return Unexpected<Error>(effectfulExpression.error());
+        if (effectfulExpression)
+            return { makeUniqueRef<AST::EffectfulExpressionStatement>(WTFMove(*effectfulExpression)) };
+    }
+
+    PARSE(variableDeclarations, VariableDeclarations);
+    CONSUME_TYPE(semicolon, Semicolon);
+    return { makeUniqueRef<AST::VariableDeclarationsStatement>(WTFMove(*variableDeclarations)) };
 }
 
 auto Parser::parseEffectfulExpression() -> Expected<UniqueRef<AST::Expression>, Error>
 {
-    auto origin = peek();
-    if (!origin)
-        return Unexpected<Error>(origin.error());
+    PEEK(origin);
 
     Vector<UniqueRef<AST::Expression>> expressions;
-
-    auto first = backtrackingScope<Optional<UniqueRef<AST::Expression>>>([&]() -> Optional<UniqueRef<AST::Expression>> {
-        auto effectfulExpression = parseEffectfulAssignment();
-        if (!effectfulExpression)
-            return WTF::nullopt;
-        return { WTFMove(*effectfulExpression) };
-    });
-    if (!first)
+    if (origin->type == Lexer::Token::Type::Semicolon)
         return { makeUniqueRef<AST::CommaExpression>(WTFMove(*origin), WTFMove(expressions)) };
 
-    expressions.append(WTFMove(*first));
+    PARSE(effectfulExpression, EffectfulAssignment);
+    expressions.append(WTFMove(*effectfulExpression));
 
     while (tryType(Lexer::Token::Type::Comma)) {
-        auto expression = parseEffectfulAssignment();
-        if (!expression)
-            return Unexpected<Error>(expression.error());
+        PARSE(expression, EffectfulAssignment);
         expressions.append(WTFMove(*expression));
     }
@@ -1795 +1323 @@
 auto Parser::parseEffectfulAssignment() -> Expected<UniqueRef<AST::Expression>, Error>
 {
-    auto assignment = backtrackingScope<Expected<UniqueRef<AST::Expression>, Error>>([&]() {
-        return parseAssignment();
-    });
-    if (assignment)
-        return assignment;
-
-    assignment = backtrackingScope<Expected<UniqueRef<AST::Expression>, Error>>([&]() {
-        return parseEffectfulPrefix();
-    });
-    if (assignment)
-        return assignment;
-
-    return Unexpected<Error>(assignment.error());
-}
-
-auto Parser::parseEffectfulPrefix() -> Expected<UniqueRef<AST::Expression>, Error>
-{
-    auto prefix = consumeTypes({ Lexer::Token::Type::PlusPlus, Lexer::Token::Type::MinusMinus });
-    if (!prefix)
-        return parseEffectfulSuffix();
-
-    auto previous = parsePossiblePrefix();
-    if (!previous)
-        return Unexpected<Error>(previous.error());
-
-    switch (prefix->type) {
-    case Lexer::Token::Type::PlusPlus: {
-        auto result = AST::ReadModifyWriteExpression::create(Lexer::Token(*prefix), WTFMove(*previous));
-        Vector<UniqueRef<AST::Expression>> callArguments;
-        callArguments.append(result->oldVariableReference());
-        result->setNewValueExpression(makeUniqueRef<AST::CallExpression>(WTFMove(*prefix), "operator++"_str, WTFMove(callArguments)));
-        result->setResultExpression(result->newVariableReference());
-        return { WTFMove(result) };
-    }
-    default: {
-        ASSERT(prefix->type == Lexer::Token::Type::MinusMinus);
-        auto result = AST::ReadModifyWriteExpression::create(Lexer::Token(*prefix), WTFMove(*previous));
-        Vector<UniqueRef<AST::Expression>> callArguments;
-        callArguments.append(result->oldVariableReference());
-        result->setNewValueExpression(makeUniqueRef<AST::CallExpression>(WTFMove(*prefix), "operator--"_str, WTFMove(callArguments)));
-        result->setResultExpression(result->newVariableReference());
-        return { WTFMove(result) };
-    }
-    }
-}
-
-auto Parser::parseEffectfulSuffix() -> Expected<UniqueRef<AST::Expression>, Error>
-{
-    auto effectfulSuffix = backtrackingScope<Expected<UniqueRef<AST::Expression>, Error>>([&]() -> Expected<UniqueRef<AST::Expression>, Error> {
-        auto previous = parsePossibleSuffix();
-        if (!previous)
-            return Unexpected<Error>(previous.error());
-
-        auto suffix = consumeTypes({ Lexer::Token::Type::PlusPlus, Lexer::Token::Type::MinusMinus });
-        if (!suffix)
-            return Unexpected<Error>(suffix.error());
-
-        switch (suffix->type) {
-        case Lexer::Token::Type::PlusPlus: {
-            auto result = AST::ReadModifyWriteExpression::create(Lexer::Token(*suffix), WTFMove(*previous));
-            Vector<UniqueRef<AST::Expression>> callArguments;
-            callArguments.append(result->oldVariableReference());
-            result->setNewValueExpression(makeUniqueRef<AST::CallExpression>(WTFMove(*suffix), "operator++"_str, WTFMove(callArguments)));
-            result->setResultExpression(result->oldVariableReference());
-            return { WTFMove(result) };
-        }
-        default: {
-            ASSERT(suffix->type == Lexer::Token::Type::MinusMinus);
-            auto result = AST::ReadModifyWriteExpression::create(Lexer::Token(*suffix), WTFMove(*previous));
-            Vector<UniqueRef<AST::Expression>> callArguments;
-            callArguments.append(result->oldVariableReference());
-            result->setNewValueExpression(makeUniqueRef<AST::CallExpression>(WTFMove(*suffix), "operator--"_str, WTFMove(callArguments)));
-            result->setResultExpression(result->oldVariableReference());
-            return { WTFMove(result) };
-        }
-        }
-    });
-    if (effectfulSuffix)
-        return effectfulSuffix;
-
-    effectfulSuffix = backtrackingScope<Expected<UniqueRef<AST::Expression>, Error>>([&]() {
-        return parseCallExpression();
-    });
-    if (effectfulSuffix)
-        return effectfulSuffix;
-
-    effectfulSuffix = backtrackingScope<Expected<UniqueRef<AST::Expression>, Error>>([&]() -> Expected<UniqueRef<AST::Expression>, Error> {
-        auto leftParenthesis = consumeType(Lexer::Token::Type::LeftParenthesis);
-        if (!leftParenthesis)
-            return Unexpected<Error>(leftParenthesis.error());
-
-        auto expression = parseExpression();
-        if (!expression)
-            return Unexpected<Error>(expression.error());
-
-        auto rightParenthesis = consumeType(Lexer::Token::Type::RightParenthesis);
-        if (!rightParenthesis)
-            return Unexpected<Error>(rightParenthesis.error());
-
-        return { WTFMove(*expression) };
-    });
-    if (effectfulSuffix)
-        return effectfulSuffix;
-
-    return Unexpected<Error>(effectfulSuffix.error());
+    PEEK(origin);
+
+    bool isEffectful = false;
+    PARSE(expression, PossiblePrefix, &isEffectful);
+
+    if (!isEffectful || peekTypes({
+        Lexer::Token::Type::EqualsSign,
+        Lexer::Token::Type::PlusEquals,
+        Lexer::Token::Type::MinusEquals,
+        Lexer::Token::Type::TimesEquals,
+        Lexer::Token::Type::DivideEquals,
+        Lexer::Token::Type::ModEquals,
+        Lexer::Token::Type::XorEquals,
+        Lexer::Token::Type::AndEquals,
+        Lexer::Token::Type::OrEquals,
+        Lexer::Token::Type::RightShiftEquals,
+        Lexer::Token::Type::LeftShiftEquals
+    })) {
+        return completeAssignment(WTFMove(*origin), WTFMove(*expression));
+    }
+
+    return expression;
 }
 
@@ -1982 +1427 @@
 auto Parser::parseExpression() -> Expected<UniqueRef<AST::Expression>, Error>
 {
-    auto origin = peek();
-    if (!origin)
-        return Unexpected<Error>(origin.error());
-
-    auto first = parsePossibleTernaryConditional();
-    if (!first)
-        return Unexpected<Error>(first.error());
-
+    PEEK(origin);
+
+    PARSE(first, PossibleTernaryConditional);
     Vector<UniqueRef<AST::Expression>> expressions;
     expressions.append(WTFMove(*first));
 
     while (tryType(Lexer::Token::Type::Comma)) {
-        auto expression = parsePossibleTernaryConditional();
-        if (!expression)
-            return Unexpected<Error>(expression.error());
+        PARSE(expression, PossibleTernaryConditional);
         expressions.append(WTFMove(*expression));
     }
@@ -2005 +1443 @@
 }
 
-auto Parser::parseTernaryConditional() -> Expected<UniqueRef<AST::Expression>, Error>
-{
-    auto origin = peek();
-    if (!origin)
-        return Unexpected<Error>(origin.error());
-
-    auto predicate = parsePossibleLogicalBinaryOperation();
-    if (!predicate)
-        return Unexpected<Error>(predicate.error());
-
-    auto questionMark = consumeType(Lexer::Token::Type::QuestionMark);
-    if (!questionMark)
-        return Unexpected<Error>(questionMark.error());
-
-    auto bodyExpression = parseExpression();
-    if (!bodyExpression)
-        return Unexpected<Error>(bodyExpression.error());
-
-    auto colon = consumeType(Lexer::Token::Type::Colon);
-    if (!colon)
-        return Unexpected<Error>(colon.error());
-
-    auto elseExpression = parsePossibleTernaryConditional();
-    if (!elseExpression)
-        return Unexpected<Error>(elseExpression.error());
+auto Parser::completeTernaryConditional(Lexer::Token&& origin, UniqueRef<AST::Expression>&& predicate) -> Expected<UniqueRef<AST::Expression>, Error>
+{
+    CONSUME_TYPE(questionMark, QuestionMark);
+    PARSE(bodyExpression, Expression);
+    CONSUME_TYPE(colon, Colon);
+    PARSE(elseExpression, PossibleTernaryConditional);
 
     Vector<UniqueRef<AST::Expression>> castArguments;
-    castArguments.append(WTFMove(*predicate));
-    auto boolCast = makeUniqueRef<AST::CallExpression>(Lexer::Token(*origin), "bool"_str, WTFMove(castArguments));
-    return { makeUniqueRef<AST::TernaryExpression>(WTFMove(*origin), WTFMove(boolCast), WTFMove(*bodyExpression), WTFMove(*elseExpression)) };
-}
-
-auto Parser::parseAssignment() -> Expected<UniqueRef<AST::Expression>, Error>
-{
-    auto origin = peek();
-    if (!origin)
-        return Unexpected<Error>(origin.error());
-
-    auto left = parsePossiblePrefix();
-    if (!left)
-        return Unexpected<Error>(left.error());
-
+    castArguments.append(WTFMove(predicate));
+    auto boolCast = makeUniqueRef<AST::CallExpression>(Lexer::Token(origin), "bool"_str, WTFMove(castArguments));
+    return { makeUniqueRef<AST::TernaryExpression>(WTFMove(origin), WTFMove(boolCast), WTFMove(*bodyExpression), WTFMove(*elseExpression)) };
+}
+
+auto Parser::completeAssignment(Lexer::Token&& origin, UniqueRef<AST::Expression>&& left) -> Expected<UniqueRef<AST::Expression>, Error>
+{
     auto assignmentOperator = consumeTypes({
         Lexer::Token::Type::EqualsSign,
@@ -2063 +1474 @@
         return Unexpected<Error>(assignmentOperator.error());
 
-    auto right = parsePossibleTernaryConditional();
-    if (!right)
-        return Unexpected<Error>(right.error());
+    PARSE(right, PossibleTernaryConditional);
 
     if (assignmentOperator->type == Lexer::Token::Type::EqualsSign)
-        return { makeUniqueRef<AST::AssignmentExpression>(WTFMove(*origin), WTFMove(*left), WTFMove(*right))};
+        return { makeUniqueRef<AST::AssignmentExpression>(WTFMove(origin), WTFMove(left), WTFMove(*right))};
 
     String name;
@@ -2105 +1514 @@
     }
 
-    auto result = AST::ReadModifyWriteExpression::create(Lexer::Token(*origin), WTFMove(*left));
+    auto result = AST::ReadModifyWriteExpression::create(Lexer::Token(origin), WTFMove(left));
     Vector<UniqueRef<AST::Expression>> callArguments;
     callArguments.append(result->oldVariableReference());
     callArguments.append(WTFMove(*right));
-    result->setNewValueExpression(makeUniqueRef<AST::CallExpression>(WTFMove(*origin), WTFMove(name), WTFMove(callArguments)));
+    result->setNewValueExpression(makeUniqueRef<AST::CallExpression>(WTFMove(origin), WTFMove(name), WTFMove(callArguments)));
     result->setResultExpression(result->newVariableReference());
     return { WTFMove(result) };
@@ -2116 +1525 @@
 auto Parser::parsePossibleTernaryConditional() -> Expected<UniqueRef<AST::Expression>, Error>
 {
-    auto ternaryExpression = backtrackingScope<Expected<UniqueRef<AST::Expression>, Error>>([&]() {
-        return parseTernaryConditional();
-    });
-    if (ternaryExpression)
-        return ternaryExpression;
-
-    auto assignmentExpression = backtrackingScope<Expected<UniqueRef<AST::Expression>, Error>>([&]() {
-        return parseAssignment();
-    });
-    if (assignmentExpression)
-        return assignmentExpression;
-
-    auto binaryOperation = backtrackingScope<Expected<UniqueRef<AST::Expression>, Error>>([&]() {
-        return parsePossibleLogicalBinaryOperation();
-    });
-    if (binaryOperation)
-        return binaryOperation;
-
-    return Unexpected<Error>(binaryOperation.error());
+    PEEK(origin);
+
+    PARSE(expression, PossiblePrefix);
+
+    if (peekTypes({Lexer::Token::Type::EqualsSign,
+        Lexer::Token::Type::PlusEquals,
+        Lexer::Token::Type::MinusEquals,
+        Lexer::Token::Type::TimesEquals,
+        Lexer::Token::Type::DivideEquals,
+        Lexer::Token::Type::ModEquals,
+        Lexer::Token::Type::XorEquals,
+        Lexer::Token::Type::AndEquals,
+        Lexer::Token::Type::OrEquals,
+        Lexer::Token::Type::RightShiftEquals,
+        Lexer::Token::Type::LeftShiftEquals})) {
+        return completeAssignment(WTFMove(*origin), WTFMove(*expression));
+    }
+
+    expression = completePossibleShift(WTFMove(*expression));
+    expression = completePossibleMultiply(WTFMove(*expression));
+    expression = completePossibleAdd(WTFMove(*expression));
+    expression = completePossibleRelationalBinaryOperation(WTFMove(*expression));
+    expression = completePossibleLogicalBinaryOperation(WTFMove(*expression));
+
+    PEEK(nextToken);
+    if (nextToken->type == Lexer::Token::Type::QuestionMark)
+        return completeTernaryConditional(WTFMove(*origin), WTFMove(*expression));
+    return expression;
 }
 
 auto Parser::parsePossibleLogicalBinaryOperation() -> Expected<UniqueRef<AST::Expression>, Error>
 {
-    auto parsedPrevious = parsePossibleRelationalBinaryOperation();
-    if (!parsedPrevious)
-        return Unexpected<Error>(parsedPrevious.error());
-    UniqueRef<AST::Expression> previous = WTFMove(*parsedPrevious);
-
+    PARSE(parsedPrevious, PossibleRelationalBinaryOperation);
+    return completePossibleLogicalBinaryOperation(WTFMove(*parsedPrevious));
+}
+
+auto Parser::completePossibleLogicalBinaryOperation(UniqueRef<AST::Expression>&& previous) -> Expected<UniqueRef<AST::Expression>, Error>
+{
     while (auto logicalBinaryOperation = tryTypes({
         Lexer::Token::Type::OrOr,
@@ -2151 +1570 @@
         Lexer::Token::Type::And
         })) {
-        auto next = parsePossibleRelationalBinaryOperation();
-        if (!next)
-            return Unexpected<Error>(next.error());
+        PARSE(next, PossibleRelationalBinaryOperation);
 
         switch (logicalBinaryOperation->type) {
@@ -2192 +1609 @@
 auto Parser::parsePossibleRelationalBinaryOperation() -> Expected<UniqueRef<AST::Expression>, Error>
 {
-    auto parsedPrevious = parsePossibleShift();
-    if (!parsedPrevious)
-        return Unexpected<Error>(parsedPrevious.error());
-    UniqueRef<AST::Expression> previous = WTFMove(*parsedPrevious);
-
+    PARSE(parsedPrevious, PossibleShift);
+    return completePossibleRelationalBinaryOperation(WTFMove(*parsedPrevious));
+}
+
+auto Parser::completePossibleRelationalBinaryOperation(UniqueRef<AST::Expression>&& previous) -> Expected<UniqueRef<AST::Expression>, Error>
+{
     while (auto relationalBinaryOperation = tryTypes({
         Lexer::Token::Type::LessThanSign,
@@ -2205 +1623 @@
         Lexer::Token::Type::NotEqual
         })) {
-        auto next = parsePossibleShift();
-        if (!next)
-            return Unexpected<Error>(next.error());
+        PARSE(next, PossibleShift);
+
+        Vector<UniqueRef<AST::Expression>> callArguments;
+        callArguments.append(WTFMove(previous));
+        callArguments.append(WTFMove(*next));
 
         switch (relationalBinaryOperation->type) {
         case Lexer::Token::Type::LessThanSign: {
-            Vector<UniqueRef<AST::Expression>> callArguments;
-            callArguments.append(WTFMove(previous));
-            callArguments.append(WTFMove(*next));
             previous = makeUniqueRef<AST::CallExpression>(WTFMove(*relationalBinaryOperation), "operator<"_str, WTFMove(callArguments));
             break;
         }
         case Lexer::Token::Type::GreaterThanSign: {
-            Vector<UniqueRef<AST::Expression>> callArguments;
-            callArguments.append(WTFMove(previous));
-            callArguments.append(WTFMove(*next));
             previous = makeUniqueRef<AST::CallExpression>(WTFMove(*relationalBinaryOperation), "operator>"_str, WTFMove(callArguments));
             break;
         }
         case Lexer::Token::Type::LessThanOrEqualTo: {
-            Vector<UniqueRef<AST::Expression>> callArguments;
-            callArguments.append(WTFMove(previous));
-            callArguments.append(WTFMove(*next));
             previous = makeUniqueRef<AST::CallExpression>(WTFMove(*relationalBinaryOperation), "operator<="_str, WTFMove(callArguments));
             break;
         }
         case Lexer::Token::Type::GreaterThanOrEqualTo: {
-            Vector<UniqueRef<AST::Expression>> callArguments;
-            callArguments.append(WTFMove(previous));
-            callArguments.append(WTFMove(*next));
             previous = makeUniqueRef<AST::CallExpression>(WTFMove(*relationalBinaryOperation), "operator>="_str, WTFMove(callArguments));
             break;
         }
         case Lexer::Token::Type::EqualComparison: {
-            Vector<UniqueRef<AST::Expression>> callArguments;
-            callArguments.append(WTFMove(previous));
-            callArguments.append(WTFMove(*next));
             previous = makeUniqueRef<AST::CallExpression>(WTFMove(*relationalBinaryOperation), "operator=="_str, WTFMove(callArguments));
             break;
@@ -2247 +1652 @@
         default: {
             ASSERT(relationalBinaryOperation->type == Lexer::Token::Type::NotEqual);
-            Vector<UniqueRef<AST::Expression>> callArguments;
-            callArguments.append(WTFMove(previous));
-            callArguments.append(WTFMove(*next));
             previous = makeUniqueRef<AST::CallExpression>(Lexer::Token(*relationalBinaryOperation), "operator=="_str, WTFMove(callArguments));
             previous = makeUniqueRef<AST::LogicalNotExpression>(WTFMove(*relationalBinaryOperation), WTFMove(previous));
@@ -2262 +1664 @@
 auto Parser::parsePossibleShift() -> Expected<UniqueRef<AST::Expression>, Error>
 {
-    auto parsedPrevious = parsePossibleAdd();
-    if (!parsedPrevious)
-        return Unexpected<Error>(parsedPrevious.error());
-    UniqueRef<AST::Expression> previous = WTFMove(*parsedPrevious);
-
+    PARSE(parsedPrevious, PossibleAdd);
+    return completePossibleShift(WTFMove(*parsedPrevious));
+}
+
+auto Parser::completePossibleShift(UniqueRef<AST::Expression>&& previous) -> Expected<UniqueRef<AST::Expression>, Error>
+{
     while (auto shift = tryTypes({
         Lexer::Token::Type::LeftShift,
         Lexer::Token::Type::RightShift
         })) {
-        auto next = parsePossibleAdd();
-        if (!next)
-            return Unexpected<Error>(next.error());
+        PARSE(next, PossibleAdd);
+
+        Vector<UniqueRef<AST::Expression>> callArguments;
+        callArguments.append(WTFMove(previous));
+        callArguments.append(WTFMove(*next));
 
         switch (shift->type) {
         case Lexer::Token::Type::LeftShift: {
-            Vector<UniqueRef<AST::Expression>> callArguments;
-            callArguments.append(WTFMove(previous));
-            callArguments.append(WTFMove(*next));
             previous = makeUniqueRef<AST::CallExpression>(WTFMove(*shift), "operator<<"_str, WTFMove(callArguments));
             break;
@@ -2285 +1687 @@
         default: {
             ASSERT(shift->type == Lexer::Token::Type::RightShift);
-            Vector<UniqueRef<AST::Expression>> callArguments;
-            callArguments.append(WTFMove(previous));
-            callArguments.append(WTFMove(*next));
             previous = makeUniqueRef<AST::CallExpression>(WTFMove(*shift), "operator>>"_str, WTFMove(callArguments));
             break;
@@ -2299 +1698 @@
 auto Parser::parsePossibleAdd() -> Expected<UniqueRef<AST::Expression>, Error>
 {
-    auto parsedPrevious = parsePossibleMultiply();
-    if (!parsedPrevious)
-        return Unexpected<Error>(parsedPrevious.error());
-    UniqueRef<AST::Expression> previous = WTFMove(*parsedPrevious);
-
+    PARSE(parsedPrevious, PossibleMultiply);
+    return completePossibleAdd(WTFMove(*parsedPrevious));
+}
+
+auto Parser::completePossibleAdd(UniqueRef<AST::Expression>&& previous) -> Expected<UniqueRef<AST::Expression>, Error>
+{
     while (auto add = tryTypes({
         Lexer::Token::Type::Plus,
         Lexer::Token::Type::Minus
         })) {
-        auto next = parsePossibleMultiply();
-        if (!next)
-            return Unexpected<Error>(next.error());
+        PARSE(next, PossibleMultiply);
+
+        Vector<UniqueRef<AST::Expression>> callArguments;
+        callArguments.append(WTFMove(previous));
+        callArguments.append(WTFMove(*next));
 
         switch (add->type) {
         case Lexer::Token::Type::Plus: {
-            Vector<UniqueRef<AST::Expression>> callArguments;
-            callArguments.append(WTFMove(previous));
-            callArguments.append(WTFMove(*next));
             previous = makeUniqueRef<AST::CallExpression>(WTFMove(*add), "operator+"_str, WTFMove(callArguments));
             break;
@@ -2322 +1721 @@
         default: {
             ASSERT(add->type == Lexer::Token::Type::Minus);
-            Vector<UniqueRef<AST::Expression>> callArguments;
-            callArguments.append(WTFMove(previous));
-            callArguments.append(WTFMove(*next));
             previous = makeUniqueRef<AST::CallExpression>(WTFMove(*add), "operator-"_str, WTFMove(callArguments));
             break;
@@ -2336 +1732 @@
 auto Parser::parsePossibleMultiply() -> Expected<UniqueRef<AST::Expression>, Error>
 {
-    auto parsedPrevious = parsePossiblePrefix();
-    if (!parsedPrevious)
-        return Unexpected<Error>(parsedPrevious.error());
-    UniqueRef<AST::Expression> previous = WTFMove(*parsedPrevious);
-
+    PARSE(parsedPrevious, PossiblePrefix);
+    return completePossibleMultiply(WTFMove(*parsedPrevious));
+}
+
+auto Parser::completePossibleMultiply(UniqueRef<AST::Expression>&& previous) -> Expected<UniqueRef<AST::Expression>, Error>
+{
     while (auto multiply = tryTypes({
         Lexer::Token::Type::Star,
@@ -2346 +1743 @@
         Lexer::Token::Type::Mod
         })) {
-        auto next = parsePossiblePrefix();
-        if (!next)
-            return Unexpected<Error>(next.error());
+        PARSE(next, PossiblePrefix);
+
+        Vector<UniqueRef<AST::Expression>> callArguments;
+        callArguments.append(WTFMove(previous));
+        callArguments.append(WTFMove(*next));
 
         switch (multiply->type) {
         case Lexer::Token::Type::Star: {
-            Vector<UniqueRef<AST::Expression>> callArguments;
-            callArguments.append(WTFMove(previous));
-            callArguments.append(WTFMove(*next));
             previous = makeUniqueRef<AST::CallExpression>(WTFMove(*multiply), "operator*"_str, WTFMove(callArguments));
             break;
         }
         case Lexer::Token::Type::Divide: {
-            Vector<UniqueRef<AST::Expression>> callArguments;
-            callArguments.append(WTFMove(previous));
-            callArguments.append(WTFMove(*next));
             previous = makeUniqueRef<AST::CallExpression>(WTFMove(*multiply), "operator/"_str, WTFMove(callArguments));
             break;
@@ -2367 +1760 @@
         default: {
             ASSERT(multiply->type == Lexer::Token::Type::Mod);
-            Vector<UniqueRef<AST::Expression>> callArguments;
-            callArguments.append(WTFMove(previous));
-            callArguments.append(WTFMove(*next));
             previous = makeUniqueRef<AST::CallExpression>(WTFMove(*multiply), "operator%"_str, WTFMove(callArguments));
             break;
@@ -2379 +1769 @@
 }
 
-auto Parser::parsePossiblePrefix() -> Expected<UniqueRef<AST::Expression>, Error>
+auto Parser::parsePossiblePrefix(bool *isEffectful) -> Expected<UniqueRef<AST::Expression>, Error>
 {
     if (auto prefix = tryTypes({
@@ -2392 +1782 @@
         Lexer::Token::Type::Star
     })) {
-        auto next = parsePossiblePrefix();
-        if (!next)
-            return Unexpected<Error>(next.error());
+        PARSE(next, PossiblePrefix);
 
         switch (prefix->type) {
         case Lexer::Token::Type::PlusPlus: {
+            if (isEffectful)
+                *isEffectful = true;
             auto result = AST::ReadModifyWriteExpression::create(Lexer::Token(*prefix), WTFMove(*next));
             Vector<UniqueRef<AST::Expression>> callArguments;
@@ -2406 +1796 @@
         }
         case Lexer::Token::Type::MinusMinus: {
+            if (isEffectful)
+                *isEffectful = true;
             auto result = AST::ReadModifyWriteExpression::create(Lexer::Token(*prefix), WTFMove(*next));
             Vector<UniqueRef<AST::Expression>> callArguments;
@@ -2444 +1836 @@
     }
 
-    return parsePossibleSuffix();
-}
-
-auto Parser::parsePossibleSuffix() -> Expected<UniqueRef<AST::Expression>, Error>
-{
-    auto suffix = backtrackingScope<Expected<UniqueRef<AST::Expression>, Error>>([&]() -> Expected<UniqueRef<AST::Expression>, Error> {
-        auto expression = parseCallExpression();
-        if (!expression)
-            return Unexpected<Error>(expression.error());
-
+    return parsePossibleSuffix(isEffectful);
+}
+
+auto Parser::parsePossibleSuffix(bool *isEffectful) -> Expected<UniqueRef<AST::Expression>, Error>
+{
+    PEEK(token);
+    PEEK_FURTHER(nextToken);
+
+    if (token->type == Lexer::Token::Type::Identifier && nextToken->type == Lexer::Token::Type::LeftParenthesis) {
+        PARSE(expression, CallExpression);
+        if (isEffectful)
+            *isEffectful = true;
         while (true) {
-            auto result = backtrackingScope<SuffixExpression>([&]() -> SuffixExpression {
-                return parseLimitedSuffixOperator(WTFMove(*expression));
-            });
+            PEEK(suffixToken);
+            if (suffixToken->type != Lexer::Token::Type::FullStop && suffixToken->type != Lexer::Token::Type::Arrow && suffixToken->type != Lexer::Token::Type::LeftSquareBracket)
+                break;
+            auto result = parseLimitedSuffixOperator(WTFMove(*expression));
             expression = WTFMove(result.result);
-            if (!result)
-                break;
         }
         return expression;
-    });
-    if (suffix)
-        return suffix;
-
-    suffix = backtrackingScope<Expected<UniqueRef<AST::Expression>, Error>>([&]() -> Expected<UniqueRef<AST::Expression>, Error> {
-        auto expression = parseTerm();
-        if (!expression)
-            return Unexpected<Error>(expression.error());
-
-        while (true) {
-            auto result = backtrackingScope<SuffixExpression>([&]() -> SuffixExpression {
-                return parseSuffixOperator(WTFMove(*expression));
-            });
-            expression = WTFMove(result.result);
-            if (!result)
-                break;
-        }
-        return expression;
-    });
-    if (suffix)
-        return suffix;
-
-    return Unexpected<Error>(suffix.error());
+    }
+
+    if (token->type == Lexer::Token::Type::LeftParenthesis && isEffectful)
+        *isEffectful = true;
+
+    PARSE(expression, Term);
+    bool isLastSuffixTokenEffectful = false;
+    while (true) {
+        PEEK(suffixToken);
+        if (suffixToken->type != Lexer::Token::Type::FullStop
+            && suffixToken->type != Lexer::Token::Type::Arrow
+            && suffixToken->type != Lexer::Token::Type::LeftSquareBracket
+            && suffixToken->type != Lexer::Token::Type::PlusPlus
+            && suffixToken->type != Lexer::Token::Type::MinusMinus) {
+            break;
+        }
+        isLastSuffixTokenEffectful = suffixToken->type == Lexer::Token::Type::PlusPlus || suffixToken->type == Lexer::Token::Type::MinusMinus;
+        auto result = parseSuffixOperator(WTFMove(*expression));
+        expression = WTFMove(result.result);
+    }
+    if (isLastSuffixTokenEffectful && isEffectful)
+        *isEffectful = true;
+    return expression;
 }
 
 auto Parser::parseCallExpression() -> Expected<UniqueRef<AST::Expression>, Error>
 {
-    auto name = consumeType(Lexer::Token::Type::Identifier);
-    if (!name)
-        return Unexpected<Error>(name.error());
+    CONSUME_TYPE(name, Identifier);
     auto callName = name->stringView.toString();
 
-    auto leftParenthesis = consumeType(Lexer::Token::Type::LeftParenthesis);
-    if (!leftParenthesis)
-        return Unexpected<Error>(leftParenthesis.error());
+    CONSUME_TYPE(leftParenthesis, LeftParenthesis);
 
     Vector<UniqueRef<AST::Expression>> arguments;
@@ -2503 +1892 @@
         return { makeUniqueRef<AST::CallExpression>(WTFMove(*name), WTFMove(callName), WTFMove(arguments)) };
 
-    auto firstArgument = parsePossibleTernaryConditional();
-    if (!firstArgument)
-        return Unexpected<Error>(firstArgument.error());
+    PARSE(firstArgument, PossibleTernaryConditional);
     arguments.append(WTFMove(*firstArgument));
     while (tryType(Lexer::Token::Type::Comma)) {
-        auto argument = parsePossibleTernaryConditional();
-        if (!argument)
-            return Unexpected<Error>(argument.error());
+        PARSE(argument, PossibleTernaryConditional);
         arguments.append(WTFMove(*argument));
     }
 
-    auto rightParenthesis = consumeType(Lexer::Token::Type::RightParenthesis);
-    if (!rightParenthesis)
-        return Unexpected<Error>(rightParenthesis.error());
+    CONSUME_TYPE(rightParenthesis, RightParenthesis);
 
     return { makeUniqueRef<AST::CallExpression>(WTFMove(*name), WTFMove(callName), WTFMove(arguments)) };
@@ -2567 +1950 @@
     default: {
         ASSERT(type->type == Lexer::Token::Type::LeftParenthesis);
-        auto expression = parseExpression();
-        if (!expression)
-            return Unexpected<Error>(expression.error());
-
-        auto rightParenthesis = consumeType(Lexer::Token::Type::RightParenthesis);
-        if (!rightParenthesis)
-            return Unexpected<Error>(rightParenthesis.error());
+        PARSE(expression, Expression);
+        CONSUME_TYPE(rightParenthesis, RightParenthesis);
 
         return { WTFMove(*expression) };

trunk/Source/WebCore/Modules/webgpu/WHLSL/WHLSLParser.h

@@ -97 +97 @@
 #include <wtf/Expected.h>
 #include <wtf/Optional.h>
+#include <wtf/PrintStream.h>
 
 namespace WebCore {
@@ -116 +117 @@
 
         String error;
+
+        void dump(PrintStream& out) const
+        {
+            out.print(error);
+        }
     };
 
@@ -121 +127 @@
 
 private:
+    // FIXME: We should not need this
+    // https://bugs.webkit.org/show_bug.cgi?id=198357
     template<typename T> T backtrackingScope(std::function<T()> callback)
     {
@@ -137 +145 @@
     Unexpected<Error> fail(const String& message, TryToPeek = TryToPeek::Yes);
     Expected<Lexer::Token, Error> peek();
+    Expected<Lexer::Token, Error> peekFurther();
+    bool peekTypes(const Vector<Lexer::Token::Type>&);
     Optional<Lexer::Token> tryType(Lexer::Token::Type);
-    Optional<Lexer::Token> tryTypes(Vector<Lexer::Token::Type>);
+    Optional<Lexer::Token> tryTypes(const Vector<Lexer::Token::Type>&);
     Expected<Lexer::Token, Error> consumeType(Lexer::Token::Type);
-    Expected<Lexer::Token, Error> consumeTypes(Vector<Lexer::Token::Type>);
+    Expected<Lexer::Token, Error> consumeTypes(const Vector<Lexer::Token::Type>&);
 
     Expected<Variant<int, unsigned>, Error> consumeIntegralLiteral();
@@ -166 +176 @@
     Expected<AST::SpecializationConstantSemantic, Error> parseSpecializationConstantSemantic();
     Expected<AST::StageInOutSemantic, Error> parseStageInOutSemantic();
-    Expected<AST::Semantic, Error> parseSemantic();
+    Expected<Optional<AST::Semantic>, Error> parseSemantic();
     AST::Qualifiers parseQualifiers();
     Expected<AST::StructureElement, Error> parseStructureElement();
@@ -177 +187 @@
     Expected<AST::VariableDeclaration, Error> parseParameter();
     Expected<AST::VariableDeclarations, Error> parseParameters();
-    Expected<AST::FunctionDeclaration, Error> parseEntryPointFunctionDeclaration();
+    Expected<AST::FunctionDeclaration, Error> parseComputeFunctionDeclaration();
+    Expected<AST::FunctionDeclaration, Error> parseVertexOrFragmentFunctionDeclaration();
     Expected<AST::FunctionDeclaration, Error> parseRegularFunctionDeclaration();
     Expected<AST::FunctionDeclaration, Error> parseOperatorFunctionDeclaration();
@@ -185 +196 @@
 
     Expected<AST::Block, Error> parseBlock();
-    AST::Block parseBlockBody(Lexer::Token&& origin);
+    Expected<AST::Block, Error> parseBlockBody(Lexer::Token&& origin);
     Expected<AST::IfStatement, Error> parseIfStatement();
     Expected<AST::SwitchStatement, Error> parseSwitchStatement();
@@ -198 +209 @@
     Expected<UniqueRef<AST::Expression>, Error> parseEffectfulExpression();
     Expected<UniqueRef<AST::Expression>, Error> parseEffectfulAssignment();
-    Expected<UniqueRef<AST::Expression>, Error> parseEffectfulPrefix();
-    Expected<UniqueRef<AST::Expression>, Error> parseEffectfulSuffix();
     struct SuffixExpression {
         SuffixExpression(UniqueRef<AST::Expression>&& result, bool success)
@@ -215 +224 @@
 
     Expected<UniqueRef<AST::Expression>, Error> parseExpression();
-    Expected<UniqueRef<AST::Expression>, Error> parseTernaryConditional();
-    Expected<UniqueRef<AST::Expression>, Error> parseAssignment();
     Expected<UniqueRef<AST::Expression>, Error> parsePossibleTernaryConditional();
+    Expected<UniqueRef<AST::Expression>, Error> completeTernaryConditional(Lexer::Token&& origin, UniqueRef<AST::Expression>&& predicate);
+    Expected<UniqueRef<AST::Expression>, Error> completeAssignment(Lexer::Token&& origin, UniqueRef<AST::Expression>&& left);
     Expected<UniqueRef<AST::Expression>, Error> parsePossibleLogicalBinaryOperation();
+    Expected<UniqueRef<AST::Expression>, Error> completePossibleLogicalBinaryOperation(UniqueRef<AST::Expression>&& previous);
     Expected<UniqueRef<AST::Expression>, Error> parsePossibleRelationalBinaryOperation();
+    Expected<UniqueRef<AST::Expression>, Error> completePossibleRelationalBinaryOperation(UniqueRef<AST::Expression>&& previous);
     Expected<UniqueRef<AST::Expression>, Error> parsePossibleShift();
+    Expected<UniqueRef<AST::Expression>, Error> completePossibleShift(UniqueRef<AST::Expression>&& previous);
     Expected<UniqueRef<AST::Expression>, Error> parsePossibleAdd();
+    Expected<UniqueRef<AST::Expression>, Error> completePossibleAdd(UniqueRef<AST::Expression>&& previous);
     Expected<UniqueRef<AST::Expression>, Error> parsePossibleMultiply();
-    Expected<UniqueRef<AST::Expression>, Error> parsePossiblePrefix();
-    Expected<UniqueRef<AST::Expression>, Error> parsePossibleSuffix();
+    Expected<UniqueRef<AST::Expression>, Error> completePossibleMultiply(UniqueRef<AST::Expression>&& previous);
+    Expected<UniqueRef<AST::Expression>, Error> parsePossiblePrefix(bool *isEffectful = nullptr);
+    Expected<UniqueRef<AST::Expression>, Error> parsePossibleSuffix(bool *isEffectful = nullptr);
     Expected<UniqueRef<AST::Expression>, Error> parseCallExpression();
     Expected<UniqueRef<AST::Expression>, Error> parseTerm();

trunk/Source/WebCore/Modules/webgpu/WHLSL/WHLSLPrepare.cpp

@@ -59 +59 @@
 static constexpr bool dumpASTAfterParsing = false;
 static constexpr bool dumpASTAtEnd = false;
-static constexpr bool alwaysDumpPassFailures = false;
+static constexpr bool alwaysDumpPassFailures = true;
 static constexpr bool dumpPassFailure = dumpASTBeforeEachPass || dumpASTAfterParsing || dumpASTAtEnd || alwaysDumpPassFailures;
 
@@ -104 +104 @@
     Parser parser;
     auto standardLibrary = String::fromUTF8(WHLSLStandardLibrary, sizeof(WHLSLStandardLibrary));
-    auto failure = static_cast<bool>(parser.parse(program, standardLibrary, Parser::Mode::StandardLibrary));
-    ASSERT_UNUSED(failure, !failure);
-    if (parser.parse(program, whlslSource, Parser::Mode::User))
+    auto parseStdLibFailure = parser.parse(program, standardLibrary, Parser::Mode::StandardLibrary);
+    if (!ASSERT_DISABLED && parseStdLibFailure) {
+        dataLogLn("failed to parse the standard library: ", *parseStdLibFailure);
+        RELEASE_ASSERT_NOT_REACHED();
+    }
+    if (auto parseFailure = parser.parse(program, whlslSource, Parser::Mode::User)) {
+        if (dumpPassFailure)
+            dataLogLn("failed to parse the program: ", *parseFailure);
         return WTF::nullopt;
+    }
 
     if (!dumpASTBetweenEachPassIfNeeded(program, "AST after parsing"))