def convert_classdef(config: ParserConfig, children: Sequence[Any]) -> Any:
classdef, name, *arglist, colon, suite = children
# First, parse out the comments and empty lines before the statement.
leading_lines = parse_empty_lines(config, classdef.whitespace_before)
# Compute common whitespace and nodes
whitespace_after_class = parse_simple_whitespace(config,
classdef.whitespace_after)
namenode = Name(name.string)
whitespace_after_name = parse_simple_whitespace(config,
name.whitespace_after)
# Now, construct the classdef node itself
if not arglist:
# No arglist, so no arguments to this class
return ClassDef(
leading_lines=leading_lines,
lines_after_decorators=(),
whitespace_after_class=whitespace_after_class,
name=namenode,
whitespace_after_name=whitespace_after_name,
body=suite,
)
else:
# Unwrap arglist partial, because its valid to not have any
lpar, *args, rpar = arglist
args = args[0].args if args else []
bases: List[Arg] = []
keywords: List[Arg] = []
current_arg = bases
for arg in args:
if arg.star == "**" or arg.keyword is not None:
current_arg = keywords
# Some quick validation
if current_arg is keywords and (arg.star == "*" or
(arg.star == ""
and arg.keyword is None)):
raise PartialParserSyntaxError(
"Positional argument follows keyword argument.")
current_arg.append(arg)
return ClassDef(
leading_lines=leading_lines,
lines_after_decorators=(),
whitespace_after_class=whitespace_after_class,
name=namenode,
whitespace_after_name=whitespace_after_name,
lpar=LeftParen(whitespace_after=parse_parenthesizable_whitespace(
config, lpar.whitespace_after)),
bases=bases,
keywords=keywords,
rpar=RightParen(whitespace_before=parse_parenthesizable_whitespace(
config, rpar.whitespace_before)),
whitespace_before_colon=parse_simple_whitespace(
config, colon.whitespace_before),
body=suite,
)
def _convert_dict(config: ParserConfig,
children: typing.Sequence[typing.Any]) -> typing.Any:
is_first_starred = isinstance(children[0],
Token) and children[0].string == "**"
if is_first_starred:
possible_comp_for = None if len(children) < 3 else children[2]
else:
possible_comp_for = None if len(children) < 4 else children[3]
if isinstance(possible_comp_for, CompFor):
if is_first_starred:
raise PartialParserSyntaxError(
"dict unpacking cannot be used in dict comprehension")
return _convert_dict_comp(config, children)
children_iter = iter(children)
last_child = children[-1]
elements = []
while True:
try:
elements.append(
_convert_dict_element(config, children_iter, last_child))
except StopIteration:
break
# lbrace, rbrace, lpar, and rpar will be attached as-needed by the atom grammar
return WithLeadingWhitespace(Dict(tuple(elements)),
children[0].whitespace_before)
def add_param(current_param: Optional[List[Param]],
param: Union[Param, ParamStar]) -> Optional[List[Param]]:
nonlocal star_arg
nonlocal star_kwarg
if isinstance(param, ParamStar):
# Only can add this if we don't already have a "*" or a "*param".
if current_param in [params, default_params]:
star_arg = param
current_param = kwonly_params
else:
# Example code:
# def fn(*abc, *): ...
# This should be unreachable, the grammar already disallows it.
raise Exception(
"Cannot have multiple star ('*') markers in a single argument "
+ "list.")
# pyre-ignore Pyre seems to think param.star.__eq__ is not callable
elif isinstance(param.star,
str) and param.star == "" and param.default is None:
# Can only add this if we're in the params or kwonly_params section
if current_param is params:
params.append(param)
elif current_param is kwonly_params:
kwonly_params.append(param)
else:
# Example code:
# def fn(first=None, second): ...
# This code is reachable, so we should use a PartialParserSyntaxError.
raise PartialParserSyntaxError(
"Cannot have a non-default argument following a default argument."
)
elif (isinstance(param.star, str)
# pyre-ignore Pyre seems to think param.star.__eq__ is not callable
and param.star == "" and param.default is not None):
if current_param is params:
current_param = default_params
# Can only add this if we're not yet at star args.
if current_param is default_params:
default_params.append(param)
elif current_param is kwonly_params:
kwonly_params.append(param)
else:
# Example code:
# def fn(**kwargs, trailing=None)
# This should be unreachable, the grammar already disallows it.
raise Exception(
"Cannot have any arguments after a kwargs expansion.")
elif (isinstance(param.star, str)
# pyre-ignore Pyre seems to think param.star.__eq__ is not callable
and param.star == "*" and param.default is None):
# Can only add this if we're in params/default_params, since
# we only allow one of "*" or "*param".
if current_param in [params, default_params]:
star_arg = param
current_param = kwonly_params
else:
# Example code:
# def fn(*first, *second): ...
# This should be unreachable, the grammar already disallows it.
raise Exception(
"Expected a keyword argument but found a starred positional "
+ "argument expansion.")
elif (isinstance(param.star, str)
# pyre-ignore Pyre seems to think param.star.__eq__ is not callable
and param.star == "**" and param.default is None):
# Can add this in all cases where we don't have a star_kwarg
# yet.
if current_param is not None:
star_kwarg = param
current_param = None
else:
# Example code:
# def fn(**first, **second)
# This should be unreachable, the grammar already disallows it.
raise Exception(
"Multiple starred keyword argument expansions are not allowed in a "
+ "single argument list")
else:
# The state machine should never end up here.
raise Exception("Logic error!")
return current_param
def convert_argslist(config: ParserConfig, children: Sequence[Any]) -> Any:
params: List[Param] = []
default_params: List[Param] = []
star_arg: Union[Param, ParamStar, MaybeSentinel] = MaybeSentinel.DEFAULT
kwonly_params: List[Param] = []
star_kwarg: Optional[Param] = None
def add_param(current_param: Optional[List[Param]],
param: Union[Param, ParamStar]) -> Optional[List[Param]]:
nonlocal star_arg
nonlocal star_kwarg
if isinstance(param, ParamStar):
# Only can add this if we don't already have a "*" or a "*param".
if current_param in [params, default_params]:
star_arg = param
current_param = kwonly_params
else:
# Example code:
# def fn(*abc, *): ...
# This should be unreachable, the grammar already disallows it.
raise Exception(
"Cannot have multiple star ('*') markers in a single argument "
+ "list.")
# pyre-ignore Pyre seems to think param.star.__eq__ is not callable
elif isinstance(param.star,
str) and param.star == "" and param.default is None:
# Can only add this if we're in the params or kwonly_params section
if current_param is params:
params.append(param)
elif current_param is kwonly_params:
kwonly_params.append(param)
else:
# Example code:
# def fn(first=None, second): ...
# This code is reachable, so we should use a PartialParserSyntaxError.
raise PartialParserSyntaxError(
"Cannot have a non-default argument following a default argument."
)
elif (isinstance(param.star, str)
# pyre-ignore Pyre seems to think param.star.__eq__ is not callable
and param.star == "" and param.default is not None):
if current_param is params:
current_param = default_params
# Can only add this if we're not yet at star args.
if current_param is default_params:
default_params.append(param)
elif current_param is kwonly_params:
kwonly_params.append(param)
else:
# Example code:
# def fn(**kwargs, trailing=None)
# This should be unreachable, the grammar already disallows it.
raise Exception(
"Cannot have any arguments after a kwargs expansion.")
elif (isinstance(param.star, str)
# pyre-ignore Pyre seems to think param.star.__eq__ is not callable
and param.star == "*" and param.default is None):
# Can only add this if we're in params/default_params, since
# we only allow one of "*" or "*param".
if current_param in [params, default_params]:
star_arg = param
current_param = kwonly_params
else:
# Example code:
# def fn(*first, *second): ...
# This should be unreachable, the grammar already disallows it.
raise Exception(
"Expected a keyword argument but found a starred positional "
+ "argument expansion.")
elif (isinstance(param.star, str)
# pyre-ignore Pyre seems to think param.star.__eq__ is not callable
and param.star == "**" and param.default is None):
# Can add this in all cases where we don't have a star_kwarg
# yet.
if current_param is not None:
star_kwarg = param
current_param = None
else:
# Example code:
# def fn(**first, **second)
# This should be unreachable, the grammar already disallows it.
raise Exception(
"Multiple starred keyword argument expansions are not allowed in a "
+ "single argument list")
else:
# The state machine should never end up here.
raise Exception("Logic error!")
return current_param
# The parameter list we are adding to
current: Optional[List[Param]] = params
# We should have every other item in the group as a param or a comma by now,
# so split them up, add commas and then put them in the appropriate group.
for parameter, comma in grouper(children, 2):
if comma is None:
if isinstance(parameter, ParamStarPartial):
# Example:
# def fn(abc, *): ...
#
# There's also the case where we have bare * with a trailing comma.
# That's handled later.
#
# It's not valid to construct a ParamStar object without a comma, so we
# need to catch the non-comma case separately.
raise PartialParserSyntaxError(
"Named (keyword) arguments must follow a bare *.")
else:
current = add_param(current, parameter)
else:
comma = Comma(
whitespace_before=parse_parenthesizable_whitespace(
config, comma.whitespace_before),
whitespace_after=parse_parenthesizable_whitespace(
config, comma.whitespace_after),
)
if isinstance(parameter, ParamStarPartial):
current = add_param(current, ParamStar(comma=comma))
else:
current = add_param(current,
parameter.with_changes(comma=comma))
if isinstance(star_arg, ParamStar) and len(kwonly_params) == 0:
# Example:
# def fn(abc, *,): ...
#
# This will raise a validation error, but we want to make sure to raise a syntax
# error instead.
#
# The case where there's no trailing comma is already handled by this point, so
# this conditional is only for the case where we have a trailing comma.
raise PartialParserSyntaxError(
"Named (keyword) arguments must follow a bare *.")
return Parameters(
params=tuple(params),
default_params=tuple(default_params),
star_arg=star_arg,
kwonly_params=tuple(kwonly_params),
star_kwarg=star_kwarg,
)
