Add a new declare-non-slot error code

pylint/checkers/classes/class_checker.py

@@ -730,6 +730,12 @@ def _has_same_layout_slots(
         "Used when we detect that a property also has parameters, which are useless, "
         "given that properties cannot be called with additional arguments.",
     ),
+    "E0245": (
+        "No such name '%r' in __slots__",
+        "declare-non-slot",
+        "Used when a type annotation on a class is absent from the list of names in __slots__, "
+        "and __slots__ does not contain a __dict__ entry.",
+    ),
 }
 
 
@@ -872,6 +878,7 @@ def _dummy_rgx(self) -> Pattern[str]:
         "invalid-enum-extension",
         "subclassed-final-class",
         "implicit-flag-alias",
+        "declare-non-slot",
     )
     def visit_classdef(self, node: nodes.ClassDef) -> None:
         """Init visit variable _accessed."""
@@ -880,6 +887,39 @@ def visit_classdef(self, node: nodes.ClassDef) -> None:
         self._check_proper_bases(node)
         self._check_typing_final(node)
         self._check_consistent_mro(node)
+        self._check_declare_non_slot(node)
+
+    def _check_declare_non_slot(self, node: nodes.ClassDef) -> None:
+        if not self._has_valid_slots(node):
+            return
+
+        slot_names = self._get_classdef_slots_names(node)
+
+        for base in node.bases:
+            ancestor = safe_infer(base)
+            if not isinstance(ancestor, nodes.ClassDef):
+                continue
+            if not self._has_valid_slots(ancestor):
+                return
+            else:
+                slot_names.extend(self._get_classdef_slots_names(ancestor))
+
+        # Every class in bases has __slots__
+
+        if "__dict__" in slot_names:
+            return
+
+        for child in node.body:
+            if isinstance(child, nodes.AnnAssign):
+                if child.value is not None:
+                    continue
+                if isinstance(child.target, nodes.AssignName):
+                    if child.target.name not in slot_names:
+                        self.add_message(
+                            "declare-non-slot",
+                            args=child.target.name,
+                            node=child.target,
+                        )
 
     def _check_consistent_mro(self, node: nodes.ClassDef) -> None:
         """Detect that a class has a consistent mro or duplicate bases."""
@@ -1485,6 +1525,24 @@ def _check_functools_or_not(self, decorator: nodes.Attribute) -> bool:
 
         return "functools" in dict(import_node.names)
 
+    def _has_valid_slots(self, node: nodes.ClassDef) -> bool:
+        if "__slots__" not in node.locals:
+            return False
+
+        for slots in node.ilookup("__slots__"):
+            # check if __slots__ is a valid type
+            if isinstance(slots, util.UninferableBase):
+                return False
+            if not is_iterable(slots) and not is_comprehension(slots):
+                return False
+            if isinstance(slots, nodes.Const):
+                return False
+            if not hasattr(slots, "itered"):
+                # we can't obtain the values, maybe a .deque?
+                return False
+
+        return True
+
     def _check_slots(self, node: nodes.ClassDef) -> None:
         if "__slots__" not in node.locals:
             return
@@ -1518,13 +1576,22 @@ def _check_slots(self, node: nodes.ClassDef) -> None:
                     continue
             self._check_redefined_slots(node, slots, values)
 
-    def _check_redefined_slots(
-        self,
-        node: nodes.ClassDef,
-        slots_node: nodes.NodeNG,
-        slots_list: list[nodes.NodeNG],
-    ) -> None:
-        """Check if `node` redefines a slot which is defined in an ancestor class."""
+    def _get_classdef_slots_names(self, node: nodes.ClassDef):
+
+        if not self._has_valid_slots(node):
+            return []
+
+        slots_names = []
+        for slots in node.ilookup("__slots__"):
+            if isinstance(slots, nodes.Dict):
+                values = [item[0] for item in slots.items]
+            else:
+                values = slots.itered()
+            slots_names.extend(self._get_slots_names(values))
+
+        return slots_names
+
+    def _get_slots_names(self, slots_list: list[nodes.NodeNG]):
         slots_names: list[str] = []
         for slot in slots_list:
             if isinstance(slot, nodes.Const):
@@ -1534,6 +1601,16 @@ def _check_redefined_slots(
                 inferred_slot_value = getattr(inferred_slot, "value", None)
                 if isinstance(inferred_slot_value, str):
                     slots_names.append(inferred_slot_value)
+        return slots_names
+
+    def _check_redefined_slots(
+        self,
+        node: nodes.ClassDef,
+        slots_node: nodes.NodeNG,
+        slots_list: list[nodes.NodeNG],
+    ) -> None:
+        """Check if `node` redefines a slot which is defined in an ancestor class."""
+        slots_names: list[str] = self._get_slots_names(slots_list)
 
         # Slots of all parent classes
         ancestors_slots_names = {

tests/functional/r/regression_02/regression_5479.py

@@ -1,7 +1,7 @@
 """Test for a regression on slots and annotated assignments.
 Reported in https://github.com/pylint-dev/pylint/issues/5479
 """
-# pylint: disable=too-few-public-methods, unused-private-member, missing-class-docstring, missing-function-docstring
+# pylint: disable=too-few-public-methods, unused-private-member, missing-class-docstring, missing-function-docstring, declare-non-slot
 
 from __future__ import annotations
 

tests/functional/s/slots_checks.py

@@ -128,3 +128,56 @@ class Parent:
 
 class ChildNotAffectedByValueInSlot(Parent):
     __slots__ = ('first', )
+
+
+class ClassTypeHintNotInSlotsWithoutDict:
+    __slots__ = ("a", "b")
+
+    a: int
+    b: str
+    c: bool # [declare-non-slot]
+
+
+class ClassTypeHintNotInSlotsWithDict:
+    __slots__ = ("a", "b", "__dict__")
+
+    a: int
+    b: str
+    c: bool
+
+
+class BaseNoSlots:
+    pass
+
+
+class DerivedWithSlots(BaseNoSlots):
+    __slots__ = ("age",)
+
+    price: int
+
+
+class BaseWithSlots:
+    __slots__ = ("a", "b",)
+
+
+class DerivedWithMoreSlots(BaseWithSlots):
+    __slots__ = ("c",)
+
+    # Is in base __slots__
+    a: int
+
+    # Not in any base __slots__
+    d: int # [declare-non-slot]
+
+
+class BaseWithSlotsDict:
+    __slots__ = ("__dict__", )
+
+class DerivedTypeHintNotInSlots(BaseWithSlotsDict):
+    __slots__ = ("other", )
+
+    a: int
+
+    def __init__(self) -> None:
+        super().__init__()
+        self.a = 42

tests/functional/s/slots_checks.txt

@@ -14,3 +14,5 @@ invalid-slots:81:0:81:16:TwelfthBad:Invalid __slots__ object:UNDEFINED
 class-variable-slots-conflict:114:17:114:24:ValueInSlotConflict:Value 'first' in slots conflicts with class variable:UNDEFINED
 class-variable-slots-conflict:114:45:114:53:ValueInSlotConflict:Value 'fourth' in slots conflicts with class variable:UNDEFINED
 class-variable-slots-conflict:114:36:114:43:ValueInSlotConflict:Value 'third' in slots conflicts with class variable:UNDEFINED
+declare-non-slot:138:4:138:5:ClassTypeHintNotInSlotsWithoutDict:No such name 'c' in __slots__:UNDEFINED
+declare-non-slot:170:4:170:5:DerivedWithMoreSlots:No such name 'd' in __slots__:UNDEFINED