carbon-lang/toolchain/parse/node_kind.def

// 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_NODE_KIND(Name)
//   Used as a fallback if other macros are missing.
//   - CARBON_PARSE_NODE_KIND_WITH_TOKEN(Name, LexTokenKind)
//     Defines a parse node kind and specifies its corresponding token kind.
//     - CARBON_PARSE_NODE_KIND_PREFIX_OPERATOR(Name)
//       Defines a parse node for a prefix operator, with the Name as token.
//     - CARBON_PARSE_NODE_KIND_INFIX_OPERATOR(Name)
//       Defines a parse node for an infix operator, with the Name as token.
//     - CARBON_PARSE_NODE_KIND_POSTFIX_OPERATOR(Name)
//       Defines a parse node for a postfix operator, with the Name as token.
//     - CARBON_PARSE_NODE_KIND_TOKEN_LITERAL(Name, LexTokenKind)
//       Defines a parse node that corresponds to a token that is a single-token
//       literal. The token is wrapped for LexTokenKinds.
//     - CARBON_PARSE_NODE_KIND_TOKEN_MODIFIER(Name)
//       A token-based modifier. The Name is the TokenKind, and will be appended
//       with "Modifier" for the parse kind.
//
// LexTokenKind indicates the token kind required on a valid node.
// It will be either `kind_name` to indicate it's required even if the node is
// an error, or `CARBON_IF_VALID(kind_name)` to indicate that the kind is
// not enforced on error. A token kind of `Error` may be used if the kind should
// never be enforced; this should only be used when the node is either not in
// trees (`Placeholder`) or is always invalid (such as `InvalidParse`).
//
// This tree represents the subset relationship between these macros, where if a
// specific x-macro isn't defined, it'll fall back to the parent macro.
//
// Parse nodes are clustered based on language feature. See typed_nodes.h for
// the expected tree structure under each node kind.

#if !(defined(CARBON_PARSE_NODE_KIND) || \
      defined(CARBON_PARSE_NODE_KIND_WITH_TOKEN))
#error "Must define CARBON_PARSE_NODE_KIND family x-macros to use this file."
#endif

// The WITH_TOKEN macro will use CARBON_PARSE_NODE_KIND by default when
// undefined.
#ifndef CARBON_PARSE_NODE_KIND_WITH_TOKEN
#define CARBON_PARSE_NODE_KIND_WITH_TOKEN(Name, LexTokenKind) \
  CARBON_PARSE_NODE_KIND(Name)
#endif

// This is expected to be used with something like:
//
//   // Use x-macros to handle modifier cases.
//   #define CARBON_PARSE_NODE_KIND(...)
//   #define CARBON_PARSE_NODE_KIND_PREFIX_OPERATOR(Name, ...) <code>
#ifndef CARBON_PARSE_NODE_KIND_PREFIX_OPERATOR
#define CARBON_PARSE_NODE_KIND_PREFIX_OPERATOR(Name) \
  CARBON_PARSE_NODE_KIND_WITH_TOKEN(PrefixOperator##Name, Name)
#endif

// This is expected to be used with something like:
//
//   // Use x-macros to handle modifier cases.
//   #define CARBON_PARSE_NODE_KIND(...)
//   #define CARBON_PARSE_NODE_KIND_INFIX_OPERATOR(Name, ...) <code>
#ifndef CARBON_PARSE_NODE_KIND_INFIX_OPERATOR
#define CARBON_PARSE_NODE_KIND_INFIX_OPERATOR(Name) \
  CARBON_PARSE_NODE_KIND_WITH_TOKEN(InfixOperator##Name, Name)
#endif

// This is expected to be used with something like:
//
//   // Use x-macros to handle modifier cases.
//   #define CARBON_PARSE_NODE_KIND(...)
//   #define CARBON_PARSE_NODE_KIND_POSTFIX_OPERATOR(Name, ...) <code>
#ifndef CARBON_PARSE_NODE_KIND_POSTFIX_OPERATOR
#define CARBON_PARSE_NODE_KIND_POSTFIX_OPERATOR(Name) \
  CARBON_PARSE_NODE_KIND_WITH_TOKEN(PostfixOperator##Name, Name)
#endif

// This is expected to be used with something like:
//
//   // Use x-macros to handle literal cases.
//   #define CARBON_PARSE_NODE_KIND(...)
//   #define CARBON_PARSE_NODE_KIND_TOKEN_LITERAL(Name, ...) <code>
#ifndef CARBON_PARSE_NODE_KIND_TOKEN_LITERAL
#define CARBON_PARSE_NODE_KIND_TOKEN_LITERAL(Name, LexTokenKinds) \
  CARBON_PARSE_NODE_KIND_WITH_TOKEN(Name, LexTokenKinds)
#endif

// This is expected to be used with something like:
//
//   // Use x-macros to handle modifier cases.
//   #define CARBON_PARSE_NODE_KIND(...)
//   #define CARBON_PARSE_NODE_KIND_TOKEN_MODIFIER(Name, ...) <code>
#ifndef CARBON_PARSE_NODE_KIND_TOKEN_MODIFIER
#define CARBON_PARSE_NODE_KIND_TOKEN_MODIFIER(Name) \
  CARBON_PARSE_NODE_KIND_WITH_TOKEN(Name##Modifier, Name)
#endif

// The start of the file.
CARBON_PARSE_NODE_KIND_WITH_TOKEN(FileStart, FileStart)

// The end of the file.
CARBON_PARSE_NODE_KIND_WITH_TOKEN(FileEnd, FileEnd)

// An invalid parse. Used to balance the parse tree. Always has an error.
CARBON_PARSE_NODE_KIND_WITH_TOKEN(InvalidParse, Error)

// An invalid subtree. Always has an error.
CARBON_PARSE_NODE_KIND_WITH_TOKEN(InvalidParseStart, Error)
CARBON_PARSE_NODE_KIND_WITH_TOKEN(InvalidParseSubtree, Error)

// A placeholder node to be replaced; it will never exist in a valid parse tree.
// Its token kind is not enforced even when valid.
CARBON_PARSE_NODE_KIND_WITH_TOKEN(Placeholder, Error)

// An empty declaration, such as `;`.
CARBON_PARSE_NODE_KIND_WITH_TOKEN(EmptyDecl, CARBON_IF_VALID(Semi))

// An identifier name in a non-expression context, such as a declaration.
CARBON_PARSE_NODE_KIND_WITH_TOKEN(IdentifierName, CARBON_IF_VALID(Identifier))

// An identifier name in an expression context.
CARBON_PARSE_NODE_KIND_WITH_TOKEN(IdentifierNameExpr, Identifier)

// The `self` value and `Self` type identifier keywords. Typically of the form
// `self: Self`.
CARBON_PARSE_NODE_KIND_WITH_TOKEN(SelfValueName, SelfValueIdentifier)
CARBON_PARSE_NODE_KIND_WITH_TOKEN(SelfValueNameExpr, SelfValueIdentifier)
CARBON_PARSE_NODE_KIND_WITH_TOKEN(SelfTypeNameExpr, SelfTypeIdentifier)

// The `base` value keyword, introduced by `base: B`. Typically referenced in
// an expression, as in `x.base` or `{.base = ...}`, but can also be used as a
// declared name, as in `{.base: partial B}`.
CARBON_PARSE_NODE_KIND_WITH_TOKEN(BaseName, Base)

// The `package` keyword in an expression.
CARBON_PARSE_NODE_KIND_WITH_TOKEN(PackageExpr, Package)

// ----------------------------------------------------------------------------

// The comments below follow this pattern:
//
// // Descriptive heading:
// //   Child1
// //   Child2
// // Parent
//
// In this, `Child1`, `Child2`, and `Parent` are all kinds of parse nodes, which
// are then defined using the `CARBON_PARSE_NODE_KIND_*` macros. They are
// written in postorder, with the indentation showing the tree structure. See
// tree.h for more information.
//
// A parse node kind may be preceded by:
// -  `_optional_` if this node (or nodes) may be present or omitted in valid
//    parses, depending on which tokens are in the source code.
// -  `_repeated_` if this node (or nodes) may be repeated or omitted in valid
//    parses, depending on which tokens are in the source code.
// -  `_external_:` if this node is the child of multiple kinds of nodes and
//    is documented separately.
//
// There is generally a close correspondence between handling of tokens and the
// creation of non-external nodes in a given block.

// ----------------------------------------------------------------------------

// The name of a package or library for `package`, `import`, and `library`.
CARBON_PARSE_NODE_KIND_WITH_TOKEN(PackageName, Identifier)
CARBON_PARSE_NODE_KIND_WITH_TOKEN(LibraryName, StringLiteral)

// `package`:
//   PackageIntroducer
//   _repeated_ _external_: modifier
//   _optional_ _external_: PackageName
//   _optional_ _external_: LibrarySpecifier
// PackageDecl
CARBON_PARSE_NODE_KIND_WITH_TOKEN(PackageIntroducer, Package)
CARBON_PARSE_NODE_KIND_WITH_TOKEN(PackageDecl, CARBON_IF_VALID(Semi))

// `import`:
//   ImportIntroducer
//   _repeated_ _external_: modifier
//   _optional_ _external_: PackageName
//   _optional_ _external_: LibrarySpecifier
// ImportDecl
CARBON_PARSE_NODE_KIND_WITH_TOKEN(ImportIntroducer, Import)
CARBON_PARSE_NODE_KIND_WITH_TOKEN(ImportDecl, CARBON_IF_VALID(Semi))

// `library` as declaration:
//   LibraryIntroducer
//   _repeated_ _external_: modifier
//   DefaultLibrary or _external_: LibraryName
// LibraryDecl
CARBON_PARSE_NODE_KIND_WITH_TOKEN(DefaultLibrary, Default)
CARBON_PARSE_NODE_KIND_WITH_TOKEN(LibraryIntroducer, Library)
CARBON_PARSE_NODE_KIND_WITH_TOKEN(LibraryDecl, CARBON_IF_VALID(Semi))

// `library` in `package` or `import`:
//   _external_: LibraryName or DefaultLibrary
// LibrarySpecifier
CARBON_PARSE_NODE_KIND_WITH_TOKEN(LibrarySpecifier, Library)

// Declaration names.
//
//   _repeated_: NameQualifier
//   _external_: IdentifierName
//   _optional_ _external_: ImplicitParamList
//   _optional_ _external_: TuplePattern
// _declaration name_
//
//   _external_: IdentifierName
//   _optional_ _external_: ImplicitParamList
//   _optional_ _external_: TuplePattern
// NameQualifier
CARBON_PARSE_NODE_KIND_WITH_TOKEN(NameQualifier, CARBON_IF_VALID(Period))

// `export`:
//   ExportIntroducer
//   _external_: _declaration name_
// ExportDecl
CARBON_PARSE_NODE_KIND_WITH_TOKEN(ExportIntroducer, Export)
CARBON_PARSE_NODE_KIND_WITH_TOKEN(ExportDecl, CARBON_IF_VALID(Semi))

// `namespace`:
//   NamespaceStart
//   _repeated_ _external_: modifier
//   _external_: _declaration name_
// Namespace
CARBON_PARSE_NODE_KIND_WITH_TOKEN(NamespaceStart, Namespace)
CARBON_PARSE_NODE_KIND_WITH_TOKEN(Namespace, CARBON_IF_VALID(Semi))

// A code block:
//   CodeBlockStart
//   _repeated_ _external_: statement
// CodeBlock
CARBON_PARSE_NODE_KIND_WITH_TOKEN(CodeBlockStart,
                                  CARBON_IF_VALID(OpenCurlyBrace))
CARBON_PARSE_NODE_KIND_WITH_TOKEN(CodeBlock, CARBON_IF_VALID(CloseCurlyBrace))

// `fn` declarations start with a function signature:
//
//   FunctionIntroducer
//   _repeated_ _external_: modifier
//   _external_: _declaration name_
//   ReturnType
// _function signature_
//
// There are three forms of function declaration:
//
//   _function signature_
// FunctionDecl
//
//     _function signature_
//   FunctionDefinitionStart
//   _repeated_ _external_: statement
// FunctionDefinition
//
//     _function signature_
//   BuiltinFunctionDefinitionStart
//   BuiltinName
// BuiltinFunctionDefinition
CARBON_PARSE_NODE_KIND_WITH_TOKEN(FunctionIntroducer, Fn)
CARBON_PARSE_NODE_KIND_WITH_TOKEN(ReturnType, MinusGreater)
CARBON_PARSE_NODE_KIND_WITH_TOKEN(FunctionDefinitionStart, OpenCurlyBrace)
CARBON_PARSE_NODE_KIND_WITH_TOKEN(FunctionDefinition, CloseCurlyBrace)
CARBON_PARSE_NODE_KIND_WITH_TOKEN(FunctionDecl, CARBON_IF_VALID(Semi))
CARBON_PARSE_NODE_KIND_WITH_TOKEN(BuiltinFunctionDefinitionStart, Equal)
CARBON_PARSE_NODE_KIND_WITH_TOKEN(BuiltinName, StringLiteral)
CARBON_PARSE_NODE_KIND_WITH_TOKEN(BuiltinFunctionDefinition,
                                  CARBON_IF_VALID(Semi))

// `alias`:
//   AliasIntroducer
//   _repeated_ _external_: modifier
//   _external_: _declaration name_
//   AliasInitializer
//   _external_: expression
// Alias
CARBON_PARSE_NODE_KIND_WITH_TOKEN(AliasIntroducer, Alias)
CARBON_PARSE_NODE_KIND_WITH_TOKEN(AliasInitializer, Equal)
CARBON_PARSE_NODE_KIND_WITH_TOKEN(Alias, CARBON_IF_VALID(Semi))

// A tuple pattern:
//   TuplePatternStart
//     _external_: [Generic]BindingPattern
//     PatternListComma
//   _repeated_
// TuplePattern
//
// Patterns and PatternListComma may repeat with PatternListComma as a
// separator.
CARBON_PARSE_NODE_KIND_WITH_TOKEN(TuplePatternStart, OpenParen)
CARBON_PARSE_NODE_KIND_WITH_TOKEN(PatternListComma, Comma)
CARBON_PARSE_NODE_KIND_WITH_TOKEN(TuplePattern, CloseParen)

// An implicit parameter list:
//   ImplicitParamListStart
//     _external_: [Generic]BindingPattern
//     PatternListComma
//   _repeated_
// ImplicitParamList
//
// Patterns and PatternListComma may repeat with PatternListComma as a
// separator.
CARBON_PARSE_NODE_KIND_WITH_TOKEN(ImplicitParamListStart, OpenSquareBracket)
CARBON_PARSE_NODE_KIND_WITH_TOKEN(ImplicitParamList, CloseSquareBracket)

// An array type, such as  `[i32; 3]` or `[i32;]`:
//     ArrayExprStart
//     _external_: type expression
//   ArrayExprSemi
//   _optional_ _external_: expression
// ArrayExpr
CARBON_PARSE_NODE_KIND_WITH_TOKEN(ArrayExprStart, OpenSquareBracket)
CARBON_PARSE_NODE_KIND_WITH_TOKEN(ArrayExprSemi, CARBON_IF_VALID(Semi))
CARBON_PARSE_NODE_KIND_WITH_TOKEN(ArrayExpr, CloseSquareBracket)

// A binding pattern, such as `name: Type`:
//       IdentifierName or SelfValueName
//       _external_: type expression
//     [Generic]BindingPattern
//   _optional_ Addr
// _optional_ Template
CARBON_PARSE_NODE_KIND_WITH_TOKEN(BindingPattern, CARBON_IF_VALID(Colon))
CARBON_PARSE_NODE_KIND_WITH_TOKEN(CompileTimeBindingPattern, ColonExclaim)
CARBON_PARSE_NODE_KIND_WITH_TOKEN(Addr, Addr)
CARBON_PARSE_NODE_KIND_WITH_TOKEN(Template, Template)

// `let` declarations, including associated constant declarations:
//   LetIntroducer
//   _repeated_ _external_: modifier
//   _external_: BindingPattern or TuplePattern
//     LetInitializer
//     _external_: expression
//   _optional_
// LetDecl
//
// Modifier keywords only appear for `let` declarations, not `let` statements.
//
// The LetInitializer and following expression are paired: either both will be
// present, or neither will.
CARBON_PARSE_NODE_KIND_WITH_TOKEN(LetIntroducer, Let)
CARBON_PARSE_NODE_KIND_WITH_TOKEN(LetInitializer, Equal)
CARBON_PARSE_NODE_KIND_WITH_TOKEN(LetDecl, CARBON_IF_VALID(Semi))

// `var` and `returned var`:
//   VariableIntroducer
//   _repeated_ _external_: modifier
//   _optional_ ReturnedModifier
//   _external_: BindingPattern or TuplePattern
//     VariableInitializer
//     _external_: expression
//   _optional_
// VariableDecl
//
// Access and declaration modifier keywords only appear for `var` declarations,
// whereas the returned modifier only appears on `var` statements.
//
// The VariableInitializer and following expression are paired: either both will
// be present, or neither will.
CARBON_PARSE_NODE_KIND_WITH_TOKEN(VariableIntroducer, CARBON_IF_VALID(Var))
CARBON_PARSE_NODE_KIND_WITH_TOKEN(ReturnedModifier, Returned)
CARBON_PARSE_NODE_KIND_WITH_TOKEN(VariableInitializer, Equal)
CARBON_PARSE_NODE_KIND_WITH_TOKEN(VariableDecl, CARBON_IF_VALID(Semi))

// An expression statement:
//   _external_: expression
// ExprStatement
CARBON_PARSE_NODE_KIND_WITH_TOKEN(ExprStatement, CARBON_IF_VALID(Semi))

// `break`:
//   BreakStatementStart
// BreakStatement
CARBON_PARSE_NODE_KIND_WITH_TOKEN(BreakStatementStart, Break)
CARBON_PARSE_NODE_KIND_WITH_TOKEN(BreakStatement, CARBON_IF_VALID(Semi))

// `continue`:
//   ContinueStatementStart
// ContinueStatement
CARBON_PARSE_NODE_KIND_WITH_TOKEN(ContinueStatementStart, Continue)
CARBON_PARSE_NODE_KIND_WITH_TOKEN(ContinueStatement, CARBON_IF_VALID(Semi))

// `return`:
//   ReturnStatementStart
//   _optional_ ReturnVarModifier or _external_: expression
// ReturnStatement
CARBON_PARSE_NODE_KIND_WITH_TOKEN(ReturnStatementStart, Return)
CARBON_PARSE_NODE_KIND_WITH_TOKEN(ReturnVarModifier, Var)
CARBON_PARSE_NODE_KIND_WITH_TOKEN(ReturnStatement, CARBON_IF_VALID(Semi))

// `for`:
//     ForHeaderStart
//       VariableIntroducer
//       _external_: BindingPattern
//     ForIn
//     _external_: expression
//   ForHeader
//   _external_: CodeBlock
// ForStatement
//
// Versus a normal `var`, ForIn replaces VariableDecl.
CARBON_PARSE_NODE_KIND_WITH_TOKEN(ForHeaderStart, CARBON_IF_VALID(OpenParen))
CARBON_PARSE_NODE_KIND_WITH_TOKEN(ForIn, CARBON_IF_VALID(In))
CARBON_PARSE_NODE_KIND_WITH_TOKEN(ForHeader, CARBON_IF_VALID(CloseParen))
CARBON_PARSE_NODE_KIND_WITH_TOKEN(ForStatement, For)

// `if` statement + `else`:
//     IfConditionStart
//     _external_: expression
//   IfCondition
//   _external_: CodeBlock
//   IfStatementElse
//   _external_: CodeBlock or IfStatement
// IfStatement
//
// IfStatementElse and the following node are optional based on `else` presence.
CARBON_PARSE_NODE_KIND_WITH_TOKEN(IfConditionStart, CARBON_IF_VALID(OpenParen))
CARBON_PARSE_NODE_KIND_WITH_TOKEN(IfCondition, CARBON_IF_VALID(CloseParen))
CARBON_PARSE_NODE_KIND_WITH_TOKEN(IfStatementElse, Else)
CARBON_PARSE_NODE_KIND_WITH_TOKEN(IfStatement, If)

// `while`:
//     WhileConditionStart
//     _external_: expression
//   WhileCondition
//   _external_: CodeBlock
// WhileStatement
CARBON_PARSE_NODE_KIND_WITH_TOKEN(WhileConditionStart,
                                  CARBON_IF_VALID(OpenParen))
CARBON_PARSE_NODE_KIND_WITH_TOKEN(WhileCondition, CARBON_IF_VALID(CloseParen))
CARBON_PARSE_NODE_KIND_WITH_TOKEN(WhileStatement, While)

// Index expressions, such as `a[1]`:
//     _external_: expression
//   IndexExprStart
//   _external_: expression
// IndexExpr
CARBON_PARSE_NODE_KIND_WITH_TOKEN(IndexExprStart, OpenSquareBracket)
CARBON_PARSE_NODE_KIND_WITH_TOKEN(IndexExpr, CloseSquareBracket)

// Parenthesized single expressions, such as `(2)`:
//   ParenExprStart
//   _external_: expression
// ParenExpr
CARBON_PARSE_NODE_KIND_WITH_TOKEN(ParenExprStart, OpenParen)
CARBON_PARSE_NODE_KIND_WITH_TOKEN(ParenExpr, CloseParen)

// Tuples, such as `(1, 2)`:
//   TupleLiteralStart
//     _external_: expression
//     TupleLiteralComma
//   _repeated_
// TupleLiteral
//
// Expressions and TupleLiteralComma may repeat with TupleLiteralComma as a
// separator.
CARBON_PARSE_NODE_KIND_WITH_TOKEN(TupleLiteralStart, OpenParen)
CARBON_PARSE_NODE_KIND_WITH_TOKEN(TupleLiteralComma, Comma)
CARBON_PARSE_NODE_KIND_WITH_TOKEN(TupleLiteral, CloseParen)

// Call expressions, such as `a()`:
//     _external_: expression
//   CallExprStart
//     _external_: expression
//     CallExprComma
//   _repeated_
// CallExpr
//
// Exprs and CallExprComma may repeat with CallExprComma as a separator.
CARBON_PARSE_NODE_KIND_WITH_TOKEN(CallExprStart, OpenParen)
CARBON_PARSE_NODE_KIND_WITH_TOKEN(CallExprComma, Comma)
CARBON_PARSE_NODE_KIND_WITH_TOKEN(CallExpr, CloseParen)

// A member access expression, such as `a.b` or
// `GetObject().(Interface.member)`:
//   _external_: lhs expression
//   _external_: rhs expression
// MemberAccessExpr
CARBON_PARSE_NODE_KIND_WITH_TOKEN(MemberAccessExpr, Period)

// A pointer member access expression, such as `a->b` or
// `GetObject()->(Interface.member)`:
//   _external_: lhs expression
//   _external_: rhs expression
// PointerMemberAccessExpr
CARBON_PARSE_NODE_KIND_WITH_TOKEN(PointerMemberAccessExpr, MinusGreater)

// A value literal.
CARBON_PARSE_NODE_KIND_TOKEN_LITERAL(BoolLiteralFalse, False)
CARBON_PARSE_NODE_KIND_TOKEN_LITERAL(BoolLiteralTrue, True)
CARBON_PARSE_NODE_KIND_TOKEN_LITERAL(IntLiteral, IntLiteral)
CARBON_PARSE_NODE_KIND_TOKEN_LITERAL(RealLiteral, RealLiteral)
CARBON_PARSE_NODE_KIND_TOKEN_LITERAL(StringLiteral, StringLiteral)

// A type literal.
CARBON_PARSE_NODE_KIND_TOKEN_LITERAL(BoolTypeLiteral, Bool)
CARBON_PARSE_NODE_KIND_TOKEN_LITERAL(IntTypeLiteral, IntTypeLiteral)
CARBON_PARSE_NODE_KIND_TOKEN_LITERAL(UnsignedIntTypeLiteral,
                                     UnsignedIntTypeLiteral)
CARBON_PARSE_NODE_KIND_TOKEN_LITERAL(FloatTypeLiteral, FloatTypeLiteral)
CARBON_PARSE_NODE_KIND_TOKEN_LITERAL(StringTypeLiteral, StringTypeLiteral)
CARBON_PARSE_NODE_KIND_TOKEN_LITERAL(TypeTypeLiteral, Type)
CARBON_PARSE_NODE_KIND_TOKEN_LITERAL(AutoTypeLiteral, Auto)

// A prefix operator, such as `not`:
//   _external_: expression
// PrefixOperator<name>
CARBON_PARSE_NODE_KIND_PREFIX_OPERATOR(Amp)
CARBON_PARSE_NODE_KIND_PREFIX_OPERATOR(Caret)
CARBON_PARSE_NODE_KIND_PREFIX_OPERATOR(Const)
CARBON_PARSE_NODE_KIND_PREFIX_OPERATOR(Not)
CARBON_PARSE_NODE_KIND_PREFIX_OPERATOR(Minus)
CARBON_PARSE_NODE_KIND_PREFIX_OPERATOR(MinusMinus)
CARBON_PARSE_NODE_KIND_PREFIX_OPERATOR(PlusPlus)
CARBON_PARSE_NODE_KIND_PREFIX_OPERATOR(Star)

// An infix operator, such as `+`:
//   _external_: lhs expression
//   _external_: rhs expression
// InfixOperator<name>
CARBON_PARSE_NODE_KIND_INFIX_OPERATOR(Amp)
CARBON_PARSE_NODE_KIND_INFIX_OPERATOR(AmpEqual)
CARBON_PARSE_NODE_KIND_INFIX_OPERATOR(As)
CARBON_PARSE_NODE_KIND_INFIX_OPERATOR(Caret)
CARBON_PARSE_NODE_KIND_INFIX_OPERATOR(CaretEqual)
CARBON_PARSE_NODE_KIND_INFIX_OPERATOR(Equal)
CARBON_PARSE_NODE_KIND_INFIX_OPERATOR(EqualEqual)
CARBON_PARSE_NODE_KIND_INFIX_OPERATOR(ExclaimEqual)
CARBON_PARSE_NODE_KIND_INFIX_OPERATOR(Greater)
CARBON_PARSE_NODE_KIND_INFIX_OPERATOR(GreaterEqual)
CARBON_PARSE_NODE_KIND_INFIX_OPERATOR(GreaterGreater)
CARBON_PARSE_NODE_KIND_INFIX_OPERATOR(GreaterGreaterEqual)
CARBON_PARSE_NODE_KIND_INFIX_OPERATOR(Less)
CARBON_PARSE_NODE_KIND_INFIX_OPERATOR(LessEqual)
CARBON_PARSE_NODE_KIND_INFIX_OPERATOR(LessEqualGreater)
CARBON_PARSE_NODE_KIND_INFIX_OPERATOR(LessLess)
CARBON_PARSE_NODE_KIND_INFIX_OPERATOR(LessLessEqual)
CARBON_PARSE_NODE_KIND_INFIX_OPERATOR(Minus)
CARBON_PARSE_NODE_KIND_INFIX_OPERATOR(MinusEqual)
CARBON_PARSE_NODE_KIND_INFIX_OPERATOR(Percent)
CARBON_PARSE_NODE_KIND_INFIX_OPERATOR(PercentEqual)
CARBON_PARSE_NODE_KIND_INFIX_OPERATOR(Pipe)
CARBON_PARSE_NODE_KIND_INFIX_OPERATOR(PipeEqual)
CARBON_PARSE_NODE_KIND_INFIX_OPERATOR(Plus)
CARBON_PARSE_NODE_KIND_INFIX_OPERATOR(PlusEqual)
CARBON_PARSE_NODE_KIND_INFIX_OPERATOR(Slash)
CARBON_PARSE_NODE_KIND_INFIX_OPERATOR(SlashEqual)
CARBON_PARSE_NODE_KIND_INFIX_OPERATOR(Star)
CARBON_PARSE_NODE_KIND_INFIX_OPERATOR(StarEqual)

// A postfix operator, currently only `*`:
//   _external_: expression
// PostfixOperator<name>
CARBON_PARSE_NODE_KIND_POSTFIX_OPERATOR(Star)

// A short-circuiting infix operator, such as `and`:
//     _external_: expression
//   ShortCircuitOperand(And|Or)
//   _external_: expression
// ShortCircuitOperand(And|Or)
CARBON_PARSE_NODE_KIND_WITH_TOKEN(ShortCircuitOperandAnd, And)
CARBON_PARSE_NODE_KIND_WITH_TOKEN(ShortCircuitOperandOr, Or)
CARBON_PARSE_NODE_KIND_WITH_TOKEN(ShortCircuitOperatorAnd, And)
CARBON_PARSE_NODE_KIND_WITH_TOKEN(ShortCircuitOperatorOr, Or)

// `if` expression + `then` + `else`:
//     _external_: expression
//   IfExprIf
//     _external_: expression
//   IfExprThen
//   _external_: expression
// IfExprElse
CARBON_PARSE_NODE_KIND_WITH_TOKEN(IfExprIf, If)
CARBON_PARSE_NODE_KIND_WITH_TOKEN(IfExprThen, Then)
CARBON_PARSE_NODE_KIND_WITH_TOKEN(IfExprElse, CARBON_IF_VALID(Else))

// Struct literals, such as `{.a = 0}`:
//   StructLiteralStart
//         _external_: IdentifierName or BaseName
//       StructFieldDesignator
//       _external_: expression
//     StructField
//     StructComma
//   _repeated_
// StructLiteral
//
// Struct type literals, such as `{.a: i32}`:
//   StructTypeLiteralStart
//         _external_: IdentifierName or BaseName
//       StructFieldDesignator
//       _external_: type expression
//     StructTypeField
//     StructComma
//   _repeated_
// StructTypeLiteral
//
// Elements (StructField and StructTypeField, respectively) and StructComma
// may repeat with StructComma as a separator.
//
// When a valid StructTypeField or StructField cannot be formed, elements
// may be replaced by InvalidParse, which may have a preceding sibling
// StructFieldDesignator if one was successfully parsed.
CARBON_PARSE_NODE_KIND_WITH_TOKEN(StructLiteralStart, OpenCurlyBrace)
CARBON_PARSE_NODE_KIND_WITH_TOKEN(StructTypeLiteralStart, OpenCurlyBrace)
CARBON_PARSE_NODE_KIND_WITH_TOKEN(StructFieldDesignator, Period)
CARBON_PARSE_NODE_KIND_WITH_TOKEN(StructField, Equal)
CARBON_PARSE_NODE_KIND_WITH_TOKEN(StructTypeField, Colon)
CARBON_PARSE_NODE_KIND_WITH_TOKEN(StructComma, Comma)
CARBON_PARSE_NODE_KIND_WITH_TOKEN(StructLiteral, CloseCurlyBrace)
CARBON_PARSE_NODE_KIND_WITH_TOKEN(StructTypeLiteral, CloseCurlyBrace)

// Various modifiers. These are all a single token.
CARBON_PARSE_NODE_KIND_TOKEN_MODIFIER(Abstract)
CARBON_PARSE_NODE_KIND_TOKEN_MODIFIER(Base)
CARBON_PARSE_NODE_KIND_TOKEN_MODIFIER(Default)
CARBON_PARSE_NODE_KIND_TOKEN_MODIFIER(Export)
CARBON_PARSE_NODE_KIND_TOKEN_MODIFIER(Extend)
CARBON_PARSE_NODE_KIND_TOKEN_MODIFIER(Extern)
CARBON_PARSE_NODE_KIND_TOKEN_MODIFIER(Final)
CARBON_PARSE_NODE_KIND_TOKEN_MODIFIER(Impl)
CARBON_PARSE_NODE_KIND_TOKEN_MODIFIER(Private)
CARBON_PARSE_NODE_KIND_TOKEN_MODIFIER(Protected)
CARBON_PARSE_NODE_KIND_TOKEN_MODIFIER(Virtual)

// `class`:
//     ClassIntroducer
//     _repeated_ _external_: modifier
//     _external_: _declaration name_
//     _optional_ _external_: ImplicitParamList
//     _optional_ _external_: TuplePattern
//   ClassDefinitionStart
//   _external_: declarations
// ClassDefinition
//
// The above is the structure for a definition; for a declaration,
// ClassDefinitionStart and later nodes are removed and replaced by
// ClassDecl.
CARBON_PARSE_NODE_KIND_WITH_TOKEN(ClassIntroducer, Class)
CARBON_PARSE_NODE_KIND_WITH_TOKEN(ClassDefinitionStart, OpenCurlyBrace)
CARBON_PARSE_NODE_KIND_WITH_TOKEN(ClassDefinition, CloseCurlyBrace)
CARBON_PARSE_NODE_KIND_WITH_TOKEN(ClassDecl, CARBON_IF_VALID(Semi))

// `adapt`:
//   AdaptIntroducer
//   _repeated_ _external_: modifier
//   _external_: expression
// AdaptDecl
CARBON_PARSE_NODE_KIND_WITH_TOKEN(AdaptIntroducer, Adapt)
CARBON_PARSE_NODE_KIND_WITH_TOKEN(AdaptDecl, CARBON_IF_VALID(Semi))

// `base`:
//   BaseIntroducer
//   _repeated_ _external_: modifier
//   BaseColon
//   _external_: expression
// BaseDecl
CARBON_PARSE_NODE_KIND_WITH_TOKEN(BaseIntroducer, Base)
CARBON_PARSE_NODE_KIND_WITH_TOKEN(BaseColon, Colon)
CARBON_PARSE_NODE_KIND_WITH_TOKEN(BaseDecl, CARBON_IF_VALID(Semi))

// `interface`:
//     InterfaceIntroducer
//     _repeated_ _external_: modifier
//     _external_: _declaration name_
//     _optional_ _external_: ImplicitParamList
//     _optional_ _external_: TuplePattern
//   InterfaceDefinitionStart
//   _external_: declarations
// InterfaceDefinition
//
// The above is the structure for a definition; for a declaration,
// InterfaceDefinitionStart and later nodes are removed and replaced by
// InterfaceDecl.
CARBON_PARSE_NODE_KIND_WITH_TOKEN(InterfaceIntroducer, Interface)
CARBON_PARSE_NODE_KIND_WITH_TOKEN(InterfaceDefinitionStart, OpenCurlyBrace)
CARBON_PARSE_NODE_KIND_WITH_TOKEN(InterfaceDefinition, CloseCurlyBrace)
CARBON_PARSE_NODE_KIND_WITH_TOKEN(InterfaceDecl, CARBON_IF_VALID(Semi))

// `impl ... as`:
//     ImplIntroducer
//     _repeated_ _external_: modifier
//     _optional_ _external_: ImplForall
//     _optional_ _external_: expression
//     _external_: DefaultSelfImplAs or TypeImplAs
//     _external_: expression
//   ImplDefinitionStart
//   _external_: declarations
// ImplDefinition
//
// The above is the structure for a definition; for a declaration,
// ImplDefinitionStart and later nodes are removed and replaced by
// ImplDecl.
CARBON_PARSE_NODE_KIND_WITH_TOKEN(ImplIntroducer, Impl)
CARBON_PARSE_NODE_KIND_WITH_TOKEN(ImplDefinitionStart, OpenCurlyBrace)
CARBON_PARSE_NODE_KIND_WITH_TOKEN(ImplDefinition, CloseCurlyBrace)
CARBON_PARSE_NODE_KIND_WITH_TOKEN(ImplDecl, CARBON_IF_VALID(Semi))

// `forall ...`:
//   _external_: ImplicitParamList
// ImplForall
CARBON_PARSE_NODE_KIND_WITH_TOKEN(ImplForall, Forall)

// `... as`:
//   _external_: expression
// TypeImplAs
CARBON_PARSE_NODE_KIND_WITH_TOKEN(TypeImplAs, As)
// `as` without a type before it
CARBON_PARSE_NODE_KIND_WITH_TOKEN(DefaultSelfImplAs, As)

// `constraint`:
//     NamedConstraintIntroducer
//     _repeated_ _external_: modifier
//     _external_: _declaration name_
//     _optional_ _external_: ImplicitParamList
//     _optional_ _external_: TuplePattern
//   NamedConstraintDefinitionStart
//   _external_: declarations
// NamedConstraintDefinition
//
// The above is the structure for a definition; for a declaration,
// NamedConstraintDefinitionStart and later nodes are removed and replaced by
// NamedConstraintDecl.
CARBON_PARSE_NODE_KIND_WITH_TOKEN(NamedConstraintIntroducer, Constraint)
CARBON_PARSE_NODE_KIND_WITH_TOKEN(NamedConstraintDefinitionStart,
                                  OpenCurlyBrace)
CARBON_PARSE_NODE_KIND_WITH_TOKEN(NamedConstraintDefinition, CloseCurlyBrace)
CARBON_PARSE_NODE_KIND_WITH_TOKEN(NamedConstraintDecl, CARBON_IF_VALID(Semi))

// `choice`:
//     ChoiceIntroducer
//     _external_: _declaration name_
//   ChoiceDefinitionStart
//   _optional_ _external_: ChoiceAlternativeList
// ChoiceDefinition
CARBON_PARSE_NODE_KIND_WITH_TOKEN(ChoiceIntroducer, Choice)
CARBON_PARSE_NODE_KIND_WITH_TOKEN(ChoiceDefinitionStart,
                                  CARBON_IF_VALID(OpenCurlyBrace))
CARBON_PARSE_NODE_KIND_WITH_TOKEN(ChoiceDefinition,
                                  CARBON_IF_VALID(CloseCurlyBrace))

// Choice alternative list:
//     _external_: IdentifierName
//     _optional_ _external_ : TuplePattern
//     _optional_: ChoiceAlternativeListComma
//   _repeated_
// ChoiceAlternativeList
CARBON_PARSE_NODE_KIND_WITH_TOKEN(ChoiceAlternativeListComma, Comma)

// `match`:
//     MatchIntroducer
//       MatchConditionStart
//       _external_: expression
//     MatchCondition
//   MatchStatementStart
//   _repeated_ _external_: MatchCase
//   _optional_ _external_: MatchStatementDefault
// MatchStatement
CARBON_PARSE_NODE_KIND_WITH_TOKEN(MatchIntroducer, Match)
CARBON_PARSE_NODE_KIND_WITH_TOKEN(MatchConditionStart,
                                  CARBON_IF_VALID(OpenParen))
CARBON_PARSE_NODE_KIND_WITH_TOKEN(MatchCondition, CARBON_IF_VALID(CloseParen))
CARBON_PARSE_NODE_KIND_WITH_TOKEN(MatchStatementStart,
                                  CARBON_IF_VALID(OpenCurlyBrace))
CARBON_PARSE_NODE_KIND_WITH_TOKEN(MatchStatement,
                                  CARBON_IF_VALID(CloseCurlyBrace))

// `case`:
//     MatchCaseIntroducer
//     _external_: Pattern
//       MatchCaseGuardIntroducer
//       MatchCaseGuardStart
//       _external_: expression
//     MatchCaseGuard
//     MatchCaseEqualGreater
//   MatchCaseStart
//   _repeated_ _external_: statement
// MatchCase
CARBON_PARSE_NODE_KIND_WITH_TOKEN(MatchCaseIntroducer, Case)
CARBON_PARSE_NODE_KIND_WITH_TOKEN(MatchCaseGuardIntroducer, If)
CARBON_PARSE_NODE_KIND_WITH_TOKEN(MatchCaseGuardStart,
                                  CARBON_IF_VALID(OpenParen))
CARBON_PARSE_NODE_KIND_WITH_TOKEN(MatchCaseGuard, CARBON_IF_VALID(CloseParen))
CARBON_PARSE_NODE_KIND_WITH_TOKEN(MatchCaseEqualGreater,
                                  CARBON_IF_VALID(EqualGreater))
CARBON_PARSE_NODE_KIND_WITH_TOKEN(MatchCaseStart,
                                  CARBON_IF_VALID(OpenCurlyBrace))
CARBON_PARSE_NODE_KIND_WITH_TOKEN(MatchCase, CARBON_IF_VALID(CloseCurlyBrace))

// `default`:
//     MatchDefaultIntroducer
//     MatchDefaultEqualGreater
//   MatchDefaultStart
//   _repeated_ _external_: statement
// MatchDefault
CARBON_PARSE_NODE_KIND_WITH_TOKEN(MatchDefaultIntroducer, Default)
CARBON_PARSE_NODE_KIND_WITH_TOKEN(MatchDefaultEqualGreater,
                                  CARBON_IF_VALID(EqualGreater))
CARBON_PARSE_NODE_KIND_WITH_TOKEN(MatchDefaultStart,
                                  CARBON_IF_VALID(OpenCurlyBrace))
CARBON_PARSE_NODE_KIND_WITH_TOKEN(MatchDefault,
                                  CARBON_IF_VALID(CloseCurlyBrace))

#undef CARBON_PARSE_NODE_KIND
#undef CARBON_PARSE_NODE_KIND_WITH_TOKEN
#undef CARBON_PARSE_NODE_KIND_INFIX_OPERATOR
#undef CARBON_PARSE_NODE_KIND_POSTFIX_OPERATOR
#undef CARBON_PARSE_NODE_KIND_PREFIX_OPERATOR
#undef CARBON_PARSE_NODE_KIND_TOKEN_LITERAL
#undef CARBON_PARSE_NODE_KIND_TOKEN_MODIFIER
#undef CARBON_IF_VALID