mono/mini/generics.cs

   1 using System;
   2 using System.Collections.Generic;
   3 using System.Linq;
   4 using System.Runtime.CompilerServices;
   5 using System.Threading;
   6 using System.Threading.Tasks;
   7
   8 #if __MOBILE__
   9 class GenericsTests
  10 #else
  11 class Tests
  12 #endif
  13 {
  14         struct TestStruct {
  15                 public int i;
  16                 public int j;
  17
  18                 public TestStruct (int i, int j) {
  19                         this.i = i;
  20                         this.j = j;
  21                 }
  22         }
  23
  24 #if !__MOBILE__
  25         class Enumerator <T> : MyIEnumerator <T> {
  26                 T MyIEnumerator<T>.Current {
  27                         get {
  28                                 return default(T);
  29                         }
  30                 }
  31
  32                 bool MyIEnumerator<T>.MoveNext () {
  33                         return true;
  34                 }
  35         }
  36
  37         class Comparer <T> : IComparer <T> {
  38                 bool IComparer<T>.Compare (T x, T y) {
  39                         return true;
  40                 }
  41         }
  42 #endif
  43
  44 #if !__MOBILE__
  45         static int Main (string[] args)
  46         {
  47                 return TestDriver.RunTests (typeof (Tests), args);
  48         }
  49 #endif
  50
  51         public static int test_1_nullable_unbox ()
  52         {
  53                 return Unbox<int?> (1).Value;
  54         }
  55
  56         public static int test_1_nullable_unbox_null ()
  57         {
  58                 return Unbox<int?> (null).HasValue ? 0 : 1;
  59         }
  60
  61         public static int test_1_nullable_box ()
  62         {
  63                 return (int) Box<int?> (1);
  64         }
  65
  66         public static int test_1_nullable_box_null ()
  67         {
  68                 return Box<int?> (null) == null ? 1 : 0;
  69         }
  70
  71         public static int test_1_isinst_nullable ()
  72         {
  73                 object o = 1;
  74                 return (o is int?) ? 1 : 0;
  75         }
  76
  77         public static int test_1_nullable_unbox_vtype ()
  78         {
  79                 return Unbox<TestStruct?> (new TestStruct (1, 2)).Value.i;
  80         }
  81
  82         public static int test_1_nullable_unbox_null_vtype ()
  83         {
  84                 return Unbox<TestStruct?> (null).HasValue ? 0 : 1;
  85         }
  86
  87         public static int test_1_nullable_box_vtype ()
  88         {
  89                 return ((TestStruct)(Box<TestStruct?> (new TestStruct (1, 2)))).i;
  90         }
  91
  92         public static int test_1_nullable_box_null_vtype ()
  93         {
  94                 return Box<TestStruct?> (null) == null ? 1 : 0;
  95         }
  96
  97         public static int test_1_isinst_nullable_vtype ()
  98         {
  99                 object o = new TestStruct (1, 2);
 100                 return (o is TestStruct?) ? 1 : 0;
 101         }
 102
 103         public static int test_0_nullable_normal_unbox ()
 104         {
 105                 int? i = 5;
 106
 107                 object o = i;
 108                 // This uses unbox instead of unbox_any
 109                 int? j = (int?)o;
 110
 111                 if (j != 5)
 112                         return 1;
 113
 114                 return 0;
 115         }
 116
 117         public static void stelem_any<T> (T[] arr, T elem) {
 118                 arr [0] = elem;
 119         }
 120
 121         public static T ldelem_any<T> (T[] arr) {
 122                 return arr [0];
 123         }
 124
 125         public static int test_1_ldelem_stelem_any_int () {
 126                 int[] arr = new int [3];
 127                 stelem_any (arr, 1);
 128
 129                 return ldelem_any (arr);
 130         }
 131
 132         public static T return_ref<T> (ref T t) {
 133                 return t;
 134         }
 135
 136         public static T ldelema_any<T> (T[] arr) {
 137                 return return_ref<T> (ref arr [0]);
 138         }
 139
 140         public static int test_0_ldelema () {
 141                 string[] arr = new string [1];
 142
 143                 arr [0] = "Hello";
 144
 145                 if (ldelema_any <string> (arr) == "Hello")
 146                         return 0;
 147                 else
 148                         return 1;
 149         }
 150
 151         public static T[,] newarr_multi<T> () {
 152                 return new T [1, 1];
 153         }
 154
 155         public static int test_0_newarr_multi_dim () {
 156                 return newarr_multi<string> ().GetType () == typeof (string[,]) ? 0 : 1;
 157         }
 158
 159         interface ITest
 160         {
 161                 void Foo<T> ();
 162         }
 163
 164         public static int test_0_iface_call_null_bug_77442 () {
 165                 ITest test = null;
 166
 167                 try {
 168                         test.Foo<int> ();
 169                 }
 170                 catch (NullReferenceException) {
 171                         return 0;
 172                 }
 173
 174                 return 1;
 175         }
 176
 177         public static int test_18_ldobj_stobj_generics () {
 178                 GenericClass<int> t = new GenericClass <int> ();
 179                 int i = 5;
 180                 int j = 6;
 181                 return t.ldobj_stobj (ref i, ref j) + i + j;
 182         }
 183
 184         public static int test_5_ldelem_stelem_generics () {
 185                 GenericClass<TestStruct> t = new GenericClass<TestStruct> ();
 186
 187                 TestStruct s = new TestStruct (5, 5);
 188                 return t.ldelem_stelem (s).i;
 189         }
 190
 191         public static int test_0_constrained_vtype_box () {
 192                 GenericClass<TestStruct> t = new GenericClass<TestStruct> ();
 193
 194 #if __MOBILE__
 195                 return t.toString (new TestStruct ()) == "GenericsTests+TestStruct" ? 0 : 1;
 196 #else
 197                 return t.toString (new TestStruct ()) == "Tests+TestStruct" ? 0 : 1;
 198 #endif
 199         }
 200
 201         public static int test_0_constrained_vtype () {
 202                 GenericClass<int> t = new GenericClass<int> ();
 203
 204                 return t.toString (1234) == "1234" ? 0 : 1;
 205         }
 206
 207         public static int test_0_constrained_reftype () {
 208                 GenericClass<String> t = new GenericClass<String> ();
 209
 210                 return t.toString ("1234") == "1234" ? 0 : 1;
 211         }
 212
 213         public static int test_0_box_brtrue_optimizations () {
 214                 if (IsNull<int>(5))
 215                         return 1;
 216
 217                 if (!IsNull<object>(null))
 218                         return 1;
 219
 220                 return 0;
 221         }
 222
 223         [Category ("!FULLAOT")]
 224         public static int test_0_generic_get_value_optimization_int () {
 225                 int[] x = new int[] {100, 200};
 226
 227                 if (GenericClass<int>.Z (x, 0) != 100)
 228                         return 2;
 229
 230                 if (GenericClass<int>.Z (x, 1) != 200)
 231                         return 3;
 232
 233                 return 0;
 234         }
 235
 236         interface NonGenericInterface {
 237                 int return_field ();
 238         }
 239
 240         interface GenericInterface<T> : NonGenericInterface {
 241                 T not_used ();
 242         }
 243
 244         struct ImplementGenericInterface<T> : GenericInterface<T> {
 245                 public Object padding1;
 246                 public Object padding2;
 247                 public Object padding3;
 248                 public T[] arr_t;
 249
 250                 public ImplementGenericInterface (T[] arr_t) {
 251                         this.padding1 = null;
 252                         this.padding2 = null;
 253                         this.padding3 = null;
 254                         this.arr_t = arr_t;
 255                 }
 256
 257                 public T not_used () {
 258                         return arr_t [0];
 259                 }
 260
 261                 public int return_field () {
 262                         return arr_t.Length;
 263                 }
 264         }
 265
 266         public static int test_8_struct_implements_generic_interface () {
 267                 int[] arr = {1, 2, 3, 4};
 268                 NonGenericInterface s = new ImplementGenericInterface<int> (arr);
 269                 return s.return_field () + s.return_field ();
 270         }
 271
 272         public static int test_0_generic_get_value_optimization_vtype () {
 273                 TestStruct[] arr = new TestStruct[] { new TestStruct (100, 200), new TestStruct (300, 400) };
 274                 IEnumerator<TestStruct> enumerator = GenericClass<TestStruct>.Y (arr);
 275                 TestStruct s;
 276                 int sum = 0;
 277                 while (enumerator.MoveNext ()) {
 278                         s = enumerator.Current;
 279                         sum += s.i + s.j;
 280                 }
 281
 282                 if (sum != 1000)
 283                         return 1;
 284
 285                 s = GenericClass<TestStruct>.Z (arr, 0);
 286                 if (s.i != 100 || s.j != 200)
 287                         return 2;
 288
 289                 s = GenericClass<TestStruct>.Z (arr, 1);
 290                 if (s.i != 300 || s.j != 400)
 291                         return 3;
 292
 293                 return 0;
 294         }
 295
 296         public static int test_0_nullable_ldflda () {
 297                 return GenericClass<string>.BIsAClazz == false ? 0 : 1;
 298         }
 299
 300         public struct GenericStruct<T> {
 301                 public T t;
 302
 303                 public GenericStruct (T t) {
 304                         this.t = t;
 305                 }
 306         }
 307
 308         public class GenericClass<T> {
 309                 public T t;
 310
 311                 public GenericClass (T t) {
 312                         this.t = t;
 313                 }
 314
 315                 public GenericClass () {
 316                 }
 317
 318                 public T ldobj_stobj (ref T t1, ref T t2) {
 319                         t1 = t2;
 320                         T t = t1;
 321
 322                         return t;
 323                 }
 324
 325                 public T ldelem_stelem (T t) {
 326                         T[] arr = new T [10];
 327                         arr [0] = t;
 328
 329                         return arr [0];
 330                 }
 331
 332                 public String toString (T t) {
 333                         return t.ToString ();
 334                 }
 335
 336                 public static IEnumerator<T> Y (IEnumerable <T> x)
 337                 {
 338                         return x.GetEnumerator ();
 339                 }
 340
 341                 public static T Z (IList<T> x, int index)
 342                 {
 343                         return x [index];
 344                 }
 345
 346         protected static T NullB = default(T);
 347         private static Nullable<bool>  _BIsA = null;
 348         public static bool BIsAClazz {
 349             get {
 350                 _BIsA = false;
 351                 return _BIsA.Value;
 352             }
 353         }
 354         }
 355
 356         public class MRO : MarshalByRefObject {
 357                 public GenericStruct<int> struct_field;
 358                 public GenericClass<int> class_field;
 359         }
 360
 361         public class MRO<T> : MarshalByRefObject {
 362                 public T gen_field;
 363
 364                 public T stfld_ldfld (T t) {
 365                         var m = this;
 366                         m.gen_field = t;
 367                         return m.gen_field;
 368                 }
 369         }
 370
 371         public static int test_0_ldfld_stfld_mro () {
 372                 MRO m = new MRO ();
 373                 GenericStruct<int> s = new GenericStruct<int> (5);
 374                 // This generates stfld
 375                 m.struct_field = s;
 376
 377                 // This generates ldflda
 378                 if (m.struct_field.t != 5)
 379                         return 1;
 380
 381                 // This generates ldfld
 382                 GenericStruct<int> s2 = m.struct_field;
 383                 if (s2.t != 5)
 384                         return 2;
 385
 386                 if (m.struct_field.t != 5)
 387                         return 3;
 388
 389                 m.class_field = new GenericClass<int> (5);
 390                 if (m.class_field.t != 5)
 391                         return 4;
 392
 393                 // gshared
 394                 var m2 = new MRO<string> ();
 395                 if (m2.stfld_ldfld ("A") != "A")
 396                         return 5;
 397
 398                 return 0;
 399         }
 400
 401         // FIXME:
 402         [Category ("!FULLAOT")]
 403     public static int test_0_generic_virtual_call_on_vtype_unbox () {
 404                 object o = new Object ();
 405         IFoo h = new Handler(o);
 406
 407         if (h.Bar<object> () != o)
 408                         return 1;
 409                 else
 410                         return 0;
 411     }
 412
 413         public static int test_0_box_brtrue_opt () {
 414                 Foo<int> f = new Foo<int> (5);
 415
 416                 f [123] = 5;
 417
 418                 return 0;
 419         }
 420
 421         public static int test_0_box_brtrue_opt_regress_81102 () {
 422                 if (new Foo<int>(5).ToString () == "null")
 423                         return 0;
 424                 else
 425                         return 1;
 426         }
 427
 428         struct S {
 429                 public int i;
 430         }
 431
 432         public static int test_0_ldloca_initobj_opt () {
 433                 if (new Foo<S> (new S ()).get_default ().i != 0)
 434                         return 1;
 435                 if (new Foo<object> (null).get_default () != null)
 436                         return 2;
 437                 return 0;
 438         }
 439
 440 #if !__MOBILE__
 441         public static int test_0_variance_reflection () {
 442                 // covariance on IEnumerator
 443                 if (!typeof (MyIEnumerator<object>).IsAssignableFrom (typeof (MyIEnumerator<string>)))
 444                         return 1;
 445                 // covariance on IEnumerator and covariance on arrays
 446                 if (!typeof (MyIEnumerator<object>[]).IsAssignableFrom (typeof (MyIEnumerator<string>[])))
 447                         return 2;
 448                 // covariance and implemented interfaces
 449                 if (!typeof (MyIEnumerator<object>).IsAssignableFrom (typeof (Enumerator<string>)))
 450                         return 3;
 451
 452                 // contravariance on IComparer
 453                 if (!typeof (IComparer<string>).IsAssignableFrom (typeof (IComparer<object>)))
 454                         return 4;
 455                 // contravariance on IComparer, contravariance on arrays
 456                 if (!typeof (IComparer<string>[]).IsAssignableFrom (typeof (IComparer<object>[])))
 457                         return 5;
 458                 // contravariance and interface inheritance
 459                 if (!typeof (IComparer<string>[]).IsAssignableFrom (typeof (IKeyComparer<object>[])))
 460                         return 6;
 461                 return 0;
 462         }
 463 #endif
 464
 465         public static int test_0_ldvirtftn_generic_method () {
 466                 new GenericsTests ().ldvirtftn<string> ();
 467
 468                 return the_type == typeof (string) ? 0 : 1;
 469         }
 470
 471         public static int test_0_throw_dead_this () {
 472         new Foo<string> ("").throw_dead_this ();
 473                 return 0;
 474         }
 475
 476         struct S<T> {}
 477
 478         public static int test_0_inline_infinite_polymorphic_recursion () {
 479            f<int>(0);
 480
 481                    return 0;
 482         }
 483
 484         private static void f<T>(int i) {
 485                 if(i==42) f<S<T>>(i);
 486         }
 487
 488         // This cannot be made to work with full-aot, since there it is impossible to
 489         // statically determine that Foo<string>.Bar <int> is needed, the code only
 490         // references IFoo.Bar<int>
 491         [Category ("!FULLAOT")]
 492         public static int test_0_generic_virtual_on_interfaces () {
 493                 Foo<string>.count1 = 0;
 494                 Foo<string>.count2 = 0;
 495                 Foo<string>.count3 = 0;
 496
 497                 IFoo f = new Foo<string> ("");
 498                 for (int i = 0; i < 1000; ++i) {
 499                         f.Bar <int> ();
 500                         f.Bar <string> ();
 501                         f.NonGeneric ();
 502                 }
 503
 504                 if (Foo<string>.count1 != 1000)
 505                         return 1;
 506                 if (Foo<string>.count2 != 1000)
 507                         return 2;
 508                 if (Foo<string>.count3 != 1000)
 509                         return 3;
 510
 511                 VirtualInterfaceCallFromGenericMethod<long> (f);
 512
 513                 return 0;
 514         }
 515
 516         public static int test_0_generic_virtual_on_interfaces_ref () {
 517                 Foo<string>.count1 = 0;
 518                 Foo<string>.count2 = 0;
 519                 Foo<string>.count3 = 0;
 520                 Foo<string>.count4 = 0;
 521
 522                 IFoo f = new Foo<string> ("");
 523                 for (int i = 0; i < 1000; ++i) {
 524                         f.Bar <string> ();
 525                         f.Bar <object> ();
 526                         f.NonGeneric ();
 527                 }
 528
 529                 if (Foo<string>.count2 != 1000)
 530                         return 2;
 531                 if (Foo<string>.count3 != 1000)
 532                         return 3;
 533                 if (Foo<string>.count4 != 1000)
 534                         return 4;
 535
 536                 return 0;
 537         }
 538
 539         //repro for #505375
 540         [Category ("!FULLAOT")]
 541         public static int test_2_cprop_bug () {
 542                 int idx = 0;
 543                 int a = 1;
 544                 var cmp = System.Collections.Generic.Comparer<int>.Default ;
 545                 if (cmp.Compare (a, 0) > 0)
 546                         a = 0;
 547                 do { idx++; } while (cmp.Compare (idx - 1, a) == 0);
 548                 return idx;
 549         }
 550
 551         enum MyEnumUlong : ulong {
 552                 Value_2 = 2
 553         }
 554
 555         public static int test_0_regress_550964_constrained_enum_long () {
 556         MyEnumUlong a = MyEnumUlong.Value_2;
 557         MyEnumUlong b = MyEnumUlong.Value_2;
 558
 559         return Pan (a, b) ? 0 : 1;
 560         }
 561
 562     static bool Pan<T> (T a, T b)
 563     {
 564         return a.Equals (b);
 565     }
 566
 567         public class XElement {
 568                 public string Value {
 569                         get; set;
 570                 }
 571         }
 572
 573         public static int test_0_fullaot_linq () {
 574                 var allWords = new XElement [] { new XElement { Value = "one" } };
 575                 var filteredWords = allWords.Where(kw => kw.Value.StartsWith("T"));
 576                 return filteredWords.Count ();
 577         }
 578
 579         public static int test_0_fullaot_comparer_t () {
 580                 var l = new SortedList <TimeSpan, int> ();
 581                 return l.Count;
 582         }
 583
 584         public static int test_0_fullaot_comparer_t_2 () {
 585                 var l = new Dictionary <TimeSpan, int> ();
 586                 return l.Count;
 587         }
 588
 589         static void enumerate<T> (IEnumerable<T> arr) {
 590                 foreach (var o in arr)
 591                         ;
 592                 int c = ((ICollection<T>)arr).Count;
 593         }
 594
 595         /* Test that treating arrays as generic collections works with full-aot */
 596         public static int test_0_fullaot_array_wrappers () {
 597                 GenericsTests[] arr = new GenericsTests [10];
 598                 enumerate<GenericsTests> (arr);
 599                 return 0;
 600         }
 601
 602         static int cctor_count = 0;
 603
 604     public abstract class Beta<TChanged>
 605     {
 606         static Beta()
 607         {
 608                         cctor_count ++;
 609         }
 610     }
 611
 612     public class Gamma<T> : Beta<T>
 613     {
 614         static Gamma()
 615         {
 616         }
 617     }
 618
 619         // #519336
 620         public static int test_2_generic_class_init_gshared_ctor () {
 621                 new Gamma<object>();
 622                 new Gamma<string>();
 623
 624                 return cctor_count;
 625         }
 626
 627         static int cctor_count2 = 0;
 628
 629         class ServiceController<T> {
 630                 static ServiceController () {
 631                         cctor_count2 ++;
 632                 }
 633
 634                 public ServiceController () {
 635                 }
 636         }
 637
 638         static ServiceController<T> Create<T>() {
 639                 return new ServiceController<T>();
 640         }
 641
 642         // #631409
 643         public static int test_2_generic_class_init_gshared_ctor_from_gshared () {
 644                 Create<object> ();
 645                 Create<string> ();
 646
 647                 return cctor_count2;
 648         }
 649
 650         public static Type get_type<T> () {
 651                 return typeof (T);
 652         }
 653
 654         public static int test_0_gshared_delegate_rgctx () {
 655                 Func<Type> t = new Func<Type> (get_type<string>);
 656
 657                 if (t () == typeof (string))
 658                         return 0;
 659                 else
 660                         return 1;
 661         }
 662
 663         // Creating a delegate from a generic method from gshared code
 664         public static int test_0_gshared_delegate_from_gshared () {
 665                 if (gshared_delegate_from_gshared <object> () != 0)
 666                         return 1;
 667                 if (gshared_delegate_from_gshared <string> () != 0)
 668                         return 2;
 669                 return 0;
 670         }
 671
 672         public static int gshared_delegate_from_gshared <T> () {
 673                 Func<Type> t = new Func<Type> (get_type<T>);
 674
 675                 return t () == typeof (T) ? 0 : 1;
 676         }
 677
 678         public static int test_0_marshalbyref_call_from_gshared_virt_elim () {
 679                 /* Calling a virtual method from gshared code which is changed to a nonvirt call */
 680                 Class1<object> o = new Class1<object> ();
 681                 o.Do (new Class2<object> ());
 682                 return 0;
 683         }
 684
 685         class Pair<TKey, TValue> {
 686                 public static KeyValuePair<TKey, TValue> make_pair (TKey key, TValue value)
 687                         {
 688                                 return new KeyValuePair<TKey, TValue> (key, value);
 689                         }
 690
 691                 public delegate TRet Transform<TRet> (TKey key, TValue value);
 692         }
 693
 694         public static int test_0_bug_620864 () {
 695                 var d = new Pair<string, Type>.Transform<KeyValuePair<string, Type>> (Pair<string, Type>.make_pair);
 696
 697                 var p = d ("FOO", typeof (int));
 698                 if (p.Key != "FOO" || p.Value != typeof (int))
 699                         return 1;
 700
 701                 return 0;
 702         }
 703
 704
 705         struct RecStruct<T> {
 706                 public void foo (RecStruct<RecStruct<T>> baz) {
 707                 }
 708         }
 709
 710         public static int test_0_infinite_generic_recursion () {
 711                 // Check that the AOT compile can deal with infinite generic recursion through
 712                 // parameter types
 713                 RecStruct<int> bla;
 714
 715                 return 0;
 716         }
 717
 718         struct FooStruct {
 719         }
 720
 721         bool IsNull2 <T> (object value) where T : struct {
 722                 T? item = (T?) value;
 723
 724                 if (item.HasValue)
 725                         return false;
 726
 727                 return true;
 728         }
 729
 730         public static int test_0_full_aot_nullable_unbox_from_gshared_code () {
 731                 if (!new GenericsTests ().IsNull2<FooStruct> (null))
 732                         return 1;
 733                 if (new GenericsTests ().IsNull2<FooStruct> (new FooStruct ()))
 734                         return 2;
 735                 return 0;
 736         }
 737
 738         public static int test_0_partial_sharing () {
 739                 if (PartialShared1 (new List<string> (), 1) != typeof (string))
 740                         return 1;
 741                 if (PartialShared1 (new List<GenericsTests> (), 1) != typeof (GenericsTests))
 742                         return 2;
 743                 if (PartialShared2 (new List<string> (), 1) != typeof (int))
 744                         return 3;
 745                 if (PartialShared2 (new List<GenericsTests> (), 1) != typeof (int))
 746                         return 4;
 747                 return 0;
 748         }
 749
 750         [Category ("GSHAREDVT")]
 751         public static int test_6_partial_sharing_linq () {
 752                 var messages = new List<Message> ();
 753
 754                 messages.Add (new Message () { MessageID = 5 });
 755                 messages.Add (new Message () { MessageID = 6 });
 756
 757                 return messages.Max(i => i.MessageID);
 758         }
 759
 760         public static int test_0_partial_shared_method_in_nonshared_class () {
 761                 var c = new Class1<double> ();
 762                 return (c.Foo<string> (5).GetType () == typeof (Class1<string>)) ? 0 : 1;
 763         }
 764
 765         class Message {
 766                 public int MessageID {
 767                         get; set;
 768                 }
 769         }
 770
 771         public static Type PartialShared1<T, K> (List<T> list, K k) {
 772                 return typeof (T);
 773         }
 774
 775         public static Type PartialShared2<T, K> (List<T> list, K k) {
 776                 return typeof (K);
 777         }
 778
 779     public class Class1<T> {
 780                 public virtual void Do (Class2<T> t) {
 781                         t.Foo ();
 782                 }
 783
 784                 public virtual object Foo<U> (T t) {
 785                         return new Class1<U> ();
 786                 }
 787         }
 788
 789         public interface IFace1<T> {
 790                 void Foo ();
 791         }
 792
 793         public class Class2<T> : MarshalByRefObject, IFace1<T> {
 794                 public void Foo () {
 795                 }
 796         }
 797
 798
 799
 800         public static void VirtualInterfaceCallFromGenericMethod <T> (IFoo f) {
 801                 f.Bar <T> ();
 802         }
 803
 804         public static Type the_type;
 805
 806         public void ldvirtftn<T> () {
 807                 Foo <T> binding = new Foo <T> (default (T));
 808
 809                 binding.GenericEvent += event_handler;
 810                 binding.fire ();
 811         }
 812
 813         public virtual void event_handler<T> (Foo<T> sender) {
 814                 the_type = typeof (T);
 815         }
 816
 817         public interface IFoo {
 818                 void NonGeneric ();
 819                 object Bar<T>();
 820         }
 821
 822         public class Foo<T1> : IFoo
 823         {
 824                 public Foo(T1 t1)
 825                 {
 826                         m_t1 = t1;
 827                 }
 828
 829                 public override string ToString()
 830                 {
 831                         return Bar(m_t1 == null ? "null" : "null");
 832                 }
 833
 834                 public String Bar (String s) {
 835                         return s;
 836                 }
 837
 838                 public int this [T1 key] {
 839                         set {
 840                                 if (key == null)
 841                                         throw new ArgumentNullException ("key");
 842                         }
 843                 }
 844
 845                 public void throw_dead_this () {
 846                         try {
 847                                 new SomeClass().ThrowAnException();
 848                         }
 849                         catch {
 850                         }
 851                 }
 852
 853                 public T1 get_default () {
 854                         return default (T1);
 855                 }
 856
 857                 readonly T1 m_t1;
 858
 859                 public delegate void GenericEventHandler (Foo<T1> sender);
 860
 861                 public event GenericEventHandler GenericEvent;
 862
 863                 public void fire () {
 864                         GenericEvent (this);
 865                 }
 866
 867                 public static int count1, count2, count3, count4;
 868
 869                 public void NonGeneric () {
 870                         count3 ++;
 871                 }
 872
 873                 public object Bar <T> () {
 874                         if (typeof (T) == typeof (int))
 875                                 count1 ++;
 876                         else if (typeof (T) == typeof (string))
 877                                 count2 ++;
 878                         else if (typeof (T) == typeof (object))
 879                                 count4 ++;
 880                         return null;
 881                 }
 882         }
 883
 884         public class SomeClass {
 885                 public void ThrowAnException() {
 886                         throw new Exception ("Something went wrong");
 887                 }
 888         }
 889
 890         struct Handler : IFoo {
 891                 object o;
 892
 893                 public Handler(object o) {
 894                         this.o = o;
 895                 }
 896
 897                 public void NonGeneric () {
 898                 }
 899
 900                 public object Bar<T>() {
 901                         return o;
 902                 }
 903         }
 904
 905         static bool IsNull<T> (T t)
 906         {
 907                 if (t == null)
 908                         return true;
 909                 else
 910                         return false;
 911         }
 912
 913         static object Box<T> (T t)
 914         {
 915                 return t;
 916         }
 917
 918         static T Unbox <T> (object o) {
 919                 return (T) o;
 920         }
 921
 922         interface IDefaultRetriever
 923         {
 924                 T GetDefault<T>();
 925         }
 926
 927         class DefaultRetriever : IDefaultRetriever
 928         {
 929                 [MethodImpl(MethodImplOptions.Synchronized)]
 930                 public T GetDefault<T>()
 931                 {
 932                         return default(T);
 933                 }
 934         }
 935
 936         [Category ("!FULLAOT")]
 937         [Category ("!BITCODE")]
 938         public static int test_0_regress_668095_synchronized_gshared () {
 939                 return DoSomething (new DefaultRetriever ());
 940         }
 941
 942     static int DoSomething(IDefaultRetriever foo) {
 943                 int result = foo.GetDefault<int>();
 944                 return result;
 945         }
 946
 947         class SyncClass<T> {
 948                 [MethodImpl(MethodImplOptions.Synchronized)]
 949                 public Type getInstance() {
 950                         return typeof (T);
 951                 }
 952         }
 953
 954         [Category ("GSHAREDVT")]
 955         static int test_0_synchronized_gshared () {
 956                 var c = new SyncClass<string> ();
 957                 if (c.getInstance () != typeof (string))
 958                         return 1;
 959                 return 0;
 960         }
 961
 962         class Response {
 963         }
 964
 965         public static int test_0_687865_isinst_with_cache_wrapper () {
 966                 object o = new object ();
 967                 if (o is Action<IEnumerable<Response>>)
 968                         return 1;
 969                 else
 970                         return 0;
 971         }
 972
 973         enum DocType {
 974                 One,
 975                 Two,
 976                 Three
 977         }
 978
 979         class Doc {
 980                 public string Name {
 981                         get; set;
 982                 }
 983
 984                 public DocType Type {
 985                         get; set;
 986                 }
 987         }
 988
 989         // #2155
 990         [Category ("GSHAREDVT")]
 991         public static int test_0_fullaot_sflda_cctor () {
 992                 List<Doc> documents = new List<Doc>();
 993                 documents.Add(new Doc { Name = "Doc1", Type = DocType.One } );
 994                 documents.Add(new Doc { Name = "Doc2", Type = DocType.Two } );
 995                 documents.Add(new Doc { Name = "Doc3", Type = DocType.Three } );
 996                 documents.Add(new Doc { Name = "Doc4", Type = DocType.One } );
 997                 documents.Add(new Doc { Name = "Doc5", Type = DocType.Two } );
 998                 documents.Add(new Doc { Name = "Doc6", Type = DocType.Three } );
 999                 documents.Add(new Doc { Name = "Doc7", Type = DocType.One } );
1000                 documents.Add(new Doc { Name = "Doc8", Type = DocType.Two } );
1001                 documents.Add(new Doc { Name = "Doc9", Type = DocType.Three } );
1002
1003                 List<DocType> categories = documents.Select(d=>d.Type).Distinct().ToList<DocType>().OrderBy(d => d).ToList();
1004                 foreach(DocType cat in categories) {
1005                         List<Doc> catDocs = documents.Where(d => d.Type == cat).OrderBy(d => d.Name).ToList<Doc>();
1006                 }
1007                 return 0;
1008         }
1009
1010         class A { }
1011
1012     static List<A> sources = new List<A>();
1013
1014         // #6112
1015     public static int test_0_fullaot_imt () {
1016         sources.Add(null);
1017         sources.Add(null);
1018
1019         int a = sources.Count;
1020         var enumerator = sources.GetEnumerator() as IEnumerator<object>;
1021
1022         while (enumerator.MoveNext())
1023         {
1024             object o = enumerator.Current;
1025         }
1026
1027                 return 0;
1028         }
1029
1030         class AClass {
1031         }
1032
1033         class BClass : AClass {
1034         }
1035
1036         public static int test_0_fullaot_variant_iface () {
1037                 var arr = new BClass [10];
1038                 var enumerable = (IEnumerable<AClass>)arr;
1039                 enumerable.GetEnumerator ();
1040                 return 0;
1041         }
1042
1043         struct Record : Foo2<Record>.IRecord {
1044                 int counter;
1045                 int Foo2<Record>.IRecord.DoSomething () {
1046                         return counter++;
1047                 }
1048         }
1049
1050         class Foo2<T> where T : Foo2<T>.IRecord {
1051                 public interface IRecord {
1052                         int DoSomething ();
1053                 }
1054
1055                 public static int Extract (T[] t) {
1056                         return t[0].DoSomething ();
1057                 }
1058         }
1059
1060         class Foo3<T> where T : IComparable {
1061                 public static int CompareTo (T[] t) {
1062                         // This is a constrained call to Enum.CompareTo ()
1063                         return t[0].CompareTo (t [0]);
1064                 }
1065         }
1066
1067         public static int test_1_regress_constrained_iface_call_7571 () {
1068         var r = new Record [10];
1069         Foo2<Record>.Extract (r);
1070                 return Foo2<Record>.Extract (r);
1071         }
1072
1073         enum ConstrainedEnum {
1074                 Val = 1
1075         }
1076
1077         public static int test_0_regress_constrained_iface_call_enum () {
1078                 var r = new ConstrainedEnum [10];
1079                 return Foo3<ConstrainedEnum>.CompareTo (r);
1080         }
1081
1082         public interface IFoo2 {
1083                 void MoveNext ();
1084         }
1085
1086         public struct Foo2 : IFoo2 {
1087                 public void MoveNext () {
1088                 }
1089         }
1090
1091         public static Action Dingus (ref Foo2 f) {
1092                 return new Action (f.MoveNext);
1093         }
1094
1095         public static int test_0_delegate_unbox_full_aot () {
1096                 Foo2 foo = new Foo2 ();
1097                 Dingus (ref foo) ();
1098                 return 0;
1099         }
1100
1101         public static int test_0_arrays_ireadonly () {
1102                 int[] arr = new int [10];
1103                 for (int i = 0; i < 10; ++i)
1104                         arr [i] = i;
1105                 IReadOnlyList<int> a = (IReadOnlyList<int>)(object)arr;
1106                 if (a.Count != 10)
1107                         return 1;
1108                 if (a [0] != 0)
1109                         return 2;
1110                 if (a [1] != 1)
1111                         return 3;
1112                 return 0;
1113         }
1114
1115         public static int test_0_volatile_read_write () {
1116                 string foo = "ABC";
1117                 Volatile.Write (ref foo, "DEF");
1118                 return Volatile.Read (ref foo) == "DEF" ? 0 : 1;
1119         }
1120
1121         // FIXME: Doesn't work with --regression as Interlocked.Add(ref long) is only implemented as an intrinsic
1122 #if FALSE
1123         public static async Task<T> FooAsync<T> (int i, int j) {
1124                 Task<int> t = new Task<int> (delegate () { Console.WriteLine ("HIT!"); return 0; });
1125                 var response = await t;
1126                 return default(T);
1127         }
1128
1129         public static int test_0_fullaot_generic_async () {
1130                 Task<string> t = FooAsync<string> (1, 2);
1131                 t.RunSynchronously ();
1132                 return 0;
1133         }
1134 #endif
1135
1136         public static int test_0_delegate_callvirt_fullaot () {
1137                 Func<string> f = delegate () { return "A"; };
1138         var f2 = (Func<Func<string>, string>)Delegate.CreateDelegate (typeof
1139 (Func<Func<string>, string>), null, f.GetType ().GetMethod ("Invoke"));
1140
1141         var s = f2 (f);
1142                 return s == "A" ? 0 : 1;
1143         }
1144
1145     public interface ICovariant<out R>
1146     {
1147     }
1148
1149     // Deleting the `out` modifier from this line stop the problem
1150     public interface IExtCovariant<out R> : ICovariant<R>
1151     {
1152     }
1153
1154     public class Sample<R> : ICovariant<R>
1155     {
1156     }
1157
1158     public interface IMyInterface
1159     {
1160     }
1161
1162         public static int test_0_variant_cast_cache () {
1163                 object covariant = new Sample<IMyInterface>();
1164
1165                 var foo = (ICovariant<IMyInterface>)(covariant);
1166
1167                 try {
1168                         var extCovariant = (IExtCovariant<IMyInterface>)covariant;
1169                         return 1;
1170                 } catch {
1171                         return 0;
1172                 }
1173         }
1174
1175         struct FooStruct2 {
1176                 public int a1, a2, a3;
1177         }
1178
1179         class MyClass<T> where T: struct {
1180                 [MethodImplAttribute (MethodImplOptions.NoInlining)]
1181                 public MyClass(int a1, int a2, int a3, int a4, int a5, int a6, Nullable<T> a) {
1182                 }
1183
1184                 [MethodImplAttribute (MethodImplOptions.NoInlining)]
1185                 public static MyClass<T> foo () {
1186                         Nullable<T> a = new Nullable<T> ();
1187                         return new MyClass<T> (0, 0, 0, 0, 0, 0, a);
1188                 }
1189         }
1190
1191         public static int test_0_newobj_generic_context () {
1192                 MyClass<FooStruct2>.foo ();
1193                 return 0;
1194         }
1195
1196         enum AnEnum {
1197                 A,
1198                 B
1199         }
1200
1201         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1202         public static string constrained_tostring<T> (T t) {
1203                 return t.ToString ();
1204         }
1205
1206         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1207         public static bool constrained_equals<T> (T t1, T t2) {
1208                 var c = EqualityComparer<T>.Default;
1209
1210                 return c.Equals (t1, t2);
1211         }
1212
1213         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1214         public static int constrained_gethashcode<T> (T t) {
1215                 return t.GetHashCode ();
1216         }
1217
1218         public static int test_0_constrained_partial_sharing () {
1219                 string s;
1220
1221                 s = constrained_tostring<int> (5);
1222                 if (s != "5")
1223                         return 1;
1224                 s = constrained_tostring<AnEnum> (AnEnum.B);
1225                 if (s != "B")
1226                         return 2;
1227
1228                 if (!constrained_equals<int> (1, 1))
1229                         return 3;
1230                 if (constrained_equals<int> (1, 2))
1231                         return 4;
1232                 if (!constrained_equals<AnEnum> (AnEnum.A, AnEnum.A))
1233                         return 5;
1234                 if (constrained_equals<AnEnum> (AnEnum.A, AnEnum.B))
1235                         return 6;
1236
1237                 int i = constrained_gethashcode<int> (5);
1238                 if (i != 5)
1239                         return 7;
1240                 i = constrained_gethashcode<AnEnum> (AnEnum.B);
1241                 if (i != 1)
1242                         return 8;
1243                 return 0;
1244         }
1245
1246         enum Enum1 {
1247                 A,
1248                 B
1249         }
1250
1251         enum Enum2 {
1252                 A,
1253                 B
1254         }
1255
1256         public static int test_0_partial_sharing_ginst () {
1257                 var l1 = new List<KeyValuePair<int, Enum1>> ();
1258                 l1.Add (new KeyValuePair<int, Enum1>(5, Enum1.A));
1259                 if (l1 [0].Key != 5)
1260                         return 1;
1261                 if (l1 [0].Value != Enum1.A)
1262                         return 2;
1263                 var l2 = new List<KeyValuePair<int, Enum2>> ();
1264                 l2.Add (new KeyValuePair<int, Enum2>(5, Enum2.B));
1265                 if (l2 [0].Key != 5)
1266                         return 3;
1267                 if (l2 [0].Value != Enum2.B)
1268                         return 4;
1269                 return 0;
1270         }
1271
1272         static object delegate_8_args_res;
1273
1274         public static int test_0_delegate_8_args () {
1275                 delegate_8_args_res = null;
1276                 Action<string, string, string, string, string, string, string,
1277                         string> test = (a, b, c, d, e, f, g, h) =>
1278             {
1279                                 delegate_8_args_res = h;
1280             };
1281                 test("a", "b", "c", "d", "e", "f", "g", "h");
1282                 return delegate_8_args_res == "h" ? 0 : 1;
1283         }
1284
1285         static void throw_catch_t<T> () where T: Exception {
1286                 try {
1287                         throw new NotSupportedException ();
1288                 } catch (T) {
1289                 }
1290         }
1291
1292         public static int test_0_gshared_catch_open_type () {
1293                 throw_catch_t<NotSupportedException> ();
1294                 return 0;
1295         }
1296
1297         class ThrowClass<T> where T: Exception {
1298                 public void throw_catch_t () {
1299                         try {
1300                                 throw new NotSupportedException ();
1301                         } catch (T) {
1302                         }
1303                 }
1304         }
1305
1306         public static int test_0_gshared_catch_open_type_instance () {
1307                 var c = new ThrowClass<NotSupportedException> ();
1308                 c.throw_catch_t ();
1309                 return 0;
1310         }
1311
1312         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1313         public static bool is_ref_or_contains_refs<T> () {
1314                 return RuntimeHelpers.IsReferenceOrContainsReferences<T> ();
1315         }
1316
1317         class IsRefClass<T> {
1318                 [MethodImplAttribute (MethodImplOptions.NoInlining)]
1319                 public bool is_ref () {
1320                         return RuntimeHelpers.IsReferenceOrContainsReferences<T> ();
1321                 }
1322         }
1323
1324         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1325         public static bool is_ref_or_contains_refs_gen_ref<T> () {
1326                 return RuntimeHelpers.IsReferenceOrContainsReferences<GenStruct<T>> ();
1327         }
1328
1329         [MethodImplAttribute (MethodImplOptions.NoInlining)]
1330         public static bool is_ref_or_contains_refs_gen_noref<T> () {
1331                 return RuntimeHelpers.IsReferenceOrContainsReferences<NoRefGenStruct<T>> ();
1332         }
1333
1334         struct GenStruct<T> {
1335                 T t;
1336         }
1337
1338         struct NoRefGenStruct<T> {
1339         }
1340
1341         struct RefStruct {
1342                 string s;
1343         }
1344
1345         struct NestedRefStruct {
1346                 RefStruct r;
1347         }
1348
1349         struct NoRefStruct {
1350                 int i;
1351         }
1352
1353         struct AStruct3<T1, T2, T3> {
1354                 T1 t1;
1355                 T2 t2;
1356                 T3 t3;
1357         }
1358
1359         public static int test_0_isreference_intrins () {
1360                 if (RuntimeHelpers.IsReferenceOrContainsReferences<int> ())
1361                         return 1;
1362                 if (!RuntimeHelpers.IsReferenceOrContainsReferences<string> ())
1363                         return 2;
1364                 if (!RuntimeHelpers.IsReferenceOrContainsReferences<RefStruct> ())
1365                         return 3;
1366                 if (!RuntimeHelpers.IsReferenceOrContainsReferences<NestedRefStruct> ())
1367                         return 4;
1368                 if (RuntimeHelpers.IsReferenceOrContainsReferences<NoRefStruct> ())
1369                         return 5;
1370                 // Generic code
1371                 if (is_ref_or_contains_refs<int> ())
1372                         return 6;
1373                 // Shared code
1374                 if (!is_ref_or_contains_refs<string> ())
1375                         return 7;
1376                 // Complex type from shared code
1377                 if (!is_ref_or_contains_refs_gen_ref<string> ())
1378                         return 8;
1379                 if (is_ref_or_contains_refs_gen_ref<int> ())
1380                         return 9;
1381                 if (is_ref_or_contains_refs_gen_noref<string> ())
1382                         return 10;
1383
1384                 // Complex type from shared class method
1385                 var c1 = new IsRefClass<AStruct3<int, int, int>> ();
1386                 if (c1.is_ref ())
1387                         return 11;
1388                 var c2 = new IsRefClass<AStruct3<string, int, int>> ();
1389                 if (!c2.is_ref ())
1390                         return 12;
1391
1392                 return 0;
1393         }
1394 }
1395
1396 #if !__MOBILE__
1397 class GenericsTests : Tests
1398 {
1399 }
1400 #endif