Implement List Conversion, Reflect PR #37 Tests

src/embed_tests/TestConverter.cs

@@ -34,6 +34,30 @@ public void Dispose()
             PythonEngine.Shutdown();
         }
 
+        [Test]
+        public void ConvertListRoundTrip()
+        {
+            var list = new List<Type> { typeof(decimal), typeof(int) };
+            var py = list.ToPython();
+            object result;
+            var converted = Converter.ToManaged(py.Handle, typeof(List<Type>), out result, false);
+
+            Assert.IsTrue(converted);
+            Assert.AreEqual(result, list);
+        }
+
+        [Test]
+        public void ConvertPyListToArray()
+        {
+            var array = new List<Type> { typeof(decimal), typeof(int) };
+            var py = array.ToPython();
+            object result;
+            var converted = Converter.ToManaged(py.Handle, typeof(Type[]), out result, false);
+
+            Assert.IsTrue(converted);
+            Assert.AreEqual(result, array);
+        }
+
         [Test]
         public void TestConvertSingleToManaged(
             [Values(float.PositiveInfinity, float.NegativeInfinity, float.MinValue, float.MaxValue, float.NaN,

src/runtime/converter.cs

@@ -416,6 +416,15 @@ internal static bool ToManagedValue(IntPtr value, Type obType,
                 return true;
             }
 
+            if (obType.IsGenericType && Runtime.PyObject_TYPE(value) == Runtime.PyListType)
+            {
+                var typeDefinition = obType.GetGenericTypeDefinition();
+                if (typeDefinition == typeof(List<>))
+                {
+                    return ToList(value, obType, out result, setError);
+                }
+            }
+
             // Common case: if the Python value is a wrapped managed object
             // instance, just return the wrapped object.
             ManagedType mt = ManagedType.GetManagedObject(value);
@@ -948,7 +957,7 @@ private static bool ToArray(IntPtr value, Type obType, out object result, bool s
             result = null;
 
             IntPtr IterObject = Runtime.PyObject_GetIter(value);
-            if (IterObject == IntPtr.Zero)
+            if (IterObject == IntPtr.Zero || elementType.IsGenericType)
             {
                 if (setError)
                 {
@@ -962,6 +971,43 @@ private static bool ToArray(IntPtr value, Type obType, out object result, bool s
                 return false;
             }
 
+            var list = MakeList(value, IterObject, obType, elementType, setError);
+            if (list == null)
+            {
+                return false;
+            }
+
+            Array items = Array.CreateInstance(elementType, list.Count);
+            list.CopyTo(items, 0);
+
+            result = items;
+            return true;
+        }
+
+        /// <summary>
+        /// Convert a Python value to a correctly typed managed list instance.
+        /// The Python value must support the Python sequence protocol and the
+        /// items in the sequence must be convertible to the target list type.
+        /// </summary>
+        private static bool ToList(IntPtr value, Type obType, out object result, bool setError)
+        {
+            var elementType = obType.GetGenericArguments()[0];
+            IntPtr IterObject = Runtime.PyObject_GetIter(value);
+            result = MakeList(value, IterObject, obType, elementType, setError);
+            return result != null;
+        }
+
+        /// <summary>
+        /// Helper function for ToArray and ToList that creates a IList out of iterable objects
+        /// </summary>
+        /// <param name="value"></param>
+        /// <param name="IterObject"></param>
+        /// <param name="obType"></param>
+        /// <param name="elementType"></param>
+        /// <param name="setError"></param>
+        /// <returns></returns>
+        private static IList MakeList(IntPtr value, IntPtr IterObject, Type obType, Type elementType, bool setError)
+        {
             IList list;
             try
             {
@@ -989,7 +1035,8 @@ private static bool ToArray(IntPtr value, Type obType, out object result, bool s
                     Exceptions.SetError(e);
                     SetConversionError(value, obType);
                 }
-                return false;
+
+                return null;
             }
 
             IntPtr item;
@@ -1001,19 +1048,15 @@ private static bool ToArray(IntPtr value, Type obType, out object result, bool s
                 if (!Converter.ToManaged(item, elementType, out obj, setError))
                 {
                     Runtime.XDecref(item);
-                    return false;
+                    return null;
                 }
 
                 list.Add(obj);
                 Runtime.XDecref(item);
             }
             Runtime.XDecref(IterObject);
 
-            Array items = Array.CreateInstance(elementType, list.Count);
-            list.CopyTo(items, 0);
-
-            result = items;
-            return true;
+            return list;
         }