def _infer_stmts(stmts, context, frame=None): """Return an iterator on statements inferred by each statement in *stmts*.""" inferred = False if context is not None: name = context.lookupname context = context.clone() else: name = None context = InferenceContext() for stmt in stmts: if stmt is Uninferable: yield stmt inferred = True continue context.lookupname = stmt._infer_name(frame, name) try: for inf in stmt.infer(context=context): yield inf inferred = True except NameInferenceError: continue except InferenceError: yield Uninferable inferred = True if not inferred: raise InferenceError( "Inference failed for all members of {stmts!r}.", stmts=stmts, frame=frame, context=context, )
def igetattr(self, name, context=None): """inferred getattr""" if not context: context = InferenceContext() try: context.lookupname = name # avoid recursively inferring the same attr on the same class if context.push(self._proxied): raise InferenceError( message="Cannot infer the same attribute again", node=self, context=context, ) # XXX frame should be self._proxied, or not ? get_attr = self.getattr(name, context, lookupclass=False) yield from _infer_stmts(self._wrap_attr(get_attr, context), context, frame=self) except AttributeInferenceError: try: # fallback to class.igetattr since it has some logic to handle # descriptors # But only if the _proxied is the Class. if self._proxied.__class__.__name__ != "ClassDef": raise attrs = self._proxied.igetattr(name, context, class_context=False) yield from self._wrap_attr(attrs, context) except AttributeInferenceError as error: raise InferenceError(**vars(error)) from error
def _infer_augassign(self, context=None): """Inference logic for augmented binary operations.""" if context is None: context = InferenceContext() rhs_context = context.clone() lhs_iter = self.target.infer_lhs(context=context) rhs_iter = self.value.infer(context=rhs_context) for lhs, rhs in itertools.product(lhs_iter, rhs_iter): if any(value is util.Uninferable for value in (rhs, lhs)): # Don't know how to process this. yield util.Uninferable return try: yield from _infer_binary_operation( left=lhs, right=rhs, binary_opnode=self, context=context, flow_factory=_get_aug_flow, ) except _NonDeducibleTypeHierarchy: yield util.Uninferable
def _infer_binop( self: nodes.BinOp, context: InferenceContext | None = None ) -> Generator[InferenceResult | util.BadBinaryOperationMessage, None, None]: """Binary operation inference logic.""" left = self.left right = self.right # we use two separate contexts for evaluating lhs and rhs because # 1. evaluating lhs may leave some undesired entries in context.path # which may not let us infer right value of rhs context = context or InferenceContext() lhs_context = copy_context(context) rhs_context = copy_context(context) lhs_iter = left.infer(context=lhs_context) rhs_iter = right.infer(context=rhs_context) for lhs, rhs in itertools.product(lhs_iter, rhs_iter): if any(value is util.Uninferable for value in (rhs, lhs)): # Don't know how to process this. yield util.Uninferable return try: yield from _infer_binary_operation(lhs, rhs, self, context, _get_binop_flow) except _NonDeducibleTypeHierarchy: yield util.Uninferable
def infer_import_from( self: nodes.ImportFrom, context: InferenceContext | None = None, asname: bool = True, **kwargs: Any, ) -> Generator[InferenceResult, None, None]: """infer a ImportFrom node: return the imported module/object""" context = context or InferenceContext() name = context.lookupname if name is None: raise InferenceError(node=self, context=context) if asname: try: name = self.real_name(name) except AttributeInferenceError as exc: # See https://github.com/PyCQA/pylint/issues/4692 raise InferenceError(node=self, context=context) from exc try: module = self.do_import_module() except AstroidBuildingError as exc: raise InferenceError(node=self, context=context) from exc try: context = copy_context(context) context.lookupname = name stmts = module.getattr(name, ignore_locals=module is self.root()) return bases._infer_stmts(stmts, context) except AttributeInferenceError as error: raise InferenceError(str(error), target=self, attribute=name, context=context) from error
def _infer_augassign( self: nodes.AugAssign, context: InferenceContext | None = None ) -> Generator[InferenceResult | util.BadBinaryOperationMessage, None, None]: """Inference logic for augmented binary operations.""" context = context or InferenceContext() rhs_context = context.clone() lhs_iter = self.target.infer_lhs(context=context) rhs_iter = self.value.infer(context=rhs_context) for lhs, rhs in itertools.product(lhs_iter, rhs_iter): if any(value is util.Uninferable for value in (rhs, lhs)): # Don't know how to process this. yield util.Uninferable return try: yield from _infer_binary_operation( left=lhs, right=rhs, binary_opnode=self, context=context, flow_factory=_get_aug_flow, ) except _NonDeducibleTypeHierarchy: yield util.Uninferable
def infer_ifexp(self, context=None): """Support IfExp inference If we can't infer the truthiness of the condition, we default to inferring both branches. Otherwise, we infer either branch depending on the condition. """ both_branches = False # We use two separate contexts for evaluating lhs and rhs because # evaluating lhs may leave some undesired entries in context.path # which may not let us infer right value of rhs. context = context or InferenceContext() lhs_context = copy_context(context) rhs_context = copy_context(context) try: test = next(self.test.infer(context=context.clone())) except (InferenceError, StopIteration): both_branches = True else: if test is not util.Uninferable: if test.bool_value(): yield from self.body.infer(context=lhs_context) else: yield from self.orelse.infer(context=rhs_context) else: both_branches = True if both_branches: yield from self.body.infer(context=lhs_context) yield from self.orelse.infer(context=rhs_context)
def bool_value(self, context=None): """Infer the truth value for an Instance The truth value of an instance is determined by these conditions: * if it implements __bool__ on Python 3 or __nonzero__ on Python 2, then its bool value will be determined by calling this special method and checking its result. * when this method is not defined, __len__() is called, if it is defined, and the object is considered true if its result is nonzero. If a class defines neither __len__() nor __bool__(), all its instances are considered true. """ context = context or InferenceContext() context.boundnode = self try: result = _infer_method_result_truth(self, BOOL_SPECIAL_METHOD, context) except (InferenceError, AttributeInferenceError): # Fallback to __len__. try: result = _infer_method_result_truth(self, "__len__", context) except (AttributeInferenceError, InferenceError): return True return result
def test_max_inferred_for_complicated_class_hierarchy() -> None: """Regression test for a crash reported in https://github.com/PyCQA/pylint/issues/5679. The class hierarchy of 'sqlalchemy' is so intricate that it becomes uninferable with the standard max_inferred of 100. We used to crash when this happened. """ # Create module and get relevant nodes module = resources.build_file( str(resources.RESOURCE_PATH / "max_inferable_limit_for_classes" / "main.py") ) init_attr_node = module.body[-1].body[0].body[0].value.func init_object_node = module.body[-1].mro()[-1]["__init__"] super_node = next(init_attr_node.expr.infer()) # Arbitrarily limit the max number of infered nodes per context InferenceContext.max_inferred = -1 context = InferenceContext() # Try to infer 'object.__init__' > because of limit is impossible for inferred in bases._infer_stmts([init_object_node], context, frame=super): assert inferred == Uninferable # Reset inference limit InferenceContext.max_inferred = 100 # Check that we don't crash on a previously uninferable node assert super_node.getattr("__init__", context=context)[0] == Uninferable
def wrapped(node, context=None, _func=func, **kwargs): """wrapper function handling context""" if context is None: context = InferenceContext() if context.push(node): return yielded = set() for res in _func(node, context, **kwargs): # unproxy only true instance, not const, tuple, dict... if res.__class__.__name__ == "Instance": ares = res._proxied else: ares = res if ares not in yielded: yield res yielded.add(ares)
def from_call(cls, call_node, context: InferenceContext | None = None): """Get a CallSite object from the given Call node. context will be used to force a single inference path. """ # Determine the callcontext from the given `context` object if any. context = context or InferenceContext() callcontext = CallContext(call_node.args, call_node.keywords) return cls(callcontext, context=context)
def class_instance_as_index(node): """Get the value as an index for the given instance. If an instance provides an __index__ method, then it can be used in some scenarios where an integer is expected, for instance when multiplying or subscripting a list. """ context = InferenceContext() try: for inferred in node.igetattr("__index__", context=context): if not isinstance(inferred, bases.BoundMethod): continue context.boundnode = node context.callcontext = CallContext(args=[], callee=inferred) for result in inferred.infer_call_result(node, context=context): if isinstance(result, nodes.Const) and isinstance( result.value, int): return result except InferenceError: pass return None
def infer_attribute(self, context=None): """infer an Attribute node by using getattr on the associated object""" for owner in self.expr.infer(context): if owner is util.Uninferable: yield owner continue if not context: context = InferenceContext() old_boundnode = context.boundnode try: context.boundnode = owner yield from owner.igetattr(self.attrname, context) except ( AttributeInferenceError, InferenceError, AttributeError, ): pass finally: context.boundnode = old_boundnode return dict(node=self, context=context)
def _unpack_keywords(self, keywords, context=None): values = {} context = context or InferenceContext() context.extra_context = self.argument_context_map for name, value in keywords: if name is None: # Then it's an unpacking operation (**) try: inferred = next(value.infer(context=context)) except InferenceError: values[name] = Uninferable continue except StopIteration: continue if not isinstance(inferred, nodes.Dict): # Not something we can work with. values[name] = Uninferable continue for dict_key, dict_value in inferred.items: try: dict_key = next(dict_key.infer(context=context)) except InferenceError: values[name] = Uninferable continue except StopIteration: continue if not isinstance(dict_key, nodes.Const): values[name] = Uninferable continue if not isinstance(dict_key.value, str): values[name] = Uninferable continue if dict_key.value in values: # The name is already in the dictionary values[dict_key.value] = Uninferable self.duplicated_keywords.add(dict_key.value) continue values[dict_key.value] = dict_value else: values[name] = value return values
def infer_import( self: nodes.Import, context: InferenceContext | None = None, asname: bool = True, **kwargs: Any, ) -> Generator[nodes.Module, None, None]: """infer an Import node: return the imported module/object""" context = context or InferenceContext() name = context.lookupname if name is None: raise InferenceError(node=self, context=context) try: if asname: yield self.do_import_module(self.real_name(name)) else: yield self.do_import_module(name) except AstroidBuildingError as exc: raise InferenceError(node=self, context=context) from exc
def _object_type(node, context=None): astroid_manager = manager.AstroidManager() builtins = astroid_manager.builtins_module context = context or InferenceContext() for inferred in node.infer(context=context): if isinstance(inferred, scoped_nodes.ClassDef): if inferred.newstyle: metaclass = inferred.metaclass(context=context) if metaclass: yield metaclass continue yield builtins.getattr("type")[0] elif isinstance(inferred, (scoped_nodes.Lambda, bases.UnboundMethod)): yield _function_type(inferred, builtins) elif isinstance(inferred, scoped_nodes.Module): yield _build_proxy_class("module", builtins) else: yield inferred._proxied
def tl_infer_binary_op( self, opnode: nodes.BinOp, operator: str, other: nodes.NodeNG, context: InferenceContext, method: nodes.FunctionDef, ) -> Generator[nodes.NodeNG | type[util.Uninferable], None, None]: """Infer a binary operation on a tuple or list. The instance on which the binary operation is performed is a tuple or list. This refers to the left-hand side of the operation, so: 'tuple() + 1' or '[] + A()' """ # For tuples and list the boundnode is no longer the tuple or list instance context.boundnode = None not_implemented = nodes.Const(NotImplemented) if isinstance(other, self.__class__) and operator == "+": node = self.__class__(parent=opnode) node.elts = list( itertools.chain( _filter_uninferable_nodes(self.elts, context), _filter_uninferable_nodes(other.elts, context), )) yield node elif isinstance(other, nodes.Const) and operator == "*": if not isinstance(other.value, int): yield not_implemented return yield _multiply_seq_by_int(self, opnode, other, context) elif isinstance(other, bases.Instance) and operator == "*": # Verify if the instance supports __index__. as_index = helpers.class_instance_as_index(other) if not as_index: yield util.Uninferable else: yield _multiply_seq_by_int(self, opnode, as_index, context) else: yield not_implemented
def _infer_stmts( stmts: Sequence[nodes.NodeNG | type[Uninferable] | Instance], context: InferenceContext | None, frame: nodes.NodeNG | Instance | None = None, ) -> collections.abc.Generator[InferenceResult, None, None]: """Return an iterator on statements inferred by each statement in *stmts*.""" inferred = False if context is not None: name = context.lookupname context = context.clone() else: name = None context = InferenceContext() for stmt in stmts: if stmt is Uninferable: yield stmt inferred = True continue # 'context' is always InferenceContext and Instances get '_infer_name' from ClassDef context.lookupname = stmt._infer_name(frame, name) # type: ignore[union-attr] try: # Mypy doesn't recognize that 'stmt' can't be Uninferable for inf in stmt.infer(context=context): # type: ignore[union-attr] yield inf inferred = True except NameInferenceError: continue except InferenceError: yield Uninferable inferred = True if not inferred: raise InferenceError( "Inference failed for all members of {stmts!r}.", stmts=stmts, frame=frame, context=context, )
def _unpack_args(self, args, context=None): values = [] context = context or InferenceContext() context.extra_context = self.argument_context_map for arg in args: if isinstance(arg, nodes.Starred): try: inferred = next(arg.value.infer(context=context)) except InferenceError: values.append(Uninferable) continue except StopIteration: continue if inferred is Uninferable: values.append(Uninferable) continue if not hasattr(inferred, "elts"): values.append(Uninferable) continue values.extend(inferred.elts) else: values.append(arg) return values
def __init__(self): # Add a context so that inferences called from an instance don't recurse endlessly self.context = InferenceContext() super().__init__()
def attr___bases__(self): obj = node_classes.Tuple() context = InferenceContext() elts = list(self._instance._inferred_bases(context)) obj.postinit(elts=elts) return obj
def starred_assigned_stmts(self, node=None, context=None, assign_path=None): """ Arguments: self: nodes.Starred node: a node related to the current underlying Node. context: Inference context used for caching already inferred objects assign_path: A list of indices, where each index specifies what item to fetch from the inference results. """ # pylint: disable=too-many-locals,too-many-statements def _determine_starred_iteration_lookups(starred, target, lookups): # Determine the lookups for the rhs of the iteration itered = target.itered() for index, element in enumerate(itered): if ( isinstance(element, nodes.Starred) and element.value.name == starred.value.name ): lookups.append((index, len(itered))) break if isinstance(element, nodes.Tuple): lookups.append((index, len(element.itered()))) _determine_starred_iteration_lookups(starred, element, lookups) stmt = self.statement(future=True) if not isinstance(stmt, (nodes.Assign, nodes.For)): raise InferenceError( "Statement {stmt!r} enclosing {node!r} " "must be an Assign or For node.", node=self, stmt=stmt, unknown=node, context=context, ) if context is None: context = InferenceContext() if isinstance(stmt, nodes.Assign): value = stmt.value lhs = stmt.targets[0] if sum(1 for _ in lhs.nodes_of_class(nodes.Starred)) > 1: raise InferenceError( "Too many starred arguments in the " " assignment targets {lhs!r}.", node=self, targets=lhs, unknown=node, context=context, ) try: rhs = next(value.infer(context)) except (InferenceError, StopIteration): yield util.Uninferable return if rhs is util.Uninferable or not hasattr(rhs, "itered"): yield util.Uninferable return try: elts = collections.deque(rhs.itered()) except TypeError: yield util.Uninferable return # Unpack iteratively the values from the rhs of the assignment, # until the find the starred node. What will remain will # be the list of values which the Starred node will represent # This is done in two steps, from left to right to remove # anything before the starred node and from right to left # to remove anything after the starred node. for index, left_node in enumerate(lhs.elts): if not isinstance(left_node, nodes.Starred): if not elts: break elts.popleft() continue lhs_elts = collections.deque(reversed(lhs.elts[index:])) for right_node in lhs_elts: if not isinstance(right_node, nodes.Starred): if not elts: break elts.pop() continue # We're done unpacking. packed = nodes.List( ctx=Context.Store, parent=self, lineno=lhs.lineno, col_offset=lhs.col_offset, ) packed.postinit(elts=list(elts)) yield packed break if isinstance(stmt, nodes.For): try: inferred_iterable = next(stmt.iter.infer(context=context)) except (InferenceError, StopIteration): yield util.Uninferable return if inferred_iterable is util.Uninferable or not hasattr( inferred_iterable, "itered" ): yield util.Uninferable return try: itered = inferred_iterable.itered() except TypeError: yield util.Uninferable return target = stmt.target if not isinstance(target, nodes.Tuple): raise InferenceError( "Could not make sense of this, the target must be a tuple", context=context, ) lookups = [] _determine_starred_iteration_lookups(self, target, lookups) if not lookups: raise InferenceError( "Could not make sense of this, needs at least a lookup", context=context ) # Make the last lookup a slice, since that what we want for a Starred node last_element_index, last_element_length = lookups[-1] is_starred_last = last_element_index == (last_element_length - 1) lookup_slice = slice( last_element_index, None if is_starred_last else (last_element_length - last_element_index), ) lookups[-1] = lookup_slice for element in itered: # We probably want to infer the potential values *for each* element in an # iterable, but we can't infer a list of all values, when only a list of # step values are expected: # # for a, *b in [...]: # b # # *b* should now point to just the elements at that particular iteration step, # which astroid can't know about. found_element = None for lookup in lookups: if not hasattr(element, "itered"): break if not isinstance(lookup, slice): # Grab just the index, not the whole length lookup = lookup[0] try: itered_inner_element = element.itered() element = itered_inner_element[lookup] except IndexError: break except TypeError: # Most likely the itered() call failed, cannot make sense of this yield util.Uninferable return else: found_element = element unpacked = nodes.List( ctx=Context.Store, parent=self, lineno=self.lineno, col_offset=self.col_offset, ) unpacked.postinit(elts=found_element or []) yield unpacked return yield util.Uninferable