Support multiple inheritance with C3 method resolution order

Author: kidoz

src/DotPython.Compiler/DotPythonBytecodeFormat.cs

@@ -4,5 +4,5 @@ namespace DotPython.Compiler;
 public static class DotPythonBytecodeFormat
 {
     /// <summary>Gets the current bytecode format version.</summary>
-    public const int CurrentVersion = 26;
+    public const int CurrentVersion = 27;
 }

src/DotPython.Compiler/PythonCompiler.cs

@@ -1806,22 +1806,18 @@ private void CompileClassDefinition(PythonClassDefinitionStatement @class)
             var constantIndex = AddConstant(
                 new PythonConstant(PythonConstantType.CodeObject, childCode)
             );
-            if (@class.Bases.Count > 1)
-            {
-                Report(
-                    "DPY3114",
-                    "Multiple inheritance is not supported in this runtime slice.",
-                    @class.Span
-                );
-            }
-
             if (@class.Bases.Count == 0)
             {
                 Emit(PythonOpCode.MakeClass, constantIndex, @class.Span);
             }
             else
             {
-                CompileExpression(@class.Bases[0]);
+                foreach (var baseExpression in @class.Bases)
+                {
+                    CompileExpression(baseExpression);
+                }
+
+                Emit(PythonOpCode.BuildTuple, @class.Bases.Count, @class.Span);
                 Emit(PythonOpCode.MakeClassWithBases, constantIndex, @class.Span);
             }
 

src/DotPython.Runtime.Managed/Execution/ManagedObjectProtocols.cs

@@ -105,10 +105,7 @@ when module.Globals.TryGetValue(name, out var moduleValue):
 
                 throw MissingAttribute(instance.Type.Name, name, span);
             case PythonSuperProxyValue proxy:
-                if (
-                    proxy.DefiningType.BaseType is { } baseType
-                    && TryGetTypeAttribute(baseType, name, out var inherited)
-                )
+                if (TryResolveSuperAttribute(proxy, name, out var inherited))
                 {
                     return inherited is PythonFunctionValue inheritedMethod
                         ? new PythonBoundUserMethodValue(name, proxy.Instance, inheritedMethod)
@@ -143,6 +140,10 @@ proxy.DefiningType.BaseType is { } baseType
                 return value;
             case PythonManagedTypeValue type when name == "__name__":
                 return new PythonTextValue(type.Name);
+            case PythonManagedTypeValue type when name == "__mro__":
+                return new PythonTupleValue([.. type.Mro.Cast<PythonValue>()]);
+            case PythonManagedTypeValue type when name == "__bases__":
+                return new PythonTupleValue([.. type.Bases.Cast<PythonValue>()]);
             case PythonManagedTypeValue type:
                 throw MissingAttribute(type.Name, name, span);
             case PythonExternalObjectValue external:
@@ -1628,13 +1629,48 @@ PythonManagedObjectValue instance
             _ => value,
         };
 
+    /// <summary>
+    /// `super()` resolution: search the attribute in the classes after the defining
+    /// class in the instance's dynamic-type MRO (falling back to the defining class's
+    /// own MRO when the instance is not a managed object of a related type).
+    /// </summary>
+    private static bool TryResolveSuperAttribute(
+        PythonSuperProxyValue proxy,
+        string name,
+        out PythonValue value
+    )
+    {
+        var mro =
+            proxy.Instance is PythonManagedObjectValue managed
+            && managed.Type.Mro.Contains(proxy.DefiningType)
+                ? managed.Type.Mro
+                : proxy.DefiningType.Mro;
+        var searching = false;
+        foreach (var current in mro)
+        {
+            if (!searching)
+            {
+                searching = ReferenceEquals(current, proxy.DefiningType);
+                continue;
+            }
+
+            if (current.Attributes.TryGetValue(name, out value!))
+            {
+                return true;
+            }
+        }
+
+        value = null!;
+        return false;
+    }
+
     internal static bool TryGetTypeAttribute(
         PythonManagedTypeValue type,
         string name,
         out PythonValue value
     )
     {
-        for (var current = type; current is not null; current = current.BaseType)
+        foreach (var current in type.Mro)
         {
             if (current.Attributes.TryGetValue(name, out value!))
             {

src/DotPython.Runtime.Managed/Execution/PythonValue.cs

@@ -327,18 +327,40 @@ internal PythonManagedTypeValue(
         PythonManagedTypeValue? baseType = null,
         Func<IReadOnlyList<PythonValue>, PythonValue>? construct = null,
         string? exceptionBaseName = null
+    )
+        : this(
+            name,
+            baseType is null ? [] : [baseType],
+            baseType?.Mro,
+            construct,
+            exceptionBaseName
+        ) { }
+
+    internal PythonManagedTypeValue(
+        string name,
+        IReadOnlyList<PythonManagedTypeValue> bases,
+        IReadOnlyList<PythonManagedTypeValue>? linearizedBases,
+        Func<IReadOnlyList<PythonValue>, PythonValue>? construct = null,
+        string? exceptionBaseName = null
     )
     {
         ArgumentException.ThrowIfNullOrWhiteSpace(name);
         Name = name;
-        BaseType = baseType;
+        Bases = bases;
+        Mro = [this, .. linearizedBases ?? []];
         Construct = construct;
         ExceptionBaseName = exceptionBaseName;
     }
 
     internal Dictionary<string, PythonValue> Attributes { get; } = new(StringComparer.Ordinal);
 
-    internal PythonManagedTypeValue? BaseType { get; }
+    /// <summary>The declared base classes, in source order.</summary>
+    internal IReadOnlyList<PythonManagedTypeValue> Bases { get; }
+
+    /// <summary>The C3 method resolution order, starting with this type (no `object` terminus).</summary>
+    internal IReadOnlyList<PythonManagedTypeValue> Mro { get; }
+
+    internal PythonManagedTypeValue? BaseType => Bases.Count == 0 ? null : Bases[0];
 
     /// <summary>The builtin exception type this class derives from, when it is an exception class.</summary>
     internal string? ExceptionBaseName { get; }

src/DotPython.Runtime.Managed/Execution/PythonVirtualMachine.cs

@@ -4893,6 +4893,18 @@ private void MakeClass(PythonInstruction instruction, PythonValue? baseValue = n
             closure[index] = CurrentFrame.Cells[cellIndex];
         }
 
+        if (baseValue is PythonTupleValue { Elements.Length: > 1 } baseTuple)
+        {
+            var multiType = CreateMultiBaseClass(code.Definition.Name, baseTuple, instruction.Span);
+            PushClassBodyFrame(multiType, code, closure);
+            return;
+        }
+
+        if (baseValue is PythonTupleValue singleTuple)
+        {
+            baseValue = singleTuple.Elements.Length == 1 ? singleTuple.Elements[0] : null;
+        }
+
         PythonManagedTypeValue type;
         switch (baseValue)
         {
@@ -4937,8 +4949,17 @@ private void MakeClass(PythonInstruction instruction, PythonValue? baseValue = n
             _exceptionBaseOverlay[type.Name] = type.ExceptionBaseName;
         }
 
+        PushClassBodyFrame(type, code, closure);
+    }
+
+    private void PushClassBodyFrame(
+        PythonManagedTypeValue type,
+        PreparedPythonCode code,
+        PythonCell[] closure
+    )
+    {
         var hasReturnLocalContinuation = CaptureReturnLocalContinuation();
-        var cells = CreateCells(code, closure, instruction.Span);
+        var cells = CreateCells(code, closure, default);
         PushFrame(
             code,
             CurrentFrame.Globals,
@@ -4951,6 +4972,110 @@ private void MakeClass(PythonInstruction instruction, PythonValue? baseValue = n
         );
     }
 
+    private static PythonManagedTypeValue CreateMultiBaseClass(
+        string name,
+        PythonTupleValue baseTuple,
+        TextSpan span
+    )
+    {
+        var bases = new List<PythonManagedTypeValue>(baseTuple.Elements.Length);
+        foreach (var element in baseTuple.Elements)
+        {
+            switch (element)
+            {
+                case PythonManagedTypeValue { ExceptionBaseName: null } managedBase:
+                    if (bases.Contains(managedBase))
+                    {
+                        throw Fault(
+                            "DPY4034",
+                            $"duplicate base class {managedBase.Name}",
+                            span,
+                            "TypeError"
+                        );
+                    }
+
+                    bases.Add(managedBase);
+                    break;
+                case PythonManagedTypeValue or PythonExceptionTypeValue:
+                    throw Fault(
+                        "DPY3114",
+                        "Multiple inheritance with exception bases is not supported in this runtime slice.",
+                        span,
+                        "TypeError"
+                    );
+                default:
+                    throw Fault(
+                        "DPY4034",
+                        $"'{ManagedObjectProtocols.GetTypeName(element)}' is not an "
+                            + "acceptable base type.",
+                        span,
+                        "TypeError"
+                    );
+            }
+        }
+
+        return new PythonManagedTypeValue(name, bases, LinearizeBases(bases, span));
+    }
+
+    /// <summary>
+    /// C3 merge over the bases' linearizations plus the base list itself: repeatedly
+    /// take the first head that appears in no other sequence's tail.
+    /// </summary>
+    private static List<PythonManagedTypeValue> LinearizeBases(
+        List<PythonManagedTypeValue> bases,
+        TextSpan span
+    )
+    {
+        var sequences = bases
+            .Select(baseType => new List<PythonManagedTypeValue>(baseType.Mro))
+            .ToList();
+        sequences.Add([.. bases]);
+        var result = new List<PythonManagedTypeValue>();
+        while (sequences.Any(sequence => sequence.Count != 0))
+        {
+            PythonManagedTypeValue? selected = null;
+            foreach (var sequence in sequences)
+            {
+                if (sequence.Count == 0)
+                {
+                    continue;
+                }
+
+                var head = sequence[0];
+                var appearsInTail = sequences.Any(other =>
+                    other.Count != 0 && other.IndexOf(head) > 0
+                );
+                if (!appearsInTail)
+                {
+                    selected = head;
+                    break;
+                }
+            }
+
+            if (selected is null)
+            {
+                throw Fault(
+                    "DPY4034",
+                    "Cannot create a consistent method resolution order (MRO) for bases "
+                        + string.Join(", ", bases.Select(baseType => baseType.Name)),
+                    span,
+                    "TypeError"
+                );
+            }
+
+            result.Add(selected);
+            foreach (var sequence in sequences)
+            {
+                if (sequence.Count != 0 && ReferenceEquals(sequence[0], selected))
+                {
+                    sequence.RemoveAt(0);
+                }
+            }
+        }
+
+        return result;
+    }
+
     private static PythonCell[] CreateCells(
         PreparedPythonCode code,
         PythonCell[] closure,
@@ -5242,15 +5367,7 @@ private bool MatchesClassInfo(PythonValue value, PythonValue classInfo, TextSpan
                     return false;
                 }
 
-                for (var current = instance.Type; current is not null; current = current.BaseType)
-                {
-                    if (ReferenceEquals(current, managedType))
-                    {
-                        return true;
-                    }
-                }
-
-                return false;
+                return instance.Type.Mro.Any(current => ReferenceEquals(current, managedType));
             }
             case PythonExternalObjectValue externalType:
                 return externalType.Protocol.IsInstanceOf(value, span);

tests/DotPython.CompilerTests/BytecodeFormatTests.cs

@@ -6,8 +6,8 @@ namespace DotPython.CompilerTests;
 public sealed class BytecodeFormatTests
 {
     [Fact]
-    public void CurrentVersion_TracksExceptionGroupInstructions()
+    public void CurrentVersion_TracksMultipleInheritanceClassBases()
     {
-        Assert.Equal(26, DotPythonBytecodeFormat.CurrentVersion);
+        Assert.Equal(27, DotPythonBytecodeFormat.CurrentVersion);
     }
 }

tests/DotPython.CompilerTests/DotPythonModuleArtifactTests.cs

@@ -60,7 +60,7 @@ [new DotPythonModuleExport("calculate", "Calculate", DotPythonExportKind.Functio
 
         Assert.Equal(
             "{\"formatVersion\":4,\"moduleName\":\"pricing\",\"languageVersion\":\"3.14\","
-                + "\"bytecodeFormatVersion\":26,\"exports\":[{\"pythonName\":\"calculate\","
+                + "\"bytecodeFormatVersion\":27,\"exports\":[{\"pythonName\":\"calculate\","
                 + "\"contractName\":\"Calculate\",\"kind\":\"function\"}]}",
             json
         );
@@ -503,10 +503,10 @@ public void ManifestJson_RejectsLanguageVersionsOutsideTheSupportedArtifactSet()
     {
         const string unsupportedLanguage =
             "{\"formatVersion\":4,\"moduleName\":\"sample\",\"languageVersion\":\"3.13\","
-            + "\"bytecodeFormatVersion\":26,\"exports\":[]}";
+            + "\"bytecodeFormatVersion\":27,\"exports\":[]}";
         const string nonCanonicalLanguage =
             "{\"formatVersion\":4,\"moduleName\":\"sample\",\"languageVersion\":\"3.14.0\","
-            + "\"bytecodeFormatVersion\":26,\"exports\":[]}";
+            + "\"bytecodeFormatVersion\":27,\"exports\":[]}";
 
         var unsupportedFailure = Assert.Throws<InvalidDataException>(() =>
             DotPythonModuleManifestJson.Deserialize(unsupportedLanguage)

tests/DotPython.DifferentialTests/ManagedCliDifferentialTests.cs

@@ -477,6 +477,12 @@ public sealed class ManagedCliDifferentialTests
     [InlineData(
         "class Fut:\n    def __await__(self):\n        got = yield 'tick'\n        return got\nasync def paced():\n    for i in range(2):\n        v = await Fut()\n        yield i * 100 + len(v)\nasync def suspended_comp():\n    values = [x async for x in paced()]\n    print('collected', values)\ns = suspended_comp()\nprint(s.send(None))\nprint(s.send('ab'))\ntry:\n    s.send('xyz')\nexcept StopIteration:\n    pass\nasync def nums():\n    for i in range(4):\n        yield i\nasync def nested_comp():\n    grid = [[y async for y in nums()] for _ in range(2)]\n    print(grid)\nn = nested_comp()\ntry:\n    n.send(None)\nexcept StopIteration:\n    pass"
     )]
+    [InlineData(
+        "class A:\n    def who(self): return 'A'\n    tag = 'a'\nclass B(A):\n    def who(self): return 'B'\nclass C(A):\n    def who(self): return 'C'\n    tag = 'c'\nclass D(B, C):\n    pass\nprint([t.__name__ for t in D.__mro__ if t.__name__ != 'object'])\nprint([t.__name__ for t in D.__bases__])\nd = D()\nprint(d.who(), d.tag, D().who())\nprint(isinstance(d, A), isinstance(d, B), isinstance(d, C))\ntry:\n    class Bad(A, A):\n        pass\nexcept TypeError as e:\n    print('e1:', e)\nclass X: pass\nclass Y(X): pass\ntry:\n    class Z(X, Y):\n        pass\nexcept TypeError as e:\n    print('e2:', e)\nmatch d:\n    case C():\n        print('pattern-matches-C')"
+    )]
+    [InlineData(
+        "class WA:\n    def __init__(self):\n        self.trail = ['A']\nclass WB(WA):\n    def __init__(self):\n        super().__init__()\n        self.trail.append('B')\nclass WC(WA):\n    def __init__(self):\n        super().__init__()\n        self.trail.append('C')\nclass WD(WB, WC):\n    def __init__(self):\n        super().__init__()\n        self.trail.append('D')\nprint(WD().trail)\nclass M1:\n    def name(self): return 'M1'\nclass M2(M1):\n    def name(self): return 'M2+' + super().name()\nclass M3(M1):\n    def name(self): return 'M3+' + super().name()\nclass M4(M2, M3):\n    def name(self): return 'M4+' + super().name()\nprint(M4().name())\nclass Mix:\n    def helper(self): return 'mix:' + self.base()\nclass Base:\n    def base(self): return 'base'\nclass App(Mix, Base):\n    pass\nprint(App().helper())\nclass Wide(M2, M3, Mix, Base):\n    pass\nprint(Wide().name(), Wide().helper())\nprint([t.__name__ for t in Wide.__mro__ if t.__name__ != 'object'])"
+    )]
     public void CommandExecution_MatchesReferencePythonForSupportedSubset(string code)
     {
         var python = FindReferencePython();