xonsh.gram

# PEG grammar for Python

@class XonshParser

@header'''\
from __future__ import annotations

import ast
import itertools
import sys
from typing import Any, Optional, Union, List, Tuple, NoReturn, cast

from peg_parser.subheader import Del, Load, Parser, Store, Target, logger, memoize, memoize_left_rec, Node
from peg_parser.tokenize import TokenInfo
'''

@trailer''

# STARTING RULES
# ==============

#start: file

file[ast.Module]: a=[statements] ENDMARKER { ast.Module(body=a or [], type_ignores=[]) }
interactive[ast.Interactive]: a=statement_newline { ast.Interactive(body=a) }
eval[ast.Expression]: a=expressions NEWLINE* ENDMARKER { ast.Expression(body=a) }
fstring[ast.expr]: star_expressions

# GENERAL STATEMENTS
# ==================

statements[list[Any]]: a=statement+ { list(itertools.chain.from_iterable(a)) }

statement[list[Any]]: a=compound_stmt { [a] } | a=simple_stmts { a }

statement_newline[list[Any]]:
    | a=compound_stmt NEWLINE { [a] }
    | simple_stmts
    | NEWLINE { [ast.Pass(LOCATIONS)] }
    | ENDMARKER { None }

simple_stmts[list[Any]]:
    | a=simple_stmt !';' NEWLINE { [a] } # Not needed, there for speedup
    | a1=';'.simple_stmt+ [';'] NEWLINE { a1 }

# NOTE: assignment MUST precede expression, else parsing a simple assignment
# will throw a SyntaxError.
simple_stmt[ast.stmt] (memo):
    | assignment
    | &"type" type_alias
    | e=star_expressions { ast.Expr(value=e, LOCATIONS) }
    | &'return' return_stmt
    | &('import' | 'from') import_stmt
    | &'raise' raise_stmt
    | 'pass' { ast.Pass(LOCATIONS) }
    | &'del' del_stmt
    | &'yield' yield_stmt
    | &'assert' assert_stmt
    | 'break' { ast.Break(LOCATIONS) }
    | 'continue' { ast.Continue(LOCATIONS) }
    | &'global' global_stmt
    | &'nonlocal' nonlocal_stmt

compound_stmt:
    | &('def' | '@' | 'async') function_def
    | &'if' if_stmt
    | &('class' | '@') class_def
    | &('with' | 'async') with_stmt
    | &('for' | 'async') for_stmt
    | &'try' try_stmt
    | &'while' while_stmt
    | match_stmt

# SIMPLE STATEMENTS
# =================

# NOTE: annotated_rhs may start with 'yield'; yield_expr must start with 'yield'
assignment[ast.stmt]:
    | a=NAME ':' b=expression c=['=' d=annotated_rhs { d }] {
        ast.AnnAssign(
            target=ast.Name(
                id=a.string,
                ctx=Store,
                lineno=a.start[0],
                col_offset=a.start[1],
                end_lineno=a.end[0],
                end_col_offset=a.end[1],
            ),
            annotation=b,
            value=c,
            simple=1,
            LOCATIONS,
        )
     }
    | a1=('(' b=single_target ')' { b }
         | single_subscript_attribute_target) ':' b1=expression c1=['=' d1=annotated_rhs { d1 }] {
        ast.AnnAssign(
            target=a1,
            annotation=b1,
            value=c1,
            simple=0,
            LOCATIONS,
        )
     }
    | a2=(assignment_lhs)+ b2=annotated_rhs !'=' tc=[type_comment_str] {
         ast.Assign(targets=a2, value=b2, type_comment=tc, LOCATIONS)
     }
    | a3=single_target b3=augassign ~ c3=annotated_rhs {
        ast.AugAssign(target=a3, op=b3, value=c3, LOCATIONS)
     }
    | invalid_assignment

assignment_lhs[ast.expr]: z=star_targets '=' { z }

annotated_rhs: yield_expr | star_expressions

augassign:
    | '+=' { ast.Add() }
    | '-=' { ast.Sub() }
    | '*=' { ast.Mult() }
    | '@=' { ast.MatMult() }
    | '/=' { ast.Div() }
    | '%=' { ast.Mod() }
    | '&=' { ast.BitAnd() }
    | '|=' { ast.BitOr() }
    | '^=' { ast.BitXor() }
    | '<<=' { ast.LShift() }
    | '>>=' { ast.RShift() }
    | '**=' { ast.Pow() }
    | '//=' { ast.FloorDiv() }

return_stmt[ast.Return]:
    | 'return' a=[star_expressions] { ast.Return(value=a, LOCATIONS) }

raise_stmt[ast.Raise]:
    | 'raise' a=expression b=['from' z=expression { z }] { ast.Raise(exc=a, cause=b, LOCATIONS) }
    | 'raise' { ast.Raise(exc=None, cause=None, LOCATIONS) }

global_stmt[ast.Global]: 'global' a=','.NAME+ {
    ast.Global(names=[n.string for n in a], LOCATIONS)
}

nonlocal_stmt[ast.Nonlocal]: 'nonlocal' a=','.NAME+ {
    ast.Nonlocal(names=[n.string for n in a], LOCATIONS)
}

del_stmt[ast.Delete]:
    | 'del' a=del_targets &(';' | NEWLINE) { ast.Delete(targets=a, LOCATIONS) }
    | invalid_del_stmt

yield_stmt[ast.Expr]: y=yield_expr { ast.Expr(value=y, LOCATIONS) }

assert_stmt[ast.Assert]: 'assert' a=expression b=[',' z=expression { z }] {
    ast.Assert(test=a, msg=b, LOCATIONS)
}

import_stmt[ast.Import | ast.ImportFrom]:
    | invalid_import
    | import_name
    | import_from

# Import statements
# -----------------

import_name[ast.Import]: 'import' a=dotted_as_names { ast.Import(names=a, LOCATIONS) }

# note below: the ('.' | '...') is necessary because '...' is tokenized as ELLIPSIS
import_from[ast.ImportFrom | Any]:
    | 'from' a=dot_or_ellipsis* b=dotted_name 'import' c=import_from_targets {
        ast.ImportFrom(module=b, names=c, level=self.extract_import_level(a), LOCATIONS)
     }
    | 'from' a1=dot_or_ellipsis+ 'import' b1=import_from_targets {
        ast.ImportFrom(names=b1, level=self.extract_import_level(a1), LOCATIONS)
     }
dot_or_ellipsis[TokenInfo]: '.' | '...'
import_from_targets[List[ast.alias]]:
    | '(' a=import_from_as_names [','] ')' { a }
    | import_from_as_names !','
    | '*' { [ast.alias(name="*", asname=None, LOCATIONS)] }
    | invalid_import_from_targets
import_from_as_names[List[ast.alias]]:
    | a=','.import_from_as_name+ { a }
import_from_as_name[ast.alias]:
    | a=NAME b=['as' z=NAME { z.string }] { ast.alias(name=a.string, asname=b, LOCATIONS) }
dotted_as_names[List[ast.alias]]:
    | a=','.dotted_as_name+ { a }
dotted_as_name[ast.alias]:
    | a=dotted_name b=['as' z=NAME { z.string }] { ast.alias(name=a, asname=b, LOCATIONS) }
dotted_name[str]:
    | a=dotted_name '.' b=NAME { a + "." + b.string }
    | a1=NAME { a1.string }

# COMPOUND STATEMENTS
# ===================

# Common elements
# ---------------

block[list[Any]] (memo):
    | NEWLINE INDENT a=statements DEDENT { a }
    | simple_stmts
    | invalid_block

decorators: decorator+
decorator[ast.expr]:
#    | a=('@' f=dec_maybe_call NEWLINE { f }) { a }
    | a=('@' f=named_expression NEWLINE { f }) {
        a
     }
#dec_maybe_call:
#    | dn=dec_primary '(' z=[arguments] ')' {
#        ast.Call(func=dn, args=z[0] if z else [], keywords=z[1] if z else [], LOCATIONS)
#     }
#    | dec_primary
#dec_primary:
#    | a=dec_primary '.' b=NAME { ast.Attribute(value=a, attr=b.string, ctx=Load, LOCATIONS) }
#    | a=NAME { ast.Name(id=a.string, ctx=Load, LOCATIONS) }

# Class definitions
# -----------------

class_def[ast.ClassDef]:
    | a=decorators b=class_def_raw { self.set_decorators(b, a) }
    | class_def_raw

class_def_raw[ast.ClassDef]:
    | invalid_class_def_raw
    | 'class' a=NAME t=[type_params] b=['(' z=[arguments] ')' { z }] &&':' c=block {
        (
            ast.ClassDef(
                a.string,
                bases=b[0] if b else [],
                keywords=b[1] if b else [],
                body=c,
                decorator_list=[],
                **({'type_params': t or []} if sys.version_info >= (3, 12) else {}),
                LOCATIONS,
            )
        )
     }

# Function definitions
# --------------------

function_def[Union[ast.FunctionDef, ast.AsyncFunctionDef]]:
    | d=decorators f=function_def_raw { self.set_decorators(f, d) }
    | f=function_def_raw {self.set_decorators(f, [])}

function_def_raw[Union[ast.FunctionDef, ast.AsyncFunctionDef, Any]]:
    | invalid_def_raw
    | 'def' n=NAME t=[type_params] &&'(' params=[params] ')' a=[return_expr] &&':' tc=[func_type_comment] b=block {
        (
            ast.FunctionDef(
                name=n.string,
                args=params or self.make_arguments(None, [], None, [], None),
                returns=a,
                body=b,
                type_comment=tc,
                **({'type_params': t or []} if sys.version_info >= (3, 12) else {}),
                LOCATIONS,
            )
        )
     }
    | 'async' 'def' n=NAME t=[type_params] &&'(' params=[params] ')' a=[return_expr] &&':' tc=[func_type_comment] b=block {
       (
            ast.AsyncFunctionDef(
                name=n.string,
                args=params or self.make_arguments(None, [], None, [], None),
                returns=a,
                body=b,
                type_comment=tc,
                                **({'type_params': t or []} if sys.version_info >= (3, 12) else {}),

                LOCATIONS,
            )
       )
     }

return_expr[ast.expr]:
    | '->' z=expression { z }

# Function parameters
# -------------------

params[ast.arguments]:
    | invalid_parameters
    | parameters

parameters[ast.arguments]:
    | a=slash_no_default b=param_no_default* c=param_with_default* d=[star_etc] {
        self.make_arguments(a, [], b, c, d)
     }
    | a1=slash_with_default b1=param_with_default* c1=[star_etc] {
        self.make_arguments(None, a1, None, b1, c1)
     }
    | a2=param_no_default+ b2=param_with_default* c2=[star_etc] {
        self.make_arguments(None, [], a2, b2, c2)
     }
    | a3=param_with_default+ b3=[star_etc] {
        self.make_arguments(None, [], None, a3, b3)
     }
    | a4=star_etc { self.make_arguments(None, [], None, None, a4) }

# Some duplication here because we can't write (',' | &')'),
# which is because we don't support empty alternatives (yet).
#

slash_no_default[List[Tuple[ast.arg, None]]]:
    | a=param_no_default+ '/' ',' { [(p, None) for p in a] }
    | a=param_no_default+ '/' &')' { [(p, None) for p in a] }
slash_with_default[List[Tuple[ast.arg, Any]]]:
    | a=param_no_default* b=param_with_default+ '/' ',' { ([(p, None) for p in a] if a else []) + b }
    | a=param_no_default* b=param_with_default+ '/' &')' { ([(p, None) for p in a] if a else []) + b }

star_etc[Tuple[Optional[ast.arg], List[Tuple[ast.arg, Any]], Optional[ast.arg]]]:
    | invalid_star_etc
    | '*' a=param_no_default b=param_maybe_default* c=[kwds] { (a, b, c) }
    | '*' a=param_no_default_star_annotation b=param_maybe_default* c=[kwds] { (a, b, c) }
    | '*' ',' b=param_maybe_default+ c=[kwds] { (None, b, c) }
    | a=kwds { (None, [], a) }

kwds[ast.arg]:
    | invalid_kwds
    | '**' a=param_no_default { a }

# One parameter.  This *includes* a following comma and type comment.
#
# There are three styles:
# - No default
# - With default
# - Maybe with default
#
# There are two alternative forms of each, to deal with type comments:
# - Ends in a comma followed by an optional type comment
# - No comma, optional type comment, must be followed by close paren
# The latter form is for a final parameter without trailing comma.
#

param_no_default[ast.arg]:
    | a=param ',' tc=TYPE_COMMENT? { a }
    | a=param tc=TYPE_COMMENT? &')' { a }
param_no_default_star_annotation[ast.arg]:
    | a=param_star_annotation ',' tc=TYPE_COMMENT? { a }
    | a=param_star_annotation tc=TYPE_COMMENT? &')' { a }
param_with_default[Tuple[ast.arg, Any]]:
    | a=param c=default ',' tc=TYPE_COMMENT? { (a, c) }
    | a=param c=default tc=TYPE_COMMENT? &')' { (a, c) }
param_maybe_default[Tuple[ast.arg, Any]]:
    | a=param c=default? ',' tc=TYPE_COMMENT? { (a, c) }
    | a=param c=default? tc=TYPE_COMMENT? &')' { (a, c) }
param[ast.arg]: a=NAME b=annotation? { ast.arg(arg=a.string, annotation=b, LOCATIONS) }
param_star_annotation[ast.arg]: a=NAME b=star_annotation {
    ast.arg(arg=a.string, annotation=b, LOCATIONS)
 }
annotation[ast.expr]: ':' a=expression { a }
star_annotation: ':' a=star_expression { a }
default[ast.expr]: '=' a=expression { a } | invalid_default

# If statement
# ------------

if_stmt[ast.If]:
    | invalid_if_stmt
    | 'if' a=named_expression ':' b=block c=elif_stmt { ast.If(test=a, body=b, orelse=c or [], LOCATIONS) }
    | 'if' a=named_expression ':' b=block c=[else_block] { ast.If(test=a, body=b, orelse=c or [], LOCATIONS) }
elif_stmt[List[ast.If]]:
    | invalid_elif_stmt
    | 'elif' a=named_expression ':' b=block c=elif_stmt { [ast.If(test=a, body=b, orelse=c, LOCATIONS)] }
    | 'elif' a=named_expression ':' b=block c=[else_block] { [ast.If(test=a, body=b, orelse=c or [], LOCATIONS)] }
else_block[list[Any]]:
    | invalid_else_stmt
    | 'else' &&':' b=block { b }

# While statement
# ---------------

while_stmt[ast.While]:
    | invalid_while_stmt
    | 'while' a=named_expression ':' b=block c=[else_block] {
        ast.While(test=a, body=b, orelse=c or [], LOCATIONS)
     }

# For statement
# -------------

for_stmt[Union[ast.For, ast.AsyncFor]]:
    | invalid_for_stmt
    | 'for' t=star_targets 'in' ~ ex=star_expressions &&':' tc=[type_comment_str] b=block el=[else_block] {
        ast.For(target=t, iter=ex, body=b, orelse=el or [], type_comment=tc, LOCATIONS) }
    | 'async' 'for' t=star_targets 'in' ~ ex=star_expressions ':' tc=[type_comment_str] b=block el=[else_block] {
        ast.AsyncFor(target=t, iter=ex, body=b, orelse=el or [], type_comment=tc, LOCATIONS) }
    | invalid_for_target

# With statement
# --------------

with_stmt[Union[ast.With, ast.AsyncWith]]:
    | invalid_with_stmt_indent
    | &with_macro_start ~ with_macro_stmt
    | 'with' '(' a=','.with_item+ ','? ')' ':' b=block {
        ast.With(items=a, body=b, LOCATIONS)
     }
    | 'with' a=','.with_item+ ':' tc=[type_comment_str] b=block {
        ast.With(items=a, body=b, type_comment=tc, LOCATIONS)
     }
    | 'async' 'with' '(' a=','.with_item+ ','? ')' ':' b=block {
       ast.AsyncWith(items=a, body=b, LOCATIONS)
     }
    | 'async' 'with' a=','.with_item+ ':' tc=[type_comment_str] b=block {
       ast.AsyncWith(items=a, body=b, type_comment=tc, LOCATIONS) }
    | invalid_with_stmt

with_item[ast.withitem]:
    | e=expression 'as' t=star_target &(',' | ')' | ':') {
        ast.withitem(context_expr=e, optional_vars=t)
     }
    | invalid_with_item
    | e=expression { ast.withitem(context_expr=e, optional_vars=None) }

with_macro_stmt[ast.With]:
    | a=with_macro_start b=MACRO_PARAM {
        self.handle_with_macro_stmt(a, b, LOCATIONS)
     }

with_macro_start: # same line
    | 'with' '!' ~ a=with_item ':' {
        self.handle_with_macro_start(a)
    }


# Try statement
# -------------

try_stmt[ast.Try | ast.TryStar]:
    | invalid_try_stmt
    | 'try' &&':' b=block f=finally_block {
        ast.Try(body=b, handlers=[], orelse=[], finalbody=f, LOCATIONS)
     }
    | 'try' &&':' b=block ex=except_block+ el=[else_block] f=[finally_block] {
        ast.Try(body=b, handlers=ex, orelse=el or [], finalbody=f or [], LOCATIONS)
     }
    | 'try' &&':' b=block ex=except_star_block+ el=[else_block] f=[finally_block] {
        self.check_version(
            (3, 11),
            "Exception groups are",
            (
                ast.TryStar(body=b, handlers=ex, orelse=el or [], finalbody=f or [], LOCATIONS)
                if sys.version_info >= (3, 11)
                else None
            )
        )
     }

# Except statement
# ----------------

except_block[ast.ExceptHandler]:
    | invalid_except_stmt_indent
    | 'except' e=expression t=['as' z=NAME { z.string }] ':' b=block {
        ast.ExceptHandler(type=e, name=t, body=b, LOCATIONS) }
    | 'except' ':' b=block { ast.ExceptHandler(type=None, name=None, body=b, LOCATIONS) }
    | invalid_except_stmt
except_star_block[ast.ExceptHandler]:
    | invalid_except_star_stmt_indent
    | 'except' '*' e=expression t=['as' z=NAME { z.string }] ':' b=block {
        ast.ExceptHandler(type=e, name=t, body=b, LOCATIONS)
     }
    | invalid_except_stmt
finally_block[list[Any]]:
    | invalid_finally_stmt
    | 'finally' &&':' a=block { a }

# Match statement
# ---------------

# We cannot do version checks here since the production will occur after any other
# production which will have failed since the ast module does not have the right nodes.
match_stmt[ast.Match]:
    | "match" subject=subject_expr ':' NEWLINE INDENT cases=case_block+ DEDENT {
        ast.Match(subject=subject, cases=cases, LOCATIONS)
     }
    | invalid_match_stmt

# Version checking here allows to avoid tracking down every single possible production
subject_expr:
    | value=star_named_expression ',' values=star_named_expressions? {
        ast.Tuple(elts=[value] + (values or []), ctx=Load, LOCATIONS)
     }
    | e=named_expression { e }

case_block["ast.match_case"]:
    | invalid_case_block
    | "case" pattern=patterns guard=guard? ':' body=block {
        ast.match_case(pattern=pattern, guard=guard, body=body)
     }

guard: 'if' guard=named_expression { guard }

patterns:
    | patterns=open_sequence_pattern {
        ast.MatchSequence(patterns=patterns, LOCATIONS)
     }
    | pattern

pattern[ast.pattern]:
    | as_pattern
    | or_pattern

as_pattern[ast.pattern]:
    | pattern=or_pattern 'as' target=pattern_capture_target {
        ast.MatchAs(pattern=pattern, name=target, LOCATIONS)
     }
    | invalid_as_pattern

or_pattern[ast.pattern]:
    | patterns='|'.closed_pattern+ {
        ast.MatchOr(patterns=patterns, LOCATIONS) if len(patterns) > 1 else patterns[0]
     }

closed_pattern[ast.pattern]:
    | literal_pattern
    | capture_pattern
    | wildcard_pattern
    | value_pattern
    | group_pattern
    | sequence_pattern
    | mapping_pattern
    | class_pattern

# Literal patterns are used for equality and identity constraints
literal_pattern:
    | value=signed_number !('+' | '-') { ast.MatchValue(value=value, LOCATIONS) }
    | value=complex_number { ast.MatchValue(value=value, LOCATIONS) }
    | value=strings { ast.MatchValue(value=value, LOCATIONS) }
    | 'None' { ast.MatchSingleton(value=None, LOCATIONS) }
    | 'True' { ast.MatchSingleton(value=True, LOCATIONS) }
    | 'False' { ast.MatchSingleton(value=False, LOCATIONS) }

# Literal expressions are used to restrict permitted mapping pattern keys
literal_expr:
    | signed_number !('+' | '-')
    | complex_number
    | strings
    | 'None' { ast.Constant(value=None, LOCATIONS) }
    | 'True' { ast.Constant(value=True, LOCATIONS) }
    | 'False' { ast.Constant(value=False, LOCATIONS) }

complex_number:
    | real=signed_real_number '+' imag=imaginary_number {
        ast.BinOp(left=real, op=ast.Add(), right=imag, LOCATIONS)
     }
    | real=signed_real_number '-' imag=imaginary_number  {
        ast.BinOp(left=real, op=ast.Sub(), right=imag, LOCATIONS)
     }

signed_number:
    | a=NUMBER { ast.Constant(value=ast.literal_eval(a.string), LOCATIONS) }
    | '-' a=NUMBER {
        ast.UnaryOp(
            op=ast.USub(),
            operand=ast.Constant(
                value=ast.literal_eval(a.string),
                lineno=a.start[0],
                col_offset=a.start[1],
                end_lineno=a.end[0],
                end_col_offset=a.end[1]
            ),
            LOCATIONS,
        )
     }

signed_real_number:
    | real_number
    | '-' real=real_number { ast.UnaryOp(op=ast.USub(), operand=real, LOCATIONS) }

real_number[ast.Constant]:
    | real=NUMBER { ast.Constant(value=self.ensure_real(real), LOCATIONS) }

imaginary_number[ast.Constant]:
    | imag=NUMBER { ast.Constant(value=self.ensure_imaginary(imag), LOCATIONS) }

capture_pattern:
    | target=pattern_capture_target {
        ast.MatchAs(pattern=None, name=target, LOCATIONS)
     }

pattern_capture_target[str]:
    | !"_" name=NAME !('.' | '(' | '=') { name.string }

wildcard_pattern["ast.MatchAs"]:
    | "_" { ast.MatchAs(pattern=None, LOCATIONS) }

value_pattern["ast.MatchValue"]:
    | attr=attr !('.' | '(' | '=') { ast.MatchValue(value=attr, LOCATIONS) }

attr[ast.Attribute]:
    | value=name_or_attr '.' attr=NAME {
        ast.Attribute(value=value, attr=attr.string, ctx=Load, LOCATIONS)
     }

name_or_attr:
    | attr
    | name=NAME { ast.Name(id=name.string, ctx=Load, LOCATIONS) }

group_pattern:
    | '(' pattern=pattern ')' { pattern }

sequence_pattern["ast.MatchSequence"]:
    | '[' patterns=maybe_sequence_pattern? ']' { ast.MatchSequence(patterns=patterns or [], LOCATIONS) }
    | '(' patterns=open_sequence_pattern? ')' { ast.MatchSequence(patterns=patterns or [], LOCATIONS) }

open_sequence_pattern:
    | pattern=maybe_star_pattern ',' patterns=maybe_sequence_pattern? {
        [pattern] + (patterns or [])
     }

maybe_sequence_pattern[list[ast.pattern]]:
    | patterns=','.maybe_star_pattern+ ','? { patterns }

maybe_star_pattern[ast.pattern]:
    | star_pattern
    | pattern

star_pattern:
    | '*' target=pattern_capture_target { ast.MatchStar(name=target, LOCATIONS) }
    | '*' wildcard_pattern { ast.MatchStar(name=None, LOCATIONS) }

mapping_pattern:
    | '{' '}' { ast.MatchMapping(keys=[], patterns=[], rest=None, LOCATIONS) }
    | '{' rest=double_star_pattern ','? '}' {
        ast.MatchMapping(keys=[], patterns=[], rest=rest, LOCATIONS) }
    | '{' items=items_pattern ',' rest=double_star_pattern ','? '}' {
        ast.MatchMapping(
            keys=[k for k,_ in items],
            patterns=[p for _, p in items],
            rest=rest,
            LOCATIONS,
        )
     }
    | '{' items=items_pattern ','? '}' {
        ast.MatchMapping(
            keys=[k for k,_ in items],
            patterns=[p for _, p in items],
            rest=None,
            LOCATIONS,
        )
     }

items_pattern:
    | ','.key_value_pattern+

key_value_pattern[tuple[ast.expr, ast.pattern]]:
    | key=(literal_expr | attr) ':' pattern=pattern { (key, pattern) }

double_star_pattern:
    | '**' target=pattern_capture_target { target }

class_pattern["ast.MatchClass"]:
    | cls=name_or_attr '(' ')' {
        ast.MatchClass(cls=cls, patterns=[], kwd_attrs=[], kwd_patterns=[], LOCATIONS)
     }
    | cls=name_or_attr '(' patterns=positional_patterns ','? ')' {
        ast.MatchClass(cls=cls, patterns=patterns, kwd_attrs=[], kwd_patterns=[], LOCATIONS)
     }
    | cls=name_or_attr '(' keywords=keyword_patterns ','? ')' {
        ast.MatchClass(
            cls=cls,
            patterns=[],
            kwd_attrs=[k for k, _ in keywords],
            kwd_patterns=[p for _, p in keywords],
            LOCATIONS,
        )
     }
    | cls=name_or_attr '(' patterns=positional_patterns ',' keywords=keyword_patterns ','? ')' {
        ast.MatchClass(
            cls=cls,
            patterns=patterns,
            kwd_attrs=[k for k, _ in keywords],
            kwd_patterns=[p for _, p in keywords],
            LOCATIONS,
        )
     }
    | invalid_class_pattern

positional_patterns[list[ast.pattern]]:
    | args=','.pattern+ { args }

keyword_patterns:
    | ','.keyword_pattern+

keyword_pattern[tuple[str, ast.pattern]]:
    | arg=NAME '=' value=pattern { (arg.string, value) }

# Type statement
# ---------------

type_alias["ast.TypeAlias"]:
    | "type" n=NAME t=[type_params] '=' b=expression {
        self.check_version(
            (3, 12),
            "Type statement is",
            (
                ast.TypeAlias(
                    name=ast.Name(
                        id=n.string,
                        ctx=Store,
                        lineno=n.start[0],
                        col_offset=n.start[1],
                        end_lineno=n.end[0],
                        end_col_offset=n.end[1],
                    ),
                    type_params=t or [],
                    value=b,
                    LOCATIONS
                )
            )
        )
     }

# Type parameter declaration
# --------------------------

type_params[list[Any]]: '[' t=type_param_seq  ']' {
    self.check_version(
        (3, 12),
        "Type parameter lists are",
        t
    )
 }

type_param_seq[list[Any]]: a=','.type_param+ [','] { a }

type_param[ast.type_param] (memo):
    | a=NAME b=[type_param_bound] {
        ast.TypeVar(name=a.string, bound=b, LOCATIONS)
     }
    | '*' NAME colon=':' e=expression {
        self.raise_syntax_error_starting_from(
            "cannot use constraints with TypeVarTuple"
            if isinstance(e, ast.Tuple)
            else "cannot use bound with TypeVarTuple",
            colon
        )
     }
    | '*' a=NAME {
        ast.TypeVarTuple(name=a.string, LOCATIONS)
     }
    | '**' a=NAME colon=':' e=expression {
        self.raise_syntax_error_starting_from(
            "cannot use constraints with ParamSpec"
            if isinstance(e, ast.Tuple)
            else "cannot use bound with ParamSpec",
            colon
        )
     }
    | '**' a=NAME {
        ast.ParamSpec(name=a.string, LOCATIONS)
     }

type_param_bound: ':' e=expression { e }

# EXPRESSIONS
# -----------

expressions[ast.expr]:
    | a=expression b=(comma_expression)+ [','] {
        ast.Tuple(elts=[a] + b, ctx=Load, LOCATIONS) }
    | a=expression ',' { ast.Tuple(elts=[a], ctx=Load, LOCATIONS) }
    | expression

comma_expression[ast.expr]: ',' c=expression { c }

expression[ast.expr](memo):
    | invalid_expression
    | invalid_legacy_expression
    | a=disjunction 'if' b=disjunction 'else' c=expression {
        ast.IfExp(body=a, test=b, orelse=c, LOCATIONS)
     }
    | disjunction
    | lambdef

yield_expr:
    | 'yield' 'from' a=expression { ast.YieldFrom(value=a, LOCATIONS) }
    | 'yield' a=[star_expressions] { ast.Yield(value=a, LOCATIONS) }

star_expressions[ast.expr]:
    | a=star_expression b=(comma_star_expr)+ [','] {
        ast.Tuple(elts=[a] + b, ctx=Load, LOCATIONS) }
    | a=star_expression ',' { ast.Tuple(elts=[a], ctx=Load, LOCATIONS) }
    | star_expression

comma_star_expr[ast.expr]: ',' c=star_expression { c }

star_expression[ast.expr] (memo):
    | '*' a=bitwise_or { ast.Starred(value=a, ctx=Load, LOCATIONS) }
    | expression

star_named_expressions: a=','.star_named_expression+ [','] { a }

star_named_expression[ast.Starred | ast.expr]:
    | '*' a=bitwise_or { ast.Starred(value=a, ctx=Load, LOCATIONS) }
    | named_expression

assignment_expression[ast.expr]:
    | a=NAME ':=' ~ b=expression {
        ast.NamedExpr(
            target=ast.Name(
                id=a.string,
                ctx=Store,
                lineno=a.start[0],
                col_offset=a.start[1],
                end_lineno=a.end[0],
                end_col_offset=a.end[1]
            ),
            value=b,
            LOCATIONS,
        )
     }

named_expression[ast.expr]:
    | assignment_expression
    | invalid_named_expression
    | a=expression !':=' { a }

disjunction[ast.expr] (memo):
    | a=conjunction b=(disjunction_part)+ { ast.BoolOp(op=ast.Or(), values=[a] + b, LOCATIONS) }
    | conjunction

disjunction_part[ast.expr]:
    | ('or' | '||') c=conjunction { c }

conjunction[ast.expr] (memo):
    | a=inversion b=conjunction_part+ { ast.BoolOp(op=ast.And(), values=[a] + b, LOCATIONS) }
    | inversion

conjunction_part[ast.expr]:
    | ('and' | '&&' ) c=inversion { c }

inversion[ast.expr] (memo):
    | 'not' a=inversion { ast.UnaryOp(op=ast.Not(), operand=a, LOCATIONS) }
    | comparison

# Comparisons operators
# ---------------------

comparison[ast.expr]:
    | a=bitwise_or b=compare_op_bitwise_or_pair+ {
        ast.Compare(left=a, ops=self.get_comparison_ops(b), comparators=self.get_comparators(b), LOCATIONS)
     }
    | bitwise_or

# Make a tuple of operator and comparator
compare_op_bitwise_or_pair[tuple[ast.cmpop, ast.expr]]:
    | eq_bitwise_or
    | noteq_bitwise_or
    | lte_bitwise_or
    | lt_bitwise_or
    | gte_bitwise_or
    | gt_bitwise_or
    | notin_bitwise_or
    | in_bitwise_or
    | isnot_bitwise_or
    | is_bitwise_or

eq_bitwise_or[tuple[ast.cmpop, ast.expr]]: '==' a=bitwise_or { (ast.Eq(), a) }
# Do not support the Barry as BDFL <> for not eq
noteq_bitwise_or[tuple[ast.NotEq, Any]]:
    | '!=' a=bitwise_or { (ast.NotEq(), a) }
lte_bitwise_or[tuple[ast.cmpop, ast.expr]]: '<=' a=bitwise_or { (ast.LtE(), a) }
lt_bitwise_or[tuple[ast.cmpop, ast.expr]]: '<' a=bitwise_or { (ast.Lt(), a) }
gte_bitwise_or[tuple[ast.cmpop, ast.expr]]: '>=' a=bitwise_or { (ast.GtE(), a) }
gt_bitwise_or[tuple[ast.cmpop, ast.expr]]: '>' a=bitwise_or { (ast.Gt(), a) }
notin_bitwise_or[tuple[ast.cmpop, ast.expr]]: 'not' 'in' a=bitwise_or { (ast.NotIn(), a) }
in_bitwise_or[tuple[ast.cmpop, ast.expr]]: 'in' a=bitwise_or { (ast.In(), a) }
isnot_bitwise_or[tuple[ast.cmpop, ast.expr]]: 'is' 'not' a=bitwise_or { (ast.IsNot(), a) }
is_bitwise_or[tuple[ast.cmpop, ast.expr]]: 'is' a=bitwise_or { (ast.Is(), a) }

# Logical operators
# -----------------

bitwise_or:
    | a=bitwise_or '|' b=bitwise_xor { ast.BinOp(left=a, op=ast.BitOr(), right=b, LOCATIONS) }
    | bitwise_xor

bitwise_xor:
    | a=bitwise_xor '^' b=bitwise_and { ast.BinOp(left=a, op=ast.BitXor(), right=b, LOCATIONS) }
    | bitwise_and

bitwise_and:
    | a=bitwise_and '&' b=shift_expr { ast.BinOp(left=a, op=ast.BitAnd(), right=b, LOCATIONS) }
    | shift_expr

shift_expr:
    | a=shift_expr '<<' b=sum { ast.BinOp(left=a, op=ast.LShift(), right=b, LOCATIONS) }
    | a=shift_expr '>>' b=sum { ast.BinOp(left=a, op=ast.RShift(), right=b, LOCATIONS) }
    | sum

# Arithmetic operators
# --------------------

sum:
    | a=sum '+' b=term { ast.BinOp(left=a, op=ast.Add(), right=b, LOCATIONS) }
    | a=sum '-' b=term { ast.BinOp(left=a, op=ast.Sub(), right=b, LOCATIONS) }
    | term

term:
    | a=term '*' b=factor { ast.BinOp(left=a, op=ast.Mult(), right=b, LOCATIONS) }
    | a=term '/' b=factor { ast.BinOp(left=a, op=ast.Div(), right=b, LOCATIONS) }
    | a=term '//' b=factor { ast.BinOp(left=a, op=ast.FloorDiv(), right=b, LOCATIONS) }
    | a=term '%' b=factor { ast.BinOp(left=a, op=ast.Mod(), right=b, LOCATIONS) }
    | a=term '@' b=factor { ast.BinOp(left=a, op=ast.MatMult(), right=b, LOCATIONS) }
    | factor

factor (memo):
    | '+' a=factor { ast.UnaryOp(op=ast.UAdd(), operand=a, LOCATIONS) }
    | '-' a=factor { ast.UnaryOp(op=ast.USub(), operand=a, LOCATIONS) }
    | '~' a=factor { ast.UnaryOp(op=ast.Invert(), operand=a, LOCATIONS) }
    | power

power:
    | a=await_primary '**' b=factor { ast.BinOp(left=a, op=ast.Pow(), right=b, LOCATIONS) }
    | await_primary

# Primary elements
# ----------------

# Primary elements are things like "obj.something.something", "obj[something]", "obj(something)", "obj" ...

await_primary (memo):
    | 'await' a=primary { ast.Await(a, LOCATIONS) }
    | primary

primary:
    | a=primary '.' b=NAME { ast.Attribute(value=a, attr=b.string, ctx=Load, LOCATIONS) }
    | a1=primary b1=genexp { ast.Call(func=a1, args=[b1], keywords=[], LOCATIONS) }
    | a2=func_macro_start ~ b2=[MACRO_PARAM*] &&')' { self.macro_call(a2, b2, LOCATIONS) }
    | a3=primary '(' b3=[arguments] ')' {
        ast.Call(
            func=a3,
            args=b3[0] if b3 else [],
            keywords=b3[1] if b3 else [],
            LOCATIONS,
        )
     }
    | a4=primary '[' b4=slices ']' { ast.Subscript(value=a4, slice=b4, ctx=Load, LOCATIONS) }
    | &('$(' | '$[' | '![' | '!(') ~ sub_procs
    | env_atom
    | a5=(".".help_atom+) { self.expand_help(a5, LOCATIONS) }
    | atom

func_macro_start:
    | a=primary '!(' {
        self.handle_func_macro_start(a)
    }

sub_procs[ast.Call]:
    | '$(' ~ args=proc_cmds ')' { self.handle_proc("subproc_captured", args, LOCATIONS) }
    | '$[' ~ args=proc_cmds ']' { self.handle_proc("subproc_uncaptured", args, LOCATIONS) }
    | '![' ~ args=proc_cmds ']' { self.handle_proc("subproc_captured_hiddenobject", args, LOCATIONS) }
    | '!(' ~ args=proc_cmds ')' { self.handle_proc("subproc_captured_object", args, LOCATIONS) }

help_atom[tuple[ast.Name, TokenInfo]]:
    | a=atom b=('??' | '?') { (a, b) }

env_atom[ast.Subscript]:
    | '$' a=NAME { self.expand_env_name(a, LOCATIONS) }
    | '${' a=slices '}' { self.expand_env_expr(a, LOCATIONS) }

proc_cmds:
    | a=proc_cmd+ { self.proc_args(a) }


proc_cmd[ast.expr | TokenInfo]:
    | sub_procs
    | '@(' ~ a=(bare_genexp | expressions) ')' { self.proc_pyexpr(a, LOCATIONS) }
    | '@$(' ~ a=proc_cmds ')' { self.proc_inject(a, LOCATIONS) }
    | env_atom
#    | help_atom
    | search_path
    | proc_macro_start ~ a=(cmd_group | any_cmd )* { self.proc_macro_arg(a, LOCATIONS) }
    | a=cmd_group { self.proc_macro_arg(a, LOCATIONS) }
    | cmd_name

proc_macro_start:
    | &cmd_name a='!' { self.handle_proc_macro_start(a) }

cmd_name[TokenInfo]:
    | NAME
    | NUMBER
    | STRING
    | !']' !')' !'}' OP

any_cmd[TokenInfo]:
    | cmd_name
    | WS
    | KEYWORD

cmd_group[str]:
    | a=('(' | '!(' | '$(') b=any_cmd* c=')'   { ''.join(i.string for i in [a, *b, c]) }
    | a=('[' | '![' | '$[') b=any_cmd* c=']'   { ''.join(i.string for i in [a, *b, c]) }

slices:
    | a=slice !',' { a }
    | a=','.(slice | starred_expression)+ [','] {
        ast.Tuple(elts=a, ctx=Load, LOCATIONS)
     }

slice:
    | a=[expression] ':' b=[expression] c=[':' d=[expression] { d }] {
        ast.Slice(lower=a, upper=b, step=c, LOCATIONS)
     }
    | a=named_expression {
        a
     }

atom:
    | search_path
    | a=NAME { ast.Name(id=a.string, ctx=Load, LOCATIONS) }
    | 'True' { ast.Constant(value=True, LOCATIONS) }
    | 'False' {
        ast.Constant(value=False, LOCATIONS)
     }
    | 'None' {
        ast.Constant(value=None, LOCATIONS)
     }
    | &(STRING|FSTRING_START) strings
    | a=NUMBER {
        ast.Constant(value=ast.literal_eval(a.string), LOCATIONS)
     }
    | &'(' (ptuple | group | genexp)
    | &'[' (plist | listcomp)
    | &'{' (dict | set | dictcomp | setcomp)
    | '...' {
        ast.Constant(value=Ellipsis, LOCATIONS)
     }

search_path[ast.Call]: a=SEARCH_PATH { self.expand_search_path(a, LOCATIONS) }

group:
    | '(' a=(yield_expr | named_expression) ')' { a }
    | invalid_group


# Lambda functions
# ----------------

lambdef[ast.Lambda]:
    | 'lambda' a=[lambda_params] ':' b=expression {
        ast.Lambda(args=a or self.make_arguments(None, [], None, [], (None, [], None)), body=b, LOCATIONS)
     }

lambda_params:
    | invalid_lambda_parameters
    | lambda_parameters

# lambda_parameters etc. duplicates parameters but without annotations
# or type comments, and if there's no comma after a parameter, we expect
# a colon, not a close parenthesis.  (For more, see parameters above.)
#
lambda_parameters[ast.arguments]:
    | a=lambda_slash_no_default b=lambda_param_no_default* c=lambda_param_with_default* d=[lambda_star_etc] {
        self.make_arguments(a, [], b, c, d)
     }
    | a1=lambda_slash_with_default b1=lambda_param_with_default* c1=[lambda_star_etc] {
        self.make_arguments(None, a1, None, b1, c1)
     }
    | a2=lambda_param_no_default+ b2=lambda_param_with_default* c2=[lambda_star_etc] {
        self.make_arguments(None, [], a2, b2, c2)
     }
    | a3=lambda_param_with_default+ b3=[lambda_star_etc] {
        self.make_arguments(None, [], None, a3, b3)
     }
    | a4=lambda_star_etc { self.make_arguments(None, [], None, [], a4) }

lambda_slash_no_default[List[Tuple[ast.arg, None]]]:
    | a=lambda_param_no_default+ '/' ',' { [(p, None) for p in a] }
    | a=lambda_param_no_default+ '/' &':' { [(p, None) for p in a] }

lambda_slash_with_default[List[Tuple[ast.arg, Any]]]:
    | a=lambda_param_no_default* b=lambda_param_with_default+ '/' ',' { ([(p, None) for p in a] if a else []) + b }
    | a=lambda_param_no_default* b=lambda_param_with_default+ '/' &':' { ([(p, None) for p in a] if a else []) + b }

lambda_star_etc[Tuple[Optional[ast.arg], List[Tuple[ast.arg, Any]], Optional[ast.arg]]]:
    | invalid_lambda_star_etc
    | '*' a=lambda_param_no_default b=lambda_param_maybe_default* c=[lambda_kwds] {
       (a, b, c) }
    | '*' ',' b=lambda_param_maybe_default+ c=[lambda_kwds] {
        (None, b, c) }
    | a=lambda_kwds { (None, [], a) }

lambda_kwds[ast.arg]:
    | invalid_lambda_kwds
    | '**' a=lambda_param_no_default { a }

lambda_param_no_default[ast.arg]:
    | a=lambda_param ',' { a }
    | a=lambda_param &':' { a }

lambda_param_with_default[Tuple[ast.arg, Any]]:
    | a=lambda_param c=default ',' { (a, c) }
    | a=lambda_param c=default &':' { (a, c) }
lambda_param_maybe_default[Tuple[ast.arg, Any]]:
    | a=lambda_param c=default? ',' { (a, c) }
    | a=lambda_param c=default? &':' { (a, c) }
lambda_param[ast.arg]: a=NAME {
    ast.arg(arg=a.string, annotation=None, LOCATIONS)
}

# LITERALS
# ========

fstring_mid[ast.FormattedValue | ast.Constant]:
    | fstring_replacement_field
    | t=FSTRING_MIDDLE { ast.Constant(value=t.string, LOCATIONS) }
fstring_replacement_field[ast.FormattedValue]:
    | '{' a=annotated_rhs debug_expr='='? conver=[fstring_conversion] format=[fstring_full_format_spec] rbrace='}' {
        ast.FormattedValue(
            value=a,
            conversion=(
                conver
                if conver else
                (b'r'[0] if debug_expr else -1)
            ),
            format_spec=format,
            LOCATIONS
        )
     }
    | invalid_replacement_field
fstring_conversion[int]:
    | '!' conv=NAME { self.check_fstring_conversion(conv) }
fstring_full_format_spec[ast.JoinedStr]:
    | ':' spec=fstring_format_spec* {
        ast.JoinedStr(
            values=spec if spec and (len(spec) > 1 or cast(ast.Constant, spec[0]).value) else [],
            LOCATIONS,
        )
     }
fstring_format_spec[ast.Constant | ast.FormattedValue]:
    | t=FSTRING_MIDDLE { ast.Constant(value=t.string, LOCATIONS) }
    | fstring_replacement_field
fstring[ast.JoinedStr]:
    | a=FSTRING_START b=fstring_mid* c=FSTRING_END {
        self.handle_fstring(a, b, LOCATIONS)
     }

strings (memo): a=(anystr)+ {
    self.concatenate_strings(a)
}

anystr[ast.JoinedStr | TokenInfo]:
    | fstring
    | STRING

plist[ast.List]:
    | '[' a=[star_named_expressions] ']' { ast.List(elts=a or [], ctx=Load, LOCATIONS) }

ptuple[ast.Tuple]:
    | '(' a=[y=star_named_expression ',' z=[star_named_expressions] { [y] + (z or []) } ] ')' {
        ast.Tuple(elts=a or [], ctx=Load, LOCATIONS)
     }

set[ast.Set]: '{' a=star_named_expressions '}' { ast.Set(elts=a, LOCATIONS) }

# Dicts
# -----

dict[ast.Dict]:
    | '{' a=[double_starred_kvpairs] '}' {
        ast.Dict(keys=[kv[0] for kv in (a or [])], values=[kv[1] for kv in (a or [])], LOCATIONS)
     }
    | '{' invalid_double_starred_kvpairs '}'

double_starred_kvpairs[list[Any]]: a=','.double_starred_kvpair+ [','] { a }

double_starred_kvpair[tuple[ast.expr, ast.expr]]:
    | '**' a=bitwise_or { (None, a) }
    | kvpair

kvpair[tuple[ast.expr, ast.expr]]: a=expression ':' b=expression { (a, b) }

# Comprehensions & Generators
# ---------------------------

for_if_clauses[List[ast.comprehension]]:
    | a=for_if_clause+ { a }

for_if_clause[ast.comprehension]:
    | 'async' 'for' a=star_targets 'in' ~ b=disjunction c=(for_if_disjunction)* {
        ast.comprehension(target=a, iter=b, ifs=c, is_async=1)
     }
    | 'for' a=star_targets 'in' ~ b=disjunction c=(for_if_disjunction)* {
       ast.comprehension(target=a, iter=b, ifs=c, is_async=0) }
    | invalid_for_target

for_if_disjunction[ast.expr]:
    | 'if' z=disjunction { z }

listcomp[ast.ListComp]:
    | '[' a=named_expression b=for_if_clauses ']' { ast.ListComp(elt=a, generators=b, LOCATIONS) }
    | invalid_comprehension

setcomp[ast.SetComp]:
    | '{' a=named_expression b=for_if_clauses '}' { ast.SetComp(elt=a, generators=b, LOCATIONS) }
    | invalid_comprehension

genexp[ast.GeneratorExp]:
    | '(' a=( assignment_expression | expression !':=') b=for_if_clauses ')' { ast.GeneratorExp(elt=a, generators=b, LOCATIONS) }
    | invalid_comprehension

# sepearate bare_genexp from genexp to support comp inside @(...)
bare_genexp:
    | a=( assignment_expression | expression !':=') b=for_if_clauses { ast.GeneratorExp(elt=a, generators=b, LOCATIONS) }

dictcomp[ast.DictComp]:
    | '{' a=kvpair b=for_if_clauses '}' { ast.DictComp(key=a[0], value=a[1], generators=b, LOCATIONS) }
    | invalid_dict_comprehension

# FUNCTION CALL ARGUMENTS
# =======================

arguments[tuple[list[Any], list[Any]]] (memo):
    | a=args [','] &')' { a }
    | invalid_arguments

args[tuple[list[Any], list[Any]]]:
    | a=','.args_arg+ b=[',' k=kwargs {k}] {
        (a + ([e for e in b if isinstance(e, ast.Starred)] if b else []),
         ([e for e in b if not isinstance(e, ast.Starred)] if b else [])
        )
     }
    | a=kwargs {
        ([e for e in a if isinstance(e, ast.Starred)],
         [e for e in a if not isinstance(e, ast.Starred)])
    }

args_arg[ast.expr | Any]:
    | starred_expression
    | ( assignment_expression | expression !':=') !'='

kwargs[list[Any]]:
    | a=','.kwarg_or_starred+ ',' b=','.kwarg_or_double_starred+ { a + b }
    | ','.kwarg_or_starred+
    | ','.kwarg_or_double_starred+

starred_expression[ast.Starred]:
    | invalid_starred_expression
    | '*' a=expression { ast.Starred(value=a, ctx=Load, LOCATIONS) }

kwarg_or_starred[ast.keyword | ast.Starred]:
    | invalid_kwarg
    | a=NAME '=' b=expression { ast.keyword(arg=a.string, value=b, LOCATIONS) }
    | a1=starred_expression { a1 }

kwarg_or_double_starred[ast.keyword | ast.Starred]:
    | invalid_kwarg
    | a=NAME '=' b=expression { ast.keyword(arg=a.string, value=b, LOCATIONS) }   # XXX Unreachable
    | '**' a1=expression { ast.keyword(arg=None, value=a1, LOCATIONS) }

# ASSIGNMENT TARGETS
# ==================

# Generic targets
# ---------------

# NOTE: star_targets may contain *bitwise_or, targets may not.
star_targets[ast.expr]:
    | a=star_target !',' { a }
    | a=star_target b=star_target_a* [','] {
        ast.Tuple(elts=[a] + b, ctx=Store, LOCATIONS)
     }

star_targets_list_seq[list[Any]]: a=','.star_target+ [','] { a }

star_targets_tuple_seq[list[Any]]:
    | a=star_target b=star_target_a+ [','] { [a] + b }
    | a=star_target ',' { [a] }

star_target_a[ast.expr]:
    | ',' c=star_target { c }

star_target[ast.expr] (memo):
    | '*' a=(!'*' star_target) {
        ast.Starred(value=self.set_expr_context(a, Store), ctx=Store, LOCATIONS)
     }
    | target_with_star_atom

target_with_star_atom[ast.expr] (memo):
    | a=t_primary '.' b=NAME !t_lookahead { ast.Attribute(value=a, attr=b.string, ctx=Store, LOCATIONS) }
    | a=t_primary '[' b=slices ']' !t_lookahead { ast.Subscript(value=a, slice=b, ctx=Store, LOCATIONS) }
    | '$' a=NAME { self.expand_env_name(a, ctx=Store, LOCATIONS) }
    | '${' a=slices '}' { self.expand_env_expr(a, ctx=Store, LOCATIONS) }
    | star_atom

star_atom[ast.expr]:
    | a=NAME { ast.Name(id=a.string, ctx=Store, LOCATIONS) }
    | '(' a1=target_with_star_atom ')' { self.set_expr_context(a1, Store) }
    | '(' a2=[star_targets_tuple_seq] ')' { ast.Tuple(elts=a2 or [], ctx=Store, LOCATIONS) }
    | '[' a3=[star_targets_list_seq] ']' {  ast.List(elts=a3 or [], ctx=Store, LOCATIONS) }

single_target:
    | single_subscript_attribute_target
    | a=NAME { ast.Name(id=a.string, ctx=Store, LOCATIONS) }
    | '(' a=single_target ')' { a }

single_subscript_attribute_target:
    | a=t_primary '.' b=NAME !t_lookahead { ast.Attribute(value=a, attr=b.string, ctx=Store, LOCATIONS) }
    | a=t_primary '[' b=slices ']' !t_lookahead { ast.Subscript(value=a, slice=b, ctx=Store, LOCATIONS) }


t_primary:
    | a=t_primary '.' b=NAME &t_lookahead { ast.Attribute(value=a, attr=b.string, ctx=Load, LOCATIONS) }
    | a=t_primary '[' b=slices ']' &t_lookahead { ast.Subscript(value=a, slice=b, ctx=Load, LOCATIONS) }
    | a=t_primary b=genexp &t_lookahead { ast.Call(func=a, args=[b], keywords=[], LOCATIONS) }
    | a=t_primary '(' b=[arguments] ')' &t_lookahead {
        ast.Call(
            func=a,
            args=b[0] if b else [],
            keywords=b[1] if b else [],
            LOCATIONS,
        )
     }
    | a=atom &t_lookahead { a }

t_lookahead: '(' | '[' | '.'

# Targets for del statements
# --------------------------

del_targets[list[ast.expr]]: a=','.del_target+ [','] { a }

del_target[ast.expr] (memo):
    | a=t_primary '.' b=NAME !t_lookahead { ast.Attribute(value=a, attr=b.string, ctx=Del, LOCATIONS) }
    | a=t_primary '[' b=slices ']' !t_lookahead { ast.Subscript(value=a, slice=b, ctx=Del, LOCATIONS) }
    | del_t_atom

del_t_atom[ast.expr]:
    | a=NAME { ast.Name(id=a.string, ctx=Del, LOCATIONS) }
    | '(' b=del_target ')' { self.set_expr_context(b, Del) }
    | '(' c=[del_targets] ')' { ast.Tuple(elts=c or [], ctx=Del, LOCATIONS) }
    | '[' c=[del_targets] ']' { ast.List(elts=c or [], ctx=Del, LOCATIONS) }


# TYPING ELEMENTS
# ---------------

type_comment_str[str]:
    | t=TYPE_COMMENT { t.string }

func_type_comment[str]:
    | NEWLINE t=TYPE_COMMENT &(NEWLINE INDENT) { t.string }  # Must be followed by indented block
    | invalid_double_type_comments
    | type_comment_str

# ========================= END OF THE GRAMMAR ===========================



# ========================= START OF INVALID RULES =======================

# From here on, there are rules for invalid syntax with specialised error messages
invalid_arguments[NoReturn]:
    | a=args ',' '*' {
        self.raise_syntax_error_known_location(
            "iterable argument unpacking follows keyword argument unpacking",
            a[1][-1] if a[1] else a[0][-1],
        )
     }
    | a1=expression b=for_if_clauses ',' [args | expression for_if_clauses] {
        self.raise_syntax_error_known_range(
            "Generator expression must be parenthesized",
            a1,
            (b[-1].ifs[-1] if b[-1].ifs else b[-1].iter)
        )
     }
    | a2=NAME b2='=' expression for_if_clauses {
        self.raise_syntax_error_known_range(
            "invalid syntax. Maybe you meant '==' or ':=' instead of '='?", a2, b2
        )
     }
    | (args ',')? a3=NAME b3='=' &(',' | ')') {
        self.raise_syntax_error_known_range("expected argument value expression", a3, b3)
     }
    | a4=args b4=for_if_clauses {
        self.raise_syntax_error_known_range(
            "Generator expression must be parenthesized",
            a4[0][-1],
            (b4[-1].ifs[-1] if b4[-1].ifs else b4[-1].iter),
        ) if len(a4[0]) > 1 else None
     }
    | args ',' a5=expression b5=for_if_clauses {
        self.raise_syntax_error_known_range(
            "Generator expression must be parenthesized",
            a5,
            (b5[-1].ifs[-1] if b5[-1].ifs else b5[-1].iter),
        )
     }
    | a6=args ',' args {
        self.raise_syntax_error(
            "positional argument follows keyword argument unpacking"
            if a6[1][-1].arg is None else
            "positional argument follows keyword argument",
        )
     }
invalid_kwarg[NoReturn]:
    | a=('True'|'False'|'None') b='=' {
        self.raise_syntax_error_known_range(f"cannot assign to {a.string}", a, b)
     }
    | a1=NAME b1='=' expression for_if_clauses {
        self.raise_syntax_error_known_range(
            "invalid syntax. Maybe you meant '==' or ':=' instead of '='?", a1, b1
        )
     }
    | !(NAME '=') a2=expression b2='=' {
        self.raise_syntax_error_known_range(
            "expression cannot contain assignment, perhaps you meant \"==\"?", a2, b2,
        )
     }
    | a3='**' expression '=' b3=expression {
        self.raise_syntax_error_known_range(
            "cannot assign to keyword argument unpacking", a3, b3
        )
     }

# IMPORTANT: Note that the "_without_invalid" suffix causes the rule to
# not call invalid rules under it
expression_without_invalid[Node | Any]:
    | a=disjunction 'if' b=disjunction 'else' c=expression {
        ast.IfExp(body=b, test=a, orelse=c, LOCATIONS)
     }
    | disjunction
    | lambdef
invalid_legacy_expression:
    | a=NAME !'(' b=star_expressions {
        self.raise_syntax_error_known_range(
            f"Missing parentheses in call to '{a.string}' . Did you mean {a.string}(...)?", a, b,
        ) if a.string in ("exec", "print") else
        None
     }
invalid_expression[NoReturn]:
    # !(NAME STRING) is not matched so we don't show this error with some invalid string prefixes like: kf"dsfsdf"
    # Soft keywords need to also be ignored because they can be parsed as NAME NAME
    | !(NAME STRING | SOFT_KEYWORD) a=disjunction b=expression_without_invalid {
        (
            self.raise_syntax_error_known_range("invalid syntax. Perhaps you forgot a comma?", a, b)
            if not isinstance(a, ast.Name) or a.id not in ("print", "exec")
            else None
        )
     }
    | a1=disjunction 'if' b1=disjunction !('else'|':') {
        self.raise_syntax_error_known_range("expected 'else' after 'if' expression", a1, b1)
     }
    | a2='lambda' [lambda_params] b2=':' &(FSTRING_MIDDLE | fstring_replacement_field)  {
        self.raise_syntax_error_known_range(
            "f-string: lambda expressions are not allowed without parentheses", a2, b2
        )
     }
invalid_named_expression[NoReturn]:
    | a=expression ':=' expression {
        self.raise_syntax_error_known_location(
            f"cannot use assignment expressions with {self.get_expr_name(a)}", a
        )
     }
    # Use in_raw_rule
    | a1=NAME '=' b1=bitwise_or !('='|':=') {
        (
            None
            if self.in_recursive_rule else
            self.raise_syntax_error_known_range(
                "invalid syntax. Maybe you meant '==' or ':=' instead of '='?", a1, b1
            )
        )
     }
    | !(plist|ptuple|genexp|'True'|'None'|'False') a2=bitwise_or '=' bitwise_or !('='|':=') {
        (
            None
            if self.in_recursive_rule else
            self.raise_syntax_error_known_location(
                f"cannot assign to {self.get_expr_name(a)} here. Maybe you meant '==' instead of '='?", a2
            )
        )
     }

invalid_assignment[NoReturn]:
    | a=invalid_ann_assign_target ':' expression {
        self.raise_syntax_error_known_location(
            f"only single target (not {self.get_expr_name(a)}) can be annotated", a
        )
     }
    | a=star_named_expression ',' star_named_expressions* ':' expression {
        self.raise_syntax_error_known_location("only single target (not tuple) can be annotated", a) }
    | a=expression ':' expression {
        self.raise_syntax_error_known_location("illegal target for annotation", a) }
    | (star_targets '=')* a=star_expressions '=' {
        self.raise_syntax_error_invalid_target(Target.STAR_TARGETS, a)
     }
    | (star_targets '=')* a=yield_expr '=' {
        self.raise_syntax_error_known_location("assignment to yield expression not possible", a)
     }
    | a=star_expressions augassign annotated_rhs {
        self.raise_syntax_error_known_location(
            f"'{self.get_expr_name(a)}' is an illegal expression for augmented assignment", a
        )
     }
invalid_ann_assign_target[Node]:
    | a=plist { a }
    | a1=ptuple { a1 }
    | '(' a2=invalid_ann_assign_target ')' { a2 }
invalid_del_stmt[NoReturn]:
    | 'del' a=star_expressions {
        self.raise_syntax_error_invalid_target(Target.DEL_TARGETS, a)
     }
invalid_block[NoReturn]:
    | NEWLINE !INDENT { self.raise_indentation_error("expected an indented block") }
invalid_comprehension[NoReturn]:
    | ('[' | '(' | '{') a1=starred_expression for_if_clauses {
        self.raise_syntax_error_known_location("iterable unpacking cannot be used in comprehension", a1)
     }
    | ('[' | '{') a=star_named_expression ',' b=star_named_expressions for_if_clauses {
        self.raise_syntax_error_known_range(
            "did you forget parentheses around the comprehension target?", a, b[-1]
        )
     }
    | ('[' | '{') a=star_named_expression b=',' for_if_clauses {
        self.raise_syntax_error_known_range(
            "did you forget parentheses around the comprehension target?", a, b
        )
     }
invalid_dict_comprehension[NoReturn]:
    | '{' a='**' bitwise_or for_if_clauses '}' {
        self.raise_syntax_error_known_location("dict unpacking cannot be used in dict comprehension", a)
     }
invalid_parameters[NoReturn]:
    | a="/" ',' {
        self.raise_syntax_error_known_location("at least one argument must precede /", a)
     }
    | (slash_no_default | slash_with_default) param_maybe_default* a1='/' {
        self.raise_syntax_error_known_location("/ may appear only once", a1)
     }
    | slash_no_default? param_no_default* invalid_parameters_helper a2=param_no_default {
        self.raise_syntax_error_known_location(
            "parameter without a default follows parameter with a default", a2
        )
     }
    | param_no_default* a3='(' param_no_default+ ','? b=')' {
        self.raise_syntax_error_known_range(
            "Function parameters cannot be parenthesized", a3, b
        )
     }
    | (slash_no_default | slash_with_default)? param_maybe_default* '*' (',' | param_no_default) param_maybe_default* a4='/' {
        self.raise_syntax_error_known_location("/ must be ahead of *", a4)
     }
    | param_maybe_default+ '/' a5='*' {
        self.raise_syntax_error_known_location("expected comma between / and *", a5)
     }
invalid_default:
    | a='=' &(')'|',') {
        self.raise_syntax_error_known_location("expected default value expression", a)
     }
invalid_star_etc:
    | a='*' (')' | ',' (')' | '**')) {
        self.raise_syntax_error_known_location("named arguments must follow bare *", a)
     }
    | '*' ',' TYPE_COMMENT { self.raise_syntax_error("bare * has associated type comment") }
    | '*' param a='=' {
        self.raise_syntax_error_known_location("var-positional argument cannot have default value", a)
     }
    | '*' (param_no_default | ',') param_maybe_default* a='*' (param_no_default | ',') {
        self.raise_syntax_error_known_location("* argument may appear only once", a)
     }
invalid_kwds:
    | '**' param a='=' {
        self.raise_syntax_error_known_location("var-keyword argument cannot have default value", a)
     }
    | '**' param ',' a1=param {
        self.raise_syntax_error_known_location("arguments cannot follow var-keyword argument", a1)
     }
    | '**' param ',' a=('*'|'**'|'/') {
        self.raise_syntax_error_known_location("arguments cannot follow var-keyword argument", a)
     }
invalid_parameters_helper: # This is only there to avoid type errors
    | a=slash_with_default { [a] }
    | a=param_with_default+
invalid_lambda_parameters[NoReturn]:
    | a="/" ',' {
        self.raise_syntax_error_known_location("at least one argument must precede /", a)
     }
    | (lambda_slash_no_default | lambda_slash_with_default) lambda_param_maybe_default* a1='/' {
        self.raise_syntax_error_known_location("/ may appear only once", a1)
     }
    | lambda_slash_no_default? lambda_param_no_default* invalid_lambda_parameters_helper a2=lambda_param_no_default {
        self.raise_syntax_error_known_location(
            "parameter without a default follows parameter with a default", a2
        )
     }
    | lambda_param_no_default* a3='(' ','.lambda_param+ ','? b=')' {
        self.raise_syntax_error_known_range(
            "Lambda expression parameters cannot be parenthesized", a3, b
        )
     }
    | (lambda_slash_no_default | lambda_slash_with_default)? lambda_param_maybe_default* '*' (',' | lambda_param_no_default) lambda_param_maybe_default* a4='/' {
        self.raise_syntax_error_known_location("/ must be ahead of *", a4)
     }
    | lambda_param_maybe_default+ '/' a5='*' {
        self.raise_syntax_error_known_location("expected comma between / and *", a5)
     }
invalid_lambda_parameters_helper:
    | a=lambda_slash_with_default { [a] }
    | a=lambda_param_with_default+
invalid_lambda_star_etc[NoReturn]:
    | '*' (':' | ',' (':' | '**')) {
        self.raise_syntax_error("named arguments must follow bare *")
     }
    | '*' lambda_param a='=' {
        self.raise_syntax_error_known_location("var-positional argument cannot have default value", a)
     }
    | '*' (lambda_param_no_default | ',') lambda_param_maybe_default* a='*' (lambda_param_no_default | ',') {
        self.raise_syntax_error_known_location("* argument may appear only once", a)
     }
invalid_lambda_kwds:
    | '**' lambda_param a='=' {
        self.raise_syntax_error_known_location("var-keyword argument cannot have default value", a)
     }
    | '**' lambda_param ',' a1=lambda_param {
        self.raise_syntax_error_known_location("arguments cannot follow var-keyword argument", a1)
     }
    | '**' lambda_param ',' a2=('*'|'**'|'/') {
        self.raise_syntax_error_known_location("arguments cannot follow var-keyword argument", a2)
     }
invalid_double_type_comments[NoReturn]:
    | TYPE_COMMENT NEWLINE TYPE_COMMENT NEWLINE INDENT {
        self.raise_syntax_error("Cannot have two type comments on def")
     }
invalid_with_item[NoReturn]:
    | expression 'as' a=expression &(',' | ')' | ':') {
        self.raise_syntax_error_invalid_target(Target.STAR_TARGETS, a)
     }

invalid_for_target[NoReturn]:
    | 'async'? 'for' a=star_expressions {
        self.raise_syntax_error_invalid_target(Target.FOR_TARGETS, a)
     }

invalid_group[NoReturn]:
    | '(' a=starred_expression ')' {
        self.raise_syntax_error_known_location("cannot use starred expression here", a)
     }
    | '(' b='**' expression ')' {
        self.raise_syntax_error_known_location("cannot use double starred expression here", b)
     }
invalid_import:
    | a='import' ','.dotted_name+ 'from' dotted_name {
        self.raise_syntax_error_starting_from(
            "Did you mean to use 'from ... import ...' instead?", a
        )
     }
invalid_import_from_targets[NoReturn]:
    | import_from_as_names ',' NEWLINE {
        self.raise_syntax_error("trailing comma not allowed without surrounding parentheses")
     }

invalid_with_stmt[NoReturn]:
    | ['async'] 'with' ','.(expression ['as' star_target])+ &&':' { UNREACHABLE }
    | ['async'] 'with' '(' ','.(expressions ['as' star_target])+ ','? ')' &&':' { UNREACHABLE }
invalid_with_stmt_indent[NoReturn]:
    | ['async'] a='with' ','.(expression ['as' star_target])+ ':' NEWLINE !INDENT {
        self.raise_indentation_error(
            f"expected an indented block after 'with' statement on line {a.start[0]}"
        )
     }
    | ['async'] a='with' '(' ','.(expressions ['as' star_target])+ ','? ')' ':' NEWLINE !INDENT {
        self.raise_indentation_error(
            f"expected an indented block after 'with' statement on line {a.start[0]}"
        )
     }

invalid_try_stmt[NoReturn]:
    | a='try' ':' NEWLINE !INDENT {
        self.raise_indentation_error(
            f"expected an indented block after 'try' statement on line {a.start[0]}",
        )
     }
    | 'try' ':' block !('except' | 'finally') {
        self.raise_syntax_error("expected 'except' or 'finally' block")
     }
    | 'try' ':' block* except_block+ a='except' b='*' expression ['as' NAME] ':' {
        self.raise_syntax_error_known_range(
            "cannot have both 'except' and 'except*' on the same 'try'", a, b
        )
     }
    | 'try' ':' block* except_star_block+ a='except' [expression ['as' NAME]] ':' {
        self.raise_syntax_error_known_location(
            "cannot have both 'except' and 'except*' on the same 'try'", a
        )
     }
invalid_except_stmt[NoReturn]:
    | 'except' '*'? a=expression ',' expressions ['as' NAME ] ':' {
        self.raise_syntax_error_starting_from("multiple exception types must be parenthesized", a)
     }
    | a='except' '*'? expression ['as' NAME ] NEWLINE { self.raise_syntax_error("expected ':'") }
    | a='except' '*'? NEWLINE { self.raise_syntax_error("expected ':'") }
    | a='except' '*' (NEWLINE | ':') {
        self.raise_syntax_error("expected one or more exception types")
     }
invalid_finally_stmt[NoReturn]:
    | a='finally' ':' NEWLINE !INDENT {
        self.raise_indentation_error(
            f"expected an indented block after 'finally' statement on line {a.start[0]}"
        )
     }
invalid_except_stmt_indent[NoReturn]:
    | a='except' expression ['as' NAME ] ':' NEWLINE !INDENT {
        self.raise_indentation_error(
            f"expected an indented block after 'except' statement on line {a.start[0]}"
        )
     }
    | a='except' ':' NEWLINE !INDENT {
        self.raise_indentation_error(
            f"expected an indented block after 'except' statement on line {a.start[0]}"
        )
     }
invalid_except_star_stmt_indent[NoReturn]:
    | a='except' '*' expression ['as' NAME ] ':' NEWLINE !INDENT {
        self.raise_indentation_error(
            f"expected an indented block after 'except*' statement on line {a.start[0]}"
        )
     }
invalid_match_stmt[NoReturn]:
    | "match" subject_expr !':' {
        self.raise_syntax_error("expected ':'")
     }
    | a="match" subject=subject_expr ':' NEWLINE !INDENT {
        self.raise_indentation_error(
            f"expected an indented block after 'match' statement on line {a.start[0]}"
        )
     }
invalid_case_block[NoReturn]:
    | "case" patterns guard? !':' { self.raise_syntax_error("expected ':'") }
    | a="case" patterns guard? ':' NEWLINE !INDENT {
        self.raise_indentation_error(
            f"expected an indented block after 'case' statement on line {a.start[0]}"
        )
     }
invalid_as_pattern[NoReturn]:
    | or_pattern 'as' a="_" {
        self.raise_syntax_error_known_location("cannot use '_' as a target", a)
     }
    | or_pattern 'as' !NAME a1=expression {
        self.raise_syntax_error_known_location("invalid pattern target", a1)
     }
invalid_class_pattern[NoReturn]:
    | name_or_attr '(' a=invalid_class_argument_pattern  {
        self.raise_syntax_error_known_range(
            "positional patterns follow keyword patterns", a[0], a[-1]
        )
     }
invalid_class_argument_pattern:
    | [positional_patterns ','] keyword_patterns ',' a=positional_patterns { a }
invalid_if_stmt[NoReturn]:
    | 'if' named_expression NEWLINE { self.raise_syntax_error("expected ':'") }
    | a='if' a=named_expression ':' NEWLINE !INDENT {
        self.raise_indentation_error(
            f"expected an indented block after 'if' statement on line {a.start[0]}"
        )
     }
invalid_elif_stmt[NoReturn]:
    | 'elif' named_expression NEWLINE { self.raise_syntax_error("expected ':'") }
    | a='elif' named_expression ':' NEWLINE !INDENT {
        self.raise_indentation_error(
            f"expected an indented block after 'elif' statement on line {a.start[0]}"
        )
     }
invalid_else_stmt[NoReturn]:
    | a='else' ':' NEWLINE !INDENT {
        self.raise_indentation_error(
            f"expected an indented block after 'else' statement on line {a.start[0]}"
        )
     }
invalid_while_stmt[NoReturn]:
    | 'while' named_expression NEWLINE { self.raise_syntax_error("expected ':'") }
    | a='while' named_expression ':' NEWLINE !INDENT {
        self.raise_indentation_error(
            f"expected an indented block after 'while' statement on line {a.start[0]}"
        )
     }
invalid_for_stmt[NoReturn]:
    | [ASYNC] 'for' star_targets 'in' star_expressions NEWLINE { self.raise_syntax_error("expected ':'") }
    | ['async'] a='for' star_targets 'in' star_expressions ':' NEWLINE !INDENT {
        self.raise_indentation_error(
            f"expected an indented block after 'for' statement on line {a.start[0]}"
        )
     }
invalid_def_raw[NoReturn]:
    | ['async'] a='def' NAME  [type_params] '(' [params] ')' [return_expr] ':' NEWLINE !INDENT {
        self.raise_indentation_error(
            f"expected an indented block after function definition on line {a.start[0]}"
        )
     }
invalid_class_def_raw[NoReturn]:
    | 'class' NAME [type_params] ['(' [arguments] ')'] NEWLINE { self.raise_syntax_error("expected ':'") }
    | a='class' NAME  [type_params] ['(' [arguments] ')'] ':' NEWLINE !INDENT {
        self.raise_indentation_error(
            f"expected an indented block after class definition on line {a.start[0]}"
        )
     }

invalid_double_starred_kvpairs[NoReturn]:
    | ','.double_starred_kvpair+ ',' invalid_kvpair
    | expression ':' a='*' bitwise_or {
        self.raise_syntax_error_starting_from("cannot use a starred expression in a dictionary value", a)
     }
    | expression a=':' &('}'|',') {
        self.raise_syntax_error_known_location("expression expected after dictionary key and ':'", a)
     }
invalid_kvpair[NoReturn]:
    | a=expression !(':') {
        self.raise_raw_syntax_error(
            "':' expected after dictionary key",
            (a.lineno, a.col_offset),
            (a.end_lineno, a.end_col_offset)
        )
     }
    | expression ':' a1='*' bitwise_or {
        self.raise_syntax_error_starting_from("cannot use a starred expression in a dictionary value", a1)
     }
    | expression a2=':' &('}'|',') {
        self.raise_syntax_error_known_location(
            "expression expected after dictionary key and ':'", a2
        )
     }
    | expression a3=':' {
        self.raise_syntax_error_known_location("expression expected after dictionary key and ':'", a3)
     }
invalid_starred_expression:
    | a='*' expression '=' b=expression {
        self.raise_syntax_error_known_range(
            "cannot assign to iterable argument unpacking", a, b
        )
     }
invalid_replacement_field[NoReturn]:
    | '{' a='=' { self.raise_syntax_error_known_location("f-string: valid expression required before '='", a) }
    | '{' a='!' { self.raise_syntax_error_known_location("f-string: valid expression required before '!'", a) }
    | '{' a=':' { self.raise_syntax_error_known_location("f-string: valid expression required before ':'", a) }
    | '{' a='}' { self.raise_syntax_error_known_location("f-string: valid expression required before '}'", a) }
    | '{' !annotated_rhs {
        self.raise_syntax_error_on_next_token(
            "f-string: expecting a valid expression after '{'"
        )
     }
    | '{' annotated_rhs !('=' | '!' | ':' | '}') {
        self.raise_syntax_error_on_next_token("f-string: expecting '=', or '!', or ':', or '}'") }
    | '{' annotated_rhs '=' !('!' | ':' | '}') {
       self.raise_syntax_error_on_next_token("f-string: expecting '!', or ':', or '}'")
     }
    | '{' annotated_rhs '='? invalid_conversion_character
    | '{' annotated_rhs '='? ['!' NAME] !(':' | '}') {
        self.raise_syntax_error_on_next_token("f-string: expecting ':' or '}'")
     }
    | '{' annotated_rhs '='? ['!' NAME] ':' fstring_format_spec* !'}' {
        self.raise_syntax_error_on_next_token("f-string: expecting '}', or format specs")
     }
    | '{' annotated_rhs '='? ['!' NAME] !'}' {
        self.raise_syntax_error_on_next_token("f-string: expecting '}'")
     }

invalid_conversion_character[NoReturn]:
    | '!' &(':' | '}') { self.raise_syntax_error_on_next_token("f-string: missing conversion character") }
    | '!' !NAME { self.raise_syntax_error_on_next_token("f-string: invalid conversion character") }