예제 #1
0
 def test_augassign_attr(self):
     builder.parse("""
         class Counter:
             v = 0
             def inc(self):
                 self.v += 1
         """, __name__)
 def test_asstuple(self):
     code = "a, b = range(2)"
     astroid = builder.parse(code)
     self.assertIn("b", astroid.locals)
     code = """
         def visit_if(self, node):
             node.test, body = node.tests[0]
         """
     astroid = builder.parse(code)
     self.assertIn("body", astroid["visit_if"].locals)
예제 #3
0
 def test_asstuple(self):
     code = 'a, b = range(2)'
     astroid = builder.parse(code)
     self.assertIn('b', astroid.locals)
     code = '''
         def visit_if(self, node):
             node.test, body = node.tests[0]
         '''
     astroid = builder.parse(code)
     self.assertIn('body', astroid['visit_if'].locals)
예제 #4
0
    def check_as_string_ast_equality(code):
        """
        Check that as_string produces source code with exactly the same
        semantics as the source it was originally parsed from
        """
        pre = builder.parse(code)
        post = builder.parse(pre.as_string())

        pre_repr = pre.repr_tree()
        post_repr = post.repr_tree()

        assert pre_repr == post_repr
        assert pre.as_string().strip() == code.strip()
 def test_inferred_dont_pollute(self):
     code = """
         def func(a=None):
             a.custom_attr = 0
         def func2(a={}):
             a.custom_attr = 0
         """
     builder.parse(code)
     nonetype = nodes.const_factory(None)
     self.assertNotIn("custom_attr", nonetype.locals)
     self.assertNotIn("custom_attr", nonetype.instance_attrs)
     nonetype = nodes.const_factory({})
     self.assertNotIn("custom_attr", nonetype.locals)
     self.assertNotIn("custom_attr", nonetype.instance_attrs)
예제 #6
0
 def test_inferred_dont_pollute(self):
     code = '''
         def func(a=None):
             a.custom_attr = 0
         def func2(a={}):
             a.custom_attr = 0
         '''
     builder.parse(code)
     nonetype = nodes.const_factory(None)
     # pylint: disable=no-member; Infers two potential values
     self.assertNotIn('custom_attr', nonetype.locals)
     self.assertNotIn('custom_attr', nonetype.instance_attrs)
     nonetype = nodes.const_factory({})
     self.assertNotIn('custom_attr', nonetype.locals)
     self.assertNotIn('custom_attr', nonetype.instance_attrs)
예제 #7
0
 def test_inferred_dont_pollute(self):
     code = '''
         def func(a=None):
             a.custom_attr = 0
         def func2(a={}):
             a.custom_attr = 0
         '''
     builder.parse(code)
     nonetype = nodes.const_factory(None)
     # pylint: disable=no-member; union type in const_factory, this shouldn't happen
     self.assertNotIn('custom_attr', nonetype.locals)
     self.assertNotIn('custom_attr', nonetype.instance_attrs)
     nonetype = nodes.const_factory({})
     self.assertNotIn('custom_attr', nonetype.locals)
     self.assertNotIn('custom_attr', nonetype.instance_attrs)
예제 #8
0
 def test_file_stream_physical(self):
     with open(__file__) as stream:
         astroid = builder.parse(stream.read())
     with open(__file__, 'rb') as file_io:
         with astroid.stream() as stream:
             self.assertEqual([line.strip() for line in stream.read().splitlines()],
                              [line.strip() for line in file_io.read().splitlines()])
예제 #9
0
    def test_as_string(self):
        """check as_string for python syntax >= 2.7"""
        code = '''one_two = {1, 2}
b = {v: k for (k, v) in enumerate('string')}
cdd = {k for k in b}\n\n'''
        ast = builder.parse(code)
        self.assertMultiLineEqual(ast.as_string(), code)
예제 #10
0
    def test_try_except(self):
        module = builder.parse('''
        try:
            def exclusive_func2():
                "docstring"
        except TypeError:
            def exclusive_func2():
                "docstring"
        except:
            def exclusive_func2():
                "docstring"
        else:
            def exclusive_func2():
                "this one redefine the one defined line 42"
        ''')
        f1 = module.locals['exclusive_func2'][0]
        f2 = module.locals['exclusive_func2'][1]
        f3 = module.locals['exclusive_func2'][2]
        f4 = module.locals['exclusive_func2'][3]
        self.assertEqual(node_classes.are_exclusive(f1, f2), True)
        self.assertEqual(node_classes.are_exclusive(f1, f3), True)
        self.assertEqual(node_classes.are_exclusive(f1, f4), False)
        self.assertEqual(node_classes.are_exclusive(f2, f4), True)
        self.assertEqual(node_classes.are_exclusive(f3, f4), True)
        self.assertEqual(node_classes.are_exclusive(f3, f2), True)

        self.assertEqual(node_classes.are_exclusive(f2, f1), True)
        self.assertEqual(node_classes.are_exclusive(f4, f1), False)
        self.assertEqual(node_classes.are_exclusive(f4, f2), True)
    def test_limit(self):
        code = '''
            l = [a
                 for a,b in list]

            a = 1
            b = a
            a = None

            def func():
                c = 1
        '''
        astroid = builder.parse(code, __name__)
        # a & b
        a = next(astroid.nodes_of_class(nodes.Name))
        self.assertEqual(a.lineno, 2)
        if sys.version_info < (3, 0):
            self.assertEqual(len(astroid.lookup('b')[1]), 2)
            self.assertEqual(len(astroid.lookup('a')[1]), 3)
            b = astroid.locals['b'][1]
        else:
            self.assertEqual(len(astroid.lookup('b')[1]), 1)
            self.assertEqual(len(astroid.lookup('a')[1]), 2)
            b = astroid.locals['b'][0]
        stmts = a.lookup('a')[1]
        self.assertEqual(len(stmts), 1)
        self.assertEqual(b.lineno, 6)
        b_infer = b.infer()
        b_value = next(b_infer)
        self.assertEqual(b_value.value, 1)
        # c
        self.assertRaises(StopIteration, functools.partial(next, b_infer))
        func = astroid.locals['func'][0]
        self.assertEqual(len(func.lookup('c')[1]), 1)
예제 #12
0
    def test_newstyle_detection(self):
        data = '''
            class A:
                "old style"

            class B(A):
                "old style"

            class C(object):
                "new style"

            class D(C):
                "new style"

            __metaclass__ = type

            class E(A):
                "old style"

            class F:
                "new style"
        '''
        mod_ast = builder.parse(data, __name__)
        if six.PY3:
            self.assertTrue(mod_ast['A'].newstyle)
            self.assertTrue(mod_ast['B'].newstyle)
            self.assertTrue(mod_ast['E'].newstyle)
        else:
            self.assertFalse(mod_ast['A'].newstyle)
            self.assertFalse(mod_ast['B'].newstyle)
            self.assertFalse(mod_ast['E'].newstyle)
        self.assertTrue(mod_ast['C'].newstyle)
        self.assertTrue(mod_ast['D'].newstyle)
        self.assertTrue(mod_ast['F'].newstyle)
예제 #13
0
 def test_parser(self):
     module = builder.parse("""
     from dateutil.parser import parse
     d = parse('2000-01-01')
     """)
     d_type = next(module['d'].infer())
     self.assertEqual(d_type.qname(), "datetime.datetime")
 def test_set_comp_closure(self):
     astroid = builder.parse("""
         ten = { var for var in range(10) }
         var
     """)
     var = astroid.body[1].value
     self.assertRaises(exceptions.NameInferenceError, var.inferred)
예제 #15
0
 def astroid(self):
     try:
         return self.__class__.__dict__['CODE_Astroid']
     except KeyError:
         module = builder.parse(self.CODE)
         self.__class__.CODE_Astroid = module
         return module
 def astroid(self):
     try:
         return self.__class__.__dict__["CODE_Astroid"]
     except KeyError:
         astroid = builder.parse(self.CODE)
         self.__class__.CODE_Astroid = astroid
         return astroid
    def test_newstyle_detection(self):
        data = """
            class A:
                "old style"

            class B(A):
                "old style"

            class C(object):
                "new style"

            class D(C):
                "new style"

            __metaclass__ = type

            class E(A):
                "old style"

            class F:
                "new style"
        """
        mod_ast = builder.parse(data, __name__)
        if six.PY3:
            self.assertTrue(mod_ast["A"].newstyle)
            self.assertTrue(mod_ast["B"].newstyle)
            self.assertTrue(mod_ast["E"].newstyle)
        else:
            self.assertFalse(mod_ast["A"].newstyle)
            self.assertFalse(mod_ast["B"].newstyle)
            self.assertFalse(mod_ast["E"].newstyle)
        self.assertTrue(mod_ast["C"].newstyle)
        self.assertTrue(mod_ast["D"].newstyle)
        self.assertTrue(mod_ast["F"].newstyle)
예제 #18
0
def test_type_comments_function():
    module = builder.parse('''
    def func():
        # type: (int) -> str
        pass
    def func1():
        # type: (int, int, int) -> (str, str)
        pass
    def func2():
        # type: (int, int, str, List[int]) -> List[int]
        pass
    ''')
    expected_annotations = [
        (["int"], astroid.Name, "str"),
        (["int", "int", "int"], astroid.Tuple, "(str, str)"),
        (["int", "int", "str", "List[int]"], astroid.Subscript, "List[int]"),
    ]
    for node, (
            expected_args,
            expected_returns_type,
            expected_returns_string
        ) in zip(module.body, expected_annotations):
        assert node.type_comment_returns is not None
        assert node.type_comment_args is not None
        for expected_arg, actual_arg in zip(expected_args, node.type_comment_args):
            assert actual_arg.as_string() == expected_arg
        assert isinstance(node.type_comment_returns, expected_returns_type)
        assert node.type_comment_returns.as_string() == expected_returns_string
예제 #19
0
    def test_starred_notation(self):
        astroid = builder.parse("*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(scope.assign_type(node), Assign))
예제 #20
0
    def test_bad_import_inference(self):
        # Explication of bug
        '''When we import PickleError from nonexistent, a call to the infer
        method of this From node will be made by unpack_infer.
        inference.infer_from will try to import this module, which will fail and
        raise a InferenceException (by mixins.do_import_module). The infer_name
        will catch this exception and yield and Uninferable instead.
        '''

        code = '''
            try:
                from pickle import PickleError
            except ImportError:
                from nonexistent import PickleError

            try:
                pass
            except PickleError:
                pass
        '''
        module = builder.parse(code)
        handler_type = module.body[1].handlers[0].type

        excs = list(node_classes.unpack_infer(handler_type))
        # The number of returned object can differ on Python 2
        # and Python 3. In one version, an additional item will
        # be returned, from the _pickle module, which is not
        # present in the other version.
        self.assertIsInstance(excs[0], nodes.ClassDef)
        self.assertEqual(excs[0].name, 'PickleError')
        self.assertIs(excs[-1], util.Uninferable)
예제 #21
0
 def test_kwoargs(self):
     ast = builder.parse('''
         def func(*, x):
             pass
     ''')
     args = ast['func'].args
     self.assertTrue(args.is_argument('x'))
 def test_function_module_special(self):
     astroid = builder.parse('''
     def initialize(linter):
         """initialize linter with checkers in this package """
         package_load(linter, __path__[0])
     ''', 'data.__init__')
     path = [n for n in astroid.nodes_of_class(nodes.Name) if n.name == '__path__'][0]
     self.assertEqual(len(path.lookup('__path__')[1]), 1)
예제 #23
0
 def test_argnames(self):
     if sys.version_info < (3, 0):
         code = 'def f(a, (b, c), *args, **kwargs): pass'
     else:
         code = 'def f(a, b, c, *args, **kwargs): pass'
     astroid = builder.parse(code, __name__)
     f = astroid.down().down()
     self.assertEqual(f.argnames(), ['a', 'b', 'c', 'args', 'kwargs'])
예제 #24
0
def test_type_comments_invalid_expression():
    module = builder.parse('''
    a, b = [1, 2, 3] # type: something completely invalid
    a, b = [1, 2, 3] # typeee: 2*+4
    a, b = [1, 2, 3] # type: List[int
    ''')
    for node in module.body:
        assert node.type_annotation is None
 def test_two_future_imports(self):
     mod = builder.parse(
         """
         from __future__ import print_function
         from __future__ import absolute_import
         """
     )
     self.assertEqual(set(["print_function", "absolute_import"]), mod.future_imports)
예제 #26
0
    def test_as_string(self):
        body = dedent("""
        from abc import ABCMeta 
        class Test(metaclass=ABCMeta): pass""")
        astroid = builder.parse(body)
        klass = astroid.body[1]

        self.assertEqual(klass.as_string(),
                         '\n\nclass Test(metaclass=ABCMeta):\n    pass\n')
예제 #27
0
 def test_yield_from_as_string(self):
     body = dedent("""
     def func():
         (yield from iter([1, 2]))
         value = (yield from other())
     """)
     astroid = builder.parse(body)
     func = astroid.body[0]
     self.assertEqual(func.as_string().strip(), body.strip())
예제 #28
0
    def test_multiprocessing_manager(self):
        # Test that we have the proper attributes
        # for a multiprocessing.managers.SyncManager
        module = builder.parse("""
        import multiprocessing
        manager = multiprocessing.Manager()
        queue = manager.Queue()
        joinable_queue = manager.JoinableQueue()
        event = manager.Event()
        rlock = manager.RLock()
        bounded_semaphore = manager.BoundedSemaphore()
        condition = manager.Condition()
        barrier = manager.Barrier()
        pool = manager.Pool()
        list = manager.list()
        dict = manager.dict()
        value = manager.Value()
        array = manager.Array()
        namespace = manager.Namespace()
        """)
        queue = next(module['queue'].infer())
        self.assertEqual(queue.qname(),
                         "{}.Queue".format(six.moves.queue.__name__))

        joinable_queue = next(module['joinable_queue'].infer())
        self.assertEqual(joinable_queue.qname(),
                         "{}.Queue".format(six.moves.queue.__name__))

        event = next(module['event'].infer())
        event_name = "threading.{}".format("Event" if six.PY3 else "_Event")
        self.assertEqual(event.qname(), event_name)

        rlock = next(module['rlock'].infer())
        rlock_name = "threading._RLock"
        self.assertEqual(rlock.qname(), rlock_name)

        bounded_semaphore = next(module['bounded_semaphore'].infer())
        semaphore_name = "threading.{}".format(
            "BoundedSemaphore" if six.PY3 else "_BoundedSemaphore")
        self.assertEqual(bounded_semaphore.qname(), semaphore_name)

        pool = next(module['pool'].infer())
        pool_name = "multiprocessing.pool.Pool"
        self.assertEqual(pool.qname(), pool_name)

        for attr in ('list', 'dict'):
            obj = next(module[attr].infer())
            self.assertEqual(obj.qname(),
                             "{}.{}".format(bases.BUILTINS, attr))

        array = next(module['array'].infer())
        self.assertEqual(array.qname(), "array.array")

        manager = next(module['manager'].infer())
        # Verify that we have these attributes
        self.assertTrue(manager.getattr('start'))
        self.assertTrue(manager.getattr('shutdown'))
예제 #29
0
 def test_yield_from_is_generator(self):
     body = dedent("""
     def func():
         yield from iter([1, 2])
     """)
     astroid = builder.parse(body)
     func = astroid.body[0]
     self.assertIsInstance(func, FunctionDef)
     self.assertTrue(func.is_generator())
 def test_gen_expr_var_scope(self):
     data = "l = list(n for n in range(10))\n"
     astroid = builder.parse(data, __name__)
     # n unavailable outside gen expr scope
     self.assertNotIn("n", astroid)
     # test n is inferable anyway
     n = test_utils.get_name_node(astroid, "n")
     self.assertIsNot(n.scope(), astroid)
     self.assertEqual([i.__class__ for i in n.infer()], [util.Uninferable.__class__])
예제 #31
0
 def test_except_var_after_block_single(self) -> None:
     """When the variable bound to an exception in an except clause, it is NOT returned
     when that variable is used after the except block.
     """
     code = """
         try:
             1 / 0
         except NameError as e:
             pass
         print(e)
     """
     astroid = builder.parse(code)
     x_name = [
         n for n in astroid.nodes_of_class(nodes.Name) if n.name == "e"
     ][0]
     _, stmts = x_name.lookup("e")
     self.assertEqual(len(stmts), 0)
예제 #32
0
def _multiprocessing_managers_transform():
    return parse("""
    import array
    import threading
    import multiprocessing.pool as pool
    import queue

    class Namespace(object):
        pass

    class Value(object):
        def __init__(self, typecode, value, lock=True):
            self._typecode = typecode
            self._value = value
        def get(self):
            return self._value
        def set(self, value):
            self._value = value
        def __repr__(self):
            return '%s(%r, %r)'%(type(self).__name__, self._typecode, self._value)
        value = property(get, set)

    def Array(typecode, sequence, lock=True):
        return array.array(typecode, sequence)

    class SyncManager(object):
        Queue = JoinableQueue = queue.Queue
        Event = threading.Event
        RLock = threading.RLock
        BoundedSemaphore = threading.BoundedSemaphore
        Condition = threading.Condition
        Barrier = threading.Barrier
        Pool = pool.Pool
        list = list
        dict = dict
        Value = Value
        Array = Array
        Namespace = Namespace
        __enter__ = lambda self: self
        __exit__ = lambda *args: args

        def start(self, initializer=None, initargs=None):
            pass
        def shutdown(self):
            pass
    """)
예제 #33
0
def test_type_comments_invalid_function_comments():
    module = builder.parse(
        """
    def func():
        # type: something completely invalid
        pass
    def func1():
        # typeee: 2*+4
        pass
    def func2():
        # type: List[int
        pass
    """
    )
    for node in module.body:
        assert node.type_comment_returns is None
        assert node.type_comment_args is None
예제 #34
0
 def test_except_var_in_block(self) -> None:
     """When the variable bound to an exception in an except clause, it is returned
     when that variable is used inside the except block.
     """
     code = """
         try:
             1 / 0
         except ZeroDivisionError as e:
             print(e)
     """
     astroid = builder.parse(code)
     x_name = [
         n for n in astroid.nodes_of_class(nodes.Name) if n.name == "e"
     ][0]
     _, stmts = x_name.lookup("e")
     self.assertEqual(len(stmts), 1)
     self.assertEqual(stmts[0].lineno, 4)
예제 #35
0
 def test_linenumbering(self):
     ast = builder.parse('''
         def func(a,
             b): pass
         x = lambda x: None
     ''')
     self.assertEqual(ast['func'].args.fromlineno, 2)
     self.assertFalse(ast['func'].args.is_statement)
     xlambda = next(ast['x'].infer())
     self.assertEqual(xlambda.args.fromlineno, 4)
     self.assertEqual(xlambda.args.tolineno, 4)
     self.assertFalse(xlambda.args.is_statement)
     if sys.version_info < (3, 0):
         self.assertEqual(ast['func'].args.tolineno, 3)
     else:
         self.skipTest('FIXME  http://bugs.python.org/issue10445 '
                       '(no line number on function args)')
예제 #36
0
 def test_loopvar_hiding(self):
     astroid = builder.parse(
         """
         x = 10
         for x in range(5):
             print (x)
         if x > 0:
             print ('#' * x)
     """, __name__)
     xnames = [
         n for n in astroid.nodes_of_class(nodes.Name) if n.name == 'x'
     ]
     # inside the loop, only one possible assignment
     self.assertEqual(len(xnames[0].lookup('x')[1]), 1)
     # outside the loop, two possible assignments
     self.assertEqual(len(xnames[1].lookup('x')[1]), 2)
     self.assertEqual(len(xnames[2].lookup('x')[1]), 2)
예제 #37
0
    def test_no_super_getattr(self):
        # This is a test for issue
        # https://bitbucket.org/logilab/astroid/issue/91, which tests
        # that UnboundMethod doesn't call super when doing .getattr.

        ast = builder.parse("""
        class A(object):
            def test(self):
                pass
        meth = A.test
        """)
        node = next(ast["meth"].infer())
        with self.assertRaises(exceptions.AttributeInferenceError):
            node.getattr("__missssing__")
        name = node.getattr("__name__")[0]
        self.assertIsInstance(name, nodes.Const)
        self.assertEqual(name.value, "test")
예제 #38
0
    def test_enum_multiple_base_classes(self):
        module = builder.parse("""
        import enum

        class Mixin:
            pass

        class MyEnum(Mixin, enum.Enum):
            one = 1
        """)
        enumeration = next(module['MyEnum'].infer())
        one = enumeration['one']

        clazz = one.getattr('__class__')[0]
        self.assertTrue(
            clazz.is_subtype_of('.Mixin'),
            'Enum instance should share base classes with generating class')
예제 #39
0
    def test_generator_attributes(self):
        tree = builder.parse(
            """
            def count():
                "test"
                yield 0

            iterer = count()
            num = iterer.next()
        """
        )
        next_node = tree.body[2].value.func
        gener = next_node.expr.inferred()[0]
        self.assertIsInstance(gener.getattr("__next__")[0], nodes.FunctionDef)
        self.assertIsInstance(gener.getattr("send")[0], nodes.FunctionDef)
        self.assertIsInstance(gener.getattr("throw")[0], nodes.FunctionDef)
        self.assertIsInstance(gener.getattr("close")[0], nodes.FunctionDef)
예제 #40
0
 def test_dict_comp_nested(self) -> None:
     astroid = builder.parse(
         """
         x = {i: {i: j for j in range(20)}
              for i in range(10)}
         x3 = [{i + j for j in range(20)}  # Can't do nested sets
               for i in range(10)]
     """,
         __name__,
     )
     xnames = [
         n for n in astroid.nodes_of_class(nodes.Name) if n.name == "i"
     ]
     self.assertEqual(len(xnames[0].lookup("i")[1]), 1)
     self.assertEqual(xnames[0].lookup("i")[1][0].lineno, 3)
     self.assertEqual(len(xnames[1].lookup("i")[1]), 1)
     self.assertEqual(xnames[1].lookup("i")[1][0].lineno, 3)
예제 #41
0
def infer_dataclass_field_call(
    node: Call, ctx: Optional[context.InferenceContext] = None
) -> Generator:
    """Inference tip for dataclass field calls."""
    if not isinstance(node.parent, (AnnAssign, Assign)):
        raise UseInferenceDefault
    result = _get_field_default(node)
    if not result:
        yield Uninferable
    else:
        default_type, default = result
        if default_type == "default":
            yield from default.infer(context=ctx)
        else:
            new_call = parse(default.as_string()).body[0].value
            new_call.parent = node.parent
            yield from new_call.infer(context=ctx)
예제 #42
0
def test_get_children_order():
    class OrderVisitor:
        def __init__(self):
            for node_class in nodes.ALL_NODE_CLASSES:
                visit_name = 'visit_' + node_class.__name__.lower()
                self.__dict__[visit_name] = self.visit

            self.position = (0, 0)

        def visit(self, node):
            if (isinstance(node, node_classes.BinOp)
                    and (isinstance(node.left, node_classes.BinOp)
                         or isinstance(node.right, node_classes.BinOp))):
                # The outer BinOp in nested BinOps has incorrect col_offset
                # at the col_offset of the operator
                return

            if isinstance(node, node_classes.ExceptHandler):
                # Exception handler name node has incorrect col_offset of 0
                return

            # All other node classes have correct positions so check they
            # are yielded in position order
            for child in node.get_children():
                if child.lineno is not None:
                    position = (child.lineno, child.col_offset)
                    assert self.position <= position, child
                    self.position = position

                child.accept(self)

    ast = builder.parse('''
    def func(a: bool, b=1, *c: str, d: str, e=2, **kwargs: int):
        return b if a else e

    a = 1 + 2 + 3

    try:
      func()
    except Exception as e:
      pass
    ''')
    ast.accept(OrderVisitor())

    for module in ['data/module.py', 'data/module2.py']:
        resources.build_file(module).accept(OrderVisitor())
예제 #43
0
 def test_if_assign(self) -> None:
     """Assignment in if statement is added to lookup results, but does not replace
     prior assignments.
     """
     code = """
         def f(b):
             x = 10
             if b:
                 x = 100
             print(x)
     """
     astroid = builder.parse(code)
     x_name = [
         n for n in astroid.nodes_of_class(nodes.Name) if n.name == "x"
     ][0]
     _, stmts = x_name.lookup("x")
     self.assertEqual(len(stmts), 2)
     self.assertCountEqual([stmt.lineno for stmt in stmts], [3, 5])
예제 #44
0
 def test_except_assign_in_block(self) -> None:
     """When a variable is assigned in an except block, it is returned
     when that variable is used in the except block.
     """
     code = """
         try:
             1 / 0
         except ZeroDivisionError as e:
             x = 10
             print(x)
     """
     astroid = builder.parse(code)
     x_name = [
         n for n in astroid.nodes_of_class(nodes.Name) if n.name == "x"
     ][0]
     _, stmts = x_name.lookup("x")
     self.assertEqual(len(stmts), 1)
     self.assertEqual(stmts[0].lineno, 5)
예제 #45
0
    def test_generator_attributes(self):
        tree = builder.parse("""
            def count():
                "test"
                yield 0

            iterer = count()
            num = iterer.next()
        """)
        next_node = tree.body[2].value.func
        gener = next_node.expr.inferred()[0]
        if sys.version_info < (3, 0):
            self.assertIsInstance(gener.getattr('next')[0], nodes.FunctionDef)
        else:
            self.assertIsInstance(gener.getattr('__next__')[0], nodes.FunctionDef)
        self.assertIsInstance(gener.getattr('send')[0], nodes.FunctionDef)
        self.assertIsInstance(gener.getattr('throw')[0], nodes.FunctionDef)
        self.assertIsInstance(gener.getattr('close')[0], nodes.FunctionDef)
예제 #46
0
 def test_try_finally_25_lineno(self):
     astroid = builder.parse(
         """
         try:
           print (a)
         except:
           pass
         finally:
           print ("bouh")
         """,
         __name__,
     )
     try_ = astroid.body[0]
     self.assertEqual(try_.fromlineno, 2)
     self.assertEqual(try_.tolineno, 7)
     self.assertEqual(try_.blockstart_tolineno, 2)
     self.assertEqual(try_.finalbody[0].fromlineno, 7)  # XXX
     self.assertEqual(try_.finalbody[0].tolineno, 7)
예제 #47
0
 def test_decorated_function_lineno(self):
     astroid = builder.parse('''
         @decorator
         def function(
             arg):
             print (arg)
         ''', __name__)
     function = astroid['function']
     # XXX discussable, but that's what is expected by pylint right now
     self.assertEqual(function.fromlineno, 3)
     self.assertEqual(function.tolineno, 5)
     self.assertEqual(function.decorators.fromlineno, 2)
     self.assertEqual(function.decorators.tolineno, 2)
     if sys.version_info < (3, 0):
         self.assertEqual(function.blockstart_tolineno, 4)
     else:
         self.skipTest('FIXME  http://bugs.python.org/issue10445 '
                       '(no line number on function args)')
예제 #48
0
 def test_list_comps(self):
     astroid = builder.parse(
         """
         print ([ i for i in range(10) ])
         print ([ i for i in range(10) ])
         print ( list( i for i in range(10) ) )
     """,
         __name__,
     )
     xnames = [
         n for n in astroid.nodes_of_class(nodes.Name) if n.name == "i"
     ]
     self.assertEqual(len(xnames[0].lookup("i")[1]), 1)
     self.assertEqual(xnames[0].lookup("i")[1][0].lineno, 2)
     self.assertEqual(len(xnames[1].lookup("i")[1]), 1)
     self.assertEqual(xnames[1].lookup("i")[1][0].lineno, 3)
     self.assertEqual(len(xnames[2].lookup("i")[1]), 1)
     self.assertEqual(xnames[2].lookup("i")[1][0].lineno, 4)
예제 #49
0
 def test_linenumbering(self):
     ast = builder.parse(
         """
         def func(a,
             b): pass
         x = lambda x: None
     """
     )
     self.assertEqual(ast["func"].args.fromlineno, 2)
     self.assertFalse(ast["func"].args.is_statement)
     xlambda = next(ast["x"].infer())
     self.assertEqual(xlambda.args.fromlineno, 4)
     self.assertEqual(xlambda.args.tolineno, 4)
     self.assertFalse(xlambda.args.is_statement)
     self.skipTest(
         "FIXME  http://bugs.python.org/issue10445 "
         "(no line number on function args)"
     )
예제 #50
0
 def test_explicit___name__(self):
     code = '''
         class Pouet:
             __name__ = "pouet"
         p1 = Pouet()
         class PouetPouet(Pouet): pass
         p2 = Pouet()
         class NoName: pass
         p3 = NoName()
     '''
     astroid = builder.parse(code, __name__)
     p1 = next(astroid['p1'].infer())
     self.assertTrue(p1.getattr('__name__'))
     p2 = next(astroid['p2'].infer())
     self.assertTrue(p2.getattr('__name__'))
     self.assertTrue(astroid['NoName'].getattr('__name__'))
     p3 = next(astroid['p3'].infer())
     self.assertRaises(exceptions.AttributeInferenceError, p3.getattr,
                       '__name__')
예제 #51
0
    def test_not_exclusive(self):
        module = builder.parse(
            """
        x = 10
        for x in range(5):
            print (x)

        if x > 0:
            print ('#' * x)
        """, __name__, __file__)
        xass1 = module.locals['x'][0]
        assert xass1.lineno == 2
        xnames = [
            n for n in module.nodes_of_class(nodes.Name) if n.name == 'x'
        ]
        assert len(xnames) == 3
        assert xnames[1].lineno == 6
        self.assertEqual(node_classes.are_exclusive(xass1, xnames[1]), False)
        self.assertEqual(node_classes.are_exclusive(xass1, xnames[2]), False)
예제 #52
0
 def test_if_assigns_same_branch(self) -> None:
     """When if branch has multiple assignment statements, only the last one
     is added.
     """
     code = """
         def f(b):
             x = 10
             if b:
                 x = 100
                 x = 1000
             print(x)
     """
     astroid = builder.parse(code)
     x_name = [
         n for n in astroid.nodes_of_class(nodes.Name) if n.name == "x"
     ][0]
     _, stmts = x_name.lookup("x")
     self.assertEqual(len(stmts), 2)
     self.assertCountEqual([stmt.lineno for stmt in stmts], [3, 6])
예제 #53
0
 def test_try_except_lineno(self):
     astroid = builder.parse('''
         try:
           print (a)
         except:
           pass
         else:
           print ("bouh")
         ''', __name__)
     try_ = astroid.body[0]
     self.assertEqual(try_.fromlineno, 2)
     self.assertEqual(try_.tolineno, 7)
     self.assertEqual(try_.blockstart_tolineno, 2)
     self.assertEqual(try_.orelse[0].fromlineno, 7) # XXX
     self.assertEqual(try_.orelse[0].tolineno, 7)
     hdlr = try_.handlers[0]
     self.assertEqual(hdlr.fromlineno, 4)
     self.assertEqual(hdlr.tolineno, 5)
     self.assertEqual(hdlr.blockstart_tolineno, 4)
예제 #54
0
    def test_global_delete(self):
        code = """
            def run2():
                f = Frobble()

            class Frobble:
                pass
            Frobble.mumble = True

            del Frobble

            def run1():
                f = Frobble()
        """
        astroid = builder.parse(code, __name__)
        stmts = astroid["run2"].lookup("Frobbel")[1]
        self.assertEqual(len(stmts), 0)
        stmts = astroid["run1"].lookup("Frobbel")[1]
        self.assertEqual(len(stmts), 0)
예제 #55
0
    def test_static_method_lookup(self) -> None:
        code = """
            class FileA:
                @staticmethod
                def funcA():
                    return 4


            class Test:
                FileA = [1,2,3]

                def __init__(self):
                    print (FileA.funcA())
        """
        astroid = builder.parse(code, __name__)
        it = astroid["Test"]["__init__"].ilookup("FileA")
        obj = next(it)
        self.assertIsInstance(obj, nodes.ClassDef)
        self.assertRaises(StopIteration, functools.partial(next, it))
예제 #56
0
    def test_static_method_lookup(self):
        code = '''
            class FileA:
                @staticmethod
                def funcA():
                    return 4


            class Test:
                FileA = [1,2,3]

                def __init__(self):
                    print (FileA.funcA())
        '''
        astroid = builder.parse(code, __name__)
        it = astroid['Test']['__init__'].ilookup('FileA')
        obj = next(it)
        self.assertIsInstance(obj, nodes.ClassDef)
        self.assertRaises(StopIteration, functools.partial(next, it))
예제 #57
0
    def test_global_delete(self):
        code = '''
            def run2():
                f = Frobble()

            class Frobble:
                pass
            Frobble.mumble = True

            del Frobble

            def run1():
                f = Frobble()
        '''
        astroid = builder.parse(code, __name__)
        stmts = astroid['run2'].lookup('Frobbel')[1]
        self.assertEqual(len(stmts), 0)
        stmts = astroid['run1'].lookup('Frobbel')[1]
        self.assertEqual(len(stmts), 0)
예제 #58
0
    def test_dict_comps(self):
        astroid = builder.parse(
            """
            print ({ i: j for i in range(10) for j in range(10) })
            print ({ i: j for i in range(10) for j in range(10) })
        """,
            __name__,
        )
        xnames = [n for n in astroid.nodes_of_class(nodes.Name) if n.name == "i"]
        self.assertEqual(len(xnames[0].lookup("i")[1]), 1)
        self.assertEqual(xnames[0].lookup("i")[1][0].lineno, 2)
        self.assertEqual(len(xnames[1].lookup("i")[1]), 1)
        self.assertEqual(xnames[1].lookup("i")[1][0].lineno, 3)

        xnames = [n for n in astroid.nodes_of_class(nodes.Name) if n.name == "j"]
        self.assertEqual(len(xnames[0].lookup("i")[1]), 1)
        self.assertEqual(xnames[0].lookup("i")[1][0].lineno, 2)
        self.assertEqual(len(xnames[1].lookup("i")[1]), 1)
        self.assertEqual(xnames[1].lookup("i")[1][0].lineno, 3)
예제 #59
0
 def test_globals(self):
     data = '''
         CSTE = 1
         def update_global():
             global CSTE
             CSTE += 1
         def global_no_effect():
             global CSTE2
             print (CSTE)
     '''
     astroid = builder.parse(data, __name__)
     self.assertEqual(len(astroid.getattr('CSTE')), 2)
     self.assertIsInstance(astroid.getattr('CSTE')[0], nodes.AssignName)
     self.assertEqual(astroid.getattr('CSTE')[0].fromlineno, 2)
     self.assertEqual(astroid.getattr('CSTE')[1].fromlineno, 6)
     with self.assertRaises(exceptions.AttributeInferenceError):
         astroid.getattr('CSTE2')
     with self.assertRaises(exceptions.InferenceError):
         next(astroid['global_no_effect'].ilookup('CSTE2'))
예제 #60
0
    def test_explicit___name__(self):
        code = """
            class Pouet:
                __name__ = "pouet"
            p1 = Pouet()

            class PouetPouet(Pouet): pass
            p2 = Pouet()

            class NoName: pass
            p3 = NoName()
        """
        astroid = builder.parse(code, __name__)
        p1 = next(astroid["p1"].infer())
        self.assertTrue(p1.getattr("__name__"))
        p2 = next(astroid["p2"].infer())
        self.assertTrue(p2.getattr("__name__"))
        self.assertTrue(astroid["NoName"].getattr("__name__"))
        p3 = next(astroid["p3"].infer())
        self.assertRaises(exceptions.AttributeInferenceError, p3.getattr, "__name__")