Support "is None" constraints from if statements during inference

ChangeLog

@@ -153,6 +153,15 @@ Release date: 2022-07-09
 
   Refs PyCQA/pylint#7109
 
+* Support "is None" constraints from if statements during inference.
+
+  Ref #791
+  Ref PyCQA/pylint#157
+  Ref PyCQA/pylint#1472
+  Ref PyCQA/pylint#2016
+  Ref PyCQA/pylint#2631
+  Ref PyCQA/pylint#2880
+
 What's New in astroid 2.11.7?
 =============================
 Release date: 2022-07-09

astroid/bases.py

@@ -11,7 +11,7 @@
 import collections.abc
 import sys
 from collections.abc import Sequence
-from typing import Any
+from typing import TYPE_CHECKING, Any
 
 from astroid import decorators, nodes
 from astroid.const import PY310_PLUS
@@ -35,6 +35,9 @@
 else:
     from typing_extensions import Literal
 
+if TYPE_CHECKING:
+    from astroid.constraint import Constraint
+
 objectmodel = lazy_import("interpreter.objectmodel")
 helpers = lazy_import("helpers")
 manager = lazy_import("manager")
@@ -146,9 +149,12 @@ def _infer_stmts(
 ) -> collections.abc.Generator[InferenceResult, None, None]:
     """Return an iterator on statements inferred by each statement in *stmts*."""
     inferred = False
+    constraint_failed = False
+    constraints: dict[str, dict[nodes.If, Constraint]] = {}
     if context is not None:
         name = context.lookupname
         context = context.clone()
+        constraints = context.constraints.get(name, {})
     else:
         name = None
         context = InferenceContext()
@@ -161,16 +167,27 @@ def _infer_stmts(
         # 'context' is always InferenceContext and Instances get '_infer_name' from ClassDef
         context.lookupname = stmt._infer_name(frame, name)  # type: ignore[union-attr]
         try:
+            stmt_constraints = {
+                constraint
+                for constraint_stmt, constraint in constraints.items()
+                if not constraint_stmt.parent_of(stmt)
+            }
             # 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
+                if all(constraint.satisfied_by(inf) for constraint in stmt_constraints):
+                    yield inf
+                    inferred = True
+                else:
+                    constraint_failed = True
         except NameInferenceError:
             continue
         except InferenceError:
             yield Uninferable
             inferred = True
-    if not inferred:
+
+    if not inferred and constraint_failed:
+        yield Uninferable
+    elif not inferred:
         raise InferenceError(
             "Inference failed for all members of {stmts!r}.",
             stmts=stmts,

astroid/constraint.py

@@ -0,0 +1,135 @@
+# 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
+# Copyright (c) https://github.com/PyCQA/astroid/blob/main/CONTRIBUTORS.txt
+
+"""Classes representing different types of constraints on inference values."""
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from typing import TypeVar, Union
+
+from astroid import nodes, util
+
+_NameNodes = Union[nodes.AssignAttr, nodes.Attribute, nodes.AssignName, nodes.Name]
+_ConstraintT = TypeVar("_ConstraintT", bound="Constraint")
+
+
+class Constraint(ABC):
+    """Represents a single constraint on a variable."""
+
+    def __init__(self, node: nodes.NodeNG, negate: bool) -> None:
+        self.node = node
+        """The node that this constraint applies to."""
+        self.negate = negate
+        """True if this constraint is negated. E.g., "is not" instead of "is"."""
+
+    @classmethod
+    @abstractmethod
+    def match(
+        cls: _ConstraintT, node: _NameNodes, expr: nodes.NodeNG, negate: bool = False
+    ) -> _ConstraintT | None:
+        """Return a new constraint for node matched from expr, if expr matches
+        the constraint pattern.
+
+        If negate is True, negate the constraint.
+        """
+
+    @abstractmethod
+    def satisfied_by(self, inferred: nodes.NodeNG | type[util.Uninferable]) -> bool:
+        """Return True if this constraint is satisfied by the given inferred value."""
+
+
+class NoneConstraint(Constraint):
+    """Represents an "is None" or "is not None" constraint."""
+
+    CONST_NONE: nodes.Const = nodes.Const(None)
+
+    @classmethod
+    def match(
+        cls: _ConstraintT, node: _NameNodes, expr: nodes.NodeNG, negate: bool = False
+    ) -> _ConstraintT | None:
+        """Return a new constraint for node matched from expr, if expr matches
+        the constraint pattern.
+
+        Negate the constraint based on the value of negate.
+        """
+        if isinstance(expr, nodes.Compare) and len(expr.ops) == 1:
+            left = expr.left
+            op, right = expr.ops[0]
+            if op in {"is", "is not"} and (
+                _matches(left, node)
+                and _matches(right, cls.CONST_NONE)
+                or _matches(left, cls.CONST_NONE)
+                and _matches(right, node)
+            ):
+                negate = (op == "is" and negate) or (op == "is not" and not negate)
+                return cls(node=node, negate=negate)
+
+        return None
+
+    def satisfied_by(self, inferred: nodes.NodeNG | type[util.Uninferable]) -> bool:
+        """Return True if this constraint is satisfied by the given inferred value."""
+        # Assume true if uninferable
+        if inferred is util.Uninferable:
+            return True
+
+        # Return the XOR of self.negate and matches(inferred, self.CONST_NONE)
+        return self.negate ^ _matches(inferred, self.CONST_NONE)
+
+
+def get_constraints(
+    expr: _NameNodes, frame: nodes.LocalsDictNodeNG
+) -> dict[nodes.If, Constraint]:
+    """Returns the constraints for the given expression.
+
+    The returned dictionary maps the node where the constraint was generated to the
+    corresponding constraint.
+
+    Constraints are computed statically by analysing the code surrounding expr.
+    Currently this only supports constraints generated from if conditions.
+    """
+    current_node = expr
+    constraints: dict[nodes.If, Constraint] = {}
+    while current_node is not None and current_node is not frame:
+        parent = current_node.parent
+        if isinstance(parent, nodes.If):
+            branch, _ = parent.locate_child(current_node)
+            constraint: Constraint | None = None
+            if branch == "body":
+                constraint = _match_constraint(expr, parent.test)
+            elif branch == "orelse":
+                constraint = _match_constraint(expr, parent.test, invert=True)
+
+            if constraint:
+                constraints[parent] = constraint
+        current_node = parent
+
+    return constraints
+
+
+ALL_CONSTRAINT_CLASSES = (NoneConstraint,)
+"""All supported constraint types."""
+
+
+def _matches(node1: nodes.NodeNG, node2: nodes.NodeNG) -> bool:
+    """Returns True if the two nodes match."""
+    if isinstance(node1, nodes.Name) and isinstance(node2, nodes.Name):
+        return node1.name == node2.name
+    if isinstance(node1, nodes.Attribute) and isinstance(node2, nodes.Attribute):
+        return node1.attrname == node2.attrname and _matches(node1.expr, node2.expr)
+    if isinstance(node1, nodes.Const) and isinstance(node2, nodes.Const):
+        return node1.value == node2.value
+
+    return False
+
+
+def _match_constraint(
+    node: _NameNodes, expr: nodes.NodeNG, invert: bool = False
+) -> Constraint | None:
+    """Returns a constraint pattern for node, if one matches."""
+    for constraint_cls in ALL_CONSTRAINT_CLASSES:
+        constraint = constraint_cls.match(node, expr, invert)
+        if constraint:
+            return constraint
+
+    return None

astroid/context.py

@@ -11,6 +11,7 @@
 from typing import TYPE_CHECKING, Dict, Optional, Sequence, Tuple
 
 if TYPE_CHECKING:
+    from astroid import constraint, nodes
     from astroid.nodes.node_classes import Keyword, NodeNG
 
 _InferenceCache = Dict[
@@ -37,6 +38,7 @@ class InferenceContext:
         "callcontext",
         "boundnode",
         "extra_context",
+        "constraints",
         "_nodes_inferred",
     )
 
@@ -80,6 +82,9 @@ def __init__(self, path=None, nodes_inferred=None):
         for call arguments
         """
 
+        self.constraints: dict[str, dict[nodes.If, constraint.Constraint]] = {}
+        """The constraints on nodes."""
+
     @property
     def nodes_inferred(self):
         """
@@ -130,6 +135,7 @@ def clone(self):
         clone.callcontext = self.callcontext
         clone.boundnode = self.boundnode
         clone.extra_context = self.extra_context
+        clone.constraints = self.constraints.copy()
         return clone
 
     @contextlib.contextmanager

astroid/inference.py

@@ -14,7 +14,7 @@
 from collections.abc import Callable, Generator, Iterable, Iterator
 from typing import TYPE_CHECKING, Any, TypeVar
 
-from astroid import bases, decorators, helpers, nodes, protocols, util
+from astroid import bases, constraint, decorators, helpers, nodes, protocols, util
 from astroid.context import (
     CallContext,
     InferenceContext,
@@ -229,6 +229,8 @@ def infer_name(
             )
     context = copy_context(context)
     context.lookupname = self.name
+    context.constraints[self.name] = constraint.get_constraints(self, frame)
+
     return bases._infer_stmts(stmts, context, frame)
 
 
@@ -349,6 +351,11 @@ def infer_attribute(
         old_boundnode = context.boundnode
         try:
             context.boundnode = owner
+            if isinstance(owner, (nodes.ClassDef, bases.Instance)):
+                frame = owner if isinstance(owner, nodes.ClassDef) else owner._proxied
+                context.constraints[self.attrname] = constraint.get_constraints(
+                    self, frame=frame
+                )
             yield from owner.igetattr(self.attrname, context)
         except (
             AttributeInferenceError,