allow creating new .NET arrays from Python using Array[T](dim1, dim2, ...) syntax

lostmsu · lostmsu · commit 46e7c6535263 · 2020-11-23T17:42:57.000-08:00
fixes #251
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -9,6 +9,8 @@ This document follows the conventions laid out in [Keep a CHANGELOG][].
 
 ### Added
 
+-   Ability to instantiate new .NET arrays using `Array[T](dim1, dim2, ...)` syntax
+
 ### Changed
 -   Drop support for Python 2, 3.4, and 3.5
 -   `clr.AddReference` may now throw errors besides `FileNotFoundException`, that provide more
diff --git a/src/runtime/arrayobject.cs b/src/runtime/arrayobject.cs
@@ -22,21 +22,98 @@ internal override bool CanSubclass()
 
         public static IntPtr tp_new(IntPtr tp, IntPtr args, IntPtr kw)
         {
+            if (kw != IntPtr.Zero)
+            {
+                return Exceptions.RaiseTypeError("array constructor takes no keyword arguments");
+            }
+
             var self = GetManagedObject(tp) as ArrayObject;
-            if (Runtime.PyTuple_Size(args) != 1)
+
+            long[] dimensions = new long[Runtime.PyTuple_Size(args)];
+            if (dimensions.Length == 0)
+            {
+                return Exceptions.RaiseTypeError("array constructor requires at least one integer argument or an object convertible to array");
+            }
+            if (dimensions.Length != 1)
             {
-                return Exceptions.RaiseTypeError("array expects 1 argument");
+                return CreateMultidimensional(self.type.GetElementType(), dimensions, args, tp);
             }
+
             IntPtr op = Runtime.PyTuple_GetItem(args, 0);
+
+            // create single dimensional array
+            if (Runtime.PyInt_Check(op))
+            {
+                dimensions[0] = Runtime.PyLong_AsLongLong(op);
+                if (dimensions[0] == -1 && Exceptions.ErrorOccurred())
+                {
+                    Exceptions.Clear();
+                }
+                else
+                {
+                    return NewInstance(self.type.GetElementType(), tp, dimensions);
+                }
+            }
             object result;
 
+            // this implements casting to Array[T]
             if (!Converter.ToManaged(op, self.type, out result, true))
             {
                 return IntPtr.Zero;
             }
             return CLRObject.GetInstHandle(result, tp);
         }
 
+        static IntPtr CreateMultidimensional(Type elementType, long[] dimensions, IntPtr shapeTuple, IntPtr pyType)
+        {
+            for (int dimIndex = 0; dimIndex < dimensions.Length; dimIndex++)
+            {
+                IntPtr dimObj = Runtime.PyTuple_GetItem(shapeTuple, dimIndex);
+                PythonException.ThrowIfIsNull(dimObj);
+
+                if (!Runtime.PyInt_Check(dimObj))
+                    return Exceptions.RaiseTypeError("array constructor expects integer dimensions");
+
+                dimensions[dimIndex] = Runtime.PyLong_AsLongLong(dimObj);
+                if (dimensions[dimIndex] == -1 && Exceptions.ErrorOccurred())
+                {
+                    return Exceptions.RaiseTypeError("array constructor expects integer dimensions");
+                }
+            }
+
+            return NewInstance(elementType, pyType, dimensions);
+        }
+
+        static IntPtr NewInstance(Type elementType, IntPtr tp, long[] dimensions)
+        {
+            object result;
+            try
+            {
+                result = Array.CreateInstance(elementType, dimensions);
+            }
+            catch (ArgumentException badArgument)
+            {
+                Exceptions.SetError(Exceptions.ValueError, badArgument.Message);
+                return IntPtr.Zero;
+            }
+            catch (OverflowException overflow)
+            {
+                Exceptions.SetError(overflow);
+                return IntPtr.Zero;
+            }
+            catch (NotSupportedException notSupported)
+            {
+                Exceptions.SetError(notSupported);
+                return IntPtr.Zero;
+            }
+            catch (OutOfMemoryException oom)
+            {
+                Exceptions.SetError(Exceptions.MemoryError, oom.Message);
+                return IntPtr.Zero;
+            }
+            return CLRObject.GetInstHandle(result, tp);
+        }
+
 
         /// <summary>
         /// Implements __getitem__ for array types.
diff --git a/src/tests/test_array.py b/src/tests/test_array.py
@@ -1174,6 +1174,20 @@ def test_boxed_value_type_mutation_result():
         assert items[i].X == i + 1
         assert items[i].Y == i + 1
 
+def test_create_array_from_shape():
+    from System import Array
+
+    value = Array[int](3)
+    assert value[1] == 0
+    assert value.Length == 3
+
+    value = Array[int](3, 4)
+    assert value[1, 1] == 0
+    assert value.GetLength(0) == 3
+    assert value.GetLength(1) == 4
+
+    with pytest.raises(ValueError):
+        Array[int](-1)
 
 def test_special_array_creation():
     """Test using the Array[<type>] syntax for creating arrays."""
