Merge remote-tracking branch 'github/master'

pythonnet · rmadsen-ks · Apr 27, 2022 · Apr 28, 2022 · Apr 29, 2022 · May 3, 2022
commit ed898197dfafc2787c24ea1485b38472c66dfd45
diff --git a/src/python_tests_runner/PythonTestRunner.cs b/src/python_tests_runner/PythonTestRunner.cs
@@ -37,6 +37,7 @@ static IEnumerable<string[]> PythonTestCases()
             // Add the test that you want to debug here.
             yield return new[] { "test_indexer", "test_boolean_indexer" };
             yield return new[] { "test_delegate", "test_bool_delegate" };
+            yield return new[] { "test_subclass", "test_implement_interface_and_class" };
             yield return new[] { "test_subclass", "test_virtual_generic_method" };
             yield return new[] { "test_subclass", "test_interface_and_class_impl2" };
             yield return new[] { "test_subclass", "test_class_with_attributes" };

diff --git a/src/runtime/Native/TypeOffset311.cs b/src/runtime/Native/TypeOffset311.cs
@@ -1,4 +1,4 @@
-// Auto-generated by geninterop.py.
+// Auto-generated by geninterop.py.
 // DO NOT MODIFY BY HAND.
 
 // Python 3.11: ABI flags: ''
@@ -21,10 +21,7 @@ namespace Python.Runtime
     [StructLayout(LayoutKind.Sequential)]
     internal class TypeOffset311 : GeneratedTypeOffsets, ITypeOffsets
     {
-        public TypeOffset311()
-        {
-
-        }
+        public TypeOffset311() { }
         // Auto-generated from PyHeapTypeObject in Python.h
         public int ob_refcnt  { get; private set; }
         public int ob_type  { get; private set; }

diff --git a/src/runtime/TypeManager.cs b/src/runtime/TypeManager.cs
@@ -374,7 +374,7 @@ static PyTuple GetBaseTypeTuple(Type clrType)
             return new PyTuple(bases);
         }
 
-        internal static NewReference CreateSubType(BorrowedReference py_name, IEnumerable<ClassBase> py_base_type, IEnumerable<Type> interfaces, BorrowedReference dictRef)
+        internal static NewReference CreateSubType(BorrowedReference py_name, ClassBase py_base_type, IList<Type> interfaces, BorrowedReference dictRef)
         {
             // Utility to create a subtype of a managed type with the ability for the
             // a python subtype able to override the managed implementation
@@ -415,12 +415,10 @@ internal static NewReference CreateSubType(BorrowedReference py_name, IEnumerabl
             }
 
             // create the new managed type subclassing the base managed type
-            var baseClass = py_base_type.FirstOrDefault();
-
-            return ReflectedClrType.CreateSubclass(baseClass, interfaces, name,
-                                                   ns: (string?)namespaceStr,
-                                                   assembly: (string?)assembly,
-                                                    dict: dictRef);
+            return ReflectedClrType.CreateSubclass(py_base_type, interfaces, name,
+                ns: (string?)namespaceStr,
+                assembly: (string?)assembly,
+                dict: dictRef);
         }
 
         internal static IntPtr WriteMethodDef(IntPtr mdef, IntPtr name, IntPtr func, PyMethodFlags flags, IntPtr doc)

diff --git a/src/runtime/Types/ClassDerived.cs b/src/runtime/Types/ClassDerived.cs
@@ -255,7 +255,7 @@ static CustomAttributeBuilder AddAttribute(PyObject attr)
         /// </summary>
         internal static Type CreateDerivedType(string name,
             Type baseType,
-            IEnumerable<Type> interfaces2,
+            IList<Type> typeInterfaces,
             BorrowedReference py_dict,
             string? namespaceStr,
             string? assemblyName,
@@ -276,7 +276,7 @@ internal static Type CreateDerivedType(string name,
 
             Type baseClass = baseType;
             var interfaces = new HashSet<Type> { typeof(IPythonDerivedType) };
-            foreach(var t in interfaces2) interfaces.Add(t);
+            foreach(var t in interfaces) interfaces.Add(t);
             // if the base type is an interface then use System.Object as the base class
             // and add the base type to the list of interfaces this new class will implement.
             if (baseType.IsInterface)
@@ -342,13 +342,16 @@ internal static Type CreateDerivedType(string name,
                 }
             }
 
-            // override any virtual methods not already overridden by the properties above
+            // override any virtual not already overridden by the properties above
+            // also override any interface method.
             var methods = baseType.GetMethods().Concat(interfaces.SelectMany(x => x.GetMethods()));
             var virtualMethods = new HashSet<string>();
             foreach (MethodInfo method in methods)
             {
-                if (!method.Attributes.HasFlag(MethodAttributes.Virtual)
-                    || method.Attributes.HasFlag(MethodAttributes.Final)
+                if (!method.Attributes.HasFlag(MethodAttributes.Virtual) |
+                    method.Attributes.HasFlag(MethodAttributes.Final)
+                    // overriding generic virtual methods is not supported
+                    // so a call to that should be deferred to the base class method.
                     || method.IsGenericMethod)
                 {
                     continue;

diff --git a/src/runtime/Types/ManagedType.cs b/src/runtime/Types/ManagedType.cs
@@ -148,9 +148,9 @@ protected static void ClearObjectDict(BorrowedReference ob)
         {
             BorrowedReference type = Runtime.PyObject_TYPE(ob);
             int instanceDictOffset = Util.ReadInt32(type, TypeOffset.tp_dictoffset);
-            //Debug.Assert(instanceDictOffset > 0);
+            // Debug.Assert(instanceDictOffset > 0);
             // Python 3.11, sometimes this dict is less than zero.
-            if(instanceDictOffset > 0)
+            if (instanceDictOffset > 0)
                 Runtime.Py_CLEAR(ob, instanceDictOffset);
         }
 

diff --git a/src/runtime/Types/MetaType.cs b/src/runtime/Types/MetaType.cs
@@ -85,47 +85,66 @@ public static NewReference tp_new(BorrowedReference tp, BorrowedReference args,
             // Extract interface types and base class types.
             var interfaces = new List<Type>();
 
+            // More than one base type case be declared, but an exception will be thrown
+            // if more than one is a class/not an interface.
+            var baseTypes = new List<ClassBase>();
 
-            List<Type> interfaces = new List<Type>();
-            List<ClassBase> baseType = new List<ClassBase>();
-
-            var cnt = Runtime.PyTuple_GetSize(bases);
+            var baseClassCount = Runtime.PyTuple_Size(bases);
+            if (baseClassCount == 0)
+            {
+                return Exceptions.RaiseTypeError("zero base classes ");
+            }
 
-            for (uint i = 0; i < cnt; i++)
+            for (nint i = 0; i < baseClassCount; i++)
             {
-                var base_type2 = Runtime.PyTuple_GetItem(bases, (int)i);
-                var cb2 = (ClassBase) GetManagedObject(base_type2);
-                if (cb2 != null)
+                var baseTypeIt = Runtime.PyTuple_GetItem(bases, (int)i);
+
+                if (GetManagedObject(baseTypeIt) is ClassBase classBaseIt)
+                {
+                    if (!classBaseIt.type.Valid)
+                    {
+                        return Exceptions.RaiseTypeError("Invalid type used as a super type.");
+                    }
+                    if (classBaseIt.type.Value.IsInterface)
+                    {
+                        interfaces.Add(classBaseIt.type.Value);
+                    }
+                    else
+                    {
+                        baseTypes.Add(classBaseIt);
+                    }
+                }
+                else
                 {
-                    if (cb2.type.Valid && cb2.type.Value.IsInterface)
-                        interfaces.Add(cb2.type.Value);
-                    else baseType.Add(cb2);
+                    return Exceptions.RaiseTypeError("Non .NET type used as super class for meta type. This is not supported.");
                 }
             }
-
-            if (baseType.Count == 0)
+            // if the base type count is 0, there might still be interfaces to implement.
+            if (baseTypes.Count == 0)
             {
-                baseType.Add(new ClassBase(typeof(object)));
+                baseTypes.Add(new ClassBase(typeof(object)));
             }
 
-
-            if (baseType.Count > 1)
+            // Multiple inheritance is not supported, unless the other types are interfaces
+            if (baseTypes.Count > 1)
             {
-                return Exceptions.RaiseTypeError("zero base classes ");
+                var types = string.Join(", ", baseTypes.Select(baseType => baseType.type.Value));
+                return Exceptions.RaiseTypeError($"Multiple inheritance with managed classes cannot be used. Types: {types} ");
             }
 
-            /*
-            BorrowedReference mt = Runtime.PyObject_TYPE(baseType);
-
-            if (!(mt == PyCLRMetaType || mt == Runtime.PyTypeType))
+            // check if the list of interfaces contains no duplicates.
+            if (interfaces.Distinct().Count() != interfaces.Count)
             {
-                return Exceptions.RaiseTypeError("invalid metatype");
-            }*/
+                // generate a string containing the problematic types.
+                var duplicateTypes = interfaces.GroupBy(type => type)
+                    .Where(typeGroup => typeGroup.Count() > 1)
+                    .Select(typeGroup => typeGroup.Key);
+                var duplicateTypesString = string.Join(", ", duplicateTypes);
 
-            // Ensure that the reflected type is appropriate for subclassing,
-            // disallowing subclassing of delegates, enums and array types.
+                return Exceptions.RaiseTypeError($"An interface can only be implemented once. Duplicate types: {duplicateTypesString}");
+            }
 
-            var cb = baseType.First();
+            var cb = baseTypes[0];
             try
             {
                 if (!cb.CanSubclass())
@@ -150,11 +169,11 @@ public static NewReference tp_new(BorrowedReference tp, BorrowedReference args,
             // into python.
             if (null != dict)
             {
-                var btt = baseType.FirstOrDefault().type.ValueOrNull;
+                var btt = baseTypes.FirstOrDefault().type.ValueOrNull;
                 var ctor = btt?.GetConstructors(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)
                     .FirstOrDefault(x => x.GetParameters().Any() == false);
                 using var clsDict = new PyDict(dict);
-                
+
                 if (clsDict.HasKey("__assembly__") || clsDict.HasKey("__namespace__")
                                                    || (ctor != null))
                 {
@@ -163,9 +182,11 @@ public static NewReference tp_new(BorrowedReference tp, BorrowedReference args,
                         clsDict["__namespace__"] =
                             (clsDict["__module__"].ToString()).ToPython();
                     }
-                    return TypeManager.CreateSubType(name, baseType, interfaces, clsDict);
+
+                    return TypeManager.CreateSubType(name, baseTypes[0], interfaces, clsDict);
+
                 }
-                
+
             }
 
             var base_type = Runtime.PyTuple_GetItem(bases, 0);

diff --git a/src/runtime/Types/ReflectedClrType.cs b/src/runtime/Types/ReflectedClrType.cs
@@ -68,7 +68,7 @@ internal void Restore(ClassBase cb)
         TypeManager.InitializeClass(this, cb, cb.type.Value);
     }
 
-    internal static NewReference CreateSubclass(ClassBase baseClass, IEnumerable<Type> interfaces,
+    internal static NewReference CreateSubclass(ClassBase baseClass, IList<Type> interfaces,
                                                 string name, string? assembly, string? ns,
                                                 BorrowedReference dict)
     {

diff --git a/src/testing/classtest.cs b/src/testing/classtest.cs
@@ -60,15 +60,4 @@ public ClassCtorTest2(string v)
     internal class InternalClass
     {
     }
-
-    public class SimpleClass
-    {
-        public static void TestObject(object obj)
-        {
-            if ((!(obj is ISayHello1 && obj is SimpleClass)))
-            {
-                throw new Exception("Expected ISayHello and SimpleClass instance");
-            }
-        }
-    }
 }
diff --git a/tests/test_subclass.py b/tests/test_subclass.py
@@ -12,8 +12,7 @@
 from System.ComponentModel import (Browsable, BrowsableAttribute)
 from System.Threading import (CancellationToken)
 import pytest
-from Python.Test import (IInterfaceTest, SubClassTest, EventArgsTest,
-                         FunctionsTest, GenericVirtualMethodTest, ISimpleInterface, SimpleClass, TestAttribute, TestAttributeAttribute, ISimpleInterface2)
+from Python.Test import (IInterfaceTest, SubClassTest, EventArgsTest, FunctionsTest,IGenericInterface, GenericVirtualMethodTest, ISimpleInterface, SimpleClass, TestAttribute, TestAttributeAttribute, ISimpleInterface2, ISayHello1)
 import Python.Test
 from System.Collections.Generic import List
 
@@ -500,3 +499,30 @@ def IncrementThing(self):
     print(x.CallIncrementThing())
 
 
+
+def test_generic_interface():
+    from System import Int32
+    from Python.Test import GenericInterfaceUser, SpecificInterfaceUser
+
+    GenericInterfaceImpl = interface_generic_class_fixture(test_generic_interface.__name__)
+
+    obj = GenericInterfaceImpl()
+    SpecificInterfaceUser(obj, Int32(0))
+    GenericInterfaceUser[Int32](obj, Int32(0))
+
+def test_virtual_generic_method():
+    class OverloadingSubclass(GenericVirtualMethodTest):
+        __namespace__ = "test_virtual_generic_method_cls"
+    class OverloadingSubclass2(OverloadingSubclass):
+        __namespace__ = "test_virtual_generic_method_cls"
+    obj = OverloadingSubclass()
+    assert obj.VirtMethod[int](5) == 5
+    obj = OverloadingSubclass2()
+    assert obj.VirtMethod[int](5) == 5
+
+def test_implement_interface_and_class():
+    class DualSubClass0(ISayHello1, SimpleClass):
+        __namespace__ = "Test"
+        def SayHello(self):
+            return "hello"
+    obj = DualSubClass0()