carbon-language/carbon-lang
1
0
Fork 0
mirror of https://github.com/carbon-language/carbon-lang.git synced 2026-09-28 20:54:52 +01:00
Code Issues Packages Projects Releases 10 Wiki Activity
Files
cf2ddc607204cb5d1de85242f030d5886c2a3fc6
carbon-lang/toolchain/parser/parser_state.def
T
Jon Ross-Perkins 918c089e03 Add namespace support. (#2940) 
This handles namespacing of functions. Parsing and semantics are changed
significantly, while lowering works without changes. Variables can't be
namespaced yet because they're dealing with patterns, and I didn't dig
through that code.

Most of the logic is done through the new name declaration stack, which
is necessary because semantics isn't quite sure where the declaration
name ends. It'd be complex for parsing to send a signal about this,
probably involving node variants and rewrites of the tree, and this
solution seems to work well. Unfortunately this means a new stack, but
that may be inevitable due to the extra information needing to be
tracked.

Note this doesn't deal with scoped lookups of non-namespace things,
which we'll need for generics. That'll probably involve pushing resolved
scopes onto a stack (or maybe just setting a singleton value?) to affect
contextual name lookup. But, I think the basics are there to make it
work when we can test the behavior.

This renames "designator expression" to "qualified expression" and adds
"qualified declaration" in order to use terminology more consistent with
C++.

Namespaces will probably need to be considered for name mangling down
the line, but this still uses the basic name.
2023-07-06 20:43:40 +00:00

690 lines
18 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_PARSER_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.
//
// Comments will describe a series of possible output states. States are listed
// 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.
//
// Where state output is conditional on a lexed token, the name of
// the TokenKind should be used rather than the string name in order to make it
// easier to compare with code.
#ifndef CARBON_PARSER_STATE
#error "Must define the x-macro to use this file."
#endif
// Use CARBON_PARSER_STATE_VARIANTSN(State, Variant1, Variant2, ...) to generate
// StateAsVariant1, StateAsVariant2, ... states.
#define CARBON_PARSER_STATE_VARIANT(State, Variant) \
CARBON_PARSER_STATE(State##As##Variant)
#define CARBON_PARSER_STATE_VARIANTS2(State, Variant1, Variant2) \
CARBON_PARSER_STATE_VARIANT(State, Variant1) \
CARBON_PARSER_STATE_VARIANT(State, Variant2)
#define CARBON_PARSER_STATE_VARIANTS3(State, Variant1, Variant2, Variant3) \
CARBON_PARSER_STATE_VARIANT(State, Variant1) \
CARBON_PARSER_STATE_VARIANTS2(State, Variant2, Variant3)
// Handles the `{` of a brace expression.
//
// If `CloseCurlyBrace`:
// 1. BraceExpressionFinishAsUnknown
// Else:
// 1. BraceExpressionParameterAsUnknown
// 2. BraceExpressionFinishAsUnknown
CARBON_PARSER_STATE(BraceExpression)
// 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.
//
// If valid:
// 1. DesignatorExpressionAsStruct
// 2. BraceExpressionParameterAfterDesignatorAs(Type|Value|Unknown)
// Else:
// 1. BraceExpressionParameterFinishAs(Type|Value|Unknown)
CARBON_PARSER_STATE_VARIANTS3(BraceExpressionParameter, 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.
//
// If valid:
// 1. Expression
// 2. BraceExpressionParameterFinishAs(Type|Value|Unknown)
// Else:
// 1. BraceExpressionParameterFinishAs(Type|Value|Unknown)
CARBON_PARSER_STATE_VARIANTS3(BraceExpressionParameterAfterDesignator, Type,
Value, Unknown)
// Handles the end of a brace expression parameter.
//
// If `Comma`:
// 1. BraceExpressionParameterAsUnknown
// Else:
// (state done)
CARBON_PARSER_STATE_VARIANTS3(BraceExpressionParameterFinish, Type, Value,
Unknown)
// Handles the `}` of a brace expression.
//
// Always:
// (state done)
CARBON_PARSER_STATE_VARIANTS3(BraceExpressionFinish, Type, Value, Unknown)
// Handles a call expression `(...)`.
//
// If `CloseParen`:
// 1. CallExpressionFinish
// Else:
// 1. Expression
// 2. CallExpressionParameterFinish
// 3. CallExpressionFinish
CARBON_PARSER_STATE(CallExpression)
// Handles the `,` or `)` after a call parameter.
//
// If `Comma`:
// 1. Expression
// 2. CallExpressionParameterFinish
// Else:
// (state done)
CARBON_PARSER_STATE(CallExpressionParameterFinish)
// Handles finishing the call expression.
//
// Always:
// (state done)
CARBON_PARSER_STATE(CallExpressionFinish)
// Handles processing at the `{` on a typical code block.
//
// If `OpenCurlyBrace`:
// 1. StatementScopeLoop
// 2. CodeBlockFinish
// Else:
// 1. Statement
// 2. CodeBlockFinish
CARBON_PARSER_STATE(CodeBlock)
// Handles processing at the `}` on a typical code block, after a statement
// scope is done.
//
// Always:
// (state done)
CARBON_PARSER_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[...](...)`.
//
// If `Identifier` followed by `Period`:
// 1. DeclarationNameAndParamsAfterNameAs(None|Optional|Required)
// If `Identifier`:
// 1. DeclarationNameAndParamsAfterNameAs(None|Optional|Required)
// 2. PeriodAsDeclaration
// Else:
// (state done)
CARBON_PARSER_STATE_VARIANTS3(DeclarationNameAndParams, None, Optional,
Required)
// Handles a declaration name between the main name and deduced parameters.
//
// For `None`, parameters aren't supported so only `Period` or `Else` paths are
// used.
//
// If `Period`:
// 1. DeclarationNameAndParamsAfterNameAs(None|Optional|Required)
// 2. PeriodAsDeclaration
// If `OpenSquareBracket`:
// 1. ParameterListAsDeduced
// 2. DeclarationNameAndParamsAfterDeduced
// If `OpenParen`:
// 1. ParameterListAsRegular
// Else:
// (state done)
CARBON_PARSER_STATE_VARIANTS3(DeclarationNameAndParamsAfterName, None, Optional,
Required)
// Handles regular parameters such as `(...)` for the general declaration case.
// Only used after deduced parameters.
//
// If `OpenParen`:
// 1. ParameterListAsRegular
// Else:
// (state done)
CARBON_PARSER_STATE(DeclarationNameAndParamsAfterDeduced)
// Handles processing of a declaration scope. Things like fn, class, interface,
// and so on.
//
// If `EndOfFile`:
// (state done)
// If `Class`:
// 1. TypeIntroducerAsClass
// 2. DeclarationScopeLoop
// If `Constraint`:
// 1. TypeIntroducerAsNamedConstraint
// 2. DeclarationScopeLoop
// If `Fn`:
// 1. FunctionIntroducer
// 2. DeclarationScopeLoop
// If `Interface`:
// 1. TypeIntroducerAsInterface
// 2. DeclarationScopeLoop
// If `Namespace`:
// 2. Namespace
// 3. DeclarationScopeLoop
// If `Semi`:
// 1. DeclarationScopeLoop
// If `Var`:
// 1. Var
// 2. DeclarationScopeLoop
// Else:
// 1. DeclarationScopeLoop
CARBON_PARSER_STATE(DeclarationScopeLoop)
// Handles periods. Only does one `.<expression>` segment; the source is
// responsible for handling chaining.
//
// The forms of this are:
// - Designated names in structs.
// - Qualified names in declarations.
// - Member access expressions.
//
// Declarations and expressions have qualifiers such as `x.y`, while structs
// have designators such as `.z`.
//
// Always:
// (state done)
CARBON_PARSER_STATE_VARIANTS3(Period, Declaration, Expression, Struct)
// Handles processing of an expression.
//
// If `If`:
// 1. Expression
// 2. IfExpressionCondition
// 3. IfExpressionFinish
// Else if valid prefix operator:
// 1. Expression
// 2. ExpressionLoopForPrefix
// Else:
// 1. ExpressionInPostfix
// 2. ExpressionLoop
CARBON_PARSER_STATE(Expression)
// Handles the initial part of postfix expressions, such as an identifier or
// literal value, then proceeds to the loop.
//
// If `Identifier` or literal (including type literals):
// 1. ExpressionInPostfixLoop
// If `OpenCurlyBrace`:
// 1. BraceExpression
// 2. ExpressionInPostfixLoop
// If `OpenParen`:
// 1. ParenExpression
// 2. ExpressionInPostfixLoop
// Else:
// (state done)
CARBON_PARSER_STATE(ExpressionInPostfix)
// Handles looping through elements following the initial postfix expression,
// such as designators or parenthesized parameters.
//
// If `Period`:
// 1. PeriodAsExpression
// 2. ExpressionInPostfixLoop
// If `OpenParen`:
// 1. CallExpression
// 2. ExpressionInPostfixLoop
// Else:
// (state done)
CARBON_PARSER_STATE(ExpressionInPostfixLoop)
// Handles processing of an expression.
//
// If binary operator:
// 1. Expression
// 2. ExpressionLoopForBinary
// If postfix operator:
// 1. ExpressionLoop
// Else:
// (state done)
CARBON_PARSER_STATE(ExpressionLoop)
// Completes an ExpressionLoop pass by adding an infix operator, then goes back
// to ExpressionLoop.
//
// Always:
// 1. ExpressionLoop
CARBON_PARSER_STATE(ExpressionLoopForBinary)
// Completes an ExpressionLoop pass by adding a prefix operator, then goes back
// to ExpressionLoop.
//
// Always:
// 1. ExpressionLoop
CARBON_PARSER_STATE(ExpressionLoopForPrefix)
// Completes the condition of an `if` expression and handles the `then` token.
//
// If `Then`:
// 1. Expression
// 2. IfExpressionFinishThen
// Else:
// (state done)
CARBON_PARSER_STATE(IfExpressionFinishCondition)
// Completes the first alternative in an `if` expression and handles the `else`
// token.
//
// If `Else`:
// 1. Expression
// 2. IfExpressionFinishElse
// Else:
// (state done)
CARBON_PARSER_STATE(IfExpressionFinishThen)
// Completes the second alternative in an `if` expression.
//
// Always:
// (state done)
CARBON_PARSER_STATE(IfExpressionFinishElse)
// Completes an IfExpression.
//
// Always:
// (state done)
CARBON_PARSER_STATE(IfExpressionFinish)
// Handles the `;` for an expression statement, which is different from most
// keyword statements.
//
// Always:
// (state done)
CARBON_PARSER_STATE(ExpressionStatementFinish)
// Handles a function's introducer.
//
// If invalid:
// (state done)
// Else:
// 1. DeclarationNameAndParamsAsRequired
// 2. FunctionAfterParameters
CARBON_PARSER_STATE(FunctionIntroducer)
// Handles processing of a function's syntax after `)`, primarily the
// possibility a `->` return type is there. Always enqueues signature finish
// handling.
//
// If `MinusGreater`:
// 1. Expression
// 2. FunctionReturnTypeFinish
// 3. FunctionSignatureFinish
// Else:
// 1. FunctionSignatureFinish
CARBON_PARSER_STATE(FunctionAfterParameters)
// Finishes a function return type.
//
// Always:
// (state done)
CARBON_PARSER_STATE(FunctionReturnTypeFinish)
// Finishes a function signature. If it's a declaration, the function is done;
// otherwise, this also starts definition processing.
//
// If `Semi`:
// (state done)
// If `OpenCurlyBrace`:
// 1. StatementScopeLoop
// 2. FunctionDefinitionFinish
// Else:
// (state done)
CARBON_PARSER_STATE(FunctionSignatureFinish)
// Finishes a function definition.
//
// Always:
// (state done)
CARBON_PARSER_STATE(FunctionDefinitionFinish)
// Handles `namespace`.
//
// Always:
// 1. DeclarationNameAndParamsAsNone
// 2. NamespaceFinish
CARBON_PARSER_STATE(Namespace)
// Handles `namespace` after the name.
//
// Always:
// (state done)
CARBON_PARSER_STATE(NamespaceFinish)
// Handles `package`.
//
// Always:
// (state done)
CARBON_PARSER_STATE(Package)
// Starts deduced parameter processing.
//
// Always:
// 1. PatternAs(DeducedParameter|Parameter)
// 2. ParameterFinishAs(Deduced|Regular)
CARBON_PARSER_STATE_VARIANTS2(Parameter, Deduced, Regular)
// Finishes deduced parameter processing, including `,`. If there are more
// parameters, enqueues another parameter processing state.
//
// If `Comma` without the list close token:
// 1. ParameterAs(Deduced|Regular)
// Else:
// (state done)
CARBON_PARSER_STATE_VARIANTS2(ParameterFinish, Deduced, Regular)
// Handles processing of a parameter list `[` or `(`.
//
// If the list close token:
// 1. ParameterListFinishAs(Deduced|Regular)
// Else:
// 1. ParameterAs(Deduced|Regular)
// 2. ParameterListFinishAs(Deduced|Regular)
CARBON_PARSER_STATE_VARIANTS2(ParameterList, Deduced, Regular)
// Handles processing of a parameter list `]` or `)`.
//
// Always:
// (state done)
CARBON_PARSER_STATE_VARIANTS2(ParameterListFinish, Deduced, Regular)
// Handles the processing of a `(condition)` up through the expression.
//
// Always:
// 1. Expression
// 2. ParenConditionAs(If|While)Finish
CARBON_PARSER_STATE_VARIANTS2(ParenCondition, If, While)
// Finishes the processing of a `(condition)` after the expression.
//
// Always:
// (state done)
CARBON_PARSER_STATE_VARIANTS2(ParenConditionFinish, If, While)
// Handles the `(` of a parenthesized expression.
//
// If `CloseParen`:
// 1. ParenExpressionFinishAsTuple
// Else:
// 1. Expression
// 2. ParenExpressionParameterFinishAsUnknown
// 3. ParenExpressionFinish
CARBON_PARSER_STATE(ParenExpression)
// 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.
//
// If `Comma` without `CloseParen`:
// 1. Expression
// 2. ParenExpressionParameterFinishAsTuple
// SPECIAL: Parent becomes ParenExpressionFinishAsTuple
// If `Comma` with `CloseParen`:
// (state done)
// SPECIAL: Parent becomes ParenExpressionFinishAsTuple
// Else `CloseParen`:
// (state done)
CARBON_PARSER_STATE_VARIANTS2(ParenExpressionParameterFinish, Unknown, Tuple)
// Handles the `)` of a parenthesized expression.
//
// Always:
// (state done)
CARBON_PARSER_STATE_VARIANTS2(ParenExpressionFinish, Normal, Tuple)
// Handles pattern parsing for a pattern, enqueuing type expression processing.
// This covers parameter and `var` support.
//
// If valid:
// 1. Expression
// 2. PatternFinishAs(Generic|Regular)
// Else:
// 1. PatternFinish
CARBON_PARSER_STATE_VARIANTS3(Pattern, DeducedParameter, Parameter, Variable)
// Handles `addr` in a pattern.
//
// Always:
// (state done)
CARBON_PARSER_STATE(PatternAddress)
// Handles `template` in a pattern.
//
// Always:
// (state done)
CARBON_PARSER_STATE(PatternTemplate)
// Finishes pattern processing.
//
// Always:
// (state done)
CARBON_PARSER_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.
//
// If `Break`:
// 1. StatementBreakFinish
// (state done)
// If `Continue`:
// 1. StatementContinueFinish
// (state done)
// If `For`:
// 1. StatementForHeader
// 2. StatementForFinish
// If `If`:
// 1. StatementIf
// If `Return`:
// 1. StatementReturn
// If `Var`:
// 1. VarAsSemicolon
// If `While`:
// 1. StatementWhile
// Else:
// 1. Expression
// 2. ExpressionStatementFinish
CARBON_PARSER_STATE(Statement)
// Handles `break` processing at the `;`.
//
// Always:
// (state done)
CARBON_PARSER_STATE(StatementBreakFinish)
// Handles `continue` processing at the `;`.
//
// Always:
// (state done)
CARBON_PARSER_STATE(StatementContinueFinish)
// Handles `for` processing of `(var`, proceeding to a pattern before
// continuing.
//
// If no `OpenParen`:
// 1. CodeBlock
// If `Var`:
// 1. VarAsFor
// 2. StatementForHeaderIn
// Else:
// 1. StatementForHeaderIn
CARBON_PARSER_STATE(StatementForHeader)
// Handles `for` procesisng of `in`, proceeding to an expression before
// continuing.
//
// If `In` or `Colon`:
// 1. Expression
// 2. StatementForHeaderFinish
// Else:
// 1. StatementForHeaderFinish
CARBON_PARSER_STATE(StatementForHeaderIn)
// Handles `for` processing of `)`, proceeding to the statement block.
//
// Always:
// 1. CodeBlock
CARBON_PARSER_STATE(StatementForHeaderFinish)
// Handles `for` processing at the final `}`.
//
// Always:
// (state done)
CARBON_PARSER_STATE(StatementForFinish)
// Handles `if` processing at the start.
//
// Always:
// 1. ParenConditionAsIf
// 2. StatementIfConditionFinish
CARBON_PARSER_STATE(StatementIf)
// Handles `if` processing between the condition and start of the first code
// block.
//
// Always:
// 1. CodeBlock
// 2. StatementIfThenBlockFinish
CARBON_PARSER_STATE(StatementIfConditionFinish)
// Handles `if` processing after the end of the first code block, with the
// optional `else`.
//
// If `Else` then `If`:
// 1. CodeBlock
// 2. StatementIfElseBlockFinish
// If `Else`:
// 1. StatementIf
// 2. StatementIfElseBlockFinish
// Else:
// (state done)
CARBON_PARSER_STATE(StatementIfThenBlockFinish)
// Handles `if` processing after a provided `else` code block.
//
// Always:
// (state done)
CARBON_PARSER_STATE(StatementIfElseBlockFinish)
// Handles `return` processing.
//
// If `Semi`:
// 1. StatementReturnFinish
// Else:
// 1. Expression
// 2. StatementReturnFinish
CARBON_PARSER_STATE(StatementReturn)
// Handles `return` processing at the `;` when there's an expression.
//
// Always:
// (state done)
CARBON_PARSER_STATE(StatementReturnFinish)
// Handles processing of statements within a scope.
//
// If `CloseCurlyBrace`:
// (state done)
// Else:
// 1. Statement
// 2. StatementScopeLoop
CARBON_PARSER_STATE(StatementScopeLoop)
// Handles `while` processing.
//
// Always:
// 1. ParenConditionAsWhile
// 2. StatementWhileConditionFinish
CARBON_PARSER_STATE(StatementWhile)
// Handles `while` processing between the condition and start of the code block.
//
// Always:
// 1. CodeBlock
// 2. StatementWhileBlockFinish
CARBON_PARSER_STATE(StatementWhileConditionFinish)
// Handles `while` processing after the end of the code block.
//
// Always:
// (state done)
CARBON_PARSER_STATE(StatementWhileBlockFinish)
// Handles parsing after the declaration scope of a type.
//
// Always:
// (state done)
CARBON_PARSER_STATE_VARIANTS3(TypeDefinitionFinish, Class, Interface,
NamedConstraint)
// Handles processing of a type's introducer.
//
// Always:
// 1. DeclarationNameAndParamsAsOptional
// 2. TypeAfterParamsAs(Class|Interface|NamedConstraint)
CARBON_PARSER_STATE_VARIANTS3(TypeIntroducer, Class, Interface, NamedConstraint)
// Handles processing of a type after its optional parameters.
//
// If `Semi`:
// (state done)
// If `OpenCurlyBrace`:
// 1. DeclarationScopeLoop
// 2. TypeDefinitionFinishAs(Class|Interface|NamedConstraint)
// Else:
// (state done)
CARBON_PARSER_STATE_VARIANTS3(TypeAfterParams, Class, Interface,
NamedConstraint)
// Handles the start of a `var`.
//
// Always:
// 1. PatternAsVariable
// 2. VarAfterPattern
// 3. VarFinishAs(Semicolon|For)
CARBON_PARSER_STATE_VARIANTS2(Var, Semicolon, For)
// Handles `var` after the pattern, either followed by an initializer or the
// semicolon.
//
// If `Equal`:
// 1. Expression
// Else:
// (state done)
CARBON_PARSER_STATE(VarAfterPattern)
// Handles `var` parsing at the end.
//
// Always:
// (state done)
CARBON_PARSER_STATE_VARIANTS2(VarFinish, Semicolon, For)
#undef CARBON_PARSER_STATE
Reference in New Issue View Git Blame Copy Permalink