def test_suite(self) -> None:
# Test that we can insert various types of statement suites into a
# spot accepting a suite.
module = parse_template_module(
"if x is True: {suite}\n",
suite=cst.SimpleStatementSuite(body=(cst.Pass(),),),
)
self.assertEqual(
module.code, "if x is True: pass\n",
)
module = parse_template_module(
"if x is True: {suite}\n",
suite=cst.IndentedBlock(body=(cst.SimpleStatementLine((cst.Pass(),),),),),
)
self.assertEqual(
module.code, "if x is True:\n pass\n",
)
module = parse_template_module(
"if x is True:\n {suite}\n",
suite=cst.SimpleStatementSuite(body=(cst.Pass(),),),
)
self.assertEqual(
module.code, "if x is True: pass\n",
)
module = parse_template_module(
"if x is True:\n {suite}\n",
suite=cst.IndentedBlock(body=(cst.SimpleStatementLine((cst.Pass(),),),),),
)
self.assertEqual(
module.code, "if x is True:\n pass\n",
)
def test_statement(self) -> None:
# Test that we can insert various types of statements into a
# statement list.
module = parse_template_module(
"{statement1}\n{statement2}\n{statement3}\n",
statement1=cst.If(
test=cst.Name("foo"), body=cst.SimpleStatementSuite((cst.Pass(),),),
),
statement2=cst.SimpleStatementLine((cst.Expr(cst.Call(cst.Name("bar"))),),),
statement3=cst.Pass(),
)
self.assertEqual(
module.code, "if foo: pass\nbar()\npass\n",
)
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)
def test_module_config_for_parsing(self) -> None:
module = parse_module("pass\r")
statement = parse_statement("if True:\r pass",
config=module.config_for_parsing)
self.assertEqual(
statement,
cst.If(
test=cst.Name(value="True"),
body=cst.IndentedBlock(
body=[cst.SimpleStatementLine(body=[cst.Pass()])],
header=cst.TrailingWhitespace(newline=cst.Newline(
# This would be "\r" if we didn't pass the module config forward.
value=None)),
),
),
)
def test_position(self) -> None:
# create a dummy node
node = cst.Pass()
# simulate codegen behavior for the dummy node
# generates the code " pass "
state = PositionProvidingCodegenState(" " * 4, "\n", PositionProvider())
state.before_codegen(node)
state.add_token(" ")
with state.record_syntactic_position(node):
state.add_token("pass")
state.add_token(" ")
state.after_codegen(node)
# check syntactic position ignores whitespace
self.assertEqual(state.provider._computed[node], CodeRange((1, 1), (1, 5)))
def test_syntactic_position(self) -> None:
# create a dummy node
node = cst.Pass()
# simulate codegen behavior for the dummy node
# generates the code " pass "
state = SyntacticCodegenState(" " * 4, "\n", SyntacticPositionProvider())
start = CodePosition(state.line, state.column)
state.add_token(" ")
with state.record_syntactic_position(node):
state.add_token("pass")
state.add_token(" ")
end = CodePosition(state.line, state.column)
state.record_position(node, CodeRange(start, end))
# check syntactic position ignores whitespace
self.assertEqual(state.provider._computed[node], CodeRange((1, 1), (1, 5)))
def astNodeFromAssertion(transform: Transform,
match: Match,
index=0) -> Sequence[cst.CSTNode]:
# TODO: aggregate intersect possible_nodes_per_prop and and raise on multiple
# results (some kind of "ambiguity error"). Also need to match with anchor placement
cur_scope_expr = transform.assertion.nested_scopes[index]
cur_capture = match.by_name.get(cur_scope_expr.capture.name)
name = cur_scope_expr.capture.name
body = ()
node = BodyType = None
if cur_capture is not None:
node = cur_capture.node
name = elemName(node=node)
body, BodyType = getNodeBody(node)
if index < len(transform.assertion.nested_scopes) - 1:
# inner doesn'make sense for ( and , nesting scopes...
inner = astNodeFromAssertion(transform, match, index+1)
if transform.destructive:
body = [s for s in body if not s.deep_equals(
match.path[-1].node)]
body = (*body, *inner)
BodyType = BodyType or cst.IndentedBlock
if not body:
body = [cst.SimpleStatementLine(body=[cst.Pass()])]
if cur_capture is not None:
# XXX: perhaps I should use tuples instead of lists to abide by the immutability of cst
return [node.with_changes(
name=cst.Name(name),
**({
'body': BodyType(body=body),
# probably need a better way to do this, ideally just ignore excess kwargs
} if isinstance(node, (cst.FunctionDef, cst.ClassDef)) else {})
)]
else:
unrefed_node = astNodeFrom(
scope_expr=cur_scope_expr, ctx=transform, match=match)
# NOTE: need a generic way to "place" the next scope in a node
if index < len(transform.assertion.nested_scopes) - 1:
return [unrefed_node.with_changes(body=BodyType(body=body))]
else:
return [unrefed_node]
def test_whitespace_inclusive_position(self) -> None:
# create a dummy node
node = cst.Pass()
# simulate codegen behavior for the dummy node
# generates the code " pass "
state = WhitespaceInclusivePositionProvidingCodegenState(
" " * 4, "\n", WhitespaceInclusivePositionProvider()
)
state.before_codegen(node)
state.add_token(" ")
with state.record_syntactic_position(node):
state.add_token("pass")
state.add_token(" ")
state.after_codegen(node)
# check whitespace is correctly recorded
self.assertEqual(state.provider._computed[node], CodeRange((1, 0), (1, 6)))
def test_span(self) -> None:
node = cst.Pass()
state = SpanProvidingCodegenState(
" " * 4,
"\n",
get_length=byte_length_in_utf8,
provider=ByteSpanPositionProvider(),
)
state.before_codegen(node)
state.add_token(" ")
with state.record_syntactic_position(node):
state.add_token("pass")
state.add_token(" ")
state.after_codegen(node)
span = state.provider._computed[node]
self.assertEqual(span.start, 1)
self.assertEqual(span.length, 4)
def test_adding_parens(self) -> None:
node = cst.With(
(
cst.WithItem(
cst.Call(cst.Name("foo")),
comma=cst.Comma(
whitespace_after=cst.ParenthesizedWhitespace(), ),
),
cst.WithItem(cst.Call(cst.Name("bar")), comma=cst.Comma()),
),
cst.SimpleStatementSuite((cst.Pass(), )),
lpar=cst.LeftParen(whitespace_after=cst.SimpleWhitespace(" ")),
rpar=cst.RightParen(whitespace_before=cst.SimpleWhitespace(" ")),
)
module = cst.Module([])
self.assertEqual(
module.code_for_node(node),
("with ( foo(),\n"
"bar(), ): pass\n") # noqa
)
def test_position(self) -> None:
# create a dummy node
node = cst.Pass()
# simulate codegen behavior for the dummy node
# generates the code " pass "
state = BasicCodegenState(" " * 4, "\n", BasicPositionProvider())
start = CodePosition(state.line, state.column)
state.add_token(" ")
with state.record_syntactic_position(node):
state.add_token("pass")
state.add_token(" ")
end = CodePosition(state.line, state.column)
state.record_position(node, CodeRange(start, end))
# check whitespace is correctly recorded
self.assertEqual(state.provider._computed[node],
CodeRange.create((1, 0), (1, 6)))
# TODO: remove this
self.assertEqual(node._metadata[BasicPositionProvider],
CodeRange.create((1, 0), (1, 6)))
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)
class NamedExprTest(CSTNodeTest):
@data_provider((
# Simple named expression
{
"node": cst.NamedExpr(cst.Name("x"), cst.Float("5.5")),
"code": "x := 5.5",
"parser":
None, # Walrus operator is illegal as top-level statement
"expected_position": None,
},
# Parenthesized named expression
{
"node":
cst.NamedExpr(
lpar=(cst.LeftParen(), ),
target=cst.Name("foo"),
value=cst.Integer("5"),
rpar=(cst.RightParen(), ),
),
"code":
"(foo := 5)",
"parser":
_parse_expression_force_38,
"expected_position":
CodeRange((1, 1), (1, 9)),
},
# Make sure that spacing works
{
"node":
cst.NamedExpr(
lpar=(cst.LeftParen(
whitespace_after=cst.SimpleWhitespace(" ")), ),
target=cst.Name("foo"),
whitespace_before_walrus=cst.SimpleWhitespace(" "),
whitespace_after_walrus=cst.SimpleWhitespace(" "),
value=cst.Name("bar"),
rpar=(cst.RightParen(
whitespace_before=cst.SimpleWhitespace(" ")), ),
),
"code":
"( foo := bar )",
"parser":
_parse_expression_force_38,
"expected_position":
CodeRange((1, 2), (1, 14)),
},
# Make sure we can use these where allowed in if/while statements
{
"node":
cst.While(
test=cst.NamedExpr(
target=cst.Name(value="x"),
value=cst.Call(func=cst.Name(value="some_input")),
),
body=cst.SimpleStatementSuite(body=[cst.Pass()]),
),
"code":
"while x := some_input(): pass\n",
"parser":
_parse_statement_force_38,
"expected_position":
None,
},
{
"node":
cst.If(
test=cst.NamedExpr(
target=cst.Name(value="x"),
value=cst.Call(func=cst.Name(value="some_input")),
),
body=cst.SimpleStatementSuite(body=[cst.Pass()]),
),
"code":
"if x := some_input(): pass\n",
"parser":
_parse_statement_force_38,
"expected_position":
None,
},
{
"node":
cst.If(
test=cst.NamedExpr(
target=cst.Name(value="x"),
value=cst.Integer(value="1"),
whitespace_before_walrus=cst.SimpleWhitespace(""),
whitespace_after_walrus=cst.SimpleWhitespace(""),
),
body=cst.SimpleStatementSuite(body=[cst.Pass()]),
),
"code":
"if x:=1: pass\n",
"parser":
_parse_statement_force_38,
"expected_position":
None,
},
# Function args
{
"node":
cst.Call(
func=cst.Name(value="f"),
args=[
cst.Arg(value=cst.NamedExpr(
target=cst.Name(value="y"),
value=cst.Integer(value="1"),
whitespace_before_walrus=cst.SimpleWhitespace(""),
whitespace_after_walrus=cst.SimpleWhitespace(""),
)),
],
),
"code":
"f(y:=1)",
"parser":
_parse_expression_force_38,
"expected_position":
None,
},
# Whitespace handling on args is fragile
{
"node":
cst.Call(
func=cst.Name(value="f"),
args=[
cst.Arg(
value=cst.Name(value="x"),
comma=cst.Comma(
whitespace_after=cst.SimpleWhitespace(" ")),
),
cst.Arg(
value=cst.NamedExpr(
target=cst.Name(value="y"),
value=cst.Integer(value="1"),
whitespace_before_walrus=cst.SimpleWhitespace(
" "),
whitespace_after_walrus=cst.SimpleWhitespace(
" "),
),
whitespace_after_arg=cst.SimpleWhitespace(" "),
),
],
),
"code":
"f(x, y := 1 )",
"parser":
_parse_expression_force_38,
"expected_position":
None,
},
{
"node":
cst.Call(
func=cst.Name(value="f"),
args=[
cst.Arg(
value=cst.NamedExpr(
target=cst.Name(value="y"),
value=cst.Integer(value="1"),
whitespace_before_walrus=cst.SimpleWhitespace(
" "),
whitespace_after_walrus=cst.SimpleWhitespace(
" "),
),
whitespace_after_arg=cst.SimpleWhitespace(" "),
),
],
whitespace_before_args=cst.SimpleWhitespace(" "),
),
"code":
"f( y := 1 )",
"parser":
_parse_expression_force_38,
"expected_position":
None,
},
))
def test_valid(self, **kwargs: Any) -> None:
self.validate_node(**kwargs)
@data_provider((
{
"get_node": (lambda: cst.NamedExpr(
cst.Name("foo"), cst.Name("bar"), lpar=(cst.LeftParen(), ))),
"expected_re":
"left paren without right paren",
},
{
"get_node": (lambda: cst.NamedExpr(
cst.Name("foo"), cst.Name("bar"), rpar=(cst.RightParen(), ))),
"expected_re":
"right paren without left paren",
},
))
def test_invalid(self, **kwargs: Any) -> None:
self.assert_invalid(**kwargs)
class ClassDefParserTest(CSTNodeTest):
@data_provider((
# Simple classdef
# pyre-fixme[6]: Incompatible parameter type
{
"node":
cst.ClassDef(cst.Name("Foo"),
cst.SimpleStatementSuite((cst.Pass(), ))),
"code":
"class Foo: pass\n",
},
{
"node":
cst.ClassDef(
cst.Name("Foo"),
cst.SimpleStatementSuite((cst.Pass(), )),
lpar=cst.LeftParen(),
rpar=cst.RightParen(),
),
"code":
"class Foo(): pass\n",
},
# Positional arguments render test
{
"node":
cst.ClassDef(
cst.Name("Foo"),
cst.SimpleStatementSuite((cst.Pass(), )),
lpar=cst.LeftParen(),
bases=(cst.Arg(cst.Name("obj")), ),
rpar=cst.RightParen(),
),
"code":
"class Foo(obj): pass\n",
},
{
"node":
cst.ClassDef(
cst.Name("Foo"),
cst.SimpleStatementSuite((cst.Pass(), )),
lpar=cst.LeftParen(),
bases=(
cst.Arg(
cst.Name("Bar"),
comma=cst.Comma(
whitespace_after=cst.SimpleWhitespace(" ")),
),
cst.Arg(
cst.Name("Baz"),
comma=cst.Comma(
whitespace_after=cst.SimpleWhitespace(" ")),
),
cst.Arg(cst.Name("object")),
),
rpar=cst.RightParen(),
),
"code":
"class Foo(Bar, Baz, object): pass\n",
},
# Keyword arguments render test
{
"node":
cst.ClassDef(
cst.Name("Foo"),
cst.SimpleStatementSuite((cst.Pass(), )),
lpar=cst.LeftParen(),
keywords=(cst.Arg(
keyword=cst.Name("metaclass"),
equal=cst.AssignEqual(),
value=cst.Name("Bar"),
), ),
rpar=cst.RightParen(),
),
"code":
"class Foo(metaclass = Bar): pass\n",
},
# Iterator expansion render test
{
"node":
cst.ClassDef(
cst.Name("Foo"),
cst.SimpleStatementSuite((cst.Pass(), )),
lpar=cst.LeftParen(),
bases=(cst.Arg(star="*", value=cst.Name("one")), ),
rpar=cst.RightParen(),
),
"code":
"class Foo(*one): pass\n",
},
{
"node":
cst.ClassDef(
cst.Name("Foo"),
cst.SimpleStatementSuite((cst.Pass(), )),
lpar=cst.LeftParen(),
bases=(
cst.Arg(
star="*",
value=cst.Name("one"),
comma=cst.Comma(
whitespace_after=cst.SimpleWhitespace(" ")),
),
cst.Arg(
star="*",
value=cst.Name("two"),
comma=cst.Comma(
whitespace_after=cst.SimpleWhitespace(" ")),
),
cst.Arg(star="*", value=cst.Name("three")),
),
rpar=cst.RightParen(),
),
"code":
"class Foo(*one, *two, *three): pass\n",
},
# Dictionary expansion render test
{
"node":
cst.ClassDef(
cst.Name("Foo"),
cst.SimpleStatementSuite((cst.Pass(), )),
lpar=cst.LeftParen(),
keywords=(cst.Arg(star="**", value=cst.Name("one")), ),
rpar=cst.RightParen(),
),
"code":
"class Foo(**one): pass\n",
},
{
"node":
cst.ClassDef(
cst.Name("Foo"),
cst.SimpleStatementSuite((cst.Pass(), )),
lpar=cst.LeftParen(),
keywords=(
cst.Arg(
star="**",
value=cst.Name("one"),
comma=cst.Comma(
whitespace_after=cst.SimpleWhitespace(" ")),
),
cst.Arg(
star="**",
value=cst.Name("two"),
comma=cst.Comma(
whitespace_after=cst.SimpleWhitespace(" ")),
),
cst.Arg(star="**", value=cst.Name("three")),
),
rpar=cst.RightParen(),
),
"code":
"class Foo(**one, **two, **three): pass\n",
},
# Decorator render tests
{
"node":
cst.ClassDef(
cst.Name("Foo"),
cst.SimpleStatementSuite((cst.Pass(), )),
decorators=(cst.Decorator(cst.Name("foo")), ),
lpar=cst.LeftParen(),
rpar=cst.RightParen(),
),
"code":
"@foo\nclass Foo(): pass\n",
"expected_position":
CodeRange((2, 0), (2, 17)),
},
{
"node":
cst.ClassDef(
leading_lines=(
cst.EmptyLine(),
cst.EmptyLine(comment=cst.Comment("# leading comment 1")),
),
decorators=(
cst.Decorator(cst.Name("foo"), leading_lines=()),
cst.Decorator(
cst.Name("bar"),
leading_lines=(cst.EmptyLine(
comment=cst.Comment("# leading comment 2")), ),
),
cst.Decorator(
cst.Name("baz"),
leading_lines=(cst.EmptyLine(
comment=cst.Comment("# leading comment 3")), ),
),
),
lines_after_decorators=(cst.EmptyLine(
comment=cst.Comment("# class comment")), ),
name=cst.Name("Foo"),
body=cst.SimpleStatementSuite((cst.Pass(), )),
lpar=cst.LeftParen(),
rpar=cst.RightParen(),
),
"code":
"\n# leading comment 1\n@foo\n# leading comment 2\n@bar\n# leading comment 3\n@baz\n# class comment\nclass Foo(): pass\n",
"expected_position":
CodeRange((9, 0), (9, 17)),
},
))
def test_valid(self, **kwargs: Any) -> None:
self.validate_node(**kwargs, parser=parse_statement)
class ClassDefCreationTest(CSTNodeTest):
@data_provider((
# Simple classdef
# pyre-fixme[6]: Incompatible parameter type
{
"node":
cst.ClassDef(cst.Name("Foo"),
cst.SimpleStatementSuite((cst.Pass(), ))),
"code":
"class Foo: pass\n",
"expected_position":
CodeRange((1, 0), (1, 15)),
},
{
"node":
cst.ClassDef(
cst.Name("Foo"),
cst.SimpleStatementSuite((cst.Pass(), )),
lpar=cst.LeftParen(),
rpar=cst.RightParen(),
),
"code":
"class Foo(): pass\n",
},
# Positional arguments render test
{
"node":
cst.ClassDef(
cst.Name("Foo"),
cst.SimpleStatementSuite((cst.Pass(), )),
bases=(cst.Arg(cst.Name("obj")), ),
),
"code":
"class Foo(obj): pass\n",
},
{
"node":
cst.ClassDef(
cst.Name("Foo"),
cst.SimpleStatementSuite((cst.Pass(), )),
bases=(
cst.Arg(cst.Name("Bar")),
cst.Arg(cst.Name("Baz")),
cst.Arg(cst.Name("object")),
),
),
"code":
"class Foo(Bar, Baz, object): pass\n",
},
# Keyword arguments render test
{
"node":
cst.ClassDef(
cst.Name("Foo"),
cst.SimpleStatementSuite((cst.Pass(), )),
keywords=(cst.Arg(keyword=cst.Name("metaclass"),
value=cst.Name("Bar")), ),
),
"code":
"class Foo(metaclass = Bar): pass\n",
"expected_position":
CodeRange((1, 0), (1, 32)),
},
# Iterator expansion render test
{
"node":
cst.ClassDef(
cst.Name("Foo"),
cst.SimpleStatementSuite((cst.Pass(), )),
bases=(cst.Arg(star="*", value=cst.Name("one")), ),
),
"code":
"class Foo(*one): pass\n",
},
{
"node":
cst.ClassDef(
cst.Name("Foo"),
cst.SimpleStatementSuite((cst.Pass(), )),
bases=(
cst.Arg(star="*", value=cst.Name("one")),
cst.Arg(star="*", value=cst.Name("two")),
cst.Arg(star="*", value=cst.Name("three")),
),
),
"code":
"class Foo(*one, *two, *three): pass\n",
},
# Dictionary expansion render test
{
"node":
cst.ClassDef(
cst.Name("Foo"),
cst.SimpleStatementSuite((cst.Pass(), )),
keywords=(cst.Arg(star="**", value=cst.Name("one")), ),
),
"code":
"class Foo(**one): pass\n",
},
{
"node":
cst.ClassDef(
cst.Name("Foo"),
cst.SimpleStatementSuite((cst.Pass(), )),
keywords=(
cst.Arg(star="**", value=cst.Name("one")),
cst.Arg(star="**", value=cst.Name("two")),
cst.Arg(star="**", value=cst.Name("three")),
),
),
"code":
"class Foo(**one, **two, **three): pass\n",
},
))
def test_valid(self, **kwargs: Any) -> None:
self.validate_node(**kwargs)
@data_provider((
# Basic parenthesis tests.
(
lambda: cst.ClassDef(
name=cst.Name("Foo"),
body=cst.SimpleStatementSuite((cst.Pass(), )),
lpar=cst.LeftParen(),
),
"Do not mix concrete LeftParen/RightParen with MaybeSentinel",
),
(
lambda: cst.ClassDef(
name=cst.Name("Foo"),
body=cst.SimpleStatementSuite((cst.Pass(), )),
rpar=cst.RightParen(),
),
"Do not mix concrete LeftParen/RightParen with MaybeSentinel",
),
# Whitespace validation
(
lambda: cst.ClassDef(
name=cst.Name("Foo"),
body=cst.SimpleStatementSuite((cst.Pass(), )),
whitespace_after_class=cst.SimpleWhitespace(""),
),
"at least one space between 'class' and name",
),
))
def test_invalid(self, get_node: Callable[[], cst.CSTNode],
expected_re: str) -> None:
self.assert_invalid(get_node, expected_re)
class LeafSmallStatementsTest(CSTNodeTest):
@data_provider(((cst.Pass(), "pass"), (cst.Break(), "break"),
(cst.Continue(), "continue")))
def test_valid(self, node: cst.CSTNode, code: str) -> None:
self.validate_node(node, code)
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 SmallStatementTest(CSTNodeTest):
@data_provider((
# pyre-fixme[6]: Incompatible parameter type
{
"node": cst.Pass(),
"code": "pass"
},
{
"node": cst.Pass(semicolon=cst.Semicolon()),
"code": "pass;"
},
{
"node":
cst.Pass(semicolon=cst.Semicolon(
whitespace_before=cst.SimpleWhitespace(" "),
whitespace_after=cst.SimpleWhitespace(" "),
)),
"code":
"pass ; ",
"expected_position":
CodeRange((1, 0), (1, 4)),
},
{
"node": cst.Continue(),
"code": "continue"
},
{
"node": cst.Continue(semicolon=cst.Semicolon()),
"code": "continue;"
},
{
"node":
cst.Continue(semicolon=cst.Semicolon(
whitespace_before=cst.SimpleWhitespace(" "),
whitespace_after=cst.SimpleWhitespace(" "),
)),
"code":
"continue ; ",
"expected_position":
CodeRange((1, 0), (1, 8)),
},
{
"node": cst.Break(),
"code": "break"
},
{
"node": cst.Break(semicolon=cst.Semicolon()),
"code": "break;"
},
{
"node":
cst.Break(semicolon=cst.Semicolon(
whitespace_before=cst.SimpleWhitespace(" "),
whitespace_after=cst.SimpleWhitespace(" "),
)),
"code":
"break ; ",
"expected_position":
CodeRange((1, 0), (1, 5)),
},
{
"node":
cst.Expr(
cst.BinaryOperation(cst.Name("x"), cst.Add(), cst.Name("y"))),
"code":
"x + y",
},
{
"node":
cst.Expr(
cst.BinaryOperation(cst.Name("x"), cst.Add(), cst.Name("y")),
semicolon=cst.Semicolon(),
),
"code":
"x + y;",
},
{
"node":
cst.Expr(
cst.BinaryOperation(cst.Name("x"), cst.Add(), cst.Name("y")),
semicolon=cst.Semicolon(
whitespace_before=cst.SimpleWhitespace(" "),
whitespace_after=cst.SimpleWhitespace(" "),
),
),
"code":
"x + y ; ",
"expected_position":
CodeRange((1, 0), (1, 5)),
},
))
def test_valid(self, **kwargs: Any) -> None:
self.validate_node(**kwargs)
class CSTNodeTest(UnitTest):
def test_with_changes(self) -> None:
initial = cst.TrailingWhitespace(
whitespace=cst.SimpleWhitespace(" \\\n "),
comment=cst.Comment("# initial"),
newline=cst.Newline("\r\n"),
)
changed = initial.with_changes(comment=cst.Comment("# new comment"))
# see that we have the updated fields
self.assertEqual(none_throws(changed.comment).value, "# new comment")
# and that the old fields are still there
self.assertEqual(changed.whitespace.value, " \\\n ")
self.assertEqual(changed.newline.value, "\r\n")
# ensure no mutation actually happened
self.assertEqual(none_throws(initial.comment).value, "# initial")
def test_default_eq(self) -> None:
sw1 = cst.SimpleWhitespace("")
sw2 = cst.SimpleWhitespace("")
self.assertNotEqual(sw1, sw2)
self.assertEqual(sw1, sw1)
self.assertEqual(sw2, sw2)
self.assertTrue(sw1.deep_equals(sw2))
self.assertTrue(sw2.deep_equals(sw1))
def test_hash(self) -> None:
sw1 = cst.SimpleWhitespace("")
sw2 = cst.SimpleWhitespace("")
self.assertNotEqual(hash(sw1), hash(sw2))
self.assertEqual(hash(sw1), hash(sw1))
self.assertEqual(hash(sw2), hash(sw2))
@data_provider(
{
"simple": (cst.SimpleWhitespace(""), cst.SimpleWhitespace("")),
"identity": (_EMPTY_SIMPLE_WHITESPACE, _EMPTY_SIMPLE_WHITESPACE),
"nested": (
cst.EmptyLine(whitespace=cst.SimpleWhitespace("")),
cst.EmptyLine(whitespace=cst.SimpleWhitespace("")),
),
"tuple_versus_list": (
cst.SimpleStatementLine(body=[cst.Pass()]),
cst.SimpleStatementLine(body=(cst.Pass(),)),
),
}
)
def test_deep_equals_success(self, a: cst.CSTNode, b: cst.CSTNode) -> None:
self.assertTrue(a.deep_equals(b))
@data_provider(
{
"simple": (cst.SimpleWhitespace(" "), cst.SimpleWhitespace(" ")),
"nested": (
cst.EmptyLine(whitespace=cst.SimpleWhitespace(" ")),
cst.EmptyLine(whitespace=cst.SimpleWhitespace(" ")),
),
"list": (
cst.SimpleStatementLine(body=[cst.Pass(semicolon=cst.Semicolon())]),
cst.SimpleStatementLine(body=[cst.Pass(semicolon=cst.Semicolon())] * 2),
),
}
)
def test_deep_equals_fails(self, a: cst.CSTNode, b: cst.CSTNode) -> None:
self.assertFalse(a.deep_equals(b))
def test_repr(self) -> None:
self.assertEqual(
repr(
cst.SimpleStatementLine(
body=[cst.Pass()],
# tuple with multiple items
leading_lines=(
cst.EmptyLine(
indent=True,
whitespace=cst.SimpleWhitespace(""),
comment=None,
newline=cst.Newline(),
),
cst.EmptyLine(
indent=True,
whitespace=cst.SimpleWhitespace(""),
comment=None,
newline=cst.Newline(),
),
),
trailing_whitespace=cst.TrailingWhitespace(
whitespace=cst.SimpleWhitespace(" "),
comment=cst.Comment("# comment"),
newline=cst.Newline(),
),
)
),
dedent(
"""
SimpleStatementLine(
body=[
Pass(
semicolon=MaybeSentinel.DEFAULT,
),
],
leading_lines=[
EmptyLine(
indent=True,
whitespace=SimpleWhitespace(
value='',
),
comment=None,
newline=Newline(
value=None,
),
),
EmptyLine(
indent=True,
whitespace=SimpleWhitespace(
value='',
),
comment=None,
newline=Newline(
value=None,
),
),
],
trailing_whitespace=TrailingWhitespace(
whitespace=SimpleWhitespace(
value=' ',
),
comment=Comment(
value='# comment',
),
newline=Newline(
value=None,
),
),
)
"""
).strip(),
)
def test_visit(self) -> None:
tree = cst.Module((cst.SimpleStatementLine((cst.Pass(),)),))
tree.visit(_TestVisitor(self))
def test_visit(self) -> None:
tree = cst.Module((cst.SimpleStatementLine((cst.Pass(),)),))
tree.visit(_TestVisitor(self))
def test_repr(self) -> None:
self.assertEqual(
repr(
cst.SimpleStatementLine(
body=[cst.Pass()],
# tuple with multiple items
leading_lines=(
cst.EmptyLine(
indent=True,
whitespace=cst.SimpleWhitespace(""),
comment=None,
newline=cst.Newline(),
),
cst.EmptyLine(
indent=True,
whitespace=cst.SimpleWhitespace(""),
comment=None,
newline=cst.Newline(),
),
),
trailing_whitespace=cst.TrailingWhitespace(
whitespace=cst.SimpleWhitespace(" "),
comment=cst.Comment("# comment"),
newline=cst.Newline(),
),
)
),
dedent(
"""
SimpleStatementLine(
body=[
Pass(
semicolon=MaybeSentinel.DEFAULT,
),
],
leading_lines=[
EmptyLine(
indent=True,
whitespace=SimpleWhitespace(
value='',
),
comment=None,
newline=Newline(
value=None,
),
),
EmptyLine(
indent=True,
whitespace=SimpleWhitespace(
value='',
),
comment=None,
newline=Newline(
value=None,
),
),
],
trailing_whitespace=TrailingWhitespace(
whitespace=SimpleWhitespace(
value=' ',
),
comment=Comment(
value='# comment',
),
newline=Newline(
value=None,
),
),
)
"""
).strip(),
)
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 ModuleTest(CSTNodeTest):
@data_provider((
# simplest possible program
(cst.Module((cst.SimpleStatementLine((cst.Pass(), )), )), "pass\n"),
# test default_newline
(
cst.Module((cst.SimpleStatementLine((cst.Pass(), )), ),
default_newline="\r"),
"pass\r",
),
# test header/footer
(
cst.Module(
(cst.SimpleStatementLine((cst.Pass(), )), ),
header=(cst.EmptyLine(comment=cst.Comment("# header")), ),
footer=(cst.EmptyLine(comment=cst.Comment("# footer")), ),
),
"# header\npass\n# footer\n",
),
# test has_trailing_newline
(
cst.Module(
(cst.SimpleStatementLine((cst.Pass(), )), ),
has_trailing_newline=False,
),
"pass",
),
# an empty file
(cst.Module((), has_trailing_newline=False), ""),
# a file with only comments
(
cst.Module(
(),
header=(cst.EmptyLine(
comment=cst.Comment("# nothing to see here")), ),
),
"# nothing to see here\n",
),
# TODO: test default_indent
))
def test_code_and_bytes_properties(self, module: cst.Module,
expected: str) -> None:
self.assertEqual(module.code, expected)
self.assertEqual(module.bytes, expected.encode("utf-8"))
@data_provider((
(cst.Module(()), cst.Newline(), "\n"),
(cst.Module((), default_newline="\r\n"), cst.Newline(), "\r\n"),
# has_trailing_newline has no effect on code_for_node
(cst.Module((), has_trailing_newline=False), cst.Newline(), "\n"),
# TODO: test default_indent
))
def test_code_for_node(self, module: cst.Module, node: cst.CSTNode,
expected: str) -> None:
self.assertEqual(module.code_for_node(node), expected)
@data_provider({
"empty_program": {
"code": "",
"expected": cst.Module([], has_trailing_newline=False),
},
"empty_program_with_newline": {
"code": "\n",
"expected": cst.Module([], has_trailing_newline=True),
},
"empty_program_with_comments": {
"code":
"# some comment\n",
"expected":
cst.Module(
[],
header=[cst.EmptyLine(comment=cst.Comment("# some comment"))]),
},
"simple_pass": {
"code": "pass\n",
"expected": cst.Module([cst.SimpleStatementLine([cst.Pass()])]),
},
"simple_pass_with_header_footer": {
"code":
"# header\npass # trailing\n# footer\n",
"expected":
cst.Module(
[
cst.SimpleStatementLine(
[cst.Pass()],
trailing_whitespace=cst.TrailingWhitespace(
whitespace=cst.SimpleWhitespace(" "),
comment=cst.Comment("# trailing"),
),
)
],
header=[cst.EmptyLine(comment=cst.Comment("# header"))],
footer=[cst.EmptyLine(comment=cst.Comment("# footer"))],
),
},
})
def test_parser(self, *, code: str, expected: cst.Module) -> None:
self.assertEqual(parse_module(code), expected)
@data_provider({
"empty": {
"code": "",
"expected": CodeRange.create((1, 0), (1, 0))
},
"empty_with_newline": {
"code": "\n",
"expected": CodeRange.create((1, 0), (2, 0)),
},
"empty_program_with_comments": {
"code": "# 2345",
"expected": CodeRange.create((1, 0), (2, 0)),
},
"simple_pass": {
"code": "pass\n",
"expected": CodeRange.create((1, 0), (2, 0)),
},
"simple_pass_with_header_footer": {
"code": "# header\npass # trailing\n# footer\n",
"expected": CodeRange.create((1, 0), (4, 0)),
},
})
def test_module_position(self, *, code: str, expected: CodeRange) -> None:
module = parse_module(code)
provider = SyntacticPositionProvider()
module.code_for_node(module, provider)
self.assertEqual(provider._computed[module], expected)
# TODO: remove this
self.assertEqual(module._metadata[SyntacticPositionProvider], expected)
def cmp_position(self, actual: CodeRange, start: Tuple[int, int],
end: Tuple[int, int]) -> None:
self.assertEqual(actual, CodeRange.create(start, end))
def test_function_position(self) -> None:
module = parse_module("def foo():\n pass")
provider = SyntacticPositionProvider()
module.code_for_node(module, provider)
fn = cast(cst.FunctionDef, module.body[0])
stmt = cast(cst.SimpleStatementLine, fn.body.body[0])
pass_stmt = cast(cst.Pass, stmt.body[0])
self.cmp_position(provider._computed[stmt], (2, 4), (2, 8))
self.cmp_position(provider._computed[pass_stmt], (2, 4), (2, 8))
def test_nested_indent_position(self) -> None:
module = parse_module(
"if True:\n if False:\n x = 1\nelse:\n return")
provider = SyntacticPositionProvider()
module.code_for_node(module, provider)
outer_if = cast(cst.If, module.body[0])
inner_if = cast(cst.If, outer_if.body.body[0])
assign = cast(cst.SimpleStatementLine, inner_if.body.body[0]).body[0]
outer_else = cast(cst.Else, outer_if.orelse)
return_stmt = cast(cst.SimpleStatementLine,
outer_else.body.body[0]).body[0]
self.cmp_position(provider._computed[outer_if], (1, 0), (5, 10))
self.cmp_position(provider._computed[inner_if], (2, 4), (3, 13))
self.cmp_position(provider._computed[assign], (3, 8), (3, 13))
self.cmp_position(provider._computed[outer_else], (4, 0), (5, 10))
self.cmp_position(provider._computed[return_stmt], (5, 4), (5, 10))
def test_multiline_string_position(self) -> None:
module = parse_module('"abc"\\\n"def"')
provider = SyntacticPositionProvider()
module.code_for_node(module, provider)
stmt = cast(cst.SimpleStatementLine, module.body[0])
expr = cast(cst.Expr, stmt.body[0])
string = expr.value
self.cmp_position(provider._computed[stmt], (1, 0), (2, 5))
self.cmp_position(provider._computed[expr], (1, 0), (2, 5))
self.cmp_position(provider._computed[string], (1, 0), (2, 5))
class ModuleTest(CSTNodeTest):
@data_provider((
# simplest possible program
(cst.Module((cst.SimpleStatementLine((cst.Pass(), )), )), "pass\n"),
# test default_newline
(
cst.Module((cst.SimpleStatementLine((cst.Pass(), )), ),
default_newline="\r"),
"pass\r",
),
# test header/footer
(
cst.Module(
(cst.SimpleStatementLine((cst.Pass(), )), ),
header=(cst.EmptyLine(comment=cst.Comment("# header")), ),
footer=(cst.EmptyLine(comment=cst.Comment("# footer")), ),
),
"# header\npass\n# footer\n",
),
# test has_trailing_newline
(
cst.Module(
(cst.SimpleStatementLine((cst.Pass(), )), ),
has_trailing_newline=False,
),
"pass",
),
# an empty file
(cst.Module((), has_trailing_newline=False), ""),
# a file with only comments
(
cst.Module(
(),
header=(cst.EmptyLine(
comment=cst.Comment("# nothing to see here")), ),
),
"# nothing to see here\n",
),
# TODO: test default_indent
))
def test_code_and_bytes_properties(self, module: cst.Module,
expected: str) -> None:
self.assertEqual(module.code, expected)
self.assertEqual(module.bytes, expected.encode("utf-8"))
@data_provider((
(cst.Module(()), cst.Newline(), "\n"),
(cst.Module((), default_newline="\r\n"), cst.Newline(), "\r\n"),
# has_trailing_newline has no effect on code_for_node
(cst.Module((), has_trailing_newline=False), cst.Newline(), "\n"),
# TODO: test default_indent
))
def test_code_for_node(self, module: cst.Module, node: cst.CSTNode,
expected: str) -> None:
self.assertEqual(module.code_for_node(node), expected)
@data_provider({
"empty_program": {
"code": "",
"expected": cst.Module([], has_trailing_newline=False),
},
"empty_program_with_newline": {
"code": "\n",
"expected": cst.Module([], has_trailing_newline=True),
"enabled_for_native": False,
},
"empty_program_with_comments": {
"code":
"# some comment\n",
"expected":
cst.Module(
[],
header=[cst.EmptyLine(comment=cst.Comment("# some comment"))]),
},
"simple_pass": {
"code": "pass\n",
"expected": cst.Module([cst.SimpleStatementLine([cst.Pass()])]),
},
"simple_pass_with_header_footer": {
"code":
"# header\npass # trailing\n# footer\n",
"expected":
cst.Module(
[
cst.SimpleStatementLine(
[cst.Pass()],
trailing_whitespace=cst.TrailingWhitespace(
whitespace=cst.SimpleWhitespace(" "),
comment=cst.Comment("# trailing"),
),
)
],
header=[cst.EmptyLine(comment=cst.Comment("# header"))],
footer=[cst.EmptyLine(comment=cst.Comment("# footer"))],
),
},
})
def test_parser(self,
*,
code: str,
expected: cst.Module,
enabled_for_native: bool = True) -> None:
if is_native() and not enabled_for_native:
self.skipTest("Disabled for native parser")
self.assertEqual(parse_module(code), expected)
@data_provider({
"empty": {
"code": "",
"expected": CodeRange((1, 0), (1, 0))
},
"empty_with_newline": {
"code": "\n",
"expected": CodeRange((1, 0), (2, 0))
},
"empty_program_with_comments": {
"code": "# 2345",
"expected": CodeRange((1, 0), (2, 0)),
},
"simple_pass": {
"code": "pass\n",
"expected": CodeRange((1, 0), (2, 0))
},
"simple_pass_with_header_footer": {
"code": "# header\npass # trailing\n# footer\n",
"expected": CodeRange((1, 0), (4, 0)),
},
})
def test_module_position(self, *, code: str, expected: CodeRange) -> None:
wrapper = MetadataWrapper(parse_module(code))
positions = wrapper.resolve(PositionProvider)
self.assertEqual(positions[wrapper.module], expected)
def cmp_position(self, actual: CodeRange, start: Tuple[int, int],
end: Tuple[int, int]) -> None:
self.assertEqual(actual, CodeRange(start, end))
def test_function_position(self) -> None:
wrapper = MetadataWrapper(parse_module("def foo():\n pass"))
module = wrapper.module
positions = wrapper.resolve(PositionProvider)
fn = cast(cst.FunctionDef, module.body[0])
stmt = cast(cst.SimpleStatementLine, fn.body.body[0])
pass_stmt = cast(cst.Pass, stmt.body[0])
self.cmp_position(positions[stmt], (2, 4), (2, 8))
self.cmp_position(positions[pass_stmt], (2, 4), (2, 8))
def test_nested_indent_position(self) -> None:
wrapper = MetadataWrapper(
parse_module(
"if True:\n if False:\n x = 1\nelse:\n return"))
module = wrapper.module
positions = wrapper.resolve(PositionProvider)
outer_if = cast(cst.If, module.body[0])
inner_if = cast(cst.If, outer_if.body.body[0])
assign = cast(cst.SimpleStatementLine, inner_if.body.body[0]).body[0]
outer_else = cast(cst.Else, outer_if.orelse)
return_stmt = cast(cst.SimpleStatementLine,
outer_else.body.body[0]).body[0]
self.cmp_position(positions[outer_if], (1, 0), (5, 10))
self.cmp_position(positions[inner_if], (2, 4), (3, 13))
self.cmp_position(positions[assign], (3, 8), (3, 13))
self.cmp_position(positions[outer_else], (4, 0), (5, 10))
self.cmp_position(positions[return_stmt], (5, 4), (5, 10))
def test_multiline_string_position(self) -> None:
wrapper = MetadataWrapper(parse_module('"abc"\\\n"def"'))
module = wrapper.module
positions = wrapper.resolve(PositionProvider)
stmt = cast(cst.SimpleStatementLine, module.body[0])
expr = cast(cst.Expr, stmt.body[0])
string = expr.value
self.cmp_position(positions[stmt], (1, 0), (2, 5))
self.cmp_position(positions[expr], (1, 0), (2, 5))
self.cmp_position(positions[string], (1, 0), (2, 5))
def test_module_config_for_parsing(self) -> None:
module = parse_module("pass\r")
statement = parse_statement("if True:\r pass",
config=module.config_for_parsing)
self.assertEqual(
statement,
cst.If(
test=cst.Name(value="True"),
body=cst.IndentedBlock(
body=[cst.SimpleStatementLine(body=[cst.Pass()])],
header=cst.TrailingWhitespace(newline=cst.Newline(
# This would be "\r" if we didn't pass the module config forward.
value=None)),
),
),
)
def _string_visit(self, original_node: cst.SimpleString,
updated_node: cst.SimpleString) -> cst.Pass:
return cst.Pass()
class TupleTest(CSTNodeTest):
@data_provider(
[
# zero-element tuple
{"node": cst.Tuple([]), "code": "()", "parser": parse_expression},
# one-element tuple, sentinel comma value
{
"node": cst.Tuple([cst.Element(cst.Name("single_element"))]),
"code": "(single_element,)",
"parser": None,
},
{
"node": cst.Tuple([cst.StarredElement(cst.Name("single_element"))]),
"code": "(*single_element,)",
"parser": None,
},
# two-element tuple, sentinel comma value
{
"node": cst.Tuple(
[cst.Element(cst.Name("one")), cst.Element(cst.Name("two"))]
),
"code": "(one, two)",
"parser": None,
},
# remove parenthesis
{
"node": cst.Tuple(
[cst.Element(cst.Name("one")), cst.Element(cst.Name("two"))],
lpar=[],
rpar=[],
),
"code": "one, two",
"parser": None,
},
# add extra parenthesis
{
"node": cst.Tuple(
[cst.Element(cst.Name("one")), cst.Element(cst.Name("two"))],
lpar=[cst.LeftParen(), cst.LeftParen()],
rpar=[cst.RightParen(), cst.RightParen()],
),
"code": "((one, two))",
"parser": None,
},
# starred element
{
"node": cst.Tuple(
[
cst.StarredElement(cst.Name("one")),
cst.StarredElement(cst.Name("two")),
]
),
"code": "(*one, *two)",
"parser": None,
},
# custom comma on Element
{
"node": cst.Tuple(
[
cst.Element(cst.Name("one"), comma=cst.Comma()),
cst.Element(cst.Name("two"), comma=cst.Comma()),
]
),
"code": "(one,two,)",
"parser": parse_expression,
},
# custom comma on StarredElement
{
"node": cst.Tuple(
[
cst.StarredElement(cst.Name("one"), comma=cst.Comma()),
cst.StarredElement(cst.Name("two"), comma=cst.Comma()),
]
),
"code": "(*one,*two,)",
"parser": parse_expression,
"expected_position": CodeRange((1, 1), (1, 11)),
},
# custom parenthesis on StarredElement
{
"node": cst.Tuple(
[
cst.StarredElement(
cst.Name("abc"),
lpar=[cst.LeftParen()],
rpar=[cst.RightParen()],
comma=cst.Comma(),
)
]
),
"code": "((*abc),)",
"parser": parse_expression,
"expected_position": CodeRange((1, 1), (1, 8)),
},
# custom whitespace on StarredElement
{
"node": cst.Tuple(
[
cst.Element(cst.Name("one"), comma=cst.Comma()),
cst.StarredElement(
cst.Name("two"),
whitespace_before_value=cst.SimpleWhitespace(" "),
lpar=[cst.LeftParen()],
rpar=[cst.RightParen()],
),
],
lpar=[],
rpar=[], # rpar can't own the trailing whitespace if it's not there
),
"code": "one,(* two)",
"parser": parse_expression,
"expected_position": CodeRange((1, 0), (1, 12)),
},
# missing spaces around tuple, okay with parenthesis
{
"node": cst.For(
target=cst.Tuple(
[
cst.Element(cst.Name("k"), comma=cst.Comma()),
cst.Element(cst.Name("v")),
]
),
iter=cst.Name("abc"),
body=cst.SimpleStatementSuite([cst.Pass()]),
whitespace_after_for=cst.SimpleWhitespace(""),
whitespace_before_in=cst.SimpleWhitespace(""),
),
"code": "for(k,v)in abc: pass\n",
"parser": parse_statement,
},
# no spaces around tuple, but using values that are parenthesized
{
"node": cst.For(
target=cst.Tuple(
[
cst.Element(
cst.Name(
"k", lpar=[cst.LeftParen()], rpar=[cst.RightParen()]
),
comma=cst.Comma(),
),
cst.Element(
cst.Name(
"v", lpar=[cst.LeftParen()], rpar=[cst.RightParen()]
)
),
],
lpar=[],
rpar=[],
),
iter=cst.Name("abc"),
body=cst.SimpleStatementSuite([cst.Pass()]),
whitespace_after_for=cst.SimpleWhitespace(""),
whitespace_before_in=cst.SimpleWhitespace(""),
),
"code": "for(k),(v)in abc: pass\n",
"parser": parse_statement,
},
# starred elements are safe to use without a space before them
{
"node": cst.For(
target=cst.Tuple(
[cst.StarredElement(cst.Name("foo"), comma=cst.Comma())],
lpar=[],
rpar=[],
),
iter=cst.Name("bar"),
body=cst.SimpleStatementSuite([cst.Pass()]),
whitespace_after_for=cst.SimpleWhitespace(""),
),
"code": "for*foo, in bar: pass\n",
"parser": parse_statement,
},
# a trailing comma doesn't mess up TrailingWhitespace
{
"node": cst.SimpleStatementLine(
[
cst.Expr(
cst.Tuple(
[
cst.Element(cst.Name("one"), comma=cst.Comma()),
cst.Element(cst.Name("two"), comma=cst.Comma()),
],
lpar=[],
rpar=[],
)
)
],
trailing_whitespace=cst.TrailingWhitespace(
whitespace=cst.SimpleWhitespace(" "),
comment=cst.Comment("# comment"),
),
),
"code": "one,two, # comment\n",
"parser": parse_statement,
},
]
)
def test_valid(self, **kwargs: Any) -> None:
self.validate_node(**kwargs)
@data_provider(
(
(
lambda: cst.Tuple([], lpar=[], rpar=[]),
"A zero-length tuple must be wrapped in parentheses.",
),
(
lambda: cst.Tuple(
[cst.Element(cst.Name("mismatched"))],
lpar=[cst.LeftParen(), cst.LeftParen()],
rpar=[cst.RightParen()],
),
"unbalanced parens",
),
(
lambda: cst.For(
target=cst.Tuple([cst.Element(cst.Name("el"))], lpar=[], rpar=[]),
iter=cst.Name("it"),
body=cst.SimpleStatementSuite([cst.Pass()]),
whitespace_after_for=cst.SimpleWhitespace(""),
),
"Must have at least one space after 'for' keyword.",
),
(
lambda: cst.For(
target=cst.Tuple([cst.Element(cst.Name("el"))], lpar=[], rpar=[]),
iter=cst.Name("it"),
body=cst.SimpleStatementSuite([cst.Pass()]),
whitespace_before_in=cst.SimpleWhitespace(""),
),
"Must have at least one space before 'in' keyword.",
),
# an additional check for StarredElement, since it's a separate codepath
(
lambda: cst.For(
target=cst.Tuple(
[cst.StarredElement(cst.Name("el"))], lpar=[], rpar=[]
),
iter=cst.Name("it"),
body=cst.SimpleStatementSuite([cst.Pass()]),
whitespace_before_in=cst.SimpleWhitespace(""),
),
"Must have at least one space before 'in' keyword.",
),
)
)
def test_invalid(
self, get_node: Callable[[], cst.CSTNode], expected_re: str
) -> None:
self.assert_invalid(get_node, expected_re)
class WithTest(CSTNodeTest):
@data_provider((
# Simple with block
{
"node":
cst.With(
(cst.WithItem(cst.Call(cst.Name("context_mgr"))), ),
cst.SimpleStatementSuite((cst.Pass(), )),
),
"code":
"with context_mgr(): pass\n",
"parser":
parse_statement,
"expected_position":
CodeRange((1, 0), (1, 24)),
},
# Simple async with block
{
"node":
cst.With(
(cst.WithItem(cst.Call(cst.Name("context_mgr"))), ),
cst.SimpleStatementSuite((cst.Pass(), )),
asynchronous=cst.Asynchronous(),
),
"code":
"async with context_mgr(): pass\n",
"parser":
lambda code: parse_statement(
code, config=PartialParserConfig(python_version="3.7")),
},
# Python 3.6 async with block
{
"node":
cst.FunctionDef(
cst.Name("foo"),
cst.Parameters(),
cst.IndentedBlock((cst.With(
(cst.WithItem(cst.Call(cst.Name("context_mgr"))), ),
cst.SimpleStatementSuite((cst.Pass(), )),
asynchronous=cst.Asynchronous(),
), )),
asynchronous=cst.Asynchronous(),
),
"code":
"async def foo():\n async with context_mgr(): pass\n",
"parser":
lambda code: parse_statement(
code, config=PartialParserConfig(python_version="3.6")),
},
# Multiple context managers
{
"node":
cst.With(
(
cst.WithItem(cst.Call(cst.Name("foo"))),
cst.WithItem(cst.Call(cst.Name("bar"))),
),
cst.SimpleStatementSuite((cst.Pass(), )),
),
"code":
"with foo(), bar(): pass\n",
"parser":
None,
},
{
"node":
cst.With(
(
cst.WithItem(
cst.Call(cst.Name("foo")),
comma=cst.Comma(
whitespace_after=cst.SimpleWhitespace(" ")),
),
cst.WithItem(cst.Call(cst.Name("bar"))),
),
cst.SimpleStatementSuite((cst.Pass(), )),
),
"code":
"with foo(), bar(): pass\n",
"parser":
parse_statement,
},
# With block containing variable for context manager.
{
"node":
cst.With(
(cst.WithItem(
cst.Call(cst.Name("context_mgr")),
cst.AsName(cst.Name("ctx")),
), ),
cst.SimpleStatementSuite((cst.Pass(), )),
),
"code":
"with context_mgr() as ctx: pass\n",
"parser":
parse_statement,
},
# indentation
{
"node":
DummyIndentedBlock(
" ",
cst.With(
(cst.WithItem(cst.Call(cst.Name("context_mgr"))), ),
cst.SimpleStatementSuite((cst.Pass(), )),
),
),
"code":
" with context_mgr(): pass\n",
"parser":
None,
"expected_position":
CodeRange((1, 4), (1, 28)),
},
# with an indented body
{
"node":
DummyIndentedBlock(
" ",
cst.With(
(cst.WithItem(cst.Call(cst.Name("context_mgr"))), ),
cst.IndentedBlock((cst.SimpleStatementLine(
(cst.Pass(), )), )),
),
),
"code":
" with context_mgr():\n pass\n",
"parser":
None,
"expected_position":
CodeRange((1, 4), (2, 12)),
},
# leading_lines
{
"node":
cst.With(
(cst.WithItem(cst.Call(cst.Name("context_mgr"))), ),
cst.SimpleStatementSuite((cst.Pass(), )),
leading_lines=(cst.EmptyLine(
comment=cst.Comment("# leading comment")), ),
),
"code":
"# leading comment\nwith context_mgr(): pass\n",
"parser":
parse_statement,
"expected_position":
CodeRange((2, 0), (2, 24)),
},
# Weird spacing rules
{
"node":
cst.With(
(cst.WithItem(
cst.Call(
cst.Name("context_mgr"),
lpar=(cst.LeftParen(), ),
rpar=(cst.RightParen(), ),
)), ),
cst.SimpleStatementSuite((cst.Pass(), )),
whitespace_after_with=cst.SimpleWhitespace(""),
),
"code":
"with(context_mgr()): pass\n",
"parser":
parse_statement,
"expected_position":
CodeRange((1, 0), (1, 25)),
},
# Whitespace
{
"node":
cst.With(
(cst.WithItem(
cst.Call(cst.Name("context_mgr")),
cst.AsName(
cst.Name("ctx"),
whitespace_before_as=cst.SimpleWhitespace(" "),
whitespace_after_as=cst.SimpleWhitespace(" "),
),
), ),
cst.SimpleStatementSuite((cst.Pass(), )),
whitespace_after_with=cst.SimpleWhitespace(" "),
whitespace_before_colon=cst.SimpleWhitespace(" "),
),
"code":
"with context_mgr() as ctx : pass\n",
"parser":
parse_statement,
"expected_position":
CodeRange((1, 0), (1, 36)),
},
))
def test_valid(self, **kwargs: Any) -> None:
self.validate_node(**kwargs)
@data_provider((
{
"get_node":
lambda: cst.With((),
cst.IndentedBlock((cst.SimpleStatementLine(
(cst.Pass(), )), ))),
"expected_re":
"A With statement must have at least one WithItem",
},
{
"get_node":
lambda: cst.With(
(cst.WithItem(
cst.Call(cst.Name("foo")),
comma=cst.Comma(whitespace_after=cst.SimpleWhitespace(" ")
),
), ),
cst.IndentedBlock((cst.SimpleStatementLine((cst.Pass(), )), )),
),
"expected_re":
"The last WithItem in a With cannot have a trailing comma",
},
{
"get_node":
lambda: cst.With(
(cst.WithItem(cst.Call(cst.Name("context_mgr"))), ),
cst.SimpleStatementSuite((cst.Pass(), )),
whitespace_after_with=cst.SimpleWhitespace(""),
),
"expected_re":
"Must have at least one space after with keyword",
},
))
def test_invalid(self, **kwargs: Any) -> None:
self.assert_invalid(**kwargs)
@data_provider((
{
"code": "with a, b: pass",
"parser": parse_statement_as(python_version="3.1"),
"expect_success": True,
},
{
"code": "with a, b: pass",
"parser": parse_statement_as(python_version="3.0"),
"expect_success": False,
},
))
def test_versions(self, **kwargs: Any) -> None:
self.assert_parses(**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 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)