Files
carbon-lang/toolchain/parse/state.def
T
Jon Ross-Perkins 204c04dbb9 Add more package and import support. (#3402)
This should cover:

```
library "lib" api;
import Foo library default;
import library default;
import library "lib";
```

This splits out `PackageName` and `LibraryName` to their own parse nodes
so that checking can ignore them and still get a balanced parse tree
(otherwise, we essentially need to implement handling of the parse nodes
only to remove the identifiers/string literals -- the optional names
mean we can't blindly do that as before). For reference, these nodes
don't need to be handled because CheckParseTree will need to directly
funnel import information along with checked IRs.
2023-11-16 17:09:36 +00:00

1102 lines
24 KiB
Modula-2

// Part of the Carbon Language project, under the Apache License v2.0 with LLVM
// Exceptions. See /LICENSE for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
// This is an X-macro header. It does not use `#include` guards, and instead is
// designed to be `#include`ed after the x-macro is defined in order for its
// inclusion to expand to the desired output. Macro definitions are cleaned up
// at the end of this file.
//
// Supported x-macros are:
// - CARBON_PARSE_STATE(Name)
// Defines a parser state.
//
// Parser states may be clustered when there are multiple related variants,
// named `StateAsVariant`. When there are variants, they share a common helper
// function for most logic.
//
// The comments before each state describe the portion of the grammar that the
// state is implementing, by giving an example of each kind of token sequence
// that this state handles. In this example, `...` indicates a sequence of
// tokens handled by some other state, and `???` indicates a sequence of invalid
// tokens. A trailing `??? ;` indicates an attempt to skip to the end of the
// declaration, which may or may not actually find a `;` token.
//
// The position in the token stream before the state is indicated by the caret
// `^` on the line below the example, and all tokens consumed by the state are
// underlined by the caret and following `~`s. If no tokens are consumed, the
// caret will point between tokens. Therefore, the position in the token stream
// after the state is the first token in the example after the underlined
// region.
//
// Following each set of examples, the output states for that situation are
// listed. States are numbered in the order they'll be executed; in other
// words, `1` is the top of the state stack. The comment `(state done)`
// indicates that no new states are added to the stack.
#ifndef CARBON_PARSE_STATE
#error "Must define the x-macro to use this file."
#endif
// Use CARBON_PARSE_STATE_VARIANTSN(State, Variant1, Variant2, ...) to generate
// StateAsVariant1, StateAsVariant2, ... states.
#define CARBON_PARSE_STATE_VARIANT(State, Variant) \
CARBON_PARSE_STATE(State##As##Variant)
#define CARBON_PARSE_STATE_VARIANTS2(State, Variant1, Variant2) \
CARBON_PARSE_STATE_VARIANT(State, Variant1) \
CARBON_PARSE_STATE_VARIANT(State, Variant2)
#define CARBON_PARSE_STATE_VARIANTS3(State, Variant1, Variant2, Variant3) \
CARBON_PARSE_STATE_VARIANT(State, Variant1) \
CARBON_PARSE_STATE_VARIANTS2(State, Variant2, Variant3)
#define CARBON_PARSE_STATE_VARIANTS4(State, Variant1, Variant2, Variant3, \
Variant4) \
CARBON_PARSE_STATE_VARIANT(State, Variant1) \
CARBON_PARSE_STATE_VARIANTS3(State, Variant2, Variant3, Variant4)
// Handles an index expression:
//
// a[0]
// ^
// 1. Expression
// 2. IndexExpressionFinish
CARBON_PARSE_STATE(IndexExpr)
// Handles finishing the index expression.
//
// a[0]
// ^
// (state done)
CARBON_PARSE_STATE(IndexExprFinish)
// Handles an array expression.
//
// [T; N]
// ^
// 1. Expr
// 2. ArrayExprSemi
CARBON_PARSE_STATE(ArrayExpr)
// Handles ';' in an array expression.
//
// [T;]
// ^
// 1. ArrayExprFinish
//
// [T; N]
// ^
// 1. Expr
// 2. ArrayExprFinish
CARBON_PARSE_STATE(ArrayExprSemi)
// Handles finishing the array expression.
//
// [T;]
// ^
// [T; N]
// ^
// (state done)
CARBON_PARSE_STATE(ArrayExprFinish)
// Handles the `{` of a brace expression.
//
// {}
// ^
// 1. BraceExprFinishAsUnknown
//
// { ... }
// ^
// 1. BraceExprParamAsUnknown
// 2. BraceExprFinishAsUnknown
CARBON_PARSE_STATE(BraceExpr)
// Handles a brace expression parameter. Note this will always start as unknown,
// but should be known after the first valid parameter. All later inconsistent
// parameters are invalid.
//
// { .foo ... }
// ^
// 1. PeriodAsStruct
// 2. BraceExprParamAfterDesignatorAs(Type|Value|Unknown)
//
// { ???
// ^
// 1. BraceExprParamFinishAs(Type|Value|Unknown)
CARBON_PARSE_STATE_VARIANTS3(BraceExprParam, Type, Value, Unknown)
// Handles a brace expression parameter after the initial designator. This
// should be at a `:` or `=`, depending on whether it's a type or value literal.
//
// { .foo = bar ... }
// ^
// 1. Expr
// 2. BraceExprParamFinishAsValue
//
// { .foo: bar ... }
// ^
// 1. Expr
// 2. BraceExprParamFinishAsType
//
// { .foo ???
// ^
// 1. BraceExprParamFinishAs(Type|Value|Unknown)
CARBON_PARSE_STATE_VARIANTS3(BraceExprParamAfterDesignator, Type, Value,
Unknown)
// Handles the end of a brace expression parameter.
//
// { ... }
// ^
// (state done)
//
// { .foo = bar, ... }
// ^
// 1. BraceExprParamAsValue
//
// { .foo: bar, ... }
// ^
// 1. BraceExprParamAsType
//
// { ??? , ... }
// ^
// 1. BraceExprParamAsUnknown
CARBON_PARSE_STATE_VARIANTS3(BraceExprParamFinish, Type, Value, Unknown)
// Handles the `}` of a brace expression.
//
// { ... }
// ^
// (state done)
CARBON_PARSE_STATE_VARIANTS3(BraceExprFinish, Type, Value, Unknown)
// Handles a call expression `(...)`.
//
// F()
// ^
// 1. CallExprFinish
//
// F( ...
// ^
// 1. Expr
// 2. CallExprParamFinish
// 3. CallExprFinish
CARBON_PARSE_STATE(CallExpr)
// Handles the `,` or `)` after a call parameter.
//
// F(a, ...)
// ^
// 1. Expr
// 2. CallExprParamFinish
//
// F(a )
// ^
// (state done)
CARBON_PARSE_STATE(CallExprParamFinish)
// Handles finishing the call expression.
//
// F(a, b)
// ^
// (state done)
CARBON_PARSE_STATE(CallExprFinish)
// Handles processing at the `{` on a typical code block.
//
// if (cond) {
// ^
// 1. StatementScopeLoop
// 2. CodeBlockFinish
//
// if (cond) ???
// ^
// 1. Statement
// 2. CodeBlockFinish
CARBON_PARSE_STATE(CodeBlock)
// Handles processing at the `}` on a typical code block, after a statement
// scope is done.
//
// if (cond) { ... }
// ^
// (state done)
CARBON_PARSE_STATE(CodeBlockFinish)
// Handles a declaration name and parameters, such as `Foo[...](...)`.
//
// Allowed parameters:
// - None: `Foo` only.
// - Optional: `Foo`, `Foo(...)`, or `Foo[...](...)`.
// - Required: `Foo(...)` or `Foo[...](...)`.
//
// name . ...
// ^~~~
// 1. PeriodAsDecl
// 2. DeclNameAndParamsAfterNameAs(None|Optional|Required)
//
// name ...
// ^~~~
// 1. DeclNameAndParamsAfterNameAs(None|Optional|Required)
//
// ???
// ^
// (state done)
CARBON_PARSE_STATE_VARIANTS3(DeclNameAndParams, None, Optional, Required)
// Handles a declaration name between the main name and implicit parameters.
//
// name . ...
// ^
// 1. PeriodAsDecl
// 2. DeclNameAndParamsAfterNameAs(None|Optional|Required)
//
// name [ ... ] (variant is not None)
// ^
// 1. ParamListAsImplicit
// 2. DeclNameAndParamsAfterImplicit
//
// name ( ... ) (variant is not None)
// ^
// 1. ParamListAsRegular
//
// name ... (variant is not Required)
// ^
// (state done)
//
// name ??? (variant is Required)
// ^
// (state done)
CARBON_PARSE_STATE_VARIANTS3(DeclNameAndParamsAfterName, None, Optional,
Required)
// Handles regular parameters such as `(...)` for the general declaration case.
// Only used after implicit parameters.
//
// name [ ... ] ( ... )
// ^
// 1. ParamListAsRegular
//
// name [ ... ] ???
// ^
// (state done)
CARBON_PARSE_STATE(DeclNameAndParamsAfterImplicit)
// Handles processing of a declaration scope. Things like fn, class, interface,
// and so on.
//
// class ...
// ^~~~~
// abstract class ...
// ^~~~~~~~~~~~~~
// base class ...
// ^~~~~~~~~~
// 1. TypeAfterIntroducerAsClass
// 2. DeclScopeLoop
//
// constraint ...
// ^~~~~~~~~~
// 1. TypeAfterIntroducerAsNamedConstraint
// 2. DeclScopeLoop
//
// fn ...
// ^
// 1. FunctionIntroducer
// 2. DeclScopeLoop
//
// interface ...
// ^~~~~~~~~
// 1. TypeAfterIntroducerAsInterface
// 2. DeclScopeLoop
//
// namespace ...
// ^
// 1. Namespace
// 2. DeclScopeLoop
//
// ;
// ^
// 1. DeclScopeLoop
//
// var ...
// ^
// 1. VarAsDecl
// 2. DeclScopeLoop
//
// let ...
// ^
// 1. Let
// 2. DeclScopeLoop
//
// ??? ;
// ^~~~~
// (state done)
CARBON_PARSE_STATE(DeclScopeLoop)
// Handles periods. Only does one `.<expression>` segment; the source is
// responsible for handling chaining.
//
// The forms of this are:
// - Qualified names in declarations.
// - Member access expressions.
// - Designated names in structs.
//
// Declarations and expressions have qualifiers such as `x.y`, while structs
// have designators such as `.z`.
//
// . name
// ^~~~~~
// (state done)
//
// . ??? (??? consumed if it is a keyword)
// ^
// (state done)
CARBON_PARSE_STATE_VARIANTS3(Period, Decl, Expr, Struct)
// Handles `->name` expressions. Identical to PeriodAsExpr except for the
// leading token.
//
// -> name
// ^~~~~~~
// (state done)
//
// -> ??? (??? consumed if it is a keyword)
// ^~
// (state done)
CARBON_PARSE_STATE(ArrowExpr)
// Handles processing of an expression.
//
// if ...
// ^~
// 1. Expr
// 2. IfExprCondition
// 3. IfExprFinish
//
// <prefix operator> ...
// ^~~~~~~~~~~~~~~~~
// 1. Expr
// 2. ExprLoopForPrefix
//
// ...
// ^
// 1. ExprInPostfix
// 2. ExprLoop
CARBON_PARSE_STATE(Expr)
// Handles the initial part of postfix expressions, such as an identifier or
// literal value, then proceeds to the loop.
//
// identifier
// ^~~~~~~~~~
// literal
// ^~~~~~~
// self
// ^~~~
// Self
// ^~~~
// 1. ExprInPostfixLoop
//
// {
// ^
// 1. BraceExpr
// 2. ExprInPostfixLoop
//
// (
// ^
// 1. ParenExpr
// 2. ExprInPostfixLoop
//
// [
// ^
// 1. ArrayExpr
// 2. ExprInPostfixLoop
//
// ???
// ^
// (state done)
CARBON_PARSE_STATE(ExprInPostfix)
// Handles looping through elements following the initial postfix expression,
// such as designators or parenthesized parameters.
//
// expr . ...
// ^
// 1. PeriodAsExpr
// 2. ExprInPostfixLoop
//
// expr -> ...
// ^
// 1. ArrowExpr
// 2. ExprInPostfixLoop
//
// expr ( ... )
// ^
// 1. CallExpr
// 2. ExprInPostfixLoop
//
// expr [ ... ]
// ^
// 1. IndexExprStart
// 2. ExprInPostfixLoop
//
// ...
// ^
// (state done)
CARBON_PARSE_STATE(ExprInPostfixLoop)
// Handles processing of an expression.
//
// expr <binary operator> ...
// ^~~~~~~~~~~~~~~~~
// 1. Expr
// 2. ExprLoopForBinary
//
// expr <postfix operator>
// ^~~~~~~~~~~~~~~~~~
// 1. ExprLoop
//
// expr ...
// ^
// (state done)
CARBON_PARSE_STATE(ExprLoop)
// Completes an ExprLoop pass by adding an infix operator, then goes back
// to ExprLoop.
//
// expr <binary operator> expr ...
// ^
// 1. ExprLoop
CARBON_PARSE_STATE(ExprLoopForBinary)
// Completes an ExprLoop pass by adding a prefix operator, then goes back
// to ExprLoop.
//
// <prefix operator> expr ...
// ^
// 1. ExprLoop
CARBON_PARSE_STATE(ExprLoopForPrefix)
// Completes the condition of an `if` expression and handles the `then` token.
//
// if expr then ...
// ^~~~
// 1. Expr
// 2. IfExprFinishThen
//
// if expr ???
// ^
// (state done)
CARBON_PARSE_STATE(IfExprFinishCondition)
// Completes the first alternative in an `if` expression and handles the `else`
// token.
//
// if expr then expr else ...
// ^~~~
// 1. Expr
// 2. IfExprFinishElse
//
// if expr then expr ???
// ^
// (state done)
CARBON_PARSE_STATE(IfExprFinishThen)
// Completes the second alternative in an `if` expression.
//
// if expr then expr else expr
// ^
// (state done)
CARBON_PARSE_STATE(IfExprFinishElse)
// Completes an IfExpr.
//
// if expr then expr else expr
// ^
// if ???
// ^
// (state done)
CARBON_PARSE_STATE(IfExprFinish)
// Handles the `;` for an expression statement, which is different from most
// keyword statements.
//
// expr ;
// ^
// expr ??? ;
// ^~~~~
// (state done)
CARBON_PARSE_STATE(ExprStatementFinish)
// Handles a function's introducer.
//
// fn ...
// ^~
// 1. DeclNameAndParamsAsRequired
// 2. FunctionAfterParams
CARBON_PARSE_STATE(FunctionIntroducer)
// Handles processing of a function's syntax after `)`, primarily the
// possibility a `->` return type is there. Always enqueues signature finish
// handling.
//
// fn F(...) -> ...
// ^~
// 1. Expr
// 2. FunctionReturnTypeFinish
// 3. FunctionSignatureFinish
//
// fn F(...) ...
// ^
// 1. FunctionSignatureFinish
CARBON_PARSE_STATE(FunctionAfterParams)
// Finishes a function return type.
//
// fn F(...) -> expr ...
// ^
// (state done)
CARBON_PARSE_STATE(FunctionReturnTypeFinish)
// Finishes a function signature. If it's a declaration, the function is done;
// otherwise, this also starts definition processing.
//
// fn ... ;
// ^
// (state done)
//
// fn ... {
// ^
// 1. StatementScopeLoop
// 2. FunctionDefinitionFinish
//
// fn ... ??? ;
// ^~~~~
// (state done)
CARBON_PARSE_STATE(FunctionSignatureFinish)
// Finishes a function definition.
//
// fn ... }
// ^
// fn ... ;
// ^
// (state done)
CARBON_PARSE_STATE(FunctionDefinitionFinish)
// Handles `import`.
//
// import pkgname [library "libname"] ;
// ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// import ??? ;
// ^~~~~~~~~~~~
// (state done)
CARBON_PARSE_STATE(Import)
// Handles `library` in directive form.
//
// Always:
// (state done)
CARBON_PARSE_STATE(Library)
// Handles `namespace`.
//
// namespace ...
// ^~~~~~~~~
// 1. DeclNameAndParamsAsNone
// 2. NamespaceFinish
CARBON_PARSE_STATE(Namespace)
// Handles `namespace` after the name.
//
// namespace ... ;
// ^
// namespace ... ??? ;
// ^~~~~
// (state done)
CARBON_PARSE_STATE(NamespaceFinish)
// Handles `package`.
//
// package pkgname [library "libname"] [api|impl] ;
// ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// package ??? ;
// ^~~~~~~~~~~~~
// (state done)
CARBON_PARSE_STATE(Package)
// Starts parameter parsing.
//
// ...
// ^
// 1. PatternAs(ImplicitParam|Param)
// 2. ParamFinishAs(Implicit|Regular)
CARBON_PARSE_STATE_VARIANTS2(Param, Implicit, Regular)
// Finishes parsing a parameter, including the optional trailing `,`. If there
// are more parameters, enqueues another parameter parsing state.
//
// ... , )
// ^
// (state done)
//
// ... , ...
// ^
// 1. ParamAs(Implicit|Regular)
//
// ...
// ^
// (state done)
CARBON_PARSE_STATE_VARIANTS2(ParamFinish, Implicit, Regular)
// Handles processing of a parameter list `[` or `(`.
//
// ( ) (variant is Regular)
// ^
// [ ] (variant is Implicit)
// ^
// 1. ParamListFinishAs(Regular|Implicit)
//
// ( ... ) (variant is Regular)
// ^
// [ ... ] (variant is Implicit)
// ^
// 1. ParamAs(Regular|Implicit)
// 2. ParamListFinishAs(Regular|Implicit)
CARBON_PARSE_STATE_VARIANTS2(ParamList, Implicit, Regular)
// Handles processing of a parameter list `]` or `)`.
//
// ( ... ) (variant is Regular)
// ^
// [ ... ] (variant is Implicit)
// ^
// (state done)
CARBON_PARSE_STATE_VARIANTS2(ParamListFinish, Implicit, Regular)
// Handles the processing of a `(condition)` up through the expression.
//
// if/while { (invalid)
// ^
// 1. ParenConditionAs(If|While)Finish
//
// if/while ( ... )
// ^
// if/while ???
// ^
// 1. Expr
// 2. ParenConditionAs(If|While)Finish
CARBON_PARSE_STATE_VARIANTS2(ParenCondition, If, While)
// Finishes the processing of a `(condition)` after the expression.
//
// if/while ( expr )
// ^
// if/while {
// ^
// if/while ??? {
// ^
// (state done)
CARBON_PARSE_STATE_VARIANTS2(ParenConditionFinish, If, While)
// Handles the `(` of a parenthesized expression.
//
// ( )
// ^
// 1. ParenExprFinishAsTuple
//
// ( ... )
// ^
// 1. Expr
// 2. ParenExprParamFinishAsUnknown
// 3. ParenExprFinishAsNormal (SPECIAL: may be replaced)
CARBON_PARSE_STATE(ParenExpr)
// Handles the end of a parenthesized expression's parameter. This will start as
// AsUnknown on the first parameter; if there are more, it switches to AsTuple
// processing.
//
// ( ... , )
// ^
// (state done)
// SPECIAL (variant is Unknown): parent becomes ParenExprFinishAsTuple
//
// ( ... , ... )
// ^
// 1. Expression
// 2. ParenExpressionParamFinishAsTuple
// SPECIAL (variant is Unknown): parent becomes ParenExprFinishAsTuple
//
// ...
// ^
// (state done)
CARBON_PARSE_STATE_VARIANTS2(ParenExprParamFinish, Unknown, Tuple)
// Handles the `)` of a parenthesized expression.
//
// ( ... )
// ^
// (state done)
CARBON_PARSE_STATE_VARIANTS2(ParenExprFinish, Normal, Tuple)
// Handles pattern parsing for a pattern, enqueuing type expression processing.
// This covers parameter, `let`, and `var` support.
//
// template (variant is not Variable)
// ^~~~~~~~
// 4. PatternTemplate
//
// THEN
//
// addr (variant is not Variable)
// ^~~~
// 3. PatternAddress
//
// THEN
//
// name: ...
// ^~~~~
// self: ...
// ^~~~~
// 1. Expr
// 2. PatternFinishAsRegular
//
// name:! ...
// ^~~~~~
// self:! ...
// ^~~~~~
// 1. Expr
// 2. PatternFinishAsGeneric
//
// ???
// ^
// 1. PatternFinishAsRegular
CARBON_PARSE_STATE_VARIANTS4(Pattern, ImplicitParam, Param, Variable,
Let)
// Handles `addr` in a pattern.
//
// addr name: type
// ^
// (state done)
CARBON_PARSE_STATE(PatternAddress)
// Handles `template` in a pattern.
//
// template name:! type
// ^
// (state done)
CARBON_PARSE_STATE(PatternTemplate)
// Finishes pattern processing.
//
// name: type
// ^
// (state done)
CARBON_PARSE_STATE_VARIANTS2(PatternFinish, Generic, Regular)
// Handles a single statement. While typically within a statement block, this
// can also be used for error recovery where we expect a statement block and
// are missing braces.
//
// break ...
// ^~~~~
// 1. StatementBreakFinish
//
// continue ...
// ^~~~~~~~
// 1. StatementContinueFinish
//
// for ...
// ^~~
// 1. StatementForHeader
// 2. StatementForFinish
//
// if ...
// ^
// 1. StatementIf
//
// return ...
// ^
// 1. StatementReturn
//
// var ...
// ^
// 1. VarAsDecl
//
// returned ...
// ^
// 1. VarAsReturned
//
// while ...
// ^
// 1. StatementWhile
//
// ...
// ^
// 1. Expr
// 2. ExprStatementFinish
CARBON_PARSE_STATE(Statement)
// Handles `break` processing at the `;`.
//
// break ;
// ^
// (state done)
CARBON_PARSE_STATE(StatementBreakFinish)
// Handles `continue` processing at the `;`.
//
// continue ;
// ^
// (state done)
CARBON_PARSE_STATE(StatementContinueFinish)
// Handles `for` processing of `(var`, proceeding to a pattern before
// continuing.
//
// for ( var ... )
// ^
// 1. VarAsFor
// 2. StatementForHeaderIn
//
// for ( ???
// ^
// for ( ??? in ...
// ^~~~~~~~
// for ??? in ...
// ^~~~~~
// for ???
// ^
// 1. StatementForHeaderIn
CARBON_PARSE_STATE(StatementForHeader)
// Handles `for` processing of `in`, proceeding to an expression before
// continuing.
//
// for ( ... in ... )
// ^
// 1. Expr
// 2. StatementForHeaderFinish
CARBON_PARSE_STATE(StatementForHeaderIn)
// Handles `for` processing of `)`, proceeding to the statement block.
//
// for ( ... ) ...
// ^
// 1. CodeBlock
CARBON_PARSE_STATE(StatementForHeaderFinish)
// Handles `for` processing after the final `}`.
//
// for ( ... ) { ... }
// ^
// (state done)
CARBON_PARSE_STATE(StatementForFinish)
// Handles `if` processing at the start.
//
// if ...
// ^~
// 1. ParenConditionAsIf
// 2. StatementIfConditionFinish
CARBON_PARSE_STATE(StatementIf)
// Handles `if` processing between the condition and start of the first code
// block.
//
// if ( ... ) ...
// ^
// 1. CodeBlock
// 2. StatementIfThenBlockFinish
CARBON_PARSE_STATE(StatementIfConditionFinish)
// Handles `if` processing after the end of the first code block, with the
// optional `else`.
//
// if ( ... ) { ... } else if ...
// ^~~~
// 1. StatementIf
// 2. StatementIfElseBlockFinish
//
// if ( ... ) { ... } else ...
// ^~~~
// 1. CodeBlock
// 2. StatementIfElseBlockFinish
//
// if ( ... ) { ... } ...
// (state done)
CARBON_PARSE_STATE(StatementIfThenBlockFinish)
// Handles `if` processing after a provided `else` code block.
//
// if ( ... ) { ... } else { ... }
// ^
// (state done)
CARBON_PARSE_STATE(StatementIfElseBlockFinish)
// Handles `return` processing.
//
// return ;
// ^~~~~~
// 1. StatementReturnFinish
//
// return var ...
// ^~~~~~~~~~
// 1. StatementReturnFinish
//
// return ...
// ^~~~~~
// 1. Expr
// 2. StatementReturnFinish
CARBON_PARSE_STATE(StatementReturn)
// Handles `return` processing at the `;`.
//
// return ... ;
// ^
// (state done)
CARBON_PARSE_STATE(StatementReturnFinish)
// Handles processing of statements within a scope.
//
// { ... }
// ^
// (state done)
//
// { ... ... }
// ^
// 1. Statement
// 2. StatementScopeLoop
CARBON_PARSE_STATE(StatementScopeLoop)
// Handles `while` processing.
//
// while ...
// ^~~~~
// 1. ParenConditionAsWhile
// 2. StatementWhileConditionFinish
CARBON_PARSE_STATE(StatementWhile)
// Handles `while` processing between the condition and start of the code block.
//
// while ( ... ) ...
// ^
// 1. CodeBlock
// 2. StatementWhileBlockFinish
CARBON_PARSE_STATE(StatementWhileConditionFinish)
// Handles `while` processing after the end of the code block.
//
// while ( ... ) { ... }
// ^
// (state done)
CARBON_PARSE_STATE(StatementWhileBlockFinish)
// Handles parsing after the declaration scope of a type.
//
// class/interface/constraint { ... }
// ^
// (state done)
CARBON_PARSE_STATE_VARIANTS3(TypeDefinitionFinish, Class, Interface,
NamedConstraint)
// Handles processing of a type after its introducer.
//
// class/interface/constraint ...
// ^~~~~~~~~~~~~~~~~~~~~~~~~~
// 1. DeclNameAndParamsAsOptional
// 2. TypeAfterParamsAs(Class|Interface|NamedConstraint)
CARBON_PARSE_STATE_VARIANTS3(TypeAfterIntroducer, Class, Interface, NamedConstraint)
// Handles processing of a type after its optional parameters.
//
// class/interface/constraint name ( ... ) {
// ^
// 1. DeclScopeLoop
// 2. TypeDefinitionFinishAs(Class|Interface|NamedConstraint)
//
// class/interface/constraint name ( ... ) ;
// ^
// class/interface/constraint name ( ... ) ???
// ^
// (state done)
CARBON_PARSE_STATE_VARIANTS3(TypeAfterParams, Class, Interface, NamedConstraint)
// Handles the start of a `var` or `returned var`.
//
// var ... (variant is not Returned)
// ^~~
// 1. PatternAsVariable
// 2. VarAfterPattern
// 3. VarFinishAs(Decl|For)
//
// returned var ... (variant is Returned)
// ^~~~~~~~~~~~
// 1. PatternAsVariable
// 2. VarAfterPattern
// 3. VarFinishAsDecl
//
// returned ??? ; (variant is Returned)
// ^~~~~~~~~~~~~~
// (state done)
CARBON_PARSE_STATE_VARIANTS3(Var, Decl, Returned, For)
// Handles `var` after the pattern, either followed by an initializer or the
// semicolon.
//
// var ... = ...
// ^
// var ... ??? = ...
// ^~~~~
// 1. Expr
//
// var ... ...
// ^
// (state done)
CARBON_PARSE_STATE(VarAfterPattern)
// Handles `var` parsing at the end.
//
// var ... ; (variant is Semicolon)
// ^
// var ... ??? ; (variant is Semicolon)
// ^~~~~
// (state done)
//
// var ... in (variant is For)
// ^~
// var ... : (variant is For, invalid)
// ^
// (state done)
CARBON_PARSE_STATE_VARIANTS2(VarFinish, Decl, For)
// Handles the start of a `let`.
//
// let ...
// ^~~
// 1. PatternAsLet
// 2. LetAfterPattern
// 3. LetFinish
CARBON_PARSE_STATE(Let)
// Handles `let` after the pattern, followed by an initializer.
//
// let ... = ...
// ^
// let ... ??? = ...
// ^~~~~
// 1. Expr
//
// let ... ??? ;
// ^~~
// (state done)
CARBON_PARSE_STATE(LetAfterPattern)
// Handles `let` parsing at the end.
//
// let ... ;
// ^
// (state done)
CARBON_PARSE_STATE(LetFinish)
#undef CARBON_PARSE_STATE