Merge pull request #901 from Blewzman/FixAggregateExceptionGetBaseException

[mono.git] / mono / mini / gshared.cs

diff --git a/mono/mini/gshared.cs b/mono/mini/gshared.cs
index 4dd155a60e4f3febd2a3ac8b96fe24ca8e6efa52..b0b95373fa7e279bcd127e38ced6db4dc5d284a1 100644 (file)
--- a/mono/mini/gshared.cs
+++ b/mono/mini/gshared.cs
@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Collections.ObjectModel;
 using System.Runtime.CompilerServices;
 using System.Threading.Tasks;
 
@@ -215,7 +216,12 @@ public class Tests
        public static int test_0_unbox_any_enum () {
                IFaceUnbox iface = new ClassUnbox ();
                AnEnum res = iface.Unbox<AnEnum, int> (AnEnum.One, 0, 1);
-               return res == AnEnum.Two ? 0 : 1;
+               if (res != AnEnum.Two)
+                       return 1;
+               res = iface.Unbox<AnEnum, int> (AnEnum.One, 0, AnEnum.Two);
+               if (res != AnEnum.Two)
+                       return 2;
+               return 0;
        }
 
        [MethodImplAttribute (MethodImplOptions.NoInlining)]
@@ -968,6 +974,26 @@ public class Tests
                return 0;
        }
 
+       interface IGetType {
+               Type gettype<T, T2>(T t, T2 t2);
+       }
+
+       public class CGetType : IGetType {
+               [MethodImplAttribute (MethodImplOptions.NoInlining)]
+               public Type gettype<T, T2>(T t, T2 t2) {
+                       return t.GetType ();
+               }
+       }
+
+       public static int test_0_constrained_gettype () {
+               IGetType c = new CGetType ();
+               if (c.gettype<int, int> (1, 1) != typeof (int))
+                       return 1;
+               if (c.gettype<string, int> ("A", 1) != typeof (string))
+                       return 2;
+               return 0;
+       }
+
        struct Pair<T1, T2> {
                public T1 First;
                public T2 Second;
@@ -1227,6 +1253,7 @@ public class Tests
 
        interface IConstrained<T3> {
                void foo_gsharedvt_arg (T3 s);
+               T3 foo_gsharedvt_ret (T3 s);
        }
 
        static object constrained_res;
@@ -1259,12 +1286,27 @@ public class Tests
                public void foo_gsharedvt_arg (T s) {
                        constrained_res = s;
                }
+
+               public T foo_gsharedvt_ret (T s) {
+                       return s;
+               }
+       }
+
+       struct ConsStructThrow : IConstrained {
+               public void foo () {
+                       throw new Exception ();
+               }
+
+               public void foo_ref_arg (string s) {
+               }
        }
 
        interface IFaceConstrained {
                void constrained_void_iface_call<T, T2>(T t, T2 t2) where T2 : IConstrained;
                void constrained_void_iface_call_ref_arg<T, T2>(T t, T2 t2) where T2 : IConstrained;
                void constrained_void_iface_call_gsharedvt_arg<T, T2, T3>(T t, T2 t2, T3 t3) where T2 : IConstrained<T>;
+               T constrained_iface_call_gsharedvt_ret<T, T2, T3>(T t, T2 t2, T3 t3) where T2 : IConstrained<T>;
+               T2 constrained_normal_call<T, T2>(T t, T2 t2) where T2 : VClass;
        }
 
        class ClassConstrained : IFaceConstrained {
@@ -1282,6 +1324,23 @@ public class Tests
                public void constrained_void_iface_call_gsharedvt_arg<T, T2, T3>(T t, T2 t2, T3 t3) where T2 : IConstrained<T> {
                        t2.foo_gsharedvt_arg (t);
                }
+
+               [MethodImplAttribute (MethodImplOptions.NoInlining)]
+               public T constrained_iface_call_gsharedvt_ret<T, T2, T3>(T t, T2 t2, T3 t3) where T2 : IConstrained<T> {
+                       return t2.foo_gsharedvt_ret (t);
+               }
+
+               [MethodImplAttribute (MethodImplOptions.NoInlining)]
+               public T2 constrained_normal_call<T, T2>(T t, T2 t2) where T2 : VClass {
+                       /* This becomes a constrained call even through 't2' is forced to be a reference type by the constraint */
+                       return (T2)t2.foo (5);
+               }
+       }
+
+       class VClass {
+               public virtual VClass foo (int i) {
+                       return this;
+               }
        }
 
        public static int test_0_constrained_void_iface_call () {
@@ -1307,7 +1366,18 @@ public class Tests
                return 0;
        }
 
-       public static int test_0_constraine_void_iface_call_gsharedvt_arg () {
+       public static int test_0_constrained_eh () {
+               var s2 = new ConsStructThrow () { };
+               try {
+                       IFaceConstrained c = new ClassConstrained ();
+                       c.constrained_void_iface_call<int, ConsStructThrow> (1, s2);
+                       return 1;
+               } catch (Exception) {
+                       return 0;
+               }
+       }
+
+       public static int test_0_constrained_void_iface_call_gsharedvt_arg () {
                // This tests constrained calls through interfaces with one gsharedvt arg, like IComparable<T>.CompareTo ()
                IFaceConstrained c = new ClassConstrained ();
 
@@ -1326,6 +1396,30 @@ public class Tests
                return 0;
        }
 
+       public static int test_0_constrained_iface_call_gsharedvt_ret () {
+               IFaceConstrained c = new ClassConstrained ();
+
+               var s = new ConsStruct<int> ();
+               int ires = c.constrained_iface_call_gsharedvt_ret<int, ConsStruct<int>, int> (42, s, 55);
+               if (ires != 42)
+                       return 1;
+
+               var s2 = new ConsStruct<string> ();
+               string sres = c.constrained_iface_call_gsharedvt_ret<string, ConsStruct<string>, int> ("A", s2, 55);
+               if (sres != "A")
+                       return 2;
+
+               return 0;
+       }
+
+       public static int test_0_constrained_normal_call () {
+               IFaceConstrained c = new ClassConstrained ();
+
+               var o = new VClass ();
+               var res = c.constrained_normal_call<int, VClass> (1, o);
+               return res == o ? 0 : 1;
+       }
+
        public static async Task<T> FooAsync<T> (int i, int j) {
                Task<int> t = new Task<int> (delegate () { return 42; });
                var response = await t;
@@ -1335,7 +1429,8 @@ public class Tests
        [MethodImplAttribute (MethodImplOptions.NoInlining)]
        public static void call_async<T> (int i, int j) {
                Task<T> t = FooAsync<T> (1, 2);
-               t.RunSynchronously ();
+               // FIXME: This doesn't work
+               //t.RunSynchronously ();
        }
 
        // In AOT mode, the async infrastructure depends on gsharedvt methods
@@ -1343,6 +1438,12 @@ public class Tests
                call_async<string> (1, 2);
                return 0;
        }
+
+       public static int test_0_array_helper_gsharedvt () {
+               var arr = new AnEnum [16];
+               var c = new ReadOnlyCollection<AnEnum> (arr);
+               return c.Contains (AnEnum.Two) == false ? 0 : 1;
+       }
 }
 
 // #13191