Support "is None" constraints from if statements during inference

ChangeLog

@@ -6,7 +6,14 @@ What's New in astroid 2.12.0?
 =============================
 Release date: TBA
 
-
+* Support "is None" constraints from if statements during inference.
+
+  Closes #791
+  Closes PyCQA/pylint#157
+  Closes PyCQA/pylint#1472
+  Closes PyCQA/pylint#2016
+  Closes PyCQA/pylint#2631
+  Closes PyCQA/pylint#2880
 
 What's New in astroid 2.11.1?
 =============================

astroid/bases.py

@@ -7,6 +7,7 @@
 """
 
 import collections
+from typing import Optional
 
 from astroid import decorators
 from astroid.const import PY310_PLUS
@@ -114,15 +115,18 @@ def infer(self, context=None):
         yield self
 
 
-def _infer_stmts(stmts, context, frame=None):
+def _infer_stmts(stmts, context: Optional[InferenceContext], frame=None):
     """Return an iterator on statements inferred by each statement in *stmts*."""
     inferred = False
+    constraint_failed = False
     if context is not None:
         name = context.lookupname
         context = context.clone()
+        constraints = context.constraints.get(name, {})
     else:
         name = None
         context = InferenceContext()
+        constraints = {}
 
     for stmt in stmts:
         if stmt is Uninferable:
@@ -131,15 +135,26 @@ def _infer_stmts(stmts, context, frame=None):
             continue
         context.lookupname = stmt._infer_name(frame, name)
         try:
+            stmt_constraints = {
+                constraint
+                for constraint_stmt, constraint in constraints.items()
+                if not constraint_stmt.parent_of(stmt)
+            }
             for inf in stmt.infer(context=context):
-                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,142 @@
+# 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 abc import abstractmethod
+from typing import Dict, Optional, Type, TypeVar, Union
+
+from astroid import nodes, util
+
+NameNodes = Union[nodes.AssignAttr, nodes.Attribute, nodes.AssignName, nodes.Name]
+ConstraintT = TypeVar("ConstraintT", bound="Constraint")
+
+
+class Constraint:
+    """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
+    ) -> Optional[ConstraintT]:
+        """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: Union[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."""
+
+    @classmethod
+    def match(
+        cls: ConstraintT, node: NameNodes, expr: nodes.NodeNG, negate: bool = False
+    ) -> Optional[ConstraintT]:
+        """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]
+            const_none = nodes.Const(None)
+            if op in {"is", "is not"} and (
+                matches(left, node)
+                and matches(right, const_none)
+                or matches(left, 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: Union[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
+
+        if self.negate and matches(inferred, nodes.Const(None)):
+            return False
+        if not self.negate and not matches(inferred, nodes.Const(None)):
+            return False
+
+        return True
+
+
+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 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: nodes.NodeNG = expr
+    constraints = {}
+    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)
+            if branch == "body":
+                constraint = match_constraint(expr, parent.test)
+            elif branch == "orelse":
+                constraint = match_constraint(expr, parent.test, invert=True)
+            else:
+                constraint = None
+
+            if constraint:
+                constraints[parent] = constraint
+        current_node = parent
+
+    return constraints
+
+
+ALL_CONSTRAINTS = (NoneConstraint,)
+"""All supported constraint types."""
+
+
+def match_constraint(
+    node: NameNodes, expr: nodes.NodeNG, invert: bool = False
+) -> Optional[Constraint]:
+    """Returns a constraint pattern for node, if one matches."""
+    for constraint_cls in ALL_CONSTRAINTS:
+        constraint = constraint_cls.match(node, expr, invert)
+        if constraint:
+            return constraint
+
+    return None

astroid/context.py

@@ -8,6 +8,7 @@
 from typing import TYPE_CHECKING, Dict, List, Optional, Sequence, Tuple
 
 if TYPE_CHECKING:
+    from astroid import constraint, nodes
     from astroid.nodes.node_classes import Keyword, NodeNG
 
 _InferenceCache = Dict[
@@ -34,6 +35,7 @@ class InferenceContext:
         "callcontext",
         "boundnode",
         "extra_context",
+        "constraints",
         "_nodes_inferred",
     )
 
@@ -84,6 +86,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):
         """
@@ -134,6 +139,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

@@ -25,7 +25,7 @@
 
 import wrapt
 
-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,
@@ -214,6 +214,8 @@ def infer_name(self, context=None):
             )
     context = copy_context(context)
     context.lookupname = self.name
+    context.constraints[self.name] = constraint.get_constraints(self, frame)
+
     return bases._infer_stmts(stmts, context, frame)
 
 
@@ -318,6 +320,11 @@ def infer_attribute(self, context=None):
         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,