Handle typing.Generic case in MRO

README.rst

@@ -73,6 +73,9 @@ What's New?
 in development
 ^^^^^^^^^^^^^^
 
+* Fix a bug in the MRO computing code that would result in an incorrect  
+  ``Cannot compute linearization of the class inheritance hierarchy`` message 
+  for valid types extending ``typing.Generic`` as well as other generic classes.
 * Fix a bug that would cause a variable marked as `Final` not being considered as a constant if
   it was declared under a control-flow block.
 * Fix a bug in google and numpy "Attributes" section in module docstring: 

pydoctor/model.py

@@ -9,6 +9,7 @@
 
 import abc
 import ast
+from functools import partial
 from itertools import chain
 from collections import defaultdict
 import datetime
@@ -582,7 +583,7 @@ def is_exception(cls: 'Class') -> bool:
             return True
     return False
 
-def compute_mro(cls:'Class') -> Sequence[Union['Class', str]]:
+def compute_mro(cls:'Class', cleanup_generics: bool = False) -> Sequence[Class | str]:
     """
     Compute the method resolution order for this class.
     This function will also set the 
@@ -622,23 +623,58 @@ def init_finalbaseobjects(o: 'Class', path:Optional[List['Class']]=None) -> None
             o._finalbaseobjects = finalbaseobjects
             o._finalbases = finalbases
 
-    def localbases(o:'Class') -> Iterator[Union['Class', str]]:
+    # Since the typing.Generic can be listed more than once in the class hierarchy: 
+    # ignore the ones after the first discovered one.
+    _bases: dict[Class | str, list[Class | str]] = {}
+    _has_generic: bool = False
+    def _getbases(o:'Class', ignore_generic: bool = False) -> Iterator[Class | str]:
         """
-        Like L{Class.baseobjects} but fallback to the expanded name if the base is not resolved to a L{Class} object.
+        Like L{Class.baseobjects} but fallback to the expanded 
+        name if the base is not resolved to a L{Class} object.
+
+        As well as handle multiple typing.Generic case, 
+        see https://github.com/twisted/pydoctor/issues/846.
         """
         for s,b in zip(o.bases, o.baseobjects):
             if isinstance(b, Class):
                 yield b
             else:
-                yield s
+                # Should we make it work event when typing.py is part of the system ? 
+                # since pydoctor is not used to document the standard library
+                # it's probably not worth it...
+                if s == 'typing.Generic':
+                    nonlocal _has_generic
+                    _has_generic = True
+                    if not ignore_generic:
+                        yield s
+                    else:
+                        continue
+                else:
+                    yield s
+
+    def getbases(o:Class | str) -> list[Class | str]:
+        nonlocal _getbases
 
-    def getbases(o:Union['Class', str]) -> List[Union['Class', str]]:
         if isinstance(o, str):
             return []
-        return list(localbases(o))
+
+        if o in _bases:
+            return _bases[o]
+
+        r = list(_getbases(o))
+        _bases[o] = r
+
+        if _has_generic and cleanup_generics:
+            _getbases = partial(_getbases, ignore_generic=True)
+
+        return r
 
     init_finalbaseobjects(cls)
-    return mro.mro(cls, getbases)
+    _mro: list[Class | str] =  mro.mro(cls, getbases)
+
+    if cleanup_generics:
+        _mro.sort(key=lambda c: c == 'typing.Generic')
+    return _mro
 
 def _find_dunder_constructor(cls:'Class') -> Optional['Function']:
     """
@@ -698,7 +734,7 @@ class Class(CanContainImportsDocumentable):
     # set in post-processing:
     _finalbaseobjects: Optional[List[Optional['Class']]] = None 
     _finalbases: Optional[List[str]] = None
-    _mro: Optional[Sequence[Union['Class', str]]] = None
+    _mro: Optional[Sequence[Class | str]] = None
 
     def setup(self) -> None:
         super().setup()
@@ -714,15 +750,18 @@ def _init_mro(self) -> None:
         """
         try:
             self._mro = compute_mro(self)
-        except ValueError as e:
-            self.report(str(e), 'mro')
-            self._mro = list(self.allbases(True))
+        except ValueError:
+            try:
+                self._mro = compute_mro(self, cleanup_generics=True)
+            except ValueError as e:
+                self.report(str(e), 'mro')
+                self._mro = list(self.allbases(True))
 
     @overload
-    def mro(self, include_external:'Literal[True]', include_self:bool=True) -> Sequence[Union['Class', str]]:...
+    def mro(self, include_external:'Literal[True]', include_self:bool=True) -> Sequence[Class | str]:...
     @overload
     def mro(self, include_external:'Literal[False]'=False, include_self:bool=True) -> Sequence['Class']:...
-    def mro(self, include_external:bool=False, include_self:bool=True) -> Sequence[Union['Class', str]]:
+    def mro(self, include_external:bool=False, include_self:bool=True) -> Sequence[Class | str]:
         """
         Get the method resution order of this class. 
 

pydoctor/test/test_mro.py

@@ -130,6 +130,50 @@ class D(C):...
 cycle:4: Cycle found while computing inheritance hierarchy: cycle.D -> cycle.C -> cycle.A -> cycle.D
 '''
 
+@systemcls_param
+def test_mro_generic(systemcls: Type[model.System], capsys:CapSys) -> None:
+    src = '''
+    from typing import Generic, TypeVar
+    T = TypeVar('T')
+    class A: ...
+    class B(Generic[T]): ...
+    class C(A, Generic[T], B[T]): ...
+    '''
+    mod = fromText(src, modname='t', systemcls=systemcls)
+    assert not capsys.readouterr().out
+    assert_mro_equals(mod.contents['C'], 
+                      ["t.C", "t.A", "t.B", "typing.Generic"])
+
+@systemcls_param
+def test_mro_generic_2(systemcls: Type[model.System], capsys:CapSys) -> None:
+    src = '''
+    from typing import Generic, TypeVar
+    T1 = TypeVar('T1')
+    T2 = TypeVar('T2')
+    class A(Generic[T1]): ...
+    class B(Generic[T2]): ...
+    class C(A[T1], B[T2]): ...
+    '''
+    mod = fromText(src, modname='t', systemcls=systemcls)
+    assert not capsys.readouterr().out
+    assert_mro_equals(mod.contents['C'], 
+                      ["t.C", "t.A", "t.B", "typing.Generic"])
+
+@systemcls_param
+def test_mro_generic_3(systemcls: Type[model.System], capsys:CapSys) -> None:
+    src = '''
+    from typing import Generic as TGeneric, TypeVar
+    T = TypeVar('T')
+    class Generic: ...
+    class A(Generic): ...
+    class B(TGeneric[T]): ...
+    class C(A, B[T]): ...
+    '''
+    mod = fromText(src, modname='t', systemcls=systemcls)
+    assert not capsys.readouterr().out
+    assert_mro_equals(mod.contents['C'], 
+                      ["t.C", "t.A", "t.Generic", "t.B", "typing.Generic"])
+
 def test_inherited_docsources()-> None:
     simple = fromText("""\
     class A: