| # copyright 2003-2011 LOGILAB S.A. (Paris, FRANCE), all rights reserved. |
| # contact http://www.logilab.fr/ -- mailto:contact@logilab.fr |
| # copyright 2003-2010 Sylvain Thenault, all rights reserved. |
| # contact mailto:thenault@gmail.com |
| # |
| # This file is part of logilab-astng. |
| # |
| # logilab-astng is free software: you can redistribute it and/or modify it |
| # under the terms of the GNU Lesser General Public License as published by the |
| # Free Software Foundation, either version 2.1 of the License, or (at your |
| # option) any later version. |
| # |
| # logilab-astng is distributed in the hope that it will be useful, but |
| # WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| # FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License |
| # for more details. |
| # |
| # You should have received a copy of the GNU Lesser General Public License along |
| # with logilab-astng. If not, see <http://www.gnu.org/licenses/>. |
| """This module contains the classes for "scoped" node, i.e. which are opening a |
| new local scope in the language definition : Module, Class, Function (and |
| Lambda, GenExpr, DictComp and SetComp to some extent). |
| """ |
| from __future__ import with_statement |
| |
| __doctype__ = "restructuredtext en" |
| |
| import sys |
| from itertools import chain |
| |
| from logilab.common.compat import builtins |
| from logilab.common.decorators import cached |
| |
| from logilab.astng import BUILTINS_MODULE |
| from logilab.astng.exceptions import NotFoundError, NoDefault, \ |
| ASTNGBuildingException, InferenceError |
| from logilab.astng.node_classes import Const, DelName, DelAttr, \ |
| Dict, From, List, Name, Pass, Raise, Return, Tuple, Yield, \ |
| are_exclusive, LookupMixIn, const_factory as cf, unpack_infer |
| from logilab.astng.bases import NodeNG, InferenceContext, Instance,\ |
| YES, Generator, UnboundMethod, BoundMethod, _infer_stmts, copy_context, \ |
| BUILTINS_NAME |
| from logilab.astng.mixins import FilterStmtsMixin |
| from logilab.astng.bases import Statement |
| from logilab.astng.manager import ASTNGManager |
| |
| |
| def remove_nodes(func, cls): |
| def wrapper(*args, **kwargs): |
| nodes = [n for n in func(*args, **kwargs) if not isinstance(n, cls)] |
| if not nodes: |
| raise NotFoundError() |
| return nodes |
| return wrapper |
| |
| |
| def function_to_method(n, klass): |
| if isinstance(n, Function): |
| if n.type == 'classmethod': |
| return BoundMethod(n, klass) |
| if n.type != 'staticmethod': |
| return UnboundMethod(n) |
| return n |
| |
| def std_special_attributes(self, name, add_locals=True): |
| if add_locals: |
| locals = self.locals |
| else: |
| locals = {} |
| if name == '__name__': |
| return [cf(self.name)] + locals.get(name, []) |
| if name == '__doc__': |
| return [cf(self.doc)] + locals.get(name, []) |
| if name == '__dict__': |
| return [Dict()] + locals.get(name, []) |
| raise NotFoundError(name) |
| |
| MANAGER = ASTNGManager() |
| def builtin_lookup(name): |
| """lookup a name into the builtin module |
| return the list of matching statements and the astng for the builtin |
| module |
| """ |
| builtin_astng = MANAGER.astng_from_module(builtins) |
| if name == '__dict__': |
| return builtin_astng, () |
| try: |
| stmts = builtin_astng.locals[name] |
| except KeyError: |
| stmts = () |
| return builtin_astng, stmts |
| |
| |
| # TODO move this Mixin to mixins.py; problem: 'Function' in _scope_lookup |
| class LocalsDictNodeNG(LookupMixIn, NodeNG): |
| """ this class provides locals handling common to Module, Function |
| and Class nodes, including a dict like interface for direct access |
| to locals information |
| """ |
| |
| # attributes below are set by the builder module or by raw factories |
| |
| # dictionary of locals with name as key and node defining the local as |
| # value |
| |
| def qname(self): |
| """return the 'qualified' name of the node, eg module.name, |
| module.class.name ... |
| """ |
| if self.parent is None: |
| return self.name |
| return '%s.%s' % (self.parent.frame().qname(), self.name) |
| |
| def frame(self): |
| """return the first parent frame node (i.e. Module, Function or Class) |
| """ |
| return self |
| |
| def scope(self): |
| """return the first node defining a new scope (i.e. Module, |
| Function, Class, Lambda but also GenExpr, DictComp and SetComp) |
| """ |
| return self |
| |
| |
| def _scope_lookup(self, node, name, offset=0): |
| """XXX method for interfacing the scope lookup""" |
| try: |
| stmts = node._filter_stmts(self.locals[name], self, offset) |
| except KeyError: |
| stmts = () |
| if stmts: |
| return self, stmts |
| if self.parent: # i.e. not Module |
| # nested scope: if parent scope is a function, that's fine |
| # else jump to the module |
| pscope = self.parent.scope() |
| if not pscope.is_function: |
| pscope = pscope.root() |
| return pscope.scope_lookup(node, name) |
| return builtin_lookup(name) # Module |
| |
| |
| |
| def set_local(self, name, stmt): |
| """define <name> in locals (<stmt> is the node defining the name) |
| if the node is a Module node (i.e. has globals), add the name to |
| globals |
| |
| if the name is already defined, ignore it |
| """ |
| #assert not stmt in self.locals.get(name, ()), (self, stmt) |
| self.locals.setdefault(name, []).append(stmt) |
| |
| __setitem__ = set_local |
| |
| def _append_node(self, child): |
| """append a child, linking it in the tree""" |
| self.body.append(child) |
| child.parent = self |
| |
| def add_local_node(self, child_node, name=None): |
| """append a child which should alter locals to the given node""" |
| if name != '__class__': |
| # add __class__ node as a child will cause infinite recursion later! |
| self._append_node(child_node) |
| self.set_local(name or child_node.name, child_node) |
| |
| |
| def __getitem__(self, item): |
| """method from the `dict` interface returning the first node |
| associated with the given name in the locals dictionary |
| |
| :type item: str |
| :param item: the name of the locally defined object |
| :raises KeyError: if the name is not defined |
| """ |
| return self.locals[item][0] |
| |
| def __iter__(self): |
| """method from the `dict` interface returning an iterator on |
| `self.keys()` |
| """ |
| return iter(self.keys()) |
| |
| def keys(self): |
| """method from the `dict` interface returning a tuple containing |
| locally defined names |
| """ |
| return self.locals.keys() |
| |
| def values(self): |
| """method from the `dict` interface returning a tuple containing |
| locally defined nodes which are instance of `Function` or `Class` |
| """ |
| return [self[key] for key in self.keys()] |
| |
| def items(self): |
| """method from the `dict` interface returning a list of tuple |
| containing each locally defined name with its associated node, |
| which is an instance of `Function` or `Class` |
| """ |
| return zip(self.keys(), self.values()) |
| |
| |
| def __contains__(self, name): |
| return name in self.locals |
| has_key = __contains__ |
| |
| # Module ##################################################################### |
| |
| class Module(LocalsDictNodeNG): |
| _astng_fields = ('body',) |
| |
| fromlineno = 0 |
| lineno = 0 |
| |
| # attributes below are set by the builder module or by raw factories |
| |
| # the file from which as been extracted the astng representation. It may |
| # be None if the representation has been built from a built-in module |
| file = None |
| # the module name |
| name = None |
| # boolean for astng built from source (i.e. ast) |
| pure_python = None |
| # boolean for package module |
| package = None |
| # dictionary of globals with name as key and node defining the global |
| # as value |
| globals = None |
| |
| # names of python special attributes (handled by getattr impl.) |
| special_attributes = set(('__name__', '__doc__', '__file__', '__path__', |
| '__dict__')) |
| # names of module attributes available through the global scope |
| scope_attrs = set(('__name__', '__doc__', '__file__', '__path__')) |
| |
| def __init__(self, name, doc, pure_python=True): |
| self.name = name |
| self.doc = doc |
| self.pure_python = pure_python |
| self.locals = self.globals = {} |
| self.body = [] |
| |
| @property |
| def file_stream(self): |
| if self.file is not None: |
| return file(self.file) |
| return None |
| |
| def block_range(self, lineno): |
| """return block line numbers. |
| |
| start from the beginning whatever the given lineno |
| """ |
| return self.fromlineno, self.tolineno |
| |
| def scope_lookup(self, node, name, offset=0): |
| if name in self.scope_attrs and not name in self.locals: |
| try: |
| return self, self.getattr(name) |
| except NotFoundError: |
| return self, () |
| return self._scope_lookup(node, name, offset) |
| |
| def pytype(self): |
| return '%s.module' % BUILTINS_MODULE |
| |
| def display_type(self): |
| return 'Module' |
| |
| def getattr(self, name, context=None, ignore_locals=False): |
| if name in self.special_attributes: |
| if name == '__file__': |
| return [cf(self.file)] + self.locals.get(name, []) |
| if name == '__path__' and self.package: |
| return [List()] + self.locals.get(name, []) |
| return std_special_attributes(self, name) |
| if not ignore_locals and name in self.locals: |
| return self.locals[name] |
| if self.package: |
| try: |
| return [self.import_module(name, relative_only=True)] |
| except ASTNGBuildingException: |
| raise NotFoundError(name) |
| except Exception:# XXX pylint tests never pass here; do we need it? |
| import traceback |
| traceback.print_exc() |
| raise NotFoundError(name) |
| getattr = remove_nodes(getattr, DelName) |
| |
| def igetattr(self, name, context=None): |
| """inferred getattr""" |
| # set lookup name since this is necessary to infer on import nodes for |
| # instance |
| context = copy_context(context) |
| context.lookupname = name |
| try: |
| return _infer_stmts(self.getattr(name, context), context, frame=self) |
| except NotFoundError: |
| raise InferenceError(name) |
| |
| def fully_defined(self): |
| """return True if this module has been built from a .py file |
| and so contains a complete representation including the code |
| """ |
| return self.file is not None and self.file.endswith('.py') |
| |
| def statement(self): |
| """return the first parent node marked as statement node |
| consider a module as a statement... |
| """ |
| return self |
| |
| def previous_sibling(self): |
| """module has no sibling""" |
| return |
| |
| def next_sibling(self): |
| """module has no sibling""" |
| return |
| |
| if sys.version_info < (2, 8): |
| def absolute_import_activated(self): |
| for stmt in self.locals.get('absolute_import', ()): |
| if isinstance(stmt, From) and stmt.modname == '__future__': |
| return True |
| return False |
| else: |
| absolute_import_activated = lambda self: True |
| |
| def import_module(self, modname, relative_only=False, level=None): |
| """import the given module considering self as context""" |
| if relative_only and level is None: |
| level = 0 |
| absmodname = self.relative_to_absolute_name(modname, level) |
| try: |
| return MANAGER.astng_from_module_name(absmodname) |
| except ASTNGBuildingException: |
| # we only want to import a sub module or package of this module, |
| # skip here |
| if relative_only: |
| raise |
| return MANAGER.astng_from_module_name(modname) |
| |
| def relative_to_absolute_name(self, modname, level): |
| """return the absolute module name for a relative import. |
| |
| The relative import can be implicit or explicit. |
| """ |
| # XXX this returns non sens when called on an absolute import |
| # like 'pylint.checkers.logilab.astng.utils' |
| # XXX doesn't return absolute name if self.name isn't absolute name |
| if self.absolute_import_activated() and level is None: |
| return modname |
| if level: |
| if self.package: |
| level = level - 1 |
| package_name = self.name.rsplit('.', level)[0] |
| elif self.package: |
| package_name = self.name |
| else: |
| package_name = self.name.rsplit('.', 1)[0] |
| if package_name: |
| if not modname: |
| return package_name |
| return '%s.%s' % (package_name, modname) |
| return modname |
| |
| |
| def wildcard_import_names(self): |
| """return the list of imported names when this module is 'wildcard |
| imported' |
| |
| It doesn't include the '__builtins__' name which is added by the |
| current CPython implementation of wildcard imports. |
| """ |
| # take advantage of a living module if it exists |
| try: |
| living = sys.modules[self.name] |
| except KeyError: |
| pass |
| else: |
| try: |
| return living.__all__ |
| except AttributeError: |
| return [name for name in living.__dict__.keys() |
| if not name.startswith('_')] |
| # else lookup the astng |
| # |
| # We separate the different steps of lookup in try/excepts |
| # to avoid catching too many Exceptions |
| # However, we can not analyse dynamically constructed __all__ |
| try: |
| all = self['__all__'] |
| except KeyError: |
| return [name for name in self.keys() if not name.startswith('_')] |
| try: |
| explicit = all.assigned_stmts().next() |
| except InferenceError: |
| return [name for name in self.keys() if not name.startswith('_')] |
| except AttributeError: |
| # not an assignment node |
| # XXX infer? |
| return [name for name in self.keys() if not name.startswith('_')] |
| try: |
| # should be a Tuple/List of constant string / 1 string not allowed |
| return [const.value for const in explicit.elts] |
| except AttributeError: |
| return [name for name in self.keys() if not name.startswith('_')] |
| |
| |
| class ComprehensionScope(LocalsDictNodeNG): |
| def frame(self): |
| return self.parent.frame() |
| |
| scope_lookup = LocalsDictNodeNG._scope_lookup |
| |
| |
| class GenExpr(ComprehensionScope): |
| _astng_fields = ('elt', 'generators') |
| |
| def __init__(self): |
| self.locals = {} |
| self.elt = None |
| self.generators = [] |
| |
| |
| class DictComp(ComprehensionScope): |
| _astng_fields = ('key', 'value', 'generators') |
| |
| def __init__(self): |
| self.locals = {} |
| self.key = None |
| self.value = None |
| self.generators = [] |
| |
| |
| class SetComp(ComprehensionScope): |
| _astng_fields = ('elt', 'generators') |
| |
| def __init__(self): |
| self.locals = {} |
| self.elt = None |
| self.generators = [] |
| |
| |
| class _ListComp(NodeNG): |
| """class representing a ListComp node""" |
| _astng_fields = ('elt', 'generators') |
| elt = None |
| generators = None |
| |
| if sys.version_info >= (3, 0): |
| class ListComp(_ListComp, ComprehensionScope): |
| """class representing a ListComp node""" |
| def __init__(self): |
| self.locals = {} |
| else: |
| class ListComp(_ListComp): |
| """class representing a ListComp node""" |
| |
| # Function ################################################################### |
| |
| |
| class Lambda(LocalsDictNodeNG, FilterStmtsMixin): |
| _astng_fields = ('args', 'body',) |
| name = '<lambda>' |
| |
| # function's type, 'function' | 'method' | 'staticmethod' | 'classmethod' |
| type = 'function' |
| |
| def __init__(self): |
| self.locals = {} |
| self.args = [] |
| self.body = [] |
| |
| def pytype(self): |
| if 'method' in self.type: |
| return '%s.instancemethod' % BUILTINS_MODULE |
| return '%s.function' % BUILTINS_MODULE |
| |
| def display_type(self): |
| if 'method' in self.type: |
| return 'Method' |
| return 'Function' |
| |
| def callable(self): |
| return True |
| |
| def argnames(self): |
| """return a list of argument names""" |
| if self.args.args: # maybe None with builtin functions |
| names = _rec_get_names(self.args.args) |
| else: |
| names = [] |
| if self.args.vararg: |
| names.append(self.args.vararg) |
| if self.args.kwarg: |
| names.append(self.args.kwarg) |
| return names |
| |
| def infer_call_result(self, caller, context=None): |
| """infer what a function is returning when called""" |
| return self.body.infer(context) |
| |
| def scope_lookup(self, node, name, offset=0): |
| if node in self.args.defaults: |
| frame = self.parent.frame() |
| # line offset to avoid that def func(f=func) resolve the default |
| # value to the defined function |
| offset = -1 |
| else: |
| # check this is not used in function decorators |
| frame = self |
| return frame._scope_lookup(node, name, offset) |
| |
| |
| class Function(Statement, Lambda): |
| _astng_fields = ('decorators', 'args', 'body') |
| |
| special_attributes = set(('__name__', '__doc__', '__dict__')) |
| is_function = True |
| # attributes below are set by the builder module or by raw factories |
| blockstart_tolineno = None |
| decorators = None |
| |
| def __init__(self, name, doc): |
| self.locals = {} |
| self.args = [] |
| self.body = [] |
| self.decorators = None |
| self.name = name |
| self.doc = doc |
| self.extra_decorators = [] |
| self.instance_attrs = {} |
| |
| def set_line_info(self, lastchild): |
| self.fromlineno = self.lineno |
| # lineno is the line number of the first decorator, we want the def statement lineno |
| if self.decorators is not None: |
| self.fromlineno += len(self.decorators.nodes) |
| self.tolineno = lastchild.tolineno |
| self.blockstart_tolineno = self.args.tolineno |
| |
| def block_range(self, lineno): |
| """return block line numbers. |
| |
| start from the "def" position whatever the given lineno |
| """ |
| return self.fromlineno, self.tolineno |
| |
| def getattr(self, name, context=None): |
| """this method doesn't look in the instance_attrs dictionary since it's |
| done by an Instance proxy at inference time. |
| """ |
| if name == '__module__': |
| return [cf(self.root().qname())] |
| if name in self.instance_attrs: |
| return self.instance_attrs[name] |
| return std_special_attributes(self, name, False) |
| |
| def is_method(self): |
| """return true if the function node should be considered as a method""" |
| # check we are defined in a Class, because this is usually expected |
| # (e.g. pylint...) when is_method() return True |
| return self.type != 'function' and isinstance(self.parent.frame(), Class) |
| |
| def decoratornames(self): |
| """return a list of decorator qualified names""" |
| result = set() |
| decoratornodes = [] |
| if self.decorators is not None: |
| decoratornodes += self.decorators.nodes |
| decoratornodes += self.extra_decorators |
| for decnode in decoratornodes: |
| for infnode in decnode.infer(): |
| result.add(infnode.qname()) |
| return result |
| decoratornames = cached(decoratornames) |
| |
| def is_bound(self): |
| """return true if the function is bound to an Instance or a class""" |
| return self.type == 'classmethod' |
| |
| def is_abstract(self, pass_is_abstract=True): |
| """return true if the method is abstract |
| It's considered as abstract if the only statement is a raise of |
| NotImplementError, or, if pass_is_abstract, a pass statement |
| """ |
| for child_node in self.body: |
| if isinstance(child_node, Raise): |
| if child_node.raises_not_implemented(): |
| return True |
| if pass_is_abstract and isinstance(child_node, Pass): |
| return True |
| return False |
| # empty function is the same as function with a single "pass" statement |
| if pass_is_abstract: |
| return True |
| |
| def is_generator(self): |
| """return true if this is a generator function""" |
| # XXX should be flagged, not computed |
| try: |
| return self.nodes_of_class(Yield, skip_klass=Function).next() |
| except StopIteration: |
| return False |
| |
| def infer_call_result(self, caller, context=None): |
| """infer what a function is returning when called""" |
| if self.is_generator(): |
| yield Generator(self) |
| return |
| returns = self.nodes_of_class(Return, skip_klass=Function) |
| for returnnode in returns: |
| if returnnode.value is None: |
| yield Const(None) |
| else: |
| try: |
| for infered in returnnode.value.infer(context): |
| yield infered |
| except InferenceError: |
| yield YES |
| |
| |
| def _rec_get_names(args, names=None): |
| """return a list of all argument names""" |
| if names is None: |
| names = [] |
| for arg in args: |
| if isinstance(arg, Tuple): |
| _rec_get_names(arg.elts, names) |
| else: |
| names.append(arg.name) |
| return names |
| |
| |
| # Class ###################################################################### |
| |
| def _class_type(klass, ancestors=None): |
| """return a Class node type to differ metaclass, interface and exception |
| from 'regular' classes |
| """ |
| # XXX we have to store ancestors in case we have a ancestor loop |
| if klass._type is not None: |
| return klass._type |
| if klass.name == 'type': |
| klass._type = 'metaclass' |
| elif klass.name.endswith('Interface'): |
| klass._type = 'interface' |
| elif klass.name.endswith('Exception'): |
| klass._type = 'exception' |
| else: |
| if ancestors is None: |
| ancestors = set() |
| if klass in ancestors: |
| # XXX we are in loop ancestors, and have found no type |
| klass._type = 'class' |
| return 'class' |
| ancestors.add(klass) |
| # print >> sys.stderr, '_class_type', repr(klass) |
| for base in klass.ancestors(recurs=False): |
| if _class_type(base, ancestors) != 'class': |
| klass._type = base.type |
| break |
| if klass._type is None: |
| klass._type = 'class' |
| return klass._type |
| |
| def _iface_hdlr(iface_node): |
| """a handler function used by interfaces to handle suspicious |
| interface nodes |
| """ |
| return True |
| |
| |
| class Class(Statement, LocalsDictNodeNG, FilterStmtsMixin): |
| |
| # some of the attributes below are set by the builder module or |
| # by a raw factories |
| |
| # a dictionary of class instances attributes |
| _astng_fields = ('decorators', 'bases', 'body') # name |
| |
| decorators = None |
| special_attributes = set(('__name__', '__doc__', '__dict__', '__module__', |
| '__bases__', '__mro__', '__subclasses__')) |
| blockstart_tolineno = None |
| |
| _type = None |
| type = property(_class_type, |
| doc="class'type, possible values are 'class' | " |
| "'metaclass' | 'interface' | 'exception'") |
| |
| def __init__(self, name, doc): |
| self.instance_attrs = {} |
| self.locals = {} |
| self.bases = [] |
| self.body = [] |
| self.name = name |
| self.doc = doc |
| |
| def _newstyle_impl(self, context=None): |
| if context is None: |
| context = InferenceContext() |
| if self._newstyle is not None: |
| return self._newstyle |
| for base in self.ancestors(recurs=False, context=context): |
| if base._newstyle_impl(context): |
| self._newstyle = True |
| break |
| if self._newstyle is None: |
| self._newstyle = False |
| return self._newstyle |
| |
| _newstyle = None |
| newstyle = property(_newstyle_impl, |
| doc="boolean indicating if it's a new style class" |
| "or not") |
| |
| def set_line_info(self, lastchild): |
| self.fromlineno = self.lineno |
| self.blockstart_tolineno = self.bases and self.bases[-1].tolineno or self.fromlineno |
| if lastchild is not None: |
| self.tolineno = lastchild.tolineno |
| # else this is a class with only a docstring, then tolineno is (should be) already ok |
| |
| def block_range(self, lineno): |
| """return block line numbers. |
| |
| start from the "class" position whatever the given lineno |
| """ |
| return self.fromlineno, self.tolineno |
| |
| def pytype(self): |
| if self.newstyle: |
| return '%s.type' % BUILTINS_MODULE |
| return '%s.classobj' % BUILTINS_MODULE |
| |
| def display_type(self): |
| return 'Class' |
| |
| def callable(self): |
| return True |
| |
| def infer_call_result(self, caller, context=None): |
| """infer what a class is returning when called""" |
| yield Instance(self) |
| |
| def scope_lookup(self, node, name, offset=0): |
| if node in self.bases: |
| frame = self.parent.frame() |
| # line offset to avoid that class A(A) resolve the ancestor to |
| # the defined class |
| offset = -1 |
| else: |
| frame = self |
| return frame._scope_lookup(node, name, offset) |
| |
| # list of parent class as a list of string (i.e. names as they appear |
| # in the class definition) XXX bw compat |
| def basenames(self): |
| return [bnode.as_string() for bnode in self.bases] |
| basenames = property(basenames) |
| |
| def ancestors(self, recurs=True, context=None): |
| """return an iterator on the node base classes in a prefixed |
| depth first order |
| |
| :param recurs: |
| boolean indicating if it should recurse or return direct |
| ancestors only |
| """ |
| # FIXME: should be possible to choose the resolution order |
| # XXX inference make infinite loops possible here (see BaseTransformer |
| # manipulation in the builder module for instance) |
| yielded = set([self]) |
| if context is None: |
| context = InferenceContext() |
| for stmt in self.bases: |
| with context.restore_path(): |
| try: |
| for baseobj in stmt.infer(context): |
| if not isinstance(baseobj, Class): |
| # duh ? |
| continue |
| if baseobj in yielded: |
| continue # cf xxx above |
| yielded.add(baseobj) |
| yield baseobj |
| if recurs: |
| for grandpa in baseobj.ancestors(True, context): |
| if grandpa in yielded: |
| continue # cf xxx above |
| yielded.add(grandpa) |
| yield grandpa |
| except InferenceError: |
| # XXX log error ? |
| continue |
| |
| def local_attr_ancestors(self, name, context=None): |
| """return an iterator on astng representation of parent classes |
| which have <name> defined in their locals |
| """ |
| for astng in self.ancestors(context=context): |
| if name in astng: |
| yield astng |
| |
| def instance_attr_ancestors(self, name, context=None): |
| """return an iterator on astng representation of parent classes |
| which have <name> defined in their instance attribute dictionary |
| """ |
| for astng in self.ancestors(context=context): |
| if name in astng.instance_attrs: |
| yield astng |
| |
| def has_base(self, node): |
| return node in self.bases |
| |
| def local_attr(self, name, context=None): |
| """return the list of assign node associated to name in this class |
| locals or in its parents |
| |
| :raises `NotFoundError`: |
| if no attribute with this name has been find in this class or |
| its parent classes |
| """ |
| try: |
| return self.locals[name] |
| except KeyError: |
| # get if from the first parent implementing it if any |
| for class_node in self.local_attr_ancestors(name, context): |
| return class_node.locals[name] |
| raise NotFoundError(name) |
| local_attr = remove_nodes(local_attr, DelAttr) |
| |
| def instance_attr(self, name, context=None): |
| """return the astng nodes associated to name in this class instance |
| attributes dictionary and in its parents |
| |
| :raises `NotFoundError`: |
| if no attribute with this name has been find in this class or |
| its parent classes |
| """ |
| values = self.instance_attrs.get(name, []) |
| # get all values from parents |
| for class_node in self.instance_attr_ancestors(name, context): |
| values += class_node.instance_attrs[name] |
| if not values: |
| raise NotFoundError(name) |
| return values |
| instance_attr = remove_nodes(instance_attr, DelAttr) |
| |
| def instanciate_class(self): |
| """return Instance of Class node, else return self""" |
| return Instance(self) |
| |
| def getattr(self, name, context=None): |
| """this method doesn't look in the instance_attrs dictionary since it's |
| done by an Instance proxy at inference time. |
| |
| It may return a YES object if the attribute has not been actually |
| found but a __getattr__ or __getattribute__ method is defined |
| """ |
| values = self.locals.get(name, []) |
| if name in self.special_attributes: |
| if name == '__module__': |
| return [cf(self.root().qname())] + values |
| # FIXME : what is expected by passing the list of ancestors to cf: |
| # you can just do [cf(tuple())] + values without breaking any test |
| # this is ticket http://www.logilab.org/ticket/52785 |
| if name == '__bases__': |
| return [cf(tuple(self.ancestors(recurs=False, context=context)))] + values |
| # XXX need proper meta class handling + MRO implementation |
| if name == '__mro__' and self.newstyle: |
| # XXX mro is read-only but that's not our job to detect that |
| return [cf(tuple(self.ancestors(recurs=True, context=context)))] + values |
| return std_special_attributes(self, name) |
| # don't modify the list in self.locals! |
| values = list(values) |
| for classnode in self.ancestors(recurs=True, context=context): |
| values += classnode.locals.get(name, []) |
| if not values: |
| raise NotFoundError(name) |
| return values |
| |
| def igetattr(self, name, context=None): |
| """inferred getattr, need special treatment in class to handle |
| descriptors |
| """ |
| # set lookup name since this is necessary to infer on import nodes for |
| # instance |
| context = copy_context(context) |
| context.lookupname = name |
| try: |
| for infered in _infer_stmts(self.getattr(name, context), context, |
| frame=self): |
| # yield YES object instead of descriptors when necessary |
| if not isinstance(infered, Const) and isinstance(infered, Instance): |
| try: |
| infered._proxied.getattr('__get__', context) |
| except NotFoundError: |
| yield infered |
| else: |
| yield YES |
| else: |
| yield function_to_method(infered, self) |
| except NotFoundError: |
| if not name.startswith('__') and self.has_dynamic_getattr(context): |
| # class handle some dynamic attributes, return a YES object |
| yield YES |
| else: |
| raise InferenceError(name) |
| |
| def has_dynamic_getattr(self, context=None): |
| """return True if the class has a custom __getattr__ or |
| __getattribute__ method |
| """ |
| # need to explicitly handle optparse.Values (setattr is not detected) |
| if self.name == 'Values' and self.root().name == 'optparse': |
| return True |
| try: |
| self.getattr('__getattr__', context) |
| return True |
| except NotFoundError: |
| #if self.newstyle: XXX cause an infinite recursion error |
| try: |
| getattribute = self.getattr('__getattribute__', context)[0] |
| if getattribute.root().name != BUILTINS_NAME: |
| # class has a custom __getattribute__ defined |
| return True |
| except NotFoundError: |
| pass |
| return False |
| |
| def methods(self): |
| """return an iterator on all methods defined in the class and |
| its ancestors |
| """ |
| done = {} |
| for astng in chain(iter((self,)), self.ancestors()): |
| for meth in astng.mymethods(): |
| if meth.name in done: |
| continue |
| done[meth.name] = None |
| yield meth |
| |
| def mymethods(self): |
| """return an iterator on all methods defined in the class""" |
| for member in self.values(): |
| if isinstance(member, Function): |
| yield member |
| |
| def interfaces(self, herited=True, handler_func=_iface_hdlr): |
| """return an iterator on interfaces implemented by the given |
| class node |
| """ |
| # FIXME: what if __implements__ = (MyIFace, MyParent.__implements__)... |
| try: |
| implements = Instance(self).getattr('__implements__')[0] |
| except NotFoundError: |
| return |
| if not herited and not implements.frame() is self: |
| return |
| found = set() |
| missing = False |
| for iface in unpack_infer(implements): |
| if iface is YES: |
| missing = True |
| continue |
| if not iface in found and handler_func(iface): |
| found.add(iface) |
| yield iface |
| if missing: |
| raise InferenceError() |