carbon-language/carbon-lang
1
0
Fork 0
mirror of https://github.com/carbon-language/carbon-lang.git synced 2026-09-24 21:20:11 +01:00
Code Issues Packages Projects Releases 10 Wiki Activity
Files
7d9340880ea2bcf8ea371e1a35bd9ddd658d3c24
carbon-lang/toolchain/parse/node_kind.def
T
Richard Smith 7d9340880e Separate ClassType from ClassDeclaration. (#3329) 
Retain the `ClassDeclaration` node to represent a syntactic declaration
of a class (including possibly a declaration of a generic class), but
use a separate SemIR node to represent the class type itself. This
allows us to give the two separate treatment.

The `ClassDeclaration` is still entered into the name lookup table for
its enclosing scope, but when it is named in an expression, the class
type is produced instead. When the class declaration is named in a
declaration name, it can be used to define members of the class, but an
expression that resolves to the class type cannot be used to define
members of the class.

In order to distinguish these cases, use `Name` rather than
`NameExpression` for the left-hand side of a `QualifiedName` parse node.
This removes the only use of the `Expression` form of a declaration
name, so that is also removed.

In the future, `ClassType` will also be used to describe types such as
`Vector(T)`, for which there is no corresponding `ClassDeclaration`.
2023-10-24 01:26:44 +00:00

590 lines
25 KiB
Modula-2
Raw Blame History

// 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. No kinds should use this
// directly.
// - CARBON_PARSE_NODE_KIND_BRACKET(Name, BracketName, LexTokenKinds)
// Defines a bracketed node kind. BracketName should refer to the node
// kind that is the _start_ of the bracketed range.
// - CARBON_PARSE_NODE_KIND_CHILD_COUNT(Name, ChildCount, LexTokenKinds)
// Defines a parse node with a set number of children, often 0. This count
// must be correct even when the node contains errors.
//
// In both cases, LexTokenKinds says which Lex::TokenKind values that this
// parse node can correspond to, and is a sequence of:
// - CARBON_TOKEN(kind): This node can correspond to this kind of token.
// - CARBON_ANY_TOKEN: This node can correspond to any token.
// - CARBON_IF_ERROR(LexTokenKinds): This node can additionally correspond
// to the given kinds of tokens if its `has_error` flag is set.
//
// 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. Comments will show their
// relationship in postorder, using indentation for child node relationships.
#if !(defined(CARBON_PARSE_NODE_KIND) || \
(defined(CARBON_PARSE_NODE_KIND_BRACKET) && \
defined(CARBON_PARSE_NODE_KIND_CHILD_COUNT)))
#error "Must define CARBON_PARSE_NODE_KIND family x-macros to use this file."
#endif
// The BRACKET and CHILD_COUNT macros will use CARBON_PARSE_NODE_KIND by default
// when undefined.
#ifndef CARBON_PARSE_NODE_KIND_BRACKET
#define CARBON_PARSE_NODE_KIND_BRACKET(Name, ...) CARBON_PARSE_NODE_KIND(Name)
#endif
#ifndef CARBON_PARSE_NODE_KIND_CHILD_COUNT
#define CARBON_PARSE_NODE_KIND_CHILD_COUNT(Name, ...) \
CARBON_PARSE_NODE_KIND(Name)
#endif
// The start of the file.
CARBON_PARSE_NODE_KIND_CHILD_COUNT(FileStart, 0, CARBON_TOKEN(StartOfFile))
// The end of the file.
CARBON_PARSE_NODE_KIND_CHILD_COUNT(FileEnd, 0, CARBON_TOKEN(EndOfFile))
// An invalid parse. Used to balance the parse tree. Always has an error.
CARBON_PARSE_NODE_KIND_CHILD_COUNT(InvalidParse, 0,
CARBON_IF_ERROR(CARBON_ANY_TOKEN))
// An empty declaration, such as `;`.
CARBON_PARSE_NODE_KIND_CHILD_COUNT(EmptyDeclaration, 0,
CARBON_TOKEN(Semi)
CARBON_IF_ERROR(CARBON_ANY_TOKEN))
// A name in a non-expression context, such as a declaration.
CARBON_PARSE_NODE_KIND_CHILD_COUNT(Name, 0,
CARBON_TOKEN(Identifier)
CARBON_IF_ERROR(CARBON_ANY_TOKEN))
// A name in an expression context.
CARBON_PARSE_NODE_KIND_CHILD_COUNT(NameExpression, 0, CARBON_TOKEN(Identifier))
// ----------------------------------------------------------------------------
// 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:
// - `_external_:` if this node is the child of multiple kinds of nodes and
// is documented separately.
// - `_optional_` if this node may be present or omitted in valid parses,
// depending on which tokens are in the source code.
// ----------------------------------------------------------------------------
// `package`:
// PackageIntroducer
// _external_: Name
// _external_: Literal
// PackageLibrary
// PackageApi or PackageImpl
// PackageDirective
CARBON_PARSE_NODE_KIND_CHILD_COUNT(PackageIntroducer, 0, CARBON_TOKEN(Package))
CARBON_PARSE_NODE_KIND_CHILD_COUNT(PackageApi, 0, CARBON_TOKEN(Api))
CARBON_PARSE_NODE_KIND_CHILD_COUNT(PackageImpl, 0, CARBON_TOKEN(Impl))
CARBON_PARSE_NODE_KIND_CHILD_COUNT(PackageLibrary, 1, CARBON_TOKEN(Library))
CARBON_PARSE_NODE_KIND_BRACKET(PackageDirective, PackageIntroducer,
CARBON_TOKEN(Semi)
CARBON_IF_ERROR(CARBON_TOKEN(Package)))
// `namespace`:
// NamespaceStart
// _external_: Name or QualifiedDeclaration
// Namespace
CARBON_PARSE_NODE_KIND_CHILD_COUNT(NamespaceStart, 0, CARBON_TOKEN(Namespace))
CARBON_PARSE_NODE_KIND_CHILD_COUNT(Namespace, 2, CARBON_TOKEN(Semi))
// A code block:
// CodeBlockStart
// _external_: statements
// CodeBlock
CARBON_PARSE_NODE_KIND_CHILD_COUNT(CodeBlockStart, 0,
CARBON_TOKEN(OpenCurlyBrace)
CARBON_IF_ERROR(CARBON_ANY_TOKEN))
CARBON_PARSE_NODE_KIND_BRACKET(CodeBlock, CodeBlockStart,
CARBON_TOKEN(CloseCurlyBrace)
CARBON_IF_ERROR(CARBON_ANY_TOKEN))
// `fn`:
// FunctionIntroducer
// _external_: Name or QualifiedDeclaration
// _external_: ParameterList
// _external_: type expression
// ReturnType
// FunctionDefinitionStart
// _external_: statements
// FunctionDefinition
//
// The above is the structure for a definition; for a declaration,
// FunctionDefinitionStart and later nodes are removed and replaced by
// FunctionDeclaration.
CARBON_PARSE_NODE_KIND_CHILD_COUNT(FunctionIntroducer, 0, CARBON_TOKEN(Fn))
CARBON_PARSE_NODE_KIND_CHILD_COUNT(ReturnType, 1, CARBON_TOKEN(MinusGreater))
CARBON_PARSE_NODE_KIND_BRACKET(FunctionDefinitionStart, FunctionIntroducer,
CARBON_TOKEN(OpenCurlyBrace))
CARBON_PARSE_NODE_KIND_BRACKET(FunctionDefinition, FunctionDefinitionStart,
CARBON_TOKEN(CloseCurlyBrace))
CARBON_PARSE_NODE_KIND_BRACKET(FunctionDeclaration, FunctionIntroducer,
CARBON_TOKEN(Semi)
CARBON_IF_ERROR(CARBON_TOKEN(Fn)))
// A parameter list, possibly deduced:
// [Deduced]ParamertListStart
// _external_: [Generic]PatternBinding
// ParameterListComma
// [Deduced]ParameterList
//
// Expressions and ParameterListComma may repeat with ParameterListComma as a
// separator.
CARBON_PARSE_NODE_KIND_CHILD_COUNT(ParameterListStart, 0,
CARBON_TOKEN(OpenParen))
CARBON_PARSE_NODE_KIND_CHILD_COUNT(DeducedParameterListStart, 0,
CARBON_TOKEN(OpenSquareBracket))
CARBON_PARSE_NODE_KIND_CHILD_COUNT(ParameterListComma, 0, CARBON_TOKEN(Comma))
CARBON_PARSE_NODE_KIND_BRACKET(ParameterList, ParameterListStart,
CARBON_TOKEN(CloseParen))
CARBON_PARSE_NODE_KIND_BRACKET(DeducedParameterList, DeducedParameterListStart,
CARBON_TOKEN(CloseSquareBracket))
// An array type, such as `[i32; 3]` or `[i32;]`:
// ArrayExpressionStart
// _external_: type expression
// ArrayExpressionSemi
// _optional_ _external_: expression
// ArrayExpression
CARBON_PARSE_NODE_KIND_CHILD_COUNT(ArrayExpressionStart, 0,
CARBON_TOKEN(OpenSquareBracket))
CARBON_PARSE_NODE_KIND_CHILD_COUNT(
ArrayExpressionSemi, 2,
CARBON_TOKEN(Semi) CARBON_IF_ERROR(CARBON_TOKEN(CloseSquareBracket)))
CARBON_PARSE_NODE_KIND_BRACKET(ArrayExpression, ArrayExpressionSemi,
CARBON_TOKEN(CloseSquareBracket))
// A pattern binding, such as `name: Type`:
// Name
// _external_: type expression
// [Generic]PatternBinding
// _optional_ Address
// _optional_ Template
CARBON_PARSE_NODE_KIND_CHILD_COUNT(PatternBinding, 2,
CARBON_TOKEN(Colon)
CARBON_IF_ERROR(CARBON_ANY_TOKEN))
CARBON_PARSE_NODE_KIND_CHILD_COUNT(GenericPatternBinding, 2,
CARBON_TOKEN(ColonExclaim))
CARBON_PARSE_NODE_KIND_CHILD_COUNT(Address, 1, CARBON_TOKEN(Addr))
CARBON_PARSE_NODE_KIND_CHILD_COUNT(Template, 1, CARBON_TOKEN(Template))
// `let`:
// LetIntroducer
// _external_: PatternBinding
// LetInitializer
// _external_: expression
// LetDeclaration
CARBON_PARSE_NODE_KIND_CHILD_COUNT(LetIntroducer, 0, CARBON_TOKEN(Let))
CARBON_PARSE_NODE_KIND_CHILD_COUNT(LetInitializer, 0, CARBON_TOKEN(Equal))
CARBON_PARSE_NODE_KIND_BRACKET(LetDeclaration, LetIntroducer,
CARBON_TOKEN(Semi)
CARBON_IF_ERROR(CARBON_TOKEN(Let)))
// `var`:
// VariableIntroducer
// _external_: PatternBinding
// _optional_ VariableInitializer
// _optional_ _external_: expression
// VariableDeclaration
//
// The VariableInitializer and following expression are paired: either both will
// be present, or neither will.
CARBON_PARSE_NODE_KIND_CHILD_COUNT(VariableIntroducer, 0, CARBON_TOKEN(Var))
CARBON_PARSE_NODE_KIND_CHILD_COUNT(VariableInitializer, 0, CARBON_TOKEN(Equal))
CARBON_PARSE_NODE_KIND_BRACKET(VariableDeclaration, VariableIntroducer,
CARBON_TOKEN(Semi)
CARBON_IF_ERROR(CARBON_TOKEN(Var)))
// An expression statement:
// _external_: expression
// ExpressionStatement
CARBON_PARSE_NODE_KIND_CHILD_COUNT(ExpressionStatement, 1, CARBON_TOKEN(Semi))
// `break`:
// BreakStatementStart
// BreakStatement
CARBON_PARSE_NODE_KIND_CHILD_COUNT(BreakStatementStart, 0, CARBON_TOKEN(Break))
CARBON_PARSE_NODE_KIND_CHILD_COUNT(BreakStatement, 1,
CARBON_TOKEN(Semi)
CARBON_IF_ERROR(CARBON_TOKEN(Break)))
// `continue`:
// ContinueStatementStart
// ContinueStatement
CARBON_PARSE_NODE_KIND_CHILD_COUNT(ContinueStatementStart, 0,
CARBON_TOKEN(Continue))
CARBON_PARSE_NODE_KIND_CHILD_COUNT(ContinueStatement, 1,
CARBON_TOKEN(Semi)
CARBON_IF_ERROR(CARBON_TOKEN(Continue)))
// `return`:
// ReturnStatementStart
// _optional_ _external_: expression
// ReturnStatement
CARBON_PARSE_NODE_KIND_CHILD_COUNT(ReturnStatementStart, 0,
CARBON_TOKEN(Return))
CARBON_PARSE_NODE_KIND_BRACKET(ReturnStatement, ReturnStatementStart,
CARBON_TOKEN(Semi)
CARBON_IF_ERROR(CARBON_TOKEN(Return)))
// `for`:
// ForHeaderStart
// VariableIntroducer
// _external_: PatternBinding
// ForIn
// _external_: expression
// ForHeader
// _external_: CodeBlock
// ForStatement
//
// Versus a normal `var`, ForIn replaces VariableDeclaration.
CARBON_PARSE_NODE_KIND_CHILD_COUNT(ForHeaderStart, 0,
CARBON_TOKEN(OpenParen)
CARBON_IF_ERROR(CARBON_TOKEN(For)))
CARBON_PARSE_NODE_KIND_BRACKET(ForIn, VariableIntroducer,
CARBON_TOKEN(In)
CARBON_IF_ERROR(CARBON_ANY_TOKEN))
CARBON_PARSE_NODE_KIND_BRACKET(ForHeader, ForHeaderStart,
CARBON_TOKEN(CloseParen)
CARBON_IF_ERROR(CARBON_TOKEN(For)))
CARBON_PARSE_NODE_KIND_CHILD_COUNT(ForStatement, 2, CARBON_TOKEN(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_CHILD_COUNT(IfConditionStart, 0,
CARBON_TOKEN(OpenParen)
CARBON_IF_ERROR(CARBON_TOKEN(If)))
CARBON_PARSE_NODE_KIND_BRACKET(IfCondition, IfConditionStart,
CARBON_TOKEN(CloseParen)
CARBON_IF_ERROR(CARBON_TOKEN(If)))
CARBON_PARSE_NODE_KIND_CHILD_COUNT(IfStatementElse, 0, CARBON_TOKEN(Else))
CARBON_PARSE_NODE_KIND_BRACKET(IfStatement, IfCondition, CARBON_TOKEN(If))
// `while`:
// WhileConditionStart
// _external_: expression
// WhileCondition
// _external_: CodeBlock
// WhileStatement
CARBON_PARSE_NODE_KIND_CHILD_COUNT(WhileConditionStart, 0,
CARBON_TOKEN(OpenParen))
CARBON_PARSE_NODE_KIND_BRACKET(WhileCondition, WhileConditionStart,
CARBON_TOKEN(CloseParen))
CARBON_PARSE_NODE_KIND_CHILD_COUNT(WhileStatement, 2, CARBON_TOKEN(While))
// Index expressions, such as `a[1]`:
// _external_: expression
// IndexExpressionStart
// _external_: expression
// IndexExpression
CARBON_PARSE_NODE_KIND_CHILD_COUNT(IndexExpressionStart, 1,
CARBON_TOKEN(OpenSquareBracket))
CARBON_PARSE_NODE_KIND_BRACKET(IndexExpression, IndexExpressionStart,
CARBON_TOKEN(CloseSquareBracket))
// Parenthesized expressions, such as `(2)`:
// ParenExpressionOrTupleLiteralStart
// _external_: expression
// ParenExpression
//
// Tuples, such as `(1, 2)`:
// ParenExpressionOrTupleLiteralStart
// _external_: expression
// TupleLiteralComma
// TupleLiteral
//
// Expressions and TupleLiteralComma may repeat with TupleLiteralComma as a
// separator.
CARBON_PARSE_NODE_KIND_CHILD_COUNT(ParenExpressionOrTupleLiteralStart, 0,
CARBON_TOKEN(OpenParen))
CARBON_PARSE_NODE_KIND_BRACKET(ParenExpression,
ParenExpressionOrTupleLiteralStart,
CARBON_TOKEN(CloseParen))
CARBON_PARSE_NODE_KIND_CHILD_COUNT(TupleLiteralComma, 0, CARBON_TOKEN(Comma))
CARBON_PARSE_NODE_KIND_BRACKET(TupleLiteral, ParenExpressionOrTupleLiteralStart,
CARBON_TOKEN(CloseParen))
// Call expressions, such as `a()`:
// _external_: expression
// CallExpressionStart
// _external_: expression
// CallExpressionComma
// CallExpression
//
// Expressions and CallExpressionComma may repeat with CallExpressionComma as a
// separator.
CARBON_PARSE_NODE_KIND_CHILD_COUNT(CallExpressionStart, 1,
CARBON_TOKEN(OpenParen))
CARBON_PARSE_NODE_KIND_CHILD_COUNT(CallExpressionComma, 0, CARBON_TOKEN(Comma))
CARBON_PARSE_NODE_KIND_BRACKET(CallExpression, CallExpressionStart,
CARBON_TOKEN(CloseParen))
// A qualified declaration, such as `a.b`:
// _external_: Name or QualifiedDeclaration
// _external_: Name
// QualifiedDeclaration
//
// TODO: This will eventually more general expressions, for example with
// `GenericType(type_args).ChildType(child_type_args).Name`.
CARBON_PARSE_NODE_KIND_CHILD_COUNT(QualifiedDeclaration, 2,
CARBON_TOKEN(Period))
// A member access expression, such as `a.b` or
// `GetObject().(Interface.member)`:
// _external_: lhs expression
// _external_: rhs expression
// QualifiedExpression
CARBON_PARSE_NODE_KIND_CHILD_COUNT(MemberAccessExpression, 2,
CARBON_TOKEN(Period))
// A pointer member access expression, such as `a->b` or
// `GetObject()->(Interface.member)`:
// _external_: lhs expression
// _external_: rhs expression
// QualifiedExpression
CARBON_PARSE_NODE_KIND_CHILD_COUNT(PointerMemberAccessExpression, 2,
CARBON_TOKEN(MinusGreater))
// clang-format off
// A literal.
CARBON_PARSE_NODE_KIND_CHILD_COUNT(Literal, 0,
CARBON_TOKEN(False)
CARBON_TOKEN(True)
CARBON_TOKEN(IntegerLiteral)
CARBON_TOKEN(RealLiteral)
CARBON_TOKEN(StringLiteral)
CARBON_TOKEN(Bool)
CARBON_TOKEN(IntegerTypeLiteral)
CARBON_TOKEN(UnsignedIntegerTypeLiteral)
CARBON_TOKEN(FloatingPointTypeLiteral)
CARBON_TOKEN(StringTypeLiteral)
CARBON_TOKEN(Type))
// A prefix operator:
// _external_: expression
// PrefixOperator
CARBON_PARSE_NODE_KIND_CHILD_COUNT(PrefixOperator, 1,
CARBON_TOKEN(Star)
CARBON_TOKEN(Amp)
CARBON_TOKEN(Not)
CARBON_TOKEN(Minus)
CARBON_TOKEN(MinusMinus)
CARBON_TOKEN(PlusPlus)
CARBON_TOKEN(Caret)
CARBON_TOKEN(Const))
// An infix operator:
// _external_: lhs expression
// _external_: rhs expression
// InfixOperator
CARBON_PARSE_NODE_KIND_CHILD_COUNT(InfixOperator, 2,
CARBON_TOKEN(Amp)
CARBON_TOKEN(AmpEqual)
CARBON_TOKEN(And)
CARBON_TOKEN(As)
CARBON_TOKEN(Caret)
CARBON_TOKEN(CaretEqual)
CARBON_TOKEN(Equal)
CARBON_TOKEN(EqualEqual)
CARBON_TOKEN(ExclaimEqual)
CARBON_TOKEN(Greater)
CARBON_TOKEN(GreaterEqual)
CARBON_TOKEN(GreaterGreater)
CARBON_TOKEN(GreaterGreaterEqual)
CARBON_TOKEN(Less)
CARBON_TOKEN(LessEqual)
CARBON_TOKEN(LessLess)
CARBON_TOKEN(LessLessEqual)
CARBON_TOKEN(Minus)
CARBON_TOKEN(MinusEqual)
CARBON_TOKEN(Or)
CARBON_TOKEN(Percent)
CARBON_TOKEN(PercentEqual)
CARBON_TOKEN(Pipe)
CARBON_TOKEN(PipeEqual)
CARBON_TOKEN(Plus)
CARBON_TOKEN(PlusEqual)
CARBON_TOKEN(Slash)
CARBON_TOKEN(SlashEqual)
CARBON_TOKEN(Star)
CARBON_TOKEN(StarEqual))
// clang-format on
// The first operand of a short-circuiting infix operator:
// _external_: expression
// ShortCircuitOperand
// _external_: expression
// _external_: InfixOperator
CARBON_PARSE_NODE_KIND_CHILD_COUNT(ShortCircuitOperand, 1,
CARBON_TOKEN(And) CARBON_TOKEN(Or))
// A postfix operator:
// _external_: expression
// PostfixOperator
CARBON_PARSE_NODE_KIND_CHILD_COUNT(PostfixOperator, 1, CARBON_TOKEN(Star))
// `if` expression + `then` + `else`:
// _external_: expression
// IfExpressionIf
// _external_: expression
// IfExpressionThen
// _external_: expression
// IfExpressionElse
CARBON_PARSE_NODE_KIND_CHILD_COUNT(IfExpressionIf, 1, CARBON_TOKEN(If))
CARBON_PARSE_NODE_KIND_CHILD_COUNT(IfExpressionThen, 1, CARBON_TOKEN(Then))
CARBON_PARSE_NODE_KIND_CHILD_COUNT(IfExpressionElse, 3,
CARBON_TOKEN(Else)
CARBON_IF_ERROR(CARBON_TOKEN(If)))
// Struct literals, such as `{.a = 0}`:
// StructLiteralOrStructTypeLiteralStart
// _external_: Name
// StructFieldDesignator
// _external_: expression
// StructFieldValue
// StructComma
// StructLiteral
//
// Struct type literals, such as `{.a: i32}`:
// _external_: Name
// StructFieldDesignator
// _external_: type expression
// StructFieldType
// StructComma
// StructTypeLiteral
//
// Elements (StructFieldValue and StructFieldType, respectively) and StructComma
// may repeat with StructComma as a separator.
//
// When a valid StructFieldType or StructFieldValue cannot be formed, elements
// may be replaced by StructFieldUnknown, which may have a preceding sibling
// StructFieldDesignator if one was successfully parsed.
CARBON_PARSE_NODE_KIND_CHILD_COUNT(StructLiteralOrStructTypeLiteralStart, 0,
CARBON_TOKEN(OpenCurlyBrace))
CARBON_PARSE_NODE_KIND_CHILD_COUNT(StructFieldDesignator, 1,
CARBON_TOKEN(Period))
CARBON_PARSE_NODE_KIND_CHILD_COUNT(StructFieldValue, 2, CARBON_TOKEN(Equal))
CARBON_PARSE_NODE_KIND_CHILD_COUNT(StructFieldType, 2, CARBON_TOKEN(Colon))
CARBON_PARSE_NODE_KIND_CHILD_COUNT(StructFieldUnknown, 0,
CARBON_IF_ERROR(CARBON_ANY_TOKEN))
CARBON_PARSE_NODE_KIND_CHILD_COUNT(StructComma, 0, CARBON_TOKEN(Comma))
CARBON_PARSE_NODE_KIND_BRACKET(StructLiteral,
StructLiteralOrStructTypeLiteralStart,
CARBON_TOKEN(CloseCurlyBrace))
CARBON_PARSE_NODE_KIND_BRACKET(StructTypeLiteral,
StructLiteralOrStructTypeLiteralStart,
CARBON_TOKEN(CloseCurlyBrace))
// `class`:
// ClassIntroducer
// _external_: Name or QualifiedDeclaration
// ClassDefinitionStart
// _external_: declarations
// ClassDefinition
//
// The above is the structure for a definition; for a declaration,
// ClassDefinitionStart and later nodes are removed and replaced by
// ClassDeclaration.
CARBON_PARSE_NODE_KIND_CHILD_COUNT(ClassIntroducer, 0, CARBON_TOKEN(Class))
CARBON_PARSE_NODE_KIND_BRACKET(ClassDefinitionStart, ClassIntroducer,
CARBON_TOKEN(OpenCurlyBrace))
CARBON_PARSE_NODE_KIND_BRACKET(ClassDefinition, ClassDefinitionStart,
CARBON_TOKEN(CloseCurlyBrace))
CARBON_PARSE_NODE_KIND_BRACKET(ClassDeclaration, ClassIntroducer,
CARBON_TOKEN(Semi)
CARBON_IF_ERROR(CARBON_TOKEN(Class)))
// `interface`:
// InterfaceIntroducer
// _external_: Name or QualifiedDeclaration
// InterfaceDefinitionStart
// _external_: declarations
// InterfaceDefinition
//
// The above is the structure for a definition; for a declaration,
// InterfaceDefinitionStart and later nodes are removed and replaced by
// InterfaceDeclaration.
CARBON_PARSE_NODE_KIND_CHILD_COUNT(InterfaceIntroducer, 0,
CARBON_TOKEN(Interface))
CARBON_PARSE_NODE_KIND_BRACKET(InterfaceDefinitionStart, InterfaceIntroducer,
CARBON_TOKEN(OpenCurlyBrace))
CARBON_PARSE_NODE_KIND_BRACKET(InterfaceDefinition, InterfaceDefinitionStart,
CARBON_TOKEN(CloseCurlyBrace))
CARBON_PARSE_NODE_KIND_BRACKET(InterfaceDeclaration, InterfaceIntroducer,
CARBON_TOKEN(Semi)
CARBON_IF_ERROR(CARBON_TOKEN(Interface)))
// `constraint`:
// NamedConstraintIntroducer
// _external_: Name or QualifiedDeclaration
// NamedConstraintDefinitionStart
// _external_: declarations
// NamedConstraintDefinition
//
// The above is the structure for a definition; for a declaration,
// NamedConstraintDefinitionStart and later nodes are removed and replaced by
// NamedConstraintDeclaration.
CARBON_PARSE_NODE_KIND_CHILD_COUNT(NamedConstraintIntroducer, 0,
CARBON_TOKEN(Constraint))
CARBON_PARSE_NODE_KIND_BRACKET(NamedConstraintDefinitionStart,
NamedConstraintIntroducer,
CARBON_TOKEN(OpenCurlyBrace))
CARBON_PARSE_NODE_KIND_BRACKET(NamedConstraintDefinition,
NamedConstraintDefinitionStart,
CARBON_TOKEN(CloseCurlyBrace))
CARBON_PARSE_NODE_KIND_BRACKET(NamedConstraintDeclaration,
NamedConstraintIntroducer, CARBON_TOKEN(Semi))
// The `self` value and `Self` type identifier keywords. Typically of the form
// `self: Self`:
// SelfValueName
// SelfTypeNameExpression
// PatternBinding
CARBON_PARSE_NODE_KIND_CHILD_COUNT(SelfValueName, 0,
CARBON_TOKEN(SelfValueIdentifier))
CARBON_PARSE_NODE_KIND_CHILD_COUNT(SelfTypeNameExpression, 0,
CARBON_TOKEN(SelfTypeIdentifier))
#undef CARBON_PARSE_NODE_KIND
#undef CARBON_PARSE_NODE_KIND_BRACKET
#undef CARBON_PARSE_NODE_KIND_CHILD_COUNT
#undef CARBON_TOKEN
#undef CARBON_ANY_TOKEN
#undef CARBON_IF_ERROR
Reference in New Issue View Git Blame Copy Permalink