def _(
self,
original_node: cst.If,
updated_node: cst.If,
) -> cst.If:
orelse = cst.Else(body=cst.IndentedBlock(body=[updated_node.orelse]))
updated_node = updated_node.with_changes(orelse=orelse)
return updated_node
class ElseTest(CSTNodeTest):
@data_provider(
(
{
"node": cst.Else(cst.SimpleStatementSuite((cst.Pass(),))),
"code": "else: pass\n",
"expected_position": CodeRange.create((1, 0), (1, 10)),
},
{
"node": cst.Else(
cst.SimpleStatementSuite((cst.Pass(),)),
whitespace_before_colon=cst.SimpleWhitespace(" "),
),
"code": "else : pass\n",
"expected_position": CodeRange.create((1, 0), (1, 12)),
},
)
)
def test_valid(self, **kwargs: Any) -> None:
self.validate_node(**kwargs)
class WhileTest(CSTNodeTest):
@data_provider((
# Simple while block
# pyre-fixme[6]: Incompatible parameter type
{
"node":
cst.While(cst.Call(cst.Name("iter")),
cst.SimpleStatementSuite((cst.Pass(), ))),
"code":
"while iter(): pass\n",
"parser":
parse_statement,
},
# While block with else
{
"node":
cst.While(
cst.Call(cst.Name("iter")),
cst.SimpleStatementSuite((cst.Pass(), )),
cst.Else(cst.SimpleStatementSuite((cst.Pass(), ))),
),
"code":
"while iter(): pass\nelse: pass\n",
"parser":
parse_statement,
},
# indentation
{
"node":
DummyIndentedBlock(
" ",
cst.While(
cst.Call(cst.Name("iter")),
cst.SimpleStatementSuite((cst.Pass(), )),
),
),
"code":
" while iter(): pass\n",
"parser":
None,
"expected_position":
CodeRange((1, 4), (1, 22)),
},
# while an indented body
{
"node":
DummyIndentedBlock(
" ",
cst.While(
cst.Call(cst.Name("iter")),
cst.IndentedBlock((cst.SimpleStatementLine(
(cst.Pass(), )), )),
),
),
"code":
" while iter():\n pass\n",
"parser":
None,
"expected_position":
CodeRange((1, 4), (2, 12)),
},
# leading_lines
{
"node":
cst.While(
cst.Call(cst.Name("iter")),
cst.IndentedBlock((cst.SimpleStatementLine((cst.Pass(), )), )),
leading_lines=(cst.EmptyLine(
comment=cst.Comment("# leading comment")), ),
),
"code":
"# leading comment\nwhile iter():\n pass\n",
"parser":
parse_statement,
"expected_position":
CodeRange((2, 0), (3, 8)),
},
{
"node":
cst.While(
cst.Call(cst.Name("iter")),
cst.IndentedBlock((cst.SimpleStatementLine((cst.Pass(), )), )),
cst.Else(
cst.IndentedBlock((cst.SimpleStatementLine(
(cst.Pass(), )), )),
leading_lines=(cst.EmptyLine(
comment=cst.Comment("# else comment")), ),
),
leading_lines=(cst.EmptyLine(
comment=cst.Comment("# leading comment")), ),
),
"code":
"# leading comment\nwhile iter():\n pass\n# else comment\nelse:\n pass\n",
"parser":
None,
"expected_position":
CodeRange((2, 0), (6, 8)),
},
# Weird spacing rules
{
"node":
cst.While(
cst.Call(
cst.Name("iter"),
lpar=(cst.LeftParen(), ),
rpar=(cst.RightParen(), ),
),
cst.SimpleStatementSuite((cst.Pass(), )),
whitespace_after_while=cst.SimpleWhitespace(""),
),
"code":
"while(iter()): pass\n",
"parser":
parse_statement,
"expected_position":
CodeRange((1, 0), (1, 19)),
},
# Whitespace
{
"node":
cst.While(
cst.Call(cst.Name("iter")),
cst.SimpleStatementSuite((cst.Pass(), )),
whitespace_after_while=cst.SimpleWhitespace(" "),
whitespace_before_colon=cst.SimpleWhitespace(" "),
),
"code":
"while iter() : pass\n",
"parser":
parse_statement,
"expected_position":
CodeRange((1, 0), (1, 21)),
},
))
def test_valid(self, **kwargs: Any) -> None:
self.validate_node(**kwargs)
@data_provider(({
"get_node":
lambda: cst.While(
cst.Call(cst.Name("iter")),
cst.SimpleStatementSuite((cst.Pass(), )),
whitespace_after_while=cst.SimpleWhitespace(""),
),
"expected_re":
"Must have at least one space after 'while' keyword",
}, ))
def test_invalid(self, **kwargs: Any) -> None:
self.assert_invalid(**kwargs)
class FooterBehaviorTest(UnitTest):
@data_provider({
# Literally the most basic example
"simple_module": {
"code": "\n",
"expected_module": cst.Module(body=())
},
# A module with a header comment
"header_only_module": {
"code":
"# This is a header comment\n",
"expected_module":
cst.Module(
header=[
cst.EmptyLine(comment=cst.Comment(
value="# This is a header comment"))
],
body=[],
),
},
# A module with a header and footer
"simple_header_footer_module": {
"code":
"# This is a header comment\npass\n# This is a footer comment\n",
"expected_module":
cst.Module(
header=[
cst.EmptyLine(comment=cst.Comment(
value="# This is a header comment"))
],
body=[cst.SimpleStatementLine([cst.Pass()])],
footer=[
cst.EmptyLine(comment=cst.Comment(
value="# This is a footer comment"))
],
),
},
# A module which should have a footer comment taken from the
# if statement's indented block.
"simple_reparented_footer_module": {
"code":
"# This is a header comment\nif True:\n pass\n# This is a footer comment\n",
"expected_module":
cst.Module(
header=[
cst.EmptyLine(comment=cst.Comment(
value="# This is a header comment"))
],
body=[
cst.If(
test=cst.Name(value="True"),
body=cst.IndentedBlock(
header=cst.TrailingWhitespace(),
body=[
cst.SimpleStatementLine(
body=[cst.Pass()],
trailing_whitespace=cst.TrailingWhitespace(
),
)
],
),
)
],
footer=[
cst.EmptyLine(comment=cst.Comment(
value="# This is a footer comment"))
],
),
},
# Verifying that we properly parse and spread out footer comments to the
# relative indents they go with.
"complex_reparented_footer_module": {
"code":
("# This is a header comment\nif True:\n if True:\n pass"
+
"\n # This is an inner indented block comment\n # This "
+
"is an outer indented block comment\n# This is a footer comment\n"
),
"expected_module":
cst.Module(
body=[
cst.If(
test=cst.Name(value="True"),
body=cst.IndentedBlock(
body=[
cst.If(
test=cst.Name(value="True"),
body=cst.IndentedBlock(
body=[
cst.SimpleStatementLine(
body=[cst.Pass()])
],
footer=[
cst.EmptyLine(comment=cst.Comment(
value=
"# This is an inner indented block comment"
))
],
),
)
],
footer=[
cst.EmptyLine(comment=cst.Comment(
value=
"# This is an outer indented block comment"
))
],
),
)
],
header=[
cst.EmptyLine(comment=cst.Comment(
value="# This is a header comment"))
],
footer=[
cst.EmptyLine(comment=cst.Comment(
value="# This is a footer comment"))
],
),
},
# Verify that comments belonging to statements are still owned even
# after an indented block.
"statement_comment_reparent": {
"code":
"if foo:\n return\n# comment\nx = 7\n",
"expected_module":
cst.Module(body=[
cst.If(
test=cst.Name(value="foo"),
body=cst.IndentedBlock(body=[
cst.SimpleStatementLine(body=[
cst.Return(
whitespace_after_return=cst.SimpleWhitespace(
value=""))
])
]),
),
cst.SimpleStatementLine(
body=[
cst.Assign(
targets=[
cst.AssignTarget(target=cst.Name(value="x"))
],
value=cst.Integer(value="7"),
)
],
leading_lines=[
cst.EmptyLine(comment=cst.Comment(value="# comment"))
],
),
]),
},
# Verify that even if there are completely empty lines, we give all lines
# up to and including the last line that's indented correctly. That way
# comments that line up with indented block's indentation level aren't
# parented to the next line just because there's a blank line or two
# between them.
"statement_comment_with_empty_lines": {
"code":
("def foo():\n if True:\n pass\n\n # Empty " +
"line before me\n\n else:\n pass\n"),
"expected_module":
cst.Module(body=[
cst.FunctionDef(
name=cst.Name(value="foo"),
params=cst.Parameters(),
body=cst.IndentedBlock(body=[
cst.If(
test=cst.Name(value="True"),
body=cst.IndentedBlock(
body=[
cst.SimpleStatementLine(body=[cst.Pass()])
],
footer=[
cst.EmptyLine(indent=False),
cst.EmptyLine(comment=cst.Comment(
value="# Empty line before me")),
],
),
orelse=cst.Else(
body=cst.IndentedBlock(body=[
cst.SimpleStatementLine(body=[cst.Pass()])
]),
leading_lines=[cst.EmptyLine(indent=False)],
),
)
]),
)
]),
},
})
def test_parsers(self, code: str, expected_module: cst.CSTNode) -> None:
parsed_module = parse_module(dedent(code))
self.assertTrue(
deep_equals(parsed_module, expected_module),
msg=
f"\n{parsed_module!r}\nis not deeply equal to \n{expected_module!r}",
)
class TryTest(CSTNodeTest):
@data_provider(
(
# Simple try/except block
{
"node": cst.Try(
cst.SimpleStatementSuite((cst.Pass(),)),
handlers=(
cst.ExceptHandler(
cst.SimpleStatementSuite((cst.Pass(),)),
whitespace_after_except=cst.SimpleWhitespace(""),
),
),
),
"code": "try: pass\nexcept: pass\n",
"parser": parse_statement,
"expected_position": CodeRange((1, 0), (2, 12)),
},
# Try/except with a class
{
"node": cst.Try(
cst.SimpleStatementSuite((cst.Pass(),)),
handlers=(
cst.ExceptHandler(
cst.SimpleStatementSuite((cst.Pass(),)),
type=cst.Name("Exception"),
),
),
),
"code": "try: pass\nexcept Exception: pass\n",
"parser": parse_statement,
},
# Try/except with a named class
{
"node": cst.Try(
cst.SimpleStatementSuite((cst.Pass(),)),
handlers=(
cst.ExceptHandler(
cst.SimpleStatementSuite((cst.Pass(),)),
type=cst.Name("Exception"),
name=cst.AsName(cst.Name("exc")),
),
),
),
"code": "try: pass\nexcept Exception as exc: pass\n",
"parser": parse_statement,
"expected_position": CodeRange((1, 0), (2, 29)),
},
# Try/except with multiple clauses
{
"node": cst.Try(
cst.SimpleStatementSuite((cst.Pass(),)),
handlers=(
cst.ExceptHandler(
cst.SimpleStatementSuite((cst.Pass(),)),
type=cst.Name("TypeError"),
name=cst.AsName(cst.Name("e")),
),
cst.ExceptHandler(
cst.SimpleStatementSuite((cst.Pass(),)),
type=cst.Name("KeyError"),
name=cst.AsName(cst.Name("e")),
),
cst.ExceptHandler(
cst.SimpleStatementSuite((cst.Pass(),)),
whitespace_after_except=cst.SimpleWhitespace(""),
),
),
),
"code": "try: pass\n"
+ "except TypeError as e: pass\n"
+ "except KeyError as e: pass\n"
+ "except: pass\n",
"parser": parse_statement,
"expected_position": CodeRange((1, 0), (4, 12)),
},
# Simple try/finally block
{
"node": cst.Try(
cst.SimpleStatementSuite((cst.Pass(),)),
finalbody=cst.Finally(cst.SimpleStatementSuite((cst.Pass(),))),
),
"code": "try: pass\nfinally: pass\n",
"parser": parse_statement,
"expected_position": CodeRange((1, 0), (2, 13)),
},
# Simple try/except/finally block
{
"node": cst.Try(
cst.SimpleStatementSuite((cst.Pass(),)),
handlers=(
cst.ExceptHandler(
cst.SimpleStatementSuite((cst.Pass(),)),
whitespace_after_except=cst.SimpleWhitespace(""),
),
),
finalbody=cst.Finally(cst.SimpleStatementSuite((cst.Pass(),))),
),
"code": "try: pass\nexcept: pass\nfinally: pass\n",
"parser": parse_statement,
"expected_position": CodeRange((1, 0), (3, 13)),
},
# Simple try/except/else block
{
"node": cst.Try(
cst.SimpleStatementSuite((cst.Pass(),)),
handlers=(
cst.ExceptHandler(
cst.SimpleStatementSuite((cst.Pass(),)),
whitespace_after_except=cst.SimpleWhitespace(""),
),
),
orelse=cst.Else(cst.SimpleStatementSuite((cst.Pass(),))),
),
"code": "try: pass\nexcept: pass\nelse: pass\n",
"parser": parse_statement,
"expected_position": CodeRange((1, 0), (3, 10)),
},
# Simple try/except/else block/finally
{
"node": cst.Try(
cst.SimpleStatementSuite((cst.Pass(),)),
handlers=(
cst.ExceptHandler(
cst.SimpleStatementSuite((cst.Pass(),)),
whitespace_after_except=cst.SimpleWhitespace(""),
),
),
orelse=cst.Else(cst.SimpleStatementSuite((cst.Pass(),))),
finalbody=cst.Finally(cst.SimpleStatementSuite((cst.Pass(),))),
),
"code": "try: pass\nexcept: pass\nelse: pass\nfinally: pass\n",
"parser": parse_statement,
"expected_position": CodeRange((1, 0), (4, 13)),
},
# Verify whitespace in various locations
{
"node": cst.Try(
leading_lines=(cst.EmptyLine(comment=cst.Comment("# 1")),),
body=cst.SimpleStatementSuite((cst.Pass(),)),
handlers=(
cst.ExceptHandler(
leading_lines=(cst.EmptyLine(comment=cst.Comment("# 2")),),
type=cst.Name("TypeError"),
name=cst.AsName(
cst.Name("e"),
whitespace_before_as=cst.SimpleWhitespace(" "),
whitespace_after_as=cst.SimpleWhitespace(" "),
),
whitespace_after_except=cst.SimpleWhitespace(" "),
whitespace_before_colon=cst.SimpleWhitespace(" "),
body=cst.SimpleStatementSuite((cst.Pass(),)),
),
),
orelse=cst.Else(
leading_lines=(cst.EmptyLine(comment=cst.Comment("# 3")),),
body=cst.SimpleStatementSuite((cst.Pass(),)),
whitespace_before_colon=cst.SimpleWhitespace(" "),
),
finalbody=cst.Finally(
leading_lines=(cst.EmptyLine(comment=cst.Comment("# 4")),),
body=cst.SimpleStatementSuite((cst.Pass(),)),
whitespace_before_colon=cst.SimpleWhitespace(" "),
),
whitespace_before_colon=cst.SimpleWhitespace(" "),
),
"code": "# 1\ntry : pass\n# 2\nexcept TypeError as e : pass\n# 3\nelse : pass\n# 4\nfinally : pass\n",
"parser": parse_statement,
"expected_position": CodeRange((2, 0), (8, 14)),
},
# Please don't write code like this
{
"node": cst.Try(
cst.SimpleStatementSuite((cst.Pass(),)),
handlers=(
cst.ExceptHandler(
cst.SimpleStatementSuite((cst.Pass(),)),
type=cst.Name("TypeError"),
name=cst.AsName(cst.Name("e")),
),
cst.ExceptHandler(
cst.SimpleStatementSuite((cst.Pass(),)),
type=cst.Name("KeyError"),
name=cst.AsName(cst.Name("e")),
),
cst.ExceptHandler(
cst.SimpleStatementSuite((cst.Pass(),)),
whitespace_after_except=cst.SimpleWhitespace(""),
),
),
orelse=cst.Else(cst.SimpleStatementSuite((cst.Pass(),))),
finalbody=cst.Finally(cst.SimpleStatementSuite((cst.Pass(),))),
),
"code": "try: pass\n"
+ "except TypeError as e: pass\n"
+ "except KeyError as e: pass\n"
+ "except: pass\n"
+ "else: pass\n"
+ "finally: pass\n",
"parser": parse_statement,
"expected_position": CodeRange((1, 0), (6, 13)),
},
# Verify indentation
{
"node": DummyIndentedBlock(
" ",
cst.Try(
cst.SimpleStatementSuite((cst.Pass(),)),
handlers=(
cst.ExceptHandler(
cst.SimpleStatementSuite((cst.Pass(),)),
type=cst.Name("TypeError"),
name=cst.AsName(cst.Name("e")),
),
cst.ExceptHandler(
cst.SimpleStatementSuite((cst.Pass(),)),
type=cst.Name("KeyError"),
name=cst.AsName(cst.Name("e")),
),
cst.ExceptHandler(
cst.SimpleStatementSuite((cst.Pass(),)),
whitespace_after_except=cst.SimpleWhitespace(""),
),
),
orelse=cst.Else(cst.SimpleStatementSuite((cst.Pass(),))),
finalbody=cst.Finally(cst.SimpleStatementSuite((cst.Pass(),))),
),
),
"code": " try: pass\n"
+ " except TypeError as e: pass\n"
+ " except KeyError as e: pass\n"
+ " except: pass\n"
+ " else: pass\n"
+ " finally: pass\n",
"parser": None,
},
# Verify indentation in bodies
{
"node": DummyIndentedBlock(
" ",
cst.Try(
cst.IndentedBlock((cst.SimpleStatementLine((cst.Pass(),)),)),
handlers=(
cst.ExceptHandler(
cst.IndentedBlock(
(cst.SimpleStatementLine((cst.Pass(),)),)
),
whitespace_after_except=cst.SimpleWhitespace(""),
),
),
orelse=cst.Else(
cst.IndentedBlock((cst.SimpleStatementLine((cst.Pass(),)),))
),
finalbody=cst.Finally(
cst.IndentedBlock((cst.SimpleStatementLine((cst.Pass(),)),))
),
),
),
"code": " try:\n"
+ " pass\n"
+ " except:\n"
+ " pass\n"
+ " else:\n"
+ " pass\n"
+ " finally:\n"
+ " pass\n",
"parser": None,
},
# No space when using grouping parens
{
"node": cst.Try(
cst.SimpleStatementSuite((cst.Pass(),)),
handlers=(
cst.ExceptHandler(
cst.SimpleStatementSuite((cst.Pass(),)),
whitespace_after_except=cst.SimpleWhitespace(""),
type=cst.Name(
"Exception",
lpar=(cst.LeftParen(),),
rpar=(cst.RightParen(),),
),
),
),
),
"code": "try: pass\nexcept(Exception): pass\n",
"parser": parse_statement,
},
# No space when using tuple
{
"node": cst.Try(
cst.SimpleStatementSuite((cst.Pass(),)),
handlers=(
cst.ExceptHandler(
cst.SimpleStatementSuite((cst.Pass(),)),
whitespace_after_except=cst.SimpleWhitespace(""),
type=cst.Tuple(
[
cst.Element(
cst.Name("IOError"),
comma=cst.Comma(
whitespace_after=cst.SimpleWhitespace(" ")
),
),
cst.Element(cst.Name("ImportError")),
]
),
),
),
),
"code": "try: pass\nexcept(IOError, ImportError): pass\n",
"parser": parse_statement,
},
)
)
def test_valid(self, **kwargs: Any) -> None:
self.validate_node(**kwargs)
@data_provider(
(
{
"get_node": lambda: cst.AsName(cst.Name("")),
"expected_re": "empty name identifier",
},
{
"get_node": lambda: cst.AsName(
cst.Name("bla"), whitespace_after_as=cst.SimpleWhitespace("")
),
"expected_re": "between 'as'",
},
{
"get_node": lambda: cst.AsName(
cst.Name("bla"), whitespace_before_as=cst.SimpleWhitespace("")
),
"expected_re": "before 'as'",
},
{
"get_node": lambda: cst.ExceptHandler(
cst.SimpleStatementSuite((cst.Pass(),)),
name=cst.AsName(cst.Name("bla")),
),
"expected_re": "name for an empty type",
},
{
"get_node": lambda: cst.ExceptHandler(
cst.SimpleStatementSuite((cst.Pass(),)),
type=cst.Name("TypeError"),
whitespace_after_except=cst.SimpleWhitespace(""),
),
"expected_re": "at least one space after except",
},
{
"get_node": lambda: cst.Try(cst.SimpleStatementSuite((cst.Pass(),))),
"expected_re": "at least one ExceptHandler or Finally",
},
{
"get_node": lambda: cst.Try(
cst.SimpleStatementSuite((cst.Pass(),)),
orelse=cst.Else(cst.SimpleStatementSuite((cst.Pass(),))),
finalbody=cst.Finally(cst.SimpleStatementSuite((cst.Pass(),))),
),
"expected_re": "at least one ExceptHandler in order to have an Else",
},
)
)
def test_invalid(self, **kwargs: Any) -> None:
self.assert_invalid(**kwargs)
class IfTest(CSTNodeTest):
@data_provider((
# Simple if without elif or else
{
"node":
cst.If(cst.Name("conditional"),
cst.SimpleStatementSuite((cst.Pass(), ))),
"code":
"if conditional: pass\n",
"parser":
parse_statement,
"expected_position":
CodeRange((1, 0), (1, 20)),
},
# else clause
{
"node":
cst.If(
cst.Name("conditional"),
cst.SimpleStatementSuite((cst.Pass(), )),
orelse=cst.Else(cst.SimpleStatementSuite((cst.Pass(), ))),
),
"code":
"if conditional: pass\nelse: pass\n",
"parser":
parse_statement,
"expected_position":
CodeRange((1, 0), (2, 10)),
},
# elif clause
{
"node":
cst.If(
cst.Name("conditional"),
cst.SimpleStatementSuite((cst.Pass(), )),
orelse=cst.If(
cst.Name("other_conditional"),
cst.SimpleStatementSuite((cst.Pass(), )),
orelse=cst.Else(cst.SimpleStatementSuite((cst.Pass(), ))),
),
),
"code":
"if conditional: pass\nelif other_conditional: pass\nelse: pass\n",
"parser":
parse_statement,
"expected_position":
CodeRange((1, 0), (3, 10)),
},
# indentation
{
"node":
DummyIndentedBlock(
" ",
cst.If(
cst.Name("conditional"),
cst.SimpleStatementSuite((cst.Pass(), )),
orelse=cst.Else(cst.SimpleStatementSuite((cst.Pass(), ))),
),
),
"code":
" if conditional: pass\n else: pass\n",
"parser":
None,
"expected_position":
CodeRange((1, 4), (2, 14)),
},
# with an indented body
{
"node":
DummyIndentedBlock(
" ",
cst.If(
cst.Name("conditional"),
cst.IndentedBlock((cst.SimpleStatementLine(
(cst.Pass(), )), )),
),
),
"code":
" if conditional:\n pass\n",
"parser":
None,
"expected_position":
CodeRange((1, 4), (2, 12)),
},
# leading_lines
{
"node":
cst.If(
cst.Name("conditional"),
cst.SimpleStatementSuite((cst.Pass(), )),
leading_lines=(cst.EmptyLine(
comment=cst.Comment("# leading comment")), ),
),
"code":
"# leading comment\nif conditional: pass\n",
"parser":
parse_statement,
"expected_position":
CodeRange((2, 0), (2, 20)),
},
# whitespace before/after test and else
{
"node":
cst.If(
cst.Name("conditional"),
cst.SimpleStatementSuite((cst.Pass(), )),
whitespace_before_test=cst.SimpleWhitespace(" "),
whitespace_after_test=cst.SimpleWhitespace(" "),
orelse=cst.Else(
cst.SimpleStatementSuite((cst.Pass(), )),
whitespace_before_colon=cst.SimpleWhitespace(" "),
),
),
"code":
"if conditional : pass\nelse : pass\n",
"parser":
parse_statement,
"expected_position":
CodeRange((1, 0), (2, 11)),
},
# empty lines between if/elif/else clauses, not captured by the suite.
{
"node":
cst.If(
cst.Name("test_a"),
cst.SimpleStatementSuite((cst.Pass(), )),
orelse=cst.If(
cst.Name("test_b"),
cst.SimpleStatementSuite((cst.Pass(), )),
leading_lines=(cst.EmptyLine(), ),
orelse=cst.Else(
cst.SimpleStatementSuite((cst.Pass(), )),
leading_lines=(cst.EmptyLine(), ),
),
),
),
"code":
"if test_a: pass\n\nelif test_b: pass\n\nelse: pass\n",
"parser":
parse_statement,
"expected_position":
CodeRange((1, 0), (5, 10)),
},
))
def test_valid(self, **kwargs: Any) -> None:
self.validate_node(**kwargs)
class ForTest(CSTNodeTest):
@data_provider((
# Simple for block
{
"node":
cst.For(
cst.Name("target"),
cst.Call(cst.Name("iter")),
cst.SimpleStatementSuite((cst.Pass(), )),
),
"code":
"for target in iter(): pass\n",
"parser":
parse_statement,
},
# Simple async for block
{
"node":
cst.For(
cst.Name("target"),
cst.Call(cst.Name("iter")),
cst.SimpleStatementSuite((cst.Pass(), )),
asynchronous=cst.Asynchronous(),
),
"code":
"async for target in iter(): pass\n",
"parser":
lambda code: parse_statement(
code, config=PartialParserConfig(python_version="3.7")),
},
# Python 3.6 async for block
{
"node":
cst.FunctionDef(
cst.Name("foo"),
cst.Parameters(),
cst.IndentedBlock((cst.For(
cst.Name("target"),
cst.Call(cst.Name("iter")),
cst.SimpleStatementSuite((cst.Pass(), )),
asynchronous=cst.Asynchronous(),
), )),
asynchronous=cst.Asynchronous(),
),
"code":
"async def foo():\n async for target in iter(): pass\n",
"parser":
lambda code: parse_statement(
code, config=PartialParserConfig(python_version="3.6")),
},
# For block with else
{
"node":
cst.For(
cst.Name("target"),
cst.Call(cst.Name("iter")),
cst.SimpleStatementSuite((cst.Pass(), )),
cst.Else(cst.SimpleStatementSuite((cst.Pass(), ))),
),
"code":
"for target in iter(): pass\nelse: pass\n",
"parser":
parse_statement,
},
# indentation
{
"node":
DummyIndentedBlock(
" ",
cst.For(
cst.Name("target"),
cst.Call(cst.Name("iter")),
cst.SimpleStatementSuite((cst.Pass(), )),
),
),
"code":
" for target in iter(): pass\n",
"parser":
None,
},
# for an indented body
{
"node":
DummyIndentedBlock(
" ",
cst.For(
cst.Name("target"),
cst.Call(cst.Name("iter")),
cst.IndentedBlock((cst.SimpleStatementLine(
(cst.Pass(), )), )),
),
),
"code":
" for target in iter():\n pass\n",
"parser":
None,
"expected_position":
CodeRange((1, 4), (2, 12)),
},
# leading_lines
{
"node":
cst.For(
cst.Name("target"),
cst.Call(cst.Name("iter")),
cst.IndentedBlock((cst.SimpleStatementLine((cst.Pass(), )), )),
cst.Else(
cst.IndentedBlock((cst.SimpleStatementLine(
(cst.Pass(), )), )),
leading_lines=(cst.EmptyLine(
comment=cst.Comment("# else comment")), ),
),
leading_lines=(cst.EmptyLine(
comment=cst.Comment("# leading comment")), ),
),
"code":
"# leading comment\nfor target in iter():\n pass\n# else comment\nelse:\n pass\n",
"parser":
None,
"expected_position":
CodeRange((2, 0), (6, 8)),
},
# Weird spacing rules
{
"node":
cst.For(
cst.Name("target",
lpar=(cst.LeftParen(), ),
rpar=(cst.RightParen(), )),
cst.Call(
cst.Name("iter"),
lpar=(cst.LeftParen(), ),
rpar=(cst.RightParen(), ),
),
cst.SimpleStatementSuite((cst.Pass(), )),
whitespace_after_for=cst.SimpleWhitespace(""),
whitespace_before_in=cst.SimpleWhitespace(""),
whitespace_after_in=cst.SimpleWhitespace(""),
),
"code":
"for(target)in(iter()): pass\n",
"parser":
parse_statement,
"expected_position":
CodeRange((1, 0), (1, 27)),
},
# Whitespace
{
"node":
cst.For(
cst.Name("target"),
cst.Call(cst.Name("iter")),
cst.SimpleStatementSuite((cst.Pass(), )),
whitespace_after_for=cst.SimpleWhitespace(" "),
whitespace_before_in=cst.SimpleWhitespace(" "),
whitespace_after_in=cst.SimpleWhitespace(" "),
whitespace_before_colon=cst.SimpleWhitespace(" "),
),
"code":
"for target in iter() : pass\n",
"parser":
parse_statement,
"expected_position":
CodeRange((1, 0), (1, 31)),
},
))
def test_valid(self, **kwargs: Any) -> None:
self.validate_node(**kwargs)
@data_provider((
{
"get_node":
lambda: cst.For(
cst.Name("target"),
cst.Call(cst.Name("iter")),
cst.SimpleStatementSuite((cst.Pass(), )),
whitespace_after_for=cst.SimpleWhitespace(""),
),
"expected_re":
"Must have at least one space after 'for' keyword",
},
{
"get_node":
lambda: cst.For(
cst.Name("target"),
cst.Call(cst.Name("iter")),
cst.SimpleStatementSuite((cst.Pass(), )),
whitespace_before_in=cst.SimpleWhitespace(""),
),
"expected_re":
"Must have at least one space before 'in' keyword",
},
{
"get_node":
lambda: cst.For(
cst.Name("target"),
cst.Call(cst.Name("iter")),
cst.SimpleStatementSuite((cst.Pass(), )),
whitespace_after_in=cst.SimpleWhitespace(""),
),
"expected_re":
"Must have at least one space after 'in' keyword",
},
))
def test_invalid(self, **kwargs: Any) -> None:
self.assert_invalid(**kwargs)
class TryStarTest(CSTNodeTest):
@data_provider((
# Try/except with a class
{
"node":
cst.TryStar(
cst.SimpleStatementSuite((cst.Pass(), )),
handlers=(cst.ExceptStarHandler(
cst.SimpleStatementSuite((cst.Pass(), )),
type=cst.Name("Exception"),
), ),
),
"code":
"try: pass\nexcept* Exception: pass\n",
"parser":
native_parse_statement,
},
# Try/except with a named class
{
"node":
cst.TryStar(
cst.SimpleStatementSuite((cst.Pass(), )),
handlers=(cst.ExceptStarHandler(
cst.SimpleStatementSuite((cst.Pass(), )),
type=cst.Name("Exception"),
name=cst.AsName(cst.Name("exc")),
), ),
),
"code":
"try: pass\nexcept* Exception as exc: pass\n",
"parser":
native_parse_statement,
"expected_position":
CodeRange((1, 0), (2, 30)),
},
# Try/except with multiple clauses
{
"node":
cst.TryStar(
cst.SimpleStatementSuite((cst.Pass(), )),
handlers=(
cst.ExceptStarHandler(
cst.SimpleStatementSuite((cst.Pass(), )),
type=cst.Name("TypeError"),
name=cst.AsName(cst.Name("e")),
),
cst.ExceptStarHandler(
cst.SimpleStatementSuite((cst.Pass(), )),
type=cst.Name("KeyError"),
name=cst.AsName(cst.Name("e")),
),
),
),
"code":
"try: pass\n" + "except* TypeError as e: pass\n" +
"except* KeyError as e: pass\n",
"parser":
native_parse_statement,
"expected_position":
CodeRange((1, 0), (3, 27)),
},
# Simple try/except/finally block
{
"node":
cst.TryStar(
cst.SimpleStatementSuite((cst.Pass(), )),
handlers=(cst.ExceptStarHandler(
cst.SimpleStatementSuite((cst.Pass(), )),
type=cst.Name("KeyError"),
whitespace_after_except=cst.SimpleWhitespace(""),
), ),
finalbody=cst.Finally(cst.SimpleStatementSuite(
(cst.Pass(), ))),
),
"code":
"try: pass\nexcept* KeyError: pass\nfinally: pass\n",
"parser":
native_parse_statement,
"expected_position":
CodeRange((1, 0), (3, 13)),
},
# Simple try/except/else block
{
"node":
cst.TryStar(
cst.SimpleStatementSuite((cst.Pass(), )),
handlers=(cst.ExceptStarHandler(
cst.SimpleStatementSuite((cst.Pass(), )),
type=cst.Name("KeyError"),
whitespace_after_except=cst.SimpleWhitespace(""),
), ),
orelse=cst.Else(cst.SimpleStatementSuite((cst.Pass(), ))),
),
"code":
"try: pass\nexcept* KeyError: pass\nelse: pass\n",
"parser":
native_parse_statement,
"expected_position":
CodeRange((1, 0), (3, 10)),
},
# Verify whitespace in various locations
{
"node":
cst.TryStar(
leading_lines=(cst.EmptyLine(comment=cst.Comment("# 1")), ),
body=cst.SimpleStatementSuite((cst.Pass(), )),
handlers=(cst.ExceptStarHandler(
leading_lines=(cst.EmptyLine(
comment=cst.Comment("# 2")), ),
type=cst.Name("TypeError"),
name=cst.AsName(
cst.Name("e"),
whitespace_before_as=cst.SimpleWhitespace(" "),
whitespace_after_as=cst.SimpleWhitespace(" "),
),
whitespace_after_except=cst.SimpleWhitespace(" "),
whitespace_after_star=cst.SimpleWhitespace(""),
whitespace_before_colon=cst.SimpleWhitespace(" "),
body=cst.SimpleStatementSuite((cst.Pass(), )),
), ),
orelse=cst.Else(
leading_lines=(cst.EmptyLine(
comment=cst.Comment("# 3")), ),
body=cst.SimpleStatementSuite((cst.Pass(), )),
whitespace_before_colon=cst.SimpleWhitespace(" "),
),
finalbody=cst.Finally(
leading_lines=(cst.EmptyLine(
comment=cst.Comment("# 4")), ),
body=cst.SimpleStatementSuite((cst.Pass(), )),
whitespace_before_colon=cst.SimpleWhitespace(" "),
),
whitespace_before_colon=cst.SimpleWhitespace(" "),
),
"code":
"# 1\ntry : pass\n# 2\nexcept *TypeError as e : pass\n# 3\nelse : pass\n# 4\nfinally : pass\n",
"parser":
native_parse_statement,
"expected_position":
CodeRange((2, 0), (8, 14)),
},
# Now all together
{
"node":
cst.TryStar(
cst.SimpleStatementSuite((cst.Pass(), )),
handlers=(
cst.ExceptStarHandler(
cst.SimpleStatementSuite((cst.Pass(), )),
type=cst.Name("TypeError"),
name=cst.AsName(cst.Name("e")),
),
cst.ExceptStarHandler(
cst.SimpleStatementSuite((cst.Pass(), )),
type=cst.Name("KeyError"),
name=cst.AsName(cst.Name("e")),
),
),
orelse=cst.Else(cst.SimpleStatementSuite((cst.Pass(), ))),
finalbody=cst.Finally(cst.SimpleStatementSuite(
(cst.Pass(), ))),
),
"code":
"try: pass\n" + "except* TypeError as e: pass\n" +
"except* KeyError as e: pass\n" + "else: pass\n" +
"finally: pass\n",
"parser":
native_parse_statement,
"expected_position":
CodeRange((1, 0), (5, 13)),
},
))
def test_valid(self, **kwargs: Any) -> None:
self.validate_node(**kwargs)
