Merge pull request #5714 from alexischr/update_bockbuild

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

diff --git a/mono/mini/generics.cs b/mono/mini/generics.cs
index 8354e0ba3c104bdc84fc4a5071f49586b82ee7c0..eafbd1c0e541c9187885ac412d98cdb863ae173e 100644 (file)
--- a/mono/mini/generics.cs
+++ b/mono/mini/generics.cs
@@ -570,7 +570,6 @@ class Tests
                }
        }
 
-       [Category ("!INTERPRETER")]
        public static int test_0_fullaot_linq () {
                var allWords = new XElement [] { new XElement { Value = "one" } };
                var filteredWords = allWords.Where(kw => kw.Value.StartsWith("T"));
@@ -952,7 +951,6 @@ class Tests
                }
        }
 
-       [Category ("!INTERPRETER")]
        [Category ("GSHAREDVT")]
        static int test_0_synchronized_gshared () {
                var c = new SyncClass<string> ();
@@ -989,7 +987,6 @@ class Tests
        }
 
        // #2155
-       [Category ("!INTERPRETER")]
        [Category ("GSHAREDVT")]
        public static int test_0_fullaot_sflda_cctor () {
                List<Doc> documents = new List<Doc>();
@@ -1015,7 +1012,6 @@ class Tests
     static List<A> sources = new List<A>();
 
        // #6112
-       [Category ("!INTERPRETER")]
     public static int test_0_fullaot_imt () {
         sources.Add(null);
         sources.Add(null);
@@ -1037,7 +1033,6 @@ class Tests
        class BClass : AClass {
        }
 
-       [Category ("!INTERPRETER")]
        public static int test_0_fullaot_variant_iface () {
                var arr = new BClass [10];
                var enumerable = (IEnumerable<AClass>)arr;
@@ -1069,7 +1064,6 @@ class Tests
                }
        }
 
-       [Category ("!INTERPRETER")]
        public static int test_1_regress_constrained_iface_call_7571 () {
         var r = new Record [10];
         Foo2<Record>.Extract (r);
@@ -1080,7 +1074,6 @@ class Tests
                Val = 1
        }
 
-       [Category ("!INTERPRETER")]
        public static int test_0_regress_constrained_iface_call_enum () {
                var r = new ConstrainedEnum [10];
                return Foo3<ConstrainedEnum>.CompareTo (r);
@@ -1140,7 +1133,6 @@ class Tests
        }
 #endif
 
-       [Category ("!INTERPRETER")]
        public static int test_0_delegate_callvirt_fullaot () {
                Func<string> f = delegate () { return "A"; };
         var f2 = (Func<Func<string>, string>)Delegate.CreateDelegate (typeof
@@ -1223,7 +1215,6 @@ class Tests
                return t.GetHashCode ();
        }
 
-       [Category ("!INTERPRETER")]
        public static int test_0_constrained_partial_sharing () {
                string s;
 
@@ -1317,6 +1308,89 @@ class Tests
                c.throw_catch_t ();
                return 0;
        }
+
+       [MethodImplAttribute (MethodImplOptions.NoInlining)]
+       public static bool is_ref_or_contains_refs<T> () {
+               return RuntimeHelpers.IsReferenceOrContainsReferences<T> ();
+       }
+
+       class IsRefClass<T> {
+               [MethodImplAttribute (MethodImplOptions.NoInlining)]
+               public bool is_ref () {
+                       return RuntimeHelpers.IsReferenceOrContainsReferences<T> ();
+               }
+       }
+
+       [MethodImplAttribute (MethodImplOptions.NoInlining)]
+       public static bool is_ref_or_contains_refs_gen_ref<T> () {
+               return RuntimeHelpers.IsReferenceOrContainsReferences<GenStruct<T>> ();
+       }
+
+       [MethodImplAttribute (MethodImplOptions.NoInlining)]
+       public static bool is_ref_or_contains_refs_gen_noref<T> () {
+               return RuntimeHelpers.IsReferenceOrContainsReferences<NoRefGenStruct<T>> ();
+       }
+
+       struct GenStruct<T> {
+               T t;
+       }
+
+       struct NoRefGenStruct<T> {
+       }
+
+       struct RefStruct {
+               string s;
+       }
+
+       struct NestedRefStruct {
+               RefStruct r;
+       }
+
+       struct NoRefStruct {
+               int i;
+       }
+
+       struct AStruct3<T1, T2, T3> {
+               T1 t1;
+               T2 t2;
+               T3 t3;
+       }
+
+       public static int test_0_isreference_intrins () {
+               if (RuntimeHelpers.IsReferenceOrContainsReferences<int> ())
+                       return 1;
+               if (!RuntimeHelpers.IsReferenceOrContainsReferences<string> ())
+                       return 2;
+               if (!RuntimeHelpers.IsReferenceOrContainsReferences<RefStruct> ())
+                       return 3;
+               if (!RuntimeHelpers.IsReferenceOrContainsReferences<NestedRefStruct> ())
+                       return 4;
+               if (RuntimeHelpers.IsReferenceOrContainsReferences<NoRefStruct> ())
+                       return 5;
+               // Generic code
+               if (is_ref_or_contains_refs<int> ())
+                       return 6;
+               // Shared code
+               if (!is_ref_or_contains_refs<string> ())
+                       return 7;
+               // Complex type from shared code
+               if (!is_ref_or_contains_refs_gen_ref<string> ())
+                       return 8;
+               if (is_ref_or_contains_refs_gen_ref<int> ())
+                       return 9;
+               if (is_ref_or_contains_refs_gen_noref<string> ())
+                       return 10;
+
+               // Complex type from shared class method
+               var c1 = new IsRefClass<AStruct3<int, int, int>> ();
+               if (c1.is_ref ())
+                       return 11;
+               var c2 = new IsRefClass<AStruct3<string, int, int>> ();
+               if (!c2.is_ref ())
+                       return 12;
+
+               return 0;
+       }
 }
 
 #if !__MOBILE__