Per review

crates/red_knot_python_semantic/resources/mdtest/slots.md

@@ -101,6 +101,19 @@ class E(
 ): ...
 ```
 
+## Single solid base
+
+```py
+class A:
+    __slots__ = ("a", "b")
+
+class B(A): ...
+class C(A): ...
+
+class D(B, A): ...  # fine
+class E(B, C, A): ...  # fine
+```
+
 ## False negatives
 
 ### Possibly unbound

crates/red_knot_python_semantic/src/types/diagnostic.rs

@@ -157,7 +157,7 @@ declare_lint! {
     /// Inheriting from bases with incompatible `__slots__`s
     /// will lead to a `TypeError` at runtime.
     ///
-    /// Classes with no or empty `__slots__` is always compatible:
+    /// Classes with no or empty `__slots__` are always compatible:
     ///
     /// ```python
     /// class A: ...
@@ -170,7 +170,8 @@ declare_lint! {
     /// class D(A, B, C): ...
     /// ```
     ///
-    /// Class with non-empty `__slots__` cannot participate in multiple inheritance:
+    /// Multiple inheritance from more than one different class
+    /// defining non-empty `__slots__` is not allowed:
     ///
     /// ```python
     /// class A:

crates/red_knot_python_semantic/src/types/infer.rs

@@ -624,33 +624,50 @@ impl<'db> TypeInferenceBuilder<'db> {
                     }
                 }
                 Ok(_) => {
-                    let mut first_non_empty = None;
-                    let mut has_incompatible = false;
+                    let mut first_with_solid_base = None;
+                    let mut common_solid_base = None;
+                    let mut found_second = false;
 
                     for (index, base) in class.explicit_bases(self.db()).iter().enumerate() {
                         let Some(ClassLiteralType { class: base }) = base.into_class_literal()
                         else {
                             continue;
                         };
 
-                        let slots_kind = SlotsKind::from(self.db(), base);
+                        let solid_base = base.iter_mro(self.db()).find_map(|current| {
+                            let ClassBase::Class(current) = current else {
+                                return None;
+                            };
+
+                            match SlotsKind::from(self.db(), current) {
+                                SlotsKind::NotEmpty => Some(current),
+                                SlotsKind::NotSpecified | SlotsKind::Empty => None,
+                                SlotsKind::Dynamic => None,
+                            }
+                        });
+
                         let base_node = &class_node.bases()[index];
 
-                        if !matches!(slots_kind, SlotsKind::NotEmpty) {
+                        if solid_base.is_none() {
+                            continue;
+                        }
+
+                        if first_with_solid_base.is_none() {
+                            first_with_solid_base = Some(index);
+                            common_solid_base = solid_base;
                             continue;
                         }
 
-                        if first_non_empty.is_none() {
-                            first_non_empty = Some(index);
+                        if solid_base == common_solid_base {
                             continue;
                         }
 
-                        has_incompatible = true;
+                        found_second = true;
                         report_base_with_incompatible_slots(&self.context, base_node);
                     }
 
-                    if has_incompatible {
-                        if let Some(index) = first_non_empty {
+                    if found_second {
+                        if let Some(index) = first_with_solid_base {
                             let base_node = &class_node.bases()[index];
                             report_base_with_incompatible_slots(&self.context, base_node);
                         };

crates/red_knot_python_semantic/src/types/mro.rs

@@ -346,7 +346,7 @@ pub(super) enum SlotsKind {
 
 impl SlotsKind {
     pub(super) fn from(db: &dyn Db, base: Class) -> Self {
-        let Symbol::Type(slots_ty, bound) = base.class_member(db, "__slots__") else {
+        let Symbol::Type(slots_ty, bound) = base.own_class_member(db, "__slots__") else {
             return Self::NotSpecified;
         };