forked from openkylin/astroid
390 lines
14 KiB
Python
390 lines
14 KiB
Python
# Copyright (c) 2010, 2013-2014 LOGILAB S.A. (Paris, FRANCE) <contact@logilab.fr>
|
|
# Copyright (c) 2012 FELD Boris <lothiraldan@gmail.com>
|
|
# Copyright (c) 2013-2018, 2020 Claudiu Popa <pcmanticore@gmail.com>
|
|
# Copyright (c) 2014 Google, Inc.
|
|
# Copyright (c) 2015-2016 Ceridwen <ceridwenv@gmail.com>
|
|
# Copyright (c) 2016 Jared Garst <jgarst@users.noreply.github.com>
|
|
# Copyright (c) 2017, 2019 Łukasz Rogalski <rogalski.91@gmail.com>
|
|
# Copyright (c) 2017 Hugo <hugovk@users.noreply.github.com>
|
|
# Copyright (c) 2019 Ashley Whetter <ashley@awhetter.co.uk>
|
|
# Copyright (c) 2020-2021 hippo91 <guillaume.peillex@gmail.com>
|
|
# Copyright (c) 2020 David Gilman <davidgilman1@gmail.com>
|
|
# Copyright (c) 2021 Pierre Sassoulas <pierre.sassoulas@gmail.com>
|
|
# Copyright (c) 2021 Marc Mueller <30130371+cdce8p@users.noreply.github.com>
|
|
|
|
# Licensed under the LGPL: https://www.gnu.org/licenses/old-licenses/lgpl-2.1.en.html
|
|
# For details: https://github.com/PyCQA/astroid/blob/main/LICENSE
|
|
|
|
import unittest
|
|
from textwrap import dedent
|
|
|
|
from astroid import nodes
|
|
from astroid.builder import AstroidBuilder, extract_node
|
|
from astroid.test_utils import require_version
|
|
|
|
|
|
class Python3TC(unittest.TestCase):
|
|
@classmethod
|
|
def setUpClass(cls):
|
|
cls.builder = AstroidBuilder()
|
|
|
|
def test_starred_notation(self) -> None:
|
|
astroid = self.builder.string_build("*a, b = [1, 2, 3]", "test", "test")
|
|
|
|
# Get the star node
|
|
node = next(next(next(astroid.get_children()).get_children()).get_children())
|
|
|
|
self.assertTrue(isinstance(node.assign_type(), nodes.Assign))
|
|
|
|
def test_yield_from(self) -> None:
|
|
body = dedent(
|
|
"""
|
|
def func():
|
|
yield from iter([1, 2])
|
|
"""
|
|
)
|
|
astroid = self.builder.string_build(body)
|
|
func = astroid.body[0]
|
|
self.assertIsInstance(func, nodes.FunctionDef)
|
|
yieldfrom_stmt = func.body[0]
|
|
|
|
self.assertIsInstance(yieldfrom_stmt, nodes.Expr)
|
|
self.assertIsInstance(yieldfrom_stmt.value, nodes.YieldFrom)
|
|
self.assertEqual(yieldfrom_stmt.as_string(), "yield from iter([1, 2])")
|
|
|
|
def test_yield_from_is_generator(self) -> None:
|
|
body = dedent(
|
|
"""
|
|
def func():
|
|
yield from iter([1, 2])
|
|
"""
|
|
)
|
|
astroid = self.builder.string_build(body)
|
|
func = astroid.body[0]
|
|
self.assertIsInstance(func, nodes.FunctionDef)
|
|
self.assertTrue(func.is_generator())
|
|
|
|
def test_yield_from_as_string(self) -> None:
|
|
body = dedent(
|
|
"""
|
|
def func():
|
|
yield from iter([1, 2])
|
|
value = yield from other()
|
|
"""
|
|
)
|
|
astroid = self.builder.string_build(body)
|
|
func = astroid.body[0]
|
|
self.assertEqual(func.as_string().strip(), body.strip())
|
|
|
|
# metaclass tests
|
|
|
|
def test_simple_metaclass(self) -> None:
|
|
astroid = self.builder.string_build("class Test(metaclass=type): pass")
|
|
klass = astroid.body[0]
|
|
|
|
metaclass = klass.metaclass()
|
|
self.assertIsInstance(metaclass, nodes.ClassDef)
|
|
self.assertEqual(metaclass.name, "type")
|
|
|
|
def test_metaclass_error(self) -> None:
|
|
astroid = self.builder.string_build("class Test(metaclass=typ): pass")
|
|
klass = astroid.body[0]
|
|
self.assertFalse(klass.metaclass())
|
|
|
|
def test_metaclass_imported(self) -> None:
|
|
astroid = self.builder.string_build(
|
|
dedent(
|
|
"""
|
|
from abc import ABCMeta
|
|
class Test(metaclass=ABCMeta): pass"""
|
|
)
|
|
)
|
|
klass = astroid.body[1]
|
|
|
|
metaclass = klass.metaclass()
|
|
self.assertIsInstance(metaclass, nodes.ClassDef)
|
|
self.assertEqual(metaclass.name, "ABCMeta")
|
|
|
|
def test_metaclass_multiple_keywords(self) -> None:
|
|
astroid = self.builder.string_build(
|
|
"class Test(magic=None, metaclass=type): pass"
|
|
)
|
|
klass = astroid.body[0]
|
|
|
|
metaclass = klass.metaclass()
|
|
self.assertIsInstance(metaclass, nodes.ClassDef)
|
|
self.assertEqual(metaclass.name, "type")
|
|
|
|
def test_as_string(self) -> None:
|
|
body = dedent(
|
|
"""
|
|
from abc import ABCMeta
|
|
class Test(metaclass=ABCMeta): pass"""
|
|
)
|
|
astroid = self.builder.string_build(body)
|
|
klass = astroid.body[1]
|
|
|
|
self.assertEqual(
|
|
klass.as_string(), "\n\nclass Test(metaclass=ABCMeta):\n pass\n"
|
|
)
|
|
|
|
def test_old_syntax_works(self) -> None:
|
|
astroid = self.builder.string_build(
|
|
dedent(
|
|
"""
|
|
class Test:
|
|
__metaclass__ = type
|
|
class SubTest(Test): pass
|
|
"""
|
|
)
|
|
)
|
|
klass = astroid["SubTest"]
|
|
metaclass = klass.metaclass()
|
|
self.assertIsNone(metaclass)
|
|
|
|
def test_metaclass_yes_leak(self) -> None:
|
|
astroid = self.builder.string_build(
|
|
dedent(
|
|
"""
|
|
# notice `ab` instead of `abc`
|
|
from ab import ABCMeta
|
|
|
|
class Meta(metaclass=ABCMeta): pass
|
|
"""
|
|
)
|
|
)
|
|
klass = astroid["Meta"]
|
|
self.assertIsNone(klass.metaclass())
|
|
|
|
def test_parent_metaclass(self) -> None:
|
|
astroid = self.builder.string_build(
|
|
dedent(
|
|
"""
|
|
from abc import ABCMeta
|
|
class Test(metaclass=ABCMeta): pass
|
|
class SubTest(Test): pass
|
|
"""
|
|
)
|
|
)
|
|
klass = astroid["SubTest"]
|
|
self.assertTrue(klass.newstyle)
|
|
metaclass = klass.metaclass()
|
|
self.assertIsInstance(metaclass, nodes.ClassDef)
|
|
self.assertEqual(metaclass.name, "ABCMeta")
|
|
|
|
def test_metaclass_ancestors(self) -> None:
|
|
astroid = self.builder.string_build(
|
|
dedent(
|
|
"""
|
|
from abc import ABCMeta
|
|
|
|
class FirstMeta(metaclass=ABCMeta): pass
|
|
class SecondMeta(metaclass=type):
|
|
pass
|
|
|
|
class Simple:
|
|
pass
|
|
|
|
class FirstImpl(FirstMeta): pass
|
|
class SecondImpl(FirstImpl): pass
|
|
class ThirdImpl(Simple, SecondMeta):
|
|
pass
|
|
"""
|
|
)
|
|
)
|
|
classes = {"ABCMeta": ("FirstImpl", "SecondImpl"), "type": ("ThirdImpl",)}
|
|
for metaclass, names in classes.items():
|
|
for name in names:
|
|
impl = astroid[name]
|
|
meta = impl.metaclass()
|
|
self.assertIsInstance(meta, nodes.ClassDef)
|
|
self.assertEqual(meta.name, metaclass)
|
|
|
|
def test_annotation_support(self) -> None:
|
|
astroid = self.builder.string_build(
|
|
dedent(
|
|
"""
|
|
def test(a: int, b: str, c: None, d, e,
|
|
*args: float, **kwargs: int)->int:
|
|
pass
|
|
"""
|
|
)
|
|
)
|
|
func = astroid["test"]
|
|
self.assertIsInstance(func.args.varargannotation, nodes.Name)
|
|
self.assertEqual(func.args.varargannotation.name, "float")
|
|
self.assertIsInstance(func.args.kwargannotation, nodes.Name)
|
|
self.assertEqual(func.args.kwargannotation.name, "int")
|
|
self.assertIsInstance(func.returns, nodes.Name)
|
|
self.assertEqual(func.returns.name, "int")
|
|
arguments = func.args
|
|
self.assertIsInstance(arguments.annotations[0], nodes.Name)
|
|
self.assertEqual(arguments.annotations[0].name, "int")
|
|
self.assertIsInstance(arguments.annotations[1], nodes.Name)
|
|
self.assertEqual(arguments.annotations[1].name, "str")
|
|
self.assertIsInstance(arguments.annotations[2], nodes.Const)
|
|
self.assertIsNone(arguments.annotations[2].value)
|
|
self.assertIsNone(arguments.annotations[3])
|
|
self.assertIsNone(arguments.annotations[4])
|
|
|
|
astroid = self.builder.string_build(
|
|
dedent(
|
|
"""
|
|
def test(a: int=1, b: str=2):
|
|
pass
|
|
"""
|
|
)
|
|
)
|
|
func = astroid["test"]
|
|
self.assertIsInstance(func.args.annotations[0], nodes.Name)
|
|
self.assertEqual(func.args.annotations[0].name, "int")
|
|
self.assertIsInstance(func.args.annotations[1], nodes.Name)
|
|
self.assertEqual(func.args.annotations[1].name, "str")
|
|
self.assertIsNone(func.returns)
|
|
|
|
def test_kwonlyargs_annotations_supper(self) -> None:
|
|
node = self.builder.string_build(
|
|
dedent(
|
|
"""
|
|
def test(*, a: int, b: str, c: None, d, e):
|
|
pass
|
|
"""
|
|
)
|
|
)
|
|
func = node["test"]
|
|
arguments = func.args
|
|
self.assertIsInstance(arguments.kwonlyargs_annotations[0], nodes.Name)
|
|
self.assertEqual(arguments.kwonlyargs_annotations[0].name, "int")
|
|
self.assertIsInstance(arguments.kwonlyargs_annotations[1], nodes.Name)
|
|
self.assertEqual(arguments.kwonlyargs_annotations[1].name, "str")
|
|
self.assertIsInstance(arguments.kwonlyargs_annotations[2], nodes.Const)
|
|
self.assertIsNone(arguments.kwonlyargs_annotations[2].value)
|
|
self.assertIsNone(arguments.kwonlyargs_annotations[3])
|
|
self.assertIsNone(arguments.kwonlyargs_annotations[4])
|
|
|
|
def test_annotation_as_string(self) -> None:
|
|
code1 = dedent(
|
|
"""
|
|
def test(a, b: int = 4, c=2, f: 'lala' = 4) -> 2:
|
|
pass"""
|
|
)
|
|
code2 = dedent(
|
|
"""
|
|
def test(a: typing.Generic[T], c: typing.Any = 24) -> typing.Iterable:
|
|
pass"""
|
|
)
|
|
for code in (code1, code2):
|
|
func = extract_node(code)
|
|
self.assertEqual(func.as_string(), code)
|
|
|
|
def test_unpacking_in_dicts(self) -> None:
|
|
code = "{'x': 1, **{'y': 2}}"
|
|
node = extract_node(code)
|
|
self.assertEqual(node.as_string(), code)
|
|
assert isinstance(node, nodes.Dict)
|
|
keys = [key for (key, _) in node.items]
|
|
self.assertIsInstance(keys[0], nodes.Const)
|
|
self.assertIsInstance(keys[1], nodes.DictUnpack)
|
|
|
|
def test_nested_unpacking_in_dicts(self) -> None:
|
|
code = "{'x': 1, **{'y': 2, **{'z': 3}}}"
|
|
node = extract_node(code)
|
|
self.assertEqual(node.as_string(), code)
|
|
|
|
def test_unpacking_in_dict_getitem(self) -> None:
|
|
node = extract_node("{1:2, **{2:3, 3:4}, **{5: 6}}")
|
|
for key, expected in ((1, 2), (2, 3), (3, 4), (5, 6)):
|
|
value = node.getitem(nodes.Const(key))
|
|
self.assertIsInstance(value, nodes.Const)
|
|
self.assertEqual(value.value, expected)
|
|
|
|
def test_format_string(self) -> None:
|
|
code = "f'{greetings} {person}'"
|
|
node = extract_node(code)
|
|
self.assertEqual(node.as_string(), code)
|
|
|
|
def test_underscores_in_numeral_literal(self) -> None:
|
|
pairs = [("10_1000", 101000), ("10_000_000", 10000000), ("0x_FF_FF", 65535)]
|
|
for value, expected in pairs:
|
|
node = extract_node(value)
|
|
inferred = next(node.infer())
|
|
self.assertIsInstance(inferred, nodes.Const)
|
|
self.assertEqual(inferred.value, expected)
|
|
|
|
def test_async_comprehensions(self) -> None:
|
|
async_comprehensions = [
|
|
extract_node(
|
|
"async def f(): return __([i async for i in aiter() if i % 2])"
|
|
),
|
|
extract_node(
|
|
"async def f(): return __({i async for i in aiter() if i % 2})"
|
|
),
|
|
extract_node(
|
|
"async def f(): return __((i async for i in aiter() if i % 2))"
|
|
),
|
|
extract_node(
|
|
"async def f(): return __({i: i async for i in aiter() if i % 2})"
|
|
),
|
|
]
|
|
non_async_comprehensions = [
|
|
extract_node("async def f(): return __({i: i for i in iter() if i % 2})")
|
|
]
|
|
|
|
for comp in async_comprehensions:
|
|
self.assertTrue(comp.generators[0].is_async)
|
|
for comp in non_async_comprehensions:
|
|
self.assertFalse(comp.generators[0].is_async)
|
|
|
|
@require_version("3.7")
|
|
def test_async_comprehensions_outside_coroutine(self):
|
|
# When async and await will become keywords, async comprehensions
|
|
# will be allowed outside of coroutines body
|
|
comprehensions = [
|
|
"[i async for i in aiter() if condition(i)]",
|
|
"[await fun() async for fun in funcs]",
|
|
"{await fun() async for fun in funcs}",
|
|
"{fun: await fun() async for fun in funcs}",
|
|
"[await fun() async for fun in funcs if await smth]",
|
|
"{await fun() async for fun in funcs if await smth}",
|
|
"{fun: await fun() async for fun in funcs if await smth}",
|
|
"[await fun() async for fun in funcs]",
|
|
"{await fun() async for fun in funcs}",
|
|
"{fun: await fun() async for fun in funcs}",
|
|
"[await fun() async for fun in funcs if await smth]",
|
|
"{await fun() async for fun in funcs if await smth}",
|
|
"{fun: await fun() async for fun in funcs if await smth}",
|
|
]
|
|
|
|
for comp in comprehensions:
|
|
node = extract_node(comp)
|
|
self.assertTrue(node.generators[0].is_async)
|
|
|
|
def test_async_comprehensions_as_string(self) -> None:
|
|
func_bodies = [
|
|
"return [i async for i in aiter() if condition(i)]",
|
|
"return [await fun() for fun in funcs]",
|
|
"return {await fun() for fun in funcs}",
|
|
"return {fun: await fun() for fun in funcs}",
|
|
"return [await fun() for fun in funcs if await smth]",
|
|
"return {await fun() for fun in funcs if await smth}",
|
|
"return {fun: await fun() for fun in funcs if await smth}",
|
|
"return [await fun() async for fun in funcs]",
|
|
"return {await fun() async for fun in funcs}",
|
|
"return {fun: await fun() async for fun in funcs}",
|
|
"return [await fun() async for fun in funcs if await smth]",
|
|
"return {await fun() async for fun in funcs if await smth}",
|
|
"return {fun: await fun() async for fun in funcs if await smth}",
|
|
]
|
|
for func_body in func_bodies:
|
|
code = dedent(
|
|
f"""
|
|
async def f():
|
|
{func_body}"""
|
|
)
|
|
func = extract_node(code)
|
|
self.assertEqual(func.as_string().strip(), code.strip())
|
|
|
|
|
|
if __name__ == "__main__":
|
|
unittest.main()
|