1783 Implement Interface And Inherit Class: Cleanup

rmadsen-ks · rmadsen-ks · commit cf4d59a155cb · 2023-02-02T21:41:28.000+01:00
- Added exceptions during unintended use of superclasses.
- Removed invalid comment.
- Improved exceptions from MetaType slightly.
diff --git a/src/runtime/Types/MetaType.cs b/src/runtime/Types/MetaType.cs
@@ -90,16 +90,33 @@ public static NewReference tp_new(BorrowedReference tp, BorrowedReference args,
             var baseTypes = new List<ClassBase>();
 
             var baseClassCount = Runtime.PyTuple_Size(bases);
+            if (baseClassCount == 0)
+            {
+                return Exceptions.RaiseTypeError("zero base classes ");
+            }
 
             for (nint i = 0; i < baseClassCount; i++)
             {
                 var baseTypeIt = Runtime.PyTuple_GetItem(bases, (int)i);
 
                 if (GetManagedObject(baseTypeIt) is ClassBase classBaseIt)
                 {
-                    if (classBaseIt.type.Valid && classBaseIt.type.Value.IsInterface)
+                    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
+                    {
+                        baseTypes.Add(classBaseIt);
+                    }
+                }
+                else
+                {
+                    return Exceptions.RaiseTypeError("Non .NET type used as super class for meta type. This is not supported.");
                 }
             }
             // if the base type count is 0, there might still be interfaces to implement.
@@ -111,7 +128,20 @@ public static NewReference tp_new(BorrowedReference tp, BorrowedReference args,
             // Multiple inheritance is not supported, unless the other types are interfaces
             if (baseTypes.Count > 1)
             {
-                return Exceptions.RaiseTypeError("cannot use multiple inheritance with managed classes");
+                var types = string.Join(", ", baseTypes.Select(baseType => baseType.type.Value));
+                return Exceptions.RaiseTypeError($"Multiple inheritance with managed classes cannot be used. Types: {types} ");
+            }
+
+            // check if the list of interfaces contains no duplicates.
+            if (interfaces.Distinct().Count() != interfaces.Count)
+            {
+                // 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);
+
+                return Exceptions.RaiseTypeError($"An interface can only be implemented once. Duplicate types: {duplicateTypesString}");
             }
 
             var cb = baseTypes[0];
@@ -133,8 +163,7 @@ public static NewReference tp_new(BorrowedReference tp, BorrowedReference args,
                 return Exceptions.RaiseTypeError("subclasses of managed classes do not support __slots__");
             }
 
-            // If the base class has a parameterless constructor, or
-            // if __assembly__ or __namespace__ are in the class dictionary then create
+            // If __assembly__ or __namespace__ are in the class dictionary then create
             // a managed sub type.
             // This creates a new managed type that can be used from .net to call back
             // into python.
