mcs/gmcs/generic.cs

   1 //
   2 // generic.cs: Generics support
   3 //
   4 // Authors: Martin Baulig (martin@ximian.com)
   5 //          Miguel de Icaza (miguel@ximian.com)
   6 //
   7 // Licensed under the terms of the GNU GPL
   8 //
   9 // (C) 2001, 2002, 2003 Ximian, Inc (http://www.ximian.com)
  10 // (C) 2004 Novell, Inc
  11 //
  12 using System;
  13 using System.Reflection;
  14 using System.Reflection.Emit;
  15 using System.Globalization;
  16 using System.Collections;
  17 using System.Text;
  18 using System.Text.RegularExpressions;
  19
  20 namespace Mono.CSharp {
  21
  22         /// <summary>
  23         ///   Abstract base class for type parameter constraints.
  24         ///   The type parameter can come from a generic type definition or from reflection.
  25         /// </summary>
  26         public abstract class GenericConstraints {
  27                 public abstract string TypeParameter {
  28                         get;
  29                 }
  30
  31                 public abstract GenericParameterAttributes Attributes {
  32                         get;
  33                 }
  34
  35                 public bool HasConstructorConstraint {
  36                         get { return (Attributes & GenericParameterAttributes.DefaultConstructorConstraint) != 0; }
  37                 }
  38
  39                 public bool HasReferenceTypeConstraint {
  40                         get { return (Attributes & GenericParameterAttributes.ReferenceTypeConstraint) != 0; }
  41                 }
  42
  43                 public bool HasValueTypeConstraint {
  44                         get { return (Attributes & GenericParameterAttributes.NotNullableValueTypeConstraint) != 0; }
  45                 }
  46
  47                 public virtual bool HasClassConstraint {
  48                         get { return ClassConstraint != null; }
  49                 }
  50
  51                 public abstract Type ClassConstraint {
  52                         get;
  53                 }
  54
  55                 public abstract Type[] InterfaceConstraints {
  56                         get;
  57                 }
  58
  59                 public abstract Type EffectiveBaseClass {
  60                         get;
  61                 }
  62
  63                 // <summary>
  64                 //   Returns whether the type parameter is "known to be a reference type".
  65                 // </summary>
  66                 public virtual bool IsReferenceType {
  67                         get {
  68                                 if (HasReferenceTypeConstraint)
  69                                         return true;
  70                                 if (HasValueTypeConstraint)
  71                                         return false;
  72
  73                                 if (ClassConstraint != null) {
  74                                         if (ClassConstraint.IsValueType)
  75                                                 return false;
  76
  77                                         if (ClassConstraint != TypeManager.object_type)
  78                                                 return true;
  79                                 }
  80
  81                                 foreach (Type t in InterfaceConstraints) {
  82                                         if (!t.IsGenericParameter)
  83                                                 continue;
  84
  85                                         GenericConstraints gc = TypeManager.GetTypeParameterConstraints (t);
  86                                         if ((gc != null) && gc.IsReferenceType)
  87                                                 return true;
  88                                 }
  89
  90                                 return false;
  91                         }
  92                 }
  93
  94                 // <summary>
  95                 //   Returns whether the type parameter is "known to be a value type".
  96                 // </summary>
  97                 public virtual bool IsValueType {
  98                         get {
  99                                 if (HasValueTypeConstraint)
 100                                         return true;
 101                                 if (HasReferenceTypeConstraint)
 102                                         return false;
 103
 104                                 if (ClassConstraint != null) {
 105                                         if (!ClassConstraint.IsValueType)
 106                                                 return false;
 107
 108                                         if (ClassConstraint != TypeManager.value_type)
 109                                                 return true;
 110                                 }
 111
 112                                 foreach (Type t in InterfaceConstraints) {
 113                                         if (!t.IsGenericParameter)
 114                                                 continue;
 115
 116                                         GenericConstraints gc = TypeManager.GetTypeParameterConstraints (t);
 117                                         if ((gc != null) && gc.IsValueType)
 118                                                 return true;
 119                                 }
 120
 121                                 return false;
 122                         }
 123                 }
 124         }
 125
 126         public enum SpecialConstraint
 127         {
 128                 Constructor,
 129                 ReferenceType,
 130                 ValueType
 131         }
 132
 133         /// <summary>
 134         ///   Tracks the constraints for a type parameter from a generic type definition.
 135         /// </summary>
 136         public class Constraints : GenericConstraints {
 137                 string name;
 138                 ArrayList constraints;
 139                 Location loc;
 140
 141                 //
 142                 // name is the identifier, constraints is an arraylist of
 143                 // Expressions (with types) or `true' for the constructor constraint.
 144                 //
 145                 public Constraints (string name, ArrayList constraints,
 146                                     Location loc)
 147                 {
 148                         this.name = name;
 149                         this.constraints = constraints;
 150                         this.loc = loc;
 151                 }
 152
 153                 public override string TypeParameter {
 154                         get {
 155                                 return name;
 156                         }
 157                 }
 158
 159                 GenericParameterAttributes attrs;
 160                 TypeExpr class_constraint;
 161                 ArrayList iface_constraints;
 162                 ArrayList type_param_constraints;
 163                 int num_constraints;
 164                 Type class_constraint_type;
 165                 Type[] iface_constraint_types;
 166                 Type effective_base_type;
 167                 bool resolved;
 168                 bool resolved_types;
 169
 170                 /// <summary>
 171                 ///   Resolve the constraints - but only resolve things into Expression's, not
 172                 ///   into actual types.
 173                 /// </summary>
 174                 public bool Resolve (IResolveContext ec)
 175                 {
 176                         if (resolved)
 177                                 return true;
 178
 179                         iface_constraints = new ArrayList ();
 180                         type_param_constraints = new ArrayList ();
 181
 182                         foreach (object obj in constraints) {
 183                                 if (HasConstructorConstraint) {
 184                                         Report.Error (401, loc,
 185                                                       "The new() constraint must be the last constraint specified");
 186                                         return false;
 187                                 }
 188
 189                                 if (obj is SpecialConstraint) {
 190                                         SpecialConstraint sc = (SpecialConstraint) obj;
 191
 192                                         if (sc == SpecialConstraint.Constructor) {
 193                                                 if (!HasValueTypeConstraint) {
 194                                                         attrs |= GenericParameterAttributes.DefaultConstructorConstraint;
 195                                                         continue;
 196                                                 }
 197
 198                                                 Report.Error (451, loc, "The `new()' constraint " +
 199                                                         "cannot be used with the `struct' constraint");
 200                                                 return false;
 201                                         }
 202
 203                                         if ((num_constraints > 0) || HasReferenceTypeConstraint || HasValueTypeConstraint) {
 204                                                 Report.Error (449, loc, "The `class' or `struct' " +
 205                                                               "constraint must be the first constraint specified");
 206                                                 return false;
 207                                         }
 208
 209                                         if (sc == SpecialConstraint.ReferenceType)
 210                                                 attrs |= GenericParameterAttributes.ReferenceTypeConstraint;
 211                                         else
 212                                                 attrs |= GenericParameterAttributes.NotNullableValueTypeConstraint;
 213                                         continue;
 214                                 }
 215
 216                                 int errors = Report.Errors;
 217                                 FullNamedExpression fn = ((Expression) obj).ResolveAsTypeStep (ec, false);
 218
 219                                 if (fn == null) {
 220                                         if (errors != Report.Errors)
 221                                                 return false;
 222
 223                                         NamespaceEntry.Error_NamespaceNotFound (loc, ((Expression)obj).GetSignatureForError ());
 224                                         return false;
 225                                 }
 226
 227                                 TypeExpr expr;
 228                                 ConstructedType cexpr = fn as ConstructedType;
 229                                 if (cexpr != null) {
 230                                         if (!cexpr.ResolveConstructedType (ec))
 231                                                 return false;
 232
 233                                         expr = cexpr;
 234                                 } else
 235                                         expr = ((Expression) obj).ResolveAsTypeTerminal (ec, false);
 236
 237                                 if ((expr == null) || (expr.Type == null))
 238                                         return false;
 239
 240                                 // TODO: It's aleady done in ResolveAsBaseTerminal
 241                                 if (!ec.GenericDeclContainer.AsAccessible (fn.Type, ec.GenericDeclContainer.ModFlags)) {
 242                                         Report.SymbolRelatedToPreviousError (fn.Type);
 243                                         Report.Error (703, loc,
 244                                                 "Inconsistent accessibility: constraint type `{0}' is less accessible than `{1}'",
 245                                                 fn.GetSignatureForError (), ec.GenericDeclContainer.GetSignatureForError ());
 246                                         return false;
 247                                 }
 248
 249                                 TypeParameterExpr texpr = expr as TypeParameterExpr;
 250                                 if (texpr != null)
 251                                         type_param_constraints.Add (expr);
 252                                 else if (expr.IsInterface)
 253                                         iface_constraints.Add (expr);
 254                                 else if (class_constraint != null) {
 255                                         Report.Error (406, loc,
 256                                                       "`{0}': the class constraint for `{1}' " +
 257                                                       "must come before any other constraints.",
 258                                                       expr.Name, name);
 259                                         return false;
 260                                 } else if (HasReferenceTypeConstraint || HasValueTypeConstraint) {
 261                                         Report.Error (450, loc, "`{0}': cannot specify both " +
 262                                                       "a constraint class and the `class' " +
 263                                                       "or `struct' constraint", expr.GetSignatureForError ());
 264                                         return false;
 265                                 } else
 266                                         class_constraint = expr;
 267
 268                                 num_constraints++;
 269                         }
 270
 271                         ArrayList list = new ArrayList ();
 272                         foreach (TypeExpr iface_constraint in iface_constraints) {
 273                                 foreach (Type type in list) {
 274                                         if (!type.Equals (iface_constraint.Type))
 275                                                 continue;
 276
 277                                         Report.Error (405, loc,
 278                                                       "Duplicate constraint `{0}' for type " +
 279                                                       "parameter `{1}'.", iface_constraint.GetSignatureForError (),
 280                                                       name);
 281                                         return false;
 282                                 }
 283
 284                                 list.Add (iface_constraint.Type);
 285                         }
 286
 287                         foreach (TypeParameterExpr expr in type_param_constraints) {
 288                                 foreach (Type type in list) {
 289                                         if (!type.Equals (expr.Type))
 290                                                 continue;
 291
 292                                         Report.Error (405, loc,
 293                                                       "Duplicate constraint `{0}' for type " +
 294                                                       "parameter `{1}'.", expr.GetSignatureForError (), name);
 295                                         return false;
 296                                 }
 297
 298                                 list.Add (expr.Type);
 299                         }
 300
 301                         iface_constraint_types = new Type [list.Count];
 302                         list.CopyTo (iface_constraint_types, 0);
 303
 304                         if (class_constraint != null) {
 305                                 class_constraint_type = class_constraint.Type;
 306                                 if (class_constraint_type == null)
 307                                         return false;
 308
 309                                 if (class_constraint_type.IsSealed) {
 310                                         if (class_constraint_type.IsAbstract)
 311                                         {
 312                                                 Report.Error (717, loc, "`{0}' is not a valid constraint. Static classes cannot be used as constraints",
 313                                                         TypeManager.CSharpName (class_constraint_type));
 314                                         }
 315                                         else
 316                                         {
 317                                                 Report.Error (701, loc, "`{0}' is not a valid constraint. A constraint must be an interface, " +
 318                                                         "a non-sealed class or a type parameter", TypeManager.CSharpName(class_constraint_type));
 319                                         }
 320                                         return false;
 321                                 }
 322
 323                                 if ((class_constraint_type == TypeManager.array_type) ||
 324                                     (class_constraint_type == TypeManager.delegate_type) ||
 325                                     (class_constraint_type == TypeManager.enum_type) ||
 326                                     (class_constraint_type == TypeManager.value_type) ||
 327                                     (class_constraint_type == TypeManager.object_type)) {
 328                                         Report.Error (702, loc,
 329                                                       "Bound cannot be special class `{0}'",
 330                                                       TypeManager.CSharpName (class_constraint_type));
 331                                         return false;
 332                                 }
 333                         }
 334
 335                         if (class_constraint_type != null)
 336                                 effective_base_type = class_constraint_type;
 337                         else if (HasValueTypeConstraint)
 338                                 effective_base_type = TypeManager.value_type;
 339                         else
 340                                 effective_base_type = TypeManager.object_type;
 341
 342                         resolved = true;
 343                         return true;
 344                 }
 345
 346                 bool CheckTypeParameterConstraints (TypeParameter tparam, Hashtable seen)
 347                 {
 348                         seen.Add (tparam, true);
 349
 350                         Constraints constraints = tparam.Constraints;
 351                         if (constraints == null)
 352                                 return true;
 353
 354                         if (constraints.HasValueTypeConstraint) {
 355                                 Report.Error (456, loc, "Type parameter `{0}' has " +
 356                                               "the `struct' constraint, so it cannot " +
 357                                               "be used as a constraint for `{1}'",
 358                                               tparam.Name, name);
 359                                 return false;
 360                         }
 361
 362                         if (constraints.type_param_constraints == null)
 363                                 return true;
 364
 365                         foreach (TypeParameterExpr expr in constraints.type_param_constraints) {
 366                                 if (seen.Contains (expr.TypeParameter)) {
 367                                         Report.Error (454, loc, "Circular constraint " +
 368                                                       "dependency involving `{0}' and `{1}'",
 369                                                       tparam.Name, expr.Name);
 370                                         return false;
 371                                 }
 372
 373                                 if (!CheckTypeParameterConstraints (expr.TypeParameter, seen))
 374                                         return false;
 375                         }
 376
 377                         return true;
 378                 }
 379
 380                 /// <summary>
 381                 ///   Resolve the constraints into actual types.
 382                 /// </summary>
 383                 public bool ResolveTypes (IResolveContext ec)
 384                 {
 385                         if (resolved_types)
 386                                 return true;
 387
 388                         resolved_types = true;
 389
 390                         foreach (object obj in constraints) {
 391                                 ConstructedType cexpr = obj as ConstructedType;
 392                                 if (cexpr == null)
 393                                         continue;
 394
 395                                 if (!cexpr.CheckConstraints (ec))
 396                                         return false;
 397                         }
 398
 399                         foreach (TypeParameterExpr expr in type_param_constraints) {
 400                                 Hashtable seen = new Hashtable ();
 401                                 if (!CheckTypeParameterConstraints (expr.TypeParameter, seen))
 402                                         return false;
 403                         }
 404
 405                         for (int i = 0; i < iface_constraints.Count; ++i) {
 406                                 TypeExpr iface_constraint = (TypeExpr) iface_constraints [i];
 407                                 iface_constraint = iface_constraint.ResolveAsTypeTerminal (ec, false);
 408                                 if (iface_constraint == null)
 409                                         return false;
 410                                 iface_constraints [i] = iface_constraint;
 411                         }
 412
 413                         if (class_constraint != null) {
 414                                 class_constraint = class_constraint.ResolveAsTypeTerminal (ec, false);
 415                                 if (class_constraint == null)
 416                                         return false;
 417                         }
 418
 419                         return true;
 420                 }
 421
 422                 /// <summary>
 423                 ///   Check whether there are no conflicts in our type parameter constraints.
 424                 ///
 425                 ///   This is an example:
 426                 ///
 427                 ///   class Foo<T,U>
 428                 ///      where T : class
 429                 ///      where U : T, struct
 430                 /// </summary>
 431                 public bool CheckDependencies ()
 432                 {
 433                         foreach (TypeParameterExpr expr in type_param_constraints) {
 434                                 if (!CheckDependencies (expr.TypeParameter))
 435                                         return false;
 436                         }
 437
 438                         return true;
 439                 }
 440
 441                 bool CheckDependencies (TypeParameter tparam)
 442                 {
 443                         Constraints constraints = tparam.Constraints;
 444                         if (constraints == null)
 445                                 return true;
 446
 447                         if (HasValueTypeConstraint && constraints.HasClassConstraint) {
 448                                 Report.Error (455, loc, "Type parameter `{0}' inherits " +
 449                                               "conflicting constraints `{1}' and `{2}'",
 450                                               name, TypeManager.CSharpName (constraints.ClassConstraint),
 451                                               "System.ValueType");
 452                                 return false;
 453                         }
 454
 455                         if (HasClassConstraint && constraints.HasClassConstraint) {
 456                                 Type t1 = ClassConstraint;
 457                                 TypeExpr e1 = class_constraint;
 458                                 Type t2 = constraints.ClassConstraint;
 459                                 TypeExpr e2 = constraints.class_constraint;
 460
 461                                 if (!Convert.ImplicitReferenceConversionExists (e1, t2) &&
 462                                     !Convert.ImplicitReferenceConversionExists (e2, t1)) {
 463                                         Report.Error (455, loc,
 464                                                       "Type parameter `{0}' inherits " +
 465                                                       "conflicting constraints `{1}' and `{2}'",
 466                                                       name, TypeManager.CSharpName (t1), TypeManager.CSharpName (t2));
 467                                         return false;
 468                                 }
 469                         }
 470
 471                         if (constraints.type_param_constraints == null)
 472                                 return true;
 473
 474                         foreach (TypeParameterExpr expr in constraints.type_param_constraints) {
 475                                 if (!CheckDependencies (expr.TypeParameter))
 476                                         return false;
 477                         }
 478
 479                         return true;
 480                 }
 481
 482                 public override GenericParameterAttributes Attributes {
 483                         get { return attrs; }
 484                 }
 485
 486                 public override bool HasClassConstraint {
 487                         get { return class_constraint != null; }
 488                 }
 489
 490                 public override Type ClassConstraint {
 491                         get { return class_constraint_type; }
 492                 }
 493
 494                 public override Type[] InterfaceConstraints {
 495                         get { return iface_constraint_types; }
 496                 }
 497
 498                 public override Type EffectiveBaseClass {
 499                         get { return effective_base_type; }
 500                 }
 501
 502                 public bool IsSubclassOf (Type t)
 503                 {
 504                         if ((class_constraint_type != null) &&
 505                             class_constraint_type.IsSubclassOf (t))
 506                                 return true;
 507
 508                         if (iface_constraint_types == null)
 509                                 return false;
 510
 511                         foreach (Type iface in iface_constraint_types) {
 512                                 if (TypeManager.IsSubclassOf (iface, t))
 513                                         return true;
 514                         }
 515
 516                         return false;
 517                 }
 518
 519                 public Location Location {
 520                         get {
 521                                 return loc;
 522                         }
 523                 }
 524
 525                 /// <summary>
 526                 ///   This is used when we're implementing a generic interface method.
 527                 ///   Each method type parameter in implementing method must have the same
 528                 ///   constraints than the corresponding type parameter in the interface
 529                 ///   method.  To do that, we're called on each of the implementing method's
 530                 ///   type parameters.
 531                 /// </summary>
 532                 public bool CheckInterfaceMethod (GenericConstraints gc)
 533                 {
 534                         if (gc.Attributes != attrs)
 535                                 return false;
 536
 537                         if (HasClassConstraint != gc.HasClassConstraint)
 538                                 return false;
 539                         if (HasClassConstraint && !TypeManager.IsEqual (gc.ClassConstraint, ClassConstraint))
 540                                 return false;
 541
 542                         int gc_icount = gc.InterfaceConstraints != null ?
 543                                 gc.InterfaceConstraints.Length : 0;
 544                         int icount = InterfaceConstraints != null ?
 545                                 InterfaceConstraints.Length : 0;
 546
 547                         if (gc_icount != icount)
 548                                 return false;
 549
 550                         foreach (Type iface in gc.InterfaceConstraints) {
 551                                 bool ok = false;
 552                                 foreach (Type check in InterfaceConstraints) {
 553                                         if (TypeManager.IsEqual (iface, check)) {
 554                                                 ok = true;
 555                                                 break;
 556                                         }
 557                                 }
 558
 559                                 if (!ok)
 560                                         return false;
 561                         }
 562
 563                         return true;
 564                 }
 565         }
 566
 567         /// <summary>
 568         ///   A type parameter from a generic type definition.
 569         /// </summary>
 570         public class TypeParameter : MemberCore, IMemberContainer {
 571                 string name;
 572                 DeclSpace decl;
 573                 GenericConstraints gc;
 574                 Constraints constraints;
 575                 Location loc;
 576                 GenericTypeParameterBuilder type;
 577
 578                 public TypeParameter (DeclSpace parent, DeclSpace decl, string name,
 579                                       Constraints constraints, Attributes attrs, Location loc)
 580                         : base (parent, new MemberName (name, loc), attrs)
 581                 {
 582                         this.name = name;
 583                         this.decl = decl;
 584                         this.constraints = constraints;
 585                         this.loc = loc;
 586                 }
 587
 588                 public GenericConstraints GenericConstraints {
 589                         get { return gc != null ? gc : constraints; }
 590                 }
 591
 592                 public Constraints Constraints {
 593                         get { return constraints; }
 594                 }
 595
 596                 public bool HasConstructorConstraint {
 597                         get { return constraints != null && constraints.HasConstructorConstraint; }
 598                 }
 599
 600                 public DeclSpace DeclSpace {
 601                         get { return decl; }
 602                 }
 603
 604                 public Type Type {
 605                         get { return type; }
 606                 }
 607
 608                 /// <summary>
 609                 ///   This is the first method which is called during the resolving
 610                 ///   process; we're called immediately after creating the type parameters
 611                 ///   with SRE (by calling `DefineGenericParameters()' on the TypeBuilder /
 612                 ///   MethodBuilder).
 613                 ///
 614                 ///   We're either called from TypeContainer.DefineType() or from
 615                 ///   GenericMethod.Define() (called from Method.Define()).
 616                 /// </summary>
 617                 public void Define (GenericTypeParameterBuilder type)
 618                 {
 619                         if (this.type != null)
 620                                 throw new InvalidOperationException ();
 621
 622                         this.type = type;
 623                         TypeManager.AddTypeParameter (type, this);
 624                 }
 625
 626                 /// <summary>
 627                 ///   This is the second method which is called during the resolving
 628                 ///   process - in case of class type parameters, we're called from
 629                 ///   TypeContainer.ResolveType() - after it resolved the class'es
 630                 ///   base class and interfaces. For method type parameters, we're
 631                 ///   called immediately after Define().
 632                 ///
 633                 ///   We're just resolving the constraints into expressions here, we
 634                 ///   don't resolve them into actual types.
 635                 ///
 636                 ///   Note that in the special case of partial generic classes, we may be
 637                 ///   called _before_ Define() and we may also be called multiple types.
 638                 /// </summary>
 639                 public bool Resolve (DeclSpace ds)
 640                 {
 641                         if (constraints != null) {
 642                                 if (!constraints.Resolve (ds)) {
 643                                         constraints = null;
 644                                         return false;
 645                                 }
 646                         }
 647
 648                         return true;
 649                 }
 650
 651                 /// <summary>
 652                 ///   This is the third method which is called during the resolving
 653                 ///   process.  We're called immediately after calling DefineConstraints()
 654                 ///   on all of the current class'es type parameters.
 655                 ///
 656                 ///   Our job is to resolve the constraints to actual types.
 657                 ///
 658                 ///   Note that we may have circular dependencies on type parameters - this
 659                 ///   is why Resolve() and ResolveType() are separate.
 660                 /// </summary>
 661                 public bool ResolveType (IResolveContext ec)
 662                 {
 663                         if (constraints != null) {
 664                                 if (!constraints.ResolveTypes (ec)) {
 665                                         constraints = null;
 666                                         return false;
 667                                 }
 668                         }
 669
 670                         return true;
 671                 }
 672
 673                 /// <summary>
 674                 ///   This is the fourth and last method which is called during the resolving
 675                 ///   process.  We're called after everything is fully resolved and actually
 676                 ///   register the constraints with SRE and the TypeManager.
 677                 /// </summary>
 678                 public bool DefineType (IResolveContext ec)
 679                 {
 680                         return DefineType (ec, null, null, false);
 681                 }
 682
 683                 /// <summary>
 684                 ///   This is the fith and last method which is called during the resolving
 685                 ///   process.  We're called after everything is fully resolved and actually
 686                 ///   register the constraints with SRE and the TypeManager.
 687                 ///
 688                 ///   The `builder', `implementing' and `is_override' arguments are only
 689                 ///   applicable to method type parameters.
 690                 /// </summary>
 691                 public bool DefineType (IResolveContext ec, MethodBuilder builder,
 692                                         MethodInfo implementing, bool is_override)
 693                 {
 694                         if (!ResolveType (ec))
 695                                 return false;
 696
 697                         if (implementing != null) {
 698                                 if (is_override && (constraints != null)) {
 699                                         Report.Error (460, loc,
 700                                                 "`{0}': Cannot specify constraints for overrides or explicit interface implementation methods",
 701                                                 TypeManager.CSharpSignature (builder));
 702                                         return false;
 703                                 }
 704
 705                                 MethodBase mb = TypeManager.DropGenericMethodArguments (implementing);
 706
 707                                 int pos = type.GenericParameterPosition;
 708                                 Type mparam = mb.GetGenericArguments () [pos];
 709                                 GenericConstraints temp_gc = ReflectionConstraints.GetConstraints (mparam);
 710
 711                                 if (temp_gc != null)
 712                                         gc = new InflatedConstraints (temp_gc, implementing.DeclaringType);
 713                                 else if (constraints != null)
 714                                         gc = new InflatedConstraints (constraints, implementing.DeclaringType);
 715
 716                                 bool ok = true;
 717                                 if (constraints != null) {
 718                                         if (temp_gc == null)
 719                                                 ok = false;
 720                                         else if (!constraints.CheckInterfaceMethod (gc))
 721                                                 ok = false;
 722                                 } else {
 723                                         if (!is_override && (temp_gc != null))
 724                                                 ok = false;
 725                                 }
 726
 727                                 if (!ok) {
 728                                         Report.SymbolRelatedToPreviousError (implementing);
 729
 730                                         Report.Error (
 731                                                 425, loc, "The constraints for type " +
 732                                                 "parameter `{0}' of method `{1}' must match " +
 733                                                 "the constraints for type parameter `{2}' " +
 734                                                 "of interface method `{3}'. Consider using " +
 735                                                 "an explicit interface implementation instead",
 736                                                 Name, TypeManager.CSharpSignature (builder),
 737                                                 TypeManager.CSharpName (mparam), TypeManager.CSharpSignature (mb));
 738                                         return false;
 739                                 }
 740                         } else if (DeclSpace is Iterator) {
 741                                 TypeParameter[] tparams = DeclSpace.TypeParameters;
 742                                 Type[] types = new Type [tparams.Length];
 743                                 for (int i = 0; i < tparams.Length; i++)
 744                                         types [i] = tparams [i].Type;
 745
 746                                 if (constraints != null)
 747                                         gc = new InflatedConstraints (constraints, types);
 748                         } else {
 749                                 gc = (GenericConstraints) constraints;
 750                         }
 751
 752                         if (gc == null)
 753                                 return true;
 754
 755                         if (gc.HasClassConstraint)
 756                                 type.SetBaseTypeConstraint (gc.ClassConstraint);
 757
 758                         type.SetInterfaceConstraints (gc.InterfaceConstraints);
 759                         type.SetGenericParameterAttributes (gc.Attributes);
 760                         TypeManager.RegisterBuilder (type, gc.InterfaceConstraints);
 761
 762                         return true;
 763                 }
 764
 765                 /// <summary>
 766                 ///   Check whether there are no conflicts in our type parameter constraints.
 767                 ///
 768                 ///   This is an example:
 769                 ///
 770                 ///   class Foo<T,U>
 771                 ///      where T : class
 772                 ///      where U : T, struct
 773                 /// </summary>
 774                 public bool CheckDependencies ()
 775                 {
 776                         if (constraints != null)
 777                                 return constraints.CheckDependencies ();
 778
 779                         return true;
 780                 }
 781
 782                 /// <summary>
 783                 ///   This is called for each part of a partial generic type definition.
 784                 ///
 785                 ///   If `new_constraints' is not null and we don't already have constraints,
 786                 ///   they become our constraints.  If we already have constraints, we must
 787                 ///   check that they're the same.
 788                 ///   con
 789                 /// </summary>
 790                 public bool UpdateConstraints (IResolveContext ec, Constraints new_constraints)
 791                 {
 792                         if (type == null)
 793                                 throw new InvalidOperationException ();
 794
 795                         if (new_constraints == null)
 796                                 return true;
 797
 798                         if (!new_constraints.Resolve (ec))
 799                                 return false;
 800                         if (!new_constraints.ResolveTypes (ec))
 801                                 return false;
 802
 803                         if (constraints != null)
 804                                 return constraints.CheckInterfaceMethod (new_constraints);
 805
 806                         constraints = new_constraints;
 807                         return true;
 808                 }
 809
 810                 public void EmitAttributes ()
 811                 {
 812                         if (OptAttributes != null)
 813                                 OptAttributes.Emit ();
 814                 }
 815
 816                 public override string DocCommentHeader {
 817                         get {
 818                                 throw new InvalidOperationException (
 819                                         "Unexpected attempt to get doc comment from " + this.GetType () + ".");
 820                         }
 821                 }
 822
 823                 //
 824                 // MemberContainer
 825                 //
 826
 827                 public override bool Define ()
 828                 {
 829                         return true;
 830                 }
 831
 832                 public override void ApplyAttributeBuilder (Attribute a,
 833                                                             CustomAttributeBuilder cb)
 834                 {
 835                         type.SetCustomAttribute (cb);
 836                 }
 837
 838                 public override AttributeTargets AttributeTargets {
 839                         get {
 840                                 return (AttributeTargets) AttributeTargets.GenericParameter;
 841                         }
 842                 }
 843
 844                 public override string[] ValidAttributeTargets {
 845                         get {
 846                                 return new string [] { "type parameter" };
 847                         }
 848                 }
 849
 850                 //
 851                 // IMemberContainer
 852                 //
 853
 854                 string IMemberContainer.Name {
 855                         get { return Name; }
 856                 }
 857
 858                 MemberCache IMemberContainer.BaseCache {
 859                         get { return null; }
 860                 }
 861
 862                 bool IMemberContainer.IsInterface {
 863                         get { return true; }
 864                 }
 865
 866                 MemberList IMemberContainer.GetMembers (MemberTypes mt, BindingFlags bf)
 867                 {
 868                         return FindMembers (mt, bf, null, null);
 869                 }
 870
 871                 MemberCache IMemberContainer.MemberCache {
 872                         get { return null; }
 873                 }
 874
 875                 public MemberList FindMembers (MemberTypes mt, BindingFlags bf,
 876                                                MemberFilter filter, object criteria)
 877                 {
 878                         if (constraints == null)
 879                                 return MemberList.Empty;
 880
 881                         ArrayList members = new ArrayList ();
 882
 883                         if (gc.HasClassConstraint) {
 884                                 MemberList list = TypeManager.FindMembers (
 885                                         gc.ClassConstraint, mt, bf, filter, criteria);
 886
 887                                 members.AddRange (list);
 888                         }
 889
 890                         Type[] ifaces = TypeManager.ExpandInterfaces (gc.InterfaceConstraints);
 891                         foreach (Type t in ifaces) {
 892                                 MemberList list = TypeManager.FindMembers (
 893                                         t, mt, bf, filter, criteria);
 894
 895                                 members.AddRange (list);
 896                         }
 897
 898                         return new MemberList (members);
 899                 }
 900
 901                 public bool IsSubclassOf (Type t)
 902                 {
 903                         if (type.Equals (t))
 904                                 return true;
 905
 906                         if (constraints != null)
 907                                 return constraints.IsSubclassOf (t);
 908
 909                         return false;
 910                 }
 911
 912                 public override string ToString ()
 913                 {
 914                         return "TypeParameter[" + name + "]";
 915                 }
 916
 917                 public static string GetSignatureForError (TypeParameter[] tp)
 918                 {
 919                         if (tp == null || tp.Length == 0)
 920                                 return "";
 921
 922                         StringBuilder sb = new StringBuilder ("<");
 923                         for (int i = 0; i < tp.Length; ++i) {
 924                                 if (i > 0)
 925                                         sb.Append (",");
 926                                 sb.Append (tp[i].GetSignatureForError ());
 927                         }
 928                         sb.Append ('>');
 929                         return sb.ToString ();
 930                 }
 931
 932                 public void InflateConstraints (Type declaring)
 933                 {
 934                         if (constraints != null)
 935                                 gc = new InflatedConstraints (constraints, declaring);
 936                 }
 937
 938                 protected class InflatedConstraints : GenericConstraints
 939                 {
 940                         GenericConstraints gc;
 941                         Type base_type;
 942                         Type class_constraint;
 943                         Type[] iface_constraints;
 944                         Type[] dargs;
 945
 946                         public InflatedConstraints (GenericConstraints gc, Type declaring)
 947                                 : this (gc, TypeManager.GetTypeArguments (declaring))
 948                         { }
 949
 950                         public InflatedConstraints (GenericConstraints gc, Type[] dargs)
 951                         {
 952                                 this.gc = gc;
 953                                 this.dargs = dargs;
 954
 955                                 ArrayList list = new ArrayList ();
 956                                 if (gc.HasClassConstraint)
 957                                         list.Add (inflate (gc.ClassConstraint));
 958                                 foreach (Type iface in gc.InterfaceConstraints)
 959                                         list.Add (inflate (iface));
 960
 961                                 bool has_class_constr = false;
 962                                 if (list.Count > 0) {
 963                                         Type first = (Type) list [0];
 964                                         has_class_constr = !first.IsInterface && !first.IsGenericParameter;
 965                                 }
 966
 967                                 if ((list.Count > 0) && has_class_constr) {
 968                                         class_constraint = (Type) list [0];
 969                                         iface_constraints = new Type [list.Count - 1];
 970                                         list.CopyTo (1, iface_constraints, 0, list.Count - 1);
 971                                 } else {
 972                                         iface_constraints = new Type [list.Count];
 973                                         list.CopyTo (iface_constraints, 0);
 974                                 }
 975
 976                                 if (HasValueTypeConstraint)
 977                                         base_type = TypeManager.value_type;
 978                                 else if (class_constraint != null)
 979                                         base_type = class_constraint;
 980                                 else
 981                                         base_type = TypeManager.object_type;
 982                         }
 983
 984                         Type inflate (Type t)
 985                         {
 986                                 if (t == null)
 987                                         return null;
 988                                 if (t.IsGenericParameter)
 989                                         return dargs [t.GenericParameterPosition];
 990                                 if (t.IsGenericType) {
 991                                         Type[] args = t.GetGenericArguments ();
 992                                         Type[] inflated = new Type [args.Length];
 993
 994                                         for (int i = 0; i < args.Length; i++)
 995                                                 inflated [i] = inflate (args [i]);
 996
 997                                         t = t.GetGenericTypeDefinition ();
 998                                         t = t.MakeGenericType (inflated);
 999                                 }
1000
1001                                 return t;
1002                         }
1003
1004                         public override string TypeParameter {
1005                                 get { return gc.TypeParameter; }
1006                         }
1007
1008                         public override GenericParameterAttributes Attributes {
1009                                 get { return gc.Attributes; }
1010                         }
1011
1012                         public override Type ClassConstraint {
1013                                 get { return class_constraint; }
1014                         }
1015
1016                         public override Type EffectiveBaseClass {
1017                                 get { return base_type; }
1018                         }
1019
1020                         public override Type[] InterfaceConstraints {
1021                                 get { return iface_constraints; }
1022                         }
1023                 }
1024         }
1025
1026         /// <summary>
1027         ///   A TypeExpr which already resolved to a type parameter.
1028         /// </summary>
1029         public class TypeParameterExpr : TypeExpr {
1030                 TypeParameter type_parameter;
1031
1032                 public override string Name {
1033                         get {
1034                                 return type_parameter.Name;
1035                         }
1036                 }
1037
1038                 public override string FullName {
1039                         get {
1040                                 return type_parameter.Name;
1041                         }
1042                 }
1043
1044                 public TypeParameter TypeParameter {
1045                         get {
1046                                 return type_parameter;
1047                         }
1048                 }
1049
1050                 public TypeParameterExpr (TypeParameter type_parameter, Location loc)
1051                 {
1052                         this.type_parameter = type_parameter;
1053                         this.loc = loc;
1054                 }
1055
1056                 protected override TypeExpr DoResolveAsTypeStep (IResolveContext ec)
1057                 {
1058                         type = type_parameter.Type;
1059
1060                         return this;
1061                 }
1062
1063                 public override bool IsInterface {
1064                         get { return false; }
1065                 }
1066
1067                 public override bool CheckAccessLevel (DeclSpace ds)
1068                 {
1069                         return true;
1070                 }
1071
1072                 public void Error_CannotUseAsUnmanagedType (Location loc)
1073                 {
1074                         Report.Error (-203, loc, "Can not use type parameter as unmanaged type");
1075                 }
1076         }
1077
1078         /// <summary>
1079         ///   Tracks the type arguments when instantiating a generic type.  We're used in
1080         ///   ConstructedType.
1081         /// </summary>
1082         public class TypeArguments {
1083                 public readonly Location Location;
1084                 ArrayList args;
1085                 Type[] atypes;
1086                 int dimension;
1087                 bool has_type_args;
1088                 bool created;
1089
1090                 public TypeArguments (Location loc)
1091                 {
1092                         args = new ArrayList ();
1093                         this.Location = loc;
1094                 }
1095
1096                 public TypeArguments (int dimension, Location loc)
1097                 {
1098                         this.dimension = dimension;
1099                         this.Location = loc;
1100                 }
1101
1102                 public void Add (Expression type)
1103                 {
1104                         if (created)
1105                                 throw new InvalidOperationException ();
1106
1107                         args.Add (type);
1108                 }
1109
1110                 public void Add (TypeArguments new_args)
1111                 {
1112                         if (created)
1113                                 throw new InvalidOperationException ();
1114
1115                         args.AddRange (new_args.args);
1116                 }
1117
1118                 /// <summary>
1119                 ///   We're used during the parsing process: the parser can't distinguish
1120                 ///   between type parameters and type arguments.  Because of that, the
1121                 ///   parser creates a `MemberName' with `TypeArguments' for both cases and
1122                 ///   in case of a generic type definition, we call GetDeclarations().
1123                 /// </summary>
1124                 public TypeParameterName[] GetDeclarations ()
1125                 {
1126                         TypeParameterName[] ret = new TypeParameterName [args.Count];
1127                         for (int i = 0; i < args.Count; i++) {
1128                                 TypeParameterName name = args [i] as TypeParameterName;
1129                                 if (name != null) {
1130                                         ret [i] = name;
1131                                         continue;
1132                                 }
1133                                 SimpleName sn = args [i] as SimpleName;
1134                                 if (sn != null) {
1135                                         ret [i] = new TypeParameterName (sn.Name, null, sn.Location);
1136                                         continue;
1137                                 }
1138
1139                                 Report.Error (81, Location, "Type parameter declaration " +
1140                                               "must be an identifier not a type");
1141                                 return null;
1142                         }
1143                         return ret;
1144                 }
1145
1146                 /// <summary>
1147                 ///   We may only be used after Resolve() is called and return the fully
1148                 ///   resolved types.
1149                 /// </summary>
1150                 public Type[] Arguments {
1151                         get {
1152                                 return atypes;
1153                         }
1154                 }
1155
1156                 public bool HasTypeArguments {
1157                         get {
1158                                 return has_type_args;
1159                         }
1160                 }
1161
1162                 public int Count {
1163                         get {
1164                                 if (dimension > 0)
1165                                         return dimension;
1166                                 else
1167                                         return args.Count;
1168                         }
1169                 }
1170
1171                 public bool IsUnbound {
1172                         get {
1173                                 return dimension > 0;
1174                         }
1175                 }
1176
1177                 public override string ToString ()
1178                 {
1179                         StringBuilder s = new StringBuilder ();
1180
1181                         int count = Count;
1182                         for (int i = 0; i < count; i++){
1183                                 //
1184                                 // FIXME: Use TypeManager.CSharpname once we have the type
1185                                 //
1186                                 if (args != null)
1187                                         s.Append (args [i].ToString ());
1188                                 if (i+1 < count)
1189                                         s.Append (",");
1190                         }
1191                         return s.ToString ();
1192                 }
1193
1194                 public string GetSignatureForError()
1195                 {
1196                         StringBuilder sb = new StringBuilder();
1197                         for (int i = 0; i < Count; ++i)
1198                         {
1199                                 Expression expr = (Expression)args [i];
1200                                 sb.Append(expr.GetSignatureForError());
1201                                 if (i + 1 < Count)
1202                                         sb.Append(',');
1203                         }
1204                         return sb.ToString();
1205                 }
1206
1207                 /// <summary>
1208                 ///   Resolve the type arguments.
1209                 /// </summary>
1210                 public bool Resolve (IResolveContext ec)
1211                 {
1212                         int count = args.Count;
1213                         bool ok = true;
1214
1215                         atypes = new Type [count];
1216
1217                         for (int i = 0; i < count; i++){
1218                                 TypeExpr te = ((Expression) args [i]).ResolveAsTypeTerminal (ec, false);
1219                                 if (te == null) {
1220                                         ok = false;
1221                                         continue;
1222                                 }
1223                                 if (te is TypeParameterExpr)
1224                                         has_type_args = true;
1225
1226                                 if (te.Type.IsSealed && te.Type.IsAbstract) {
1227                                         Report.Error (718, Location, "`{0}': static classes cannot be used as generic arguments",
1228                                                 te.GetSignatureForError ());
1229                                         return false;
1230                                 }
1231                                 if (te.Type.IsPointer) {
1232                                         Report.Error (306, Location, "The type `{0}' may not be used " +
1233                                                           "as a type argument", TypeManager.CSharpName (te.Type));
1234                                         return false;
1235                                 }
1236
1237                                 if (te.Type == TypeManager.void_type) {
1238                                         Expression.Error_VoidInvalidInTheContext (Location);
1239                                         return false;
1240                                 }
1241
1242                                 atypes [i] = te.Type;
1243                         }
1244                         return ok;
1245                 }
1246         }
1247
1248         public class TypeParameterName : SimpleName
1249         {
1250                 Attributes attributes;
1251
1252                 public TypeParameterName (string name, Attributes attrs, Location loc)
1253                         : base (name, loc)
1254                 {
1255                         attributes = attrs;
1256                 }
1257
1258                 public Attributes OptAttributes {
1259                         get {
1260                                 return attributes;
1261                         }
1262                 }
1263         }
1264
1265         /// <summary>
1266         ///   An instantiation of a generic type.
1267         /// </summary>
1268         public class ConstructedType : TypeExpr {
1269                 string full_name;
1270                 FullNamedExpression name;
1271                 TypeArguments args;
1272                 Type[] gen_params, atypes;
1273                 Type gt;
1274
1275                 /// <summary>
1276                 ///   Instantiate the generic type `fname' with the type arguments `args'.
1277                 /// </summary>
1278                 public ConstructedType (FullNamedExpression fname, TypeArguments args, Location l)
1279                 {
1280                         loc = l;
1281                         this.name = fname;
1282                         this.args = args;
1283
1284                         eclass = ExprClass.Type;
1285                         full_name = name + "<" + args.ToString () + ">";
1286                 }
1287
1288                 protected ConstructedType (TypeArguments args, Location l)
1289                 {
1290                         loc = l;
1291                         this.args = args;
1292
1293                         eclass = ExprClass.Type;
1294                 }
1295
1296                 protected ConstructedType (TypeParameter[] type_params, Location l)
1297                 {
1298                         loc = l;
1299
1300                         args = new TypeArguments (l);
1301                         foreach (TypeParameter type_param in type_params)
1302                                 args.Add (new TypeParameterExpr (type_param, l));
1303
1304                         eclass = ExprClass.Type;
1305                 }
1306
1307                 /// <summary>
1308                 ///   This is used to construct the `this' type inside a generic type definition.
1309                 /// </summary>
1310                 public ConstructedType (Type t, TypeParameter[] type_params, Location l)
1311                         : this (type_params, l)
1312                 {
1313                         gt = t.GetGenericTypeDefinition ();
1314
1315                         this.name = new TypeExpression (gt, l);
1316                         full_name = gt.FullName + "<" + args.ToString () + ">";
1317                 }
1318
1319                 /// <summary>
1320                 ///   Instantiate the generic type `t' with the type arguments `args'.
1321                 ///   Use this constructor if you already know the fully resolved
1322                 ///   generic type.
1323                 /// </summary>
1324                 public ConstructedType (Type t, TypeArguments args, Location l)
1325                         : this (args, l)
1326                 {
1327                         gt = t.GetGenericTypeDefinition ();
1328
1329                         this.name = new TypeExpression (gt, l);
1330                         full_name = gt.FullName + "<" + args.ToString () + ">";
1331                 }
1332
1333                 public TypeArguments TypeArguments {
1334                         get { return args; }
1335                 }
1336
1337                 public override string GetSignatureForError ()
1338                 {
1339                         return TypeManager.RemoveGenericArity (gt.FullName) + "<" + args.GetSignatureForError () + ">";
1340                 }
1341
1342                 protected override TypeExpr DoResolveAsTypeStep (IResolveContext ec)
1343                 {
1344                         if (!ResolveConstructedType (ec))
1345                                 return null;
1346
1347                         return this;
1348                 }
1349
1350                 /// <summary>
1351                 ///   Check the constraints; we're called from ResolveAsTypeTerminal()
1352                 ///   after fully resolving the constructed type.
1353                 /// </summary>
1354                 public bool CheckConstraints (IResolveContext ec)
1355                 {
1356                         return ConstraintChecker.CheckConstraints (ec, gt, gen_params, atypes, loc);
1357                 }
1358
1359                 /// <summary>
1360                 ///   Resolve the constructed type, but don't check the constraints.
1361                 /// </summary>
1362                 public bool ResolveConstructedType (IResolveContext ec)
1363                 {
1364                         if (type != null)
1365                                 return true;
1366                         // If we already know the fully resolved generic type.
1367                         if (gt != null)
1368                                 return DoResolveType (ec);
1369
1370                         int num_args;
1371                         Type t = name.Type;
1372
1373                         if (t == null) {
1374                                 Report.Error (246, loc, "Cannot find type `{0}'<...>", Name);
1375                                 return false;
1376                         }
1377
1378                         num_args = TypeManager.GetNumberOfTypeArguments (t);
1379                         if (num_args == 0) {
1380                                 Report.Error (308, loc,
1381                                               "The non-generic type `{0}' cannot " +
1382                                               "be used with type arguments.",
1383                                               TypeManager.CSharpName (t));
1384                                 return false;
1385                         }
1386
1387                         gt = t.GetGenericTypeDefinition ();
1388                         return DoResolveType (ec);
1389                 }
1390
1391                 bool DoResolveType (IResolveContext ec)
1392                 {
1393                         //
1394                         // Resolve the arguments.
1395                         //
1396                         if (args.Resolve (ec) == false)
1397                                 return false;
1398
1399                         gen_params = gt.GetGenericArguments ();
1400                         atypes = args.Arguments;
1401
1402                         if (atypes.Length != gen_params.Length) {
1403                                 Report.Error (305, loc,
1404                                               "Using the generic type `{0}' " +
1405                                               "requires {1} type arguments",
1406                                               TypeManager.CSharpName (gt),
1407                                               gen_params.Length.ToString ());
1408                                 return false;
1409                         }
1410
1411                         //
1412                         // Now bind the parameters.
1413                         //
1414                         type = gt.MakeGenericType (atypes);
1415                         return true;
1416                 }
1417
1418                 public Expression GetSimpleName (EmitContext ec)
1419                 {
1420                         return this;
1421                 }
1422
1423                 public override bool CheckAccessLevel (DeclSpace ds)
1424                 {
1425                         return ds.CheckAccessLevel (gt);
1426                 }
1427
1428                 public override bool AsAccessible (DeclSpace ds, int flags)
1429                 {
1430                         return ds.AsAccessible (gt, flags);
1431                 }
1432
1433                 public override bool IsClass {
1434                         get { return gt.IsClass; }
1435                 }
1436
1437                 public override bool IsValueType {
1438                         get { return gt.IsValueType; }
1439                 }
1440
1441                 public override bool IsInterface {
1442                         get { return gt.IsInterface; }
1443                 }
1444
1445                 public override bool IsSealed {
1446                         get { return gt.IsSealed; }
1447                 }
1448
1449                 public override bool Equals (object obj)
1450                 {
1451                         ConstructedType cobj = obj as ConstructedType;
1452                         if (cobj == null)
1453                                 return false;
1454
1455                         if ((type == null) || (cobj.type == null))
1456                                 return false;
1457
1458                         return type == cobj.type;
1459                 }
1460
1461                 public override int GetHashCode ()
1462                 {
1463                         return base.GetHashCode ();
1464                 }
1465
1466                 public override string Name {
1467                         get {
1468                                 return full_name;
1469                         }
1470                 }
1471
1472
1473                 public override string FullName {
1474                         get {
1475                                 return full_name;
1476                         }
1477                 }
1478         }
1479
1480         public abstract class ConstraintChecker
1481         {
1482                 protected readonly Type[] gen_params;
1483                 protected readonly Type[] atypes;
1484                 protected readonly Location loc;
1485
1486                 protected ConstraintChecker (Type[] gen_params, Type[] atypes, Location loc)
1487                 {
1488                         this.gen_params = gen_params;
1489                         this.atypes = atypes;
1490                         this.loc = loc;
1491                 }
1492
1493                 /// <summary>
1494                 ///   Check the constraints; we're called from ResolveAsTypeTerminal()
1495                 ///   after fully resolving the constructed type.
1496                 /// </summary>
1497                 public bool CheckConstraints (IResolveContext ec)
1498                 {
1499                         for (int i = 0; i < gen_params.Length; i++) {
1500                                 if (!CheckConstraints (ec, i))
1501                                         return false;
1502                         }
1503
1504                         return true;
1505                 }
1506
1507                 protected bool CheckConstraints (IResolveContext ec, int index)
1508                 {
1509                         Type atype = atypes [index];
1510                         Type ptype = gen_params [index];
1511
1512                         if (atype == ptype)
1513                                 return true;
1514
1515                         Expression aexpr = new EmptyExpression (atype);
1516
1517                         GenericConstraints gc = TypeManager.GetTypeParameterConstraints (ptype);
1518                         if (gc == null)
1519                                 return true;
1520
1521                         bool is_class, is_struct;
1522                         if (atype.IsGenericParameter) {
1523                                 GenericConstraints agc = TypeManager.GetTypeParameterConstraints (atype);
1524                                 if (agc != null) {
1525                                         if (agc is Constraints)
1526                                                 ((Constraints) agc).Resolve (ec);
1527                                         is_class = agc.HasReferenceTypeConstraint;
1528                                         is_struct = agc.HasValueTypeConstraint;
1529                                 } else {
1530                                         is_class = is_struct = false;
1531                                 }
1532                         } else {
1533 #if MS_COMPATIBLE
1534                                 is_class = false;
1535                                 if (!atype.IsGenericType)
1536 #endif
1537                                 is_class = atype.IsClass || atype.IsInterface;
1538                                 is_struct = atype.IsValueType && !TypeManager.IsNullableType (atype);
1539                         }
1540
1541                         //
1542                         // First, check the `class' and `struct' constraints.
1543                         //
1544                         if (gc.HasReferenceTypeConstraint && !is_class) {
1545                                 Report.Error (452, loc, "The type `{0}' must be " +
1546                                               "a reference type in order to use it " +
1547                                               "as type parameter `{1}' in the " +
1548                                               "generic type or method `{2}'.",
1549                                               TypeManager.CSharpName (atype),
1550                                               TypeManager.CSharpName (ptype),
1551                                               GetSignatureForError ());
1552                                 return false;
1553                         } else if (gc.HasValueTypeConstraint && !is_struct) {
1554                                 Report.Error (453, loc, "The type `{0}' must be a " +
1555                                               "non-nullable value type in order to use it " +
1556                                               "as type parameter `{1}' in the " +
1557                                               "generic type or method `{2}'.",
1558                                               TypeManager.CSharpName (atype),
1559                                               TypeManager.CSharpName (ptype),
1560                                               GetSignatureForError ());
1561                                 return false;
1562                         }
1563
1564                         //
1565                         // The class constraint comes next.
1566                         //
1567                         if (gc.HasClassConstraint) {
1568                                 if (!CheckConstraint (ec, ptype, aexpr, gc.ClassConstraint))
1569                                         return false;
1570                         }
1571
1572                         //
1573                         // Now, check the interface constraints.
1574                         //
1575                         if (gc.InterfaceConstraints != null) {
1576                                 foreach (Type it in gc.InterfaceConstraints) {
1577                                         if (!CheckConstraint (ec, ptype, aexpr, it))
1578                                                 return false;
1579                                 }
1580                         }
1581
1582                         //
1583                         // Finally, check the constructor constraint.
1584                         //
1585
1586                         if (!gc.HasConstructorConstraint)
1587                                 return true;
1588
1589                         if (TypeManager.IsBuiltinType (atype) || atype.IsValueType)
1590                                 return true;
1591
1592                         if (HasDefaultConstructor (ec.DeclContainer.TypeBuilder, atype))
1593                                 return true;
1594
1595                         Report_SymbolRelatedToPreviousError ();
1596                         Report.SymbolRelatedToPreviousError (atype);
1597                         Report.Error (310, loc, "The type `{0}' must have a public " +
1598                                       "parameterless constructor in order to use it " +
1599                                       "as parameter `{1}' in the generic type or " +
1600                                       "method `{2}'",
1601                                       TypeManager.CSharpName (atype),
1602                                       TypeManager.CSharpName (ptype),
1603                                       GetSignatureForError ());
1604                         return false;
1605                 }
1606
1607                 protected bool CheckConstraint (IResolveContext ec, Type ptype, Expression expr,
1608                                                 Type ctype)
1609                 {
1610                         if (TypeManager.HasGenericArguments (ctype)) {
1611                                 Type[] types = TypeManager.GetTypeArguments (ctype);
1612
1613                                 TypeArguments new_args = new TypeArguments (loc);
1614
1615                                 for (int i = 0; i < types.Length; i++) {
1616                                         Type t = types [i];
1617
1618                                         if (t.IsGenericParameter) {
1619                                                 int pos = t.GenericParameterPosition;
1620                                                 t = atypes [pos];
1621                                         }
1622                                         new_args.Add (new TypeExpression (t, loc));
1623                                 }
1624
1625                                 TypeExpr ct = new ConstructedType (ctype, new_args, loc);
1626                                 if (ct.ResolveAsTypeStep (ec, false) == null)
1627                                         return false;
1628                                 ctype = ct.Type;
1629                         } else if (ctype.IsGenericParameter) {
1630                                 int pos = ctype.GenericParameterPosition;
1631                                 ctype = atypes [pos];
1632                         }
1633
1634                         if (Convert.ImplicitStandardConversionExists (expr, ctype))
1635                                 return true;
1636
1637                         Error_TypeMustBeConvertible (expr.Type, ctype, ptype);
1638                         return false;
1639                 }
1640
1641                 bool HasDefaultConstructor (Type containerType, Type atype)
1642                 {
1643                         if (atype.IsAbstract)
1644                                 return false;
1645
1646                 again:
1647                         atype = TypeManager.DropGenericTypeArguments (atype);
1648                         if (atype is TypeBuilder) {
1649                                 TypeContainer tc = TypeManager.LookupTypeContainer (atype);
1650                                 if (tc.InstanceConstructors == null) {
1651                                         atype = atype.BaseType;
1652                                         goto again;
1653                                 }
1654
1655                                 foreach (Constructor c in tc.InstanceConstructors) {
1656                                         if ((c.ModFlags & Modifiers.PUBLIC) == 0)
1657                                                 continue;
1658                                         if ((c.Parameters.FixedParameters != null) &&
1659                                             (c.Parameters.FixedParameters.Length != 0))
1660                                                 continue;
1661                                         if (c.Parameters.HasArglist || c.Parameters.HasParams)
1662                                                 continue;
1663
1664                                         return true;
1665                                 }
1666                         }
1667
1668                         TypeParameter tparam = TypeManager.LookupTypeParameter (atype);
1669                         if (tparam != null)
1670                                 return tparam.HasConstructorConstraint;
1671
1672                         MemberList list = TypeManager.FindMembers (
1673                                 atype, MemberTypes.Constructor,
1674                                 BindingFlags.Public | BindingFlags.Instance |
1675                                 BindingFlags.DeclaredOnly, null, null);
1676
1677                         if (atype.IsAbstract || (list == null))
1678                                 return false;
1679
1680                         foreach (MethodBase mb in list) {
1681                                 ParameterData pd = TypeManager.GetParameterData (mb);
1682                                 if ((pd.Count == 0) && mb.IsPublic && !mb.IsStatic)
1683                                         return true;
1684                         }
1685
1686                         return false;
1687                 }
1688
1689                 protected abstract string GetSignatureForError ();
1690                 protected abstract void Report_SymbolRelatedToPreviousError ();
1691
1692                 void Error_TypeMustBeConvertible (Type atype, Type gc, Type ptype)
1693                 {
1694                         Report_SymbolRelatedToPreviousError ();
1695                         Report.SymbolRelatedToPreviousError (atype);
1696                         Report.Error (309, loc,
1697                                       "The type `{0}' must be convertible to `{1}' in order to " +
1698                                       "use it as parameter `{2}' in the generic type or method `{3}'",
1699                                       TypeManager.CSharpName (atype), TypeManager.CSharpName (gc),
1700                                       TypeManager.CSharpName (ptype), GetSignatureForError ());
1701                 }
1702
1703                 public static bool CheckConstraints (EmitContext ec, MethodBase definition,
1704                                                      MethodBase instantiated, Location loc)
1705                 {
1706                         MethodConstraintChecker checker = new MethodConstraintChecker (
1707                                 definition, definition.GetGenericArguments (),
1708                                 instantiated.GetGenericArguments (), loc);
1709
1710                         return checker.CheckConstraints (ec);
1711                 }
1712
1713                 public static bool CheckConstraints (IResolveContext ec, Type gt, Type[] gen_params,
1714                                                      Type[] atypes, Location loc)
1715                 {
1716                         TypeConstraintChecker checker = new TypeConstraintChecker (
1717                                 gt, gen_params, atypes, loc);
1718
1719                         return checker.CheckConstraints (ec);
1720                 }
1721
1722                 protected class MethodConstraintChecker : ConstraintChecker
1723                 {
1724                         MethodBase definition;
1725
1726                         public MethodConstraintChecker (MethodBase definition, Type[] gen_params,
1727                                                         Type[] atypes, Location loc)
1728                                 : base (gen_params, atypes, loc)
1729                         {
1730                                 this.definition = definition;
1731                         }
1732
1733                         protected override string GetSignatureForError ()
1734                         {
1735                                 return TypeManager.CSharpSignature (definition);
1736                         }
1737
1738                         protected override void Report_SymbolRelatedToPreviousError ()
1739                         {
1740                                 Report.SymbolRelatedToPreviousError (definition);
1741                         }
1742                 }
1743
1744                 protected class TypeConstraintChecker : ConstraintChecker
1745                 {
1746                         Type gt;
1747
1748                         public TypeConstraintChecker (Type gt, Type[] gen_params, Type[] atypes,
1749                                                       Location loc)
1750                                 : base (gen_params, atypes, loc)
1751                         {
1752                                 this.gt = gt;
1753                         }
1754
1755                         protected override string GetSignatureForError ()
1756                         {
1757                                 return TypeManager.CSharpName (gt);
1758                         }
1759
1760                         protected override void Report_SymbolRelatedToPreviousError ()
1761                         {
1762                                 Report.SymbolRelatedToPreviousError (gt);
1763                         }
1764                 }
1765         }
1766
1767         /// <summary>
1768         ///   A generic method definition.
1769         /// </summary>
1770         public class GenericMethod : DeclSpace
1771         {
1772                 Expression return_type;
1773                 Parameters parameters;
1774
1775                 public GenericMethod (NamespaceEntry ns, DeclSpace parent, MemberName name,
1776                                       Expression return_type, Parameters parameters)
1777                         : base (ns, parent, name, null)
1778                 {
1779                         this.return_type = return_type;
1780                         this.parameters = parameters;
1781                 }
1782
1783                 public override TypeBuilder DefineType ()
1784                 {
1785                         throw new Exception ();
1786                 }
1787
1788                 public override bool Define ()
1789                 {
1790                         for (int i = 0; i < TypeParameters.Length; i++)
1791                                 if (!TypeParameters [i].Resolve (this))
1792                                         return false;
1793
1794                         return true;
1795                 }
1796
1797                 /// <summary>
1798                 ///   Define and resolve the type parameters.
1799                 ///   We're called from Method.Define().
1800                 /// </summary>
1801                 public bool Define (MethodBuilder mb, ToplevelBlock block)
1802                 {
1803                         TypeParameterName[] names = MemberName.TypeArguments.GetDeclarations ();
1804                         string[] snames = new string [names.Length];
1805                         for (int i = 0; i < names.Length; i++) {
1806                                 string type_argument_name = names[i].Name;
1807                                 Parameter p = parameters.GetParameterByName (type_argument_name);
1808                                 if (p != null) {
1809                                         Error_ParameterNameCollision (p.Location, type_argument_name, "method parameter");
1810                                         return false;
1811                                 }
1812                                 if (block != null) {
1813                                         LocalInfo li = (LocalInfo)block.Variables[type_argument_name];
1814                                         if (li != null) {
1815                                                 Error_ParameterNameCollision (li.Location, type_argument_name, "local variable");
1816                                                 return false;
1817                                         }
1818                                 }
1819                                 snames[i] = type_argument_name;
1820                         }
1821
1822                         GenericTypeParameterBuilder[] gen_params = mb.DefineGenericParameters (snames);
1823                         for (int i = 0; i < TypeParameters.Length; i++)
1824                                 TypeParameters [i].Define (gen_params [i]);
1825
1826                         if (!Define ())
1827                                 return false;
1828
1829                         for (int i = 0; i < TypeParameters.Length; i++) {
1830                                 if (!TypeParameters [i].ResolveType (this))
1831                                         return false;
1832                         }
1833
1834                         return true;
1835                 }
1836
1837                 static void Error_ParameterNameCollision (Location loc, string name, string collisionWith)
1838                 {
1839                         Report.Error (412, loc, "The type parameter name `{0}' is the same as `{1}'",
1840                                 name, collisionWith);
1841                 }
1842
1843                 /// <summary>
1844                 ///   We're called from MethodData.Define() after creating the MethodBuilder.
1845                 /// </summary>
1846                 public bool DefineType (EmitContext ec, MethodBuilder mb,
1847                                         MethodInfo implementing, bool is_override)
1848                 {
1849                         for (int i = 0; i < TypeParameters.Length; i++)
1850                                 if (!TypeParameters [i].DefineType (
1851                                             ec, mb, implementing, is_override))
1852                                         return false;
1853
1854                         bool ok = true;
1855                         foreach (Parameter p in parameters.FixedParameters){
1856                                 if (!p.Resolve (ec))
1857                                         ok = false;
1858                         }
1859                         if ((return_type != null) && (return_type.ResolveAsTypeTerminal (ec, false) == null))
1860                                 ok = false;
1861
1862                         return ok;
1863                 }
1864
1865                 public void EmitAttributes ()
1866                 {
1867                         for (int i = 0; i < TypeParameters.Length; i++)
1868                                 TypeParameters [i].EmitAttributes ();
1869
1870                         if (OptAttributes != null)
1871                                 OptAttributes.Emit ();
1872                 }
1873
1874                 public override bool DefineMembers ()
1875                 {
1876                         return true;
1877                 }
1878
1879                 public override MemberList FindMembers (MemberTypes mt, BindingFlags bf,
1880                                                         MemberFilter filter, object criteria)
1881                 {
1882                         throw new Exception ();
1883                 }
1884
1885                 public override MemberCache MemberCache {
1886                         get {
1887                                 return null;
1888                         }
1889                 }
1890
1891                 public override AttributeTargets AttributeTargets {
1892                         get {
1893                                 return AttributeTargets.Method | AttributeTargets.ReturnValue;
1894                         }
1895                 }
1896
1897                 public override string DocCommentHeader {
1898                         get { return "M:"; }
1899                 }
1900         }
1901
1902         public class DefaultValueExpression : Expression
1903         {
1904                 Expression expr;
1905
1906                 public DefaultValueExpression (Expression expr, Location loc)
1907                 {
1908                         this.expr = expr;
1909                         this.loc = loc;
1910                 }
1911
1912                 public override Expression DoResolve (EmitContext ec)
1913                 {
1914                         TypeExpr texpr = expr.ResolveAsTypeTerminal (ec, false);
1915                         if (texpr == null)
1916                                 return null;
1917
1918                         type = texpr.Type;
1919
1920                         eclass = ExprClass.Variable;
1921                         return this;
1922                 }
1923
1924                 public override void Emit (EmitContext ec)
1925                 {
1926                         if (type.IsGenericParameter || TypeManager.IsValueType (type)) {
1927                                 LocalTemporary temp_storage = new LocalTemporary (type);
1928
1929                                 temp_storage.AddressOf (ec, AddressOp.LoadStore);
1930                                 ec.ig.Emit (OpCodes.Initobj, type);
1931                                 temp_storage.Emit (ec);
1932                         } else
1933                                 ec.ig.Emit (OpCodes.Ldnull);
1934                 }
1935         }
1936
1937         public class NullableType : TypeExpr
1938         {
1939                 Expression underlying;
1940
1941                 public NullableType (Expression underlying, Location l)
1942                 {
1943                         this.underlying = underlying;
1944                         loc = l;
1945
1946                         eclass = ExprClass.Type;
1947                 }
1948
1949                 public NullableType (Type type, Location loc)
1950                         : this (new TypeExpression (type, loc), loc)
1951                 { }
1952
1953                 public override string Name {
1954                         get { return underlying.ToString () + "?"; }
1955                 }
1956
1957                 public override string FullName {
1958                         get { return underlying.ToString () + "?"; }
1959                 }
1960
1961                 protected override TypeExpr DoResolveAsTypeStep (IResolveContext ec)
1962                 {
1963                         TypeArguments args = new TypeArguments (loc);
1964                         args.Add (underlying);
1965
1966                         ConstructedType ctype = new ConstructedType (TypeManager.generic_nullable_type, args, loc);
1967                         return ctype.ResolveAsTypeTerminal (ec, false);
1968                 }
1969         }
1970
1971         public partial class TypeManager
1972         {
1973                 //
1974                 // A list of core types that the compiler requires or uses
1975                 //
1976                 static public Type activator_type;
1977                 static public Type generic_ilist_type;
1978                 static public Type generic_icollection_type;
1979                 static public Type generic_ienumerator_type;
1980                 static public Type generic_ienumerable_type;
1981                 static public Type generic_nullable_type;
1982
1983                 // <remarks>
1984                 //   Tracks the generic parameters.
1985                 // </remarks>
1986                 static PtrHashtable builder_to_type_param;
1987
1988                 //
1989                 // These methods are called by code generated by the compiler
1990                 //
1991                 static public MethodInfo activator_create_instance;
1992
1993                 static void InitGenerics ()
1994                 {
1995                         builder_to_type_param = new PtrHashtable ();
1996                 }
1997
1998                 static void CleanUpGenerics ()
1999                 {
2000                         builder_to_type_param = null;
2001                 }
2002
2003                 static void InitGenericCoreTypes ()
2004                 {
2005                         activator_type = CoreLookupType ("System", "Activator");
2006
2007                         generic_ilist_type = CoreLookupType (
2008                                 "System.Collections.Generic", "IList", 1);
2009                         generic_icollection_type = CoreLookupType (
2010                                 "System.Collections.Generic", "ICollection", 1);
2011                         generic_ienumerator_type = CoreLookupType (
2012                                 "System.Collections.Generic", "IEnumerator", 1);
2013                         generic_ienumerable_type = CoreLookupType (
2014                                 "System.Collections.Generic", "IEnumerable", 1);
2015                         generic_nullable_type = CoreLookupType (
2016                                 "System", "Nullable", 1);
2017                 }
2018
2019                 static void InitGenericCodeHelpers ()
2020                 {
2021                         // Activator
2022                         Type [] type_arg = { type_type };
2023                         activator_create_instance = GetMethod (
2024                                 activator_type, "CreateInstance", type_arg);
2025                 }
2026
2027                 static Type CoreLookupType (string ns, string name, int arity)
2028                 {
2029                         return CoreLookupType (ns, MemberName.MakeName (name, arity));
2030                 }
2031
2032                 public static void AddTypeParameter (Type t, TypeParameter tparam)
2033                 {
2034                         if (!builder_to_type_param.Contains (t))
2035                                 builder_to_type_param.Add (t, tparam);
2036                 }
2037
2038                 public static TypeContainer LookupGenericTypeContainer (Type t)
2039                 {
2040                         t = DropGenericTypeArguments (t);
2041                         return LookupTypeContainer (t);
2042                 }
2043
2044                 public static TypeParameter LookupTypeParameter (Type t)
2045                 {
2046                         return (TypeParameter) builder_to_type_param [t];
2047                 }
2048
2049                 public static GenericConstraints GetTypeParameterConstraints (Type t)
2050                 {
2051                         if (!t.IsGenericParameter)
2052                                 throw new InvalidOperationException ();
2053
2054                         TypeParameter tparam = LookupTypeParameter (t);
2055                         if (tparam != null)
2056                                 return tparam.GenericConstraints;
2057
2058                         return ReflectionConstraints.GetConstraints (t);
2059                 }
2060
2061                 public static bool HasGenericArguments (Type t)
2062                 {
2063                         return GetNumberOfTypeArguments (t) > 0;
2064                 }
2065
2066                 public static Type[] GetTypeArguments (Type t)
2067                 {
2068                         DeclSpace tc = LookupDeclSpace (t);
2069                         if (tc != null) {
2070                                 if (!tc.IsGeneric)
2071                                         return Type.EmptyTypes;
2072
2073                                 TypeParameter[] tparam = tc.TypeParameters;
2074                                 Type[] ret = new Type [tparam.Length];
2075                                 for (int i = 0; i < tparam.Length; i++) {
2076                                         ret [i] = tparam [i].Type;
2077                                         if (ret [i] == null)
2078                                                 throw new InternalErrorException ();
2079                                 }
2080
2081                                 return ret;
2082                         } else
2083                                 return t.GetGenericArguments ();
2084                 }
2085
2086                 public static Type DropGenericTypeArguments (Type t)
2087                 {
2088                         if (!t.IsGenericType)
2089                                 return t;
2090                         // Micro-optimization: a generic typebuilder is always a generic type definition
2091                         if (t is TypeBuilder)
2092                                 return t;
2093                         return t.GetGenericTypeDefinition ();
2094                 }
2095
2096                 public static MethodBase DropGenericMethodArguments (MethodBase m)
2097                 {
2098                         if (m.IsGenericMethodDefinition)
2099                                 return m;
2100                         if (m.IsGenericMethod)
2101                                 return ((MethodInfo) m).GetGenericMethodDefinition ();
2102                         if (!m.DeclaringType.IsGenericType)
2103                                 return m;
2104
2105                         Type t = m.DeclaringType.GetGenericTypeDefinition ();
2106                         BindingFlags bf = BindingFlags.Public | BindingFlags.NonPublic |
2107                                 BindingFlags.Static | BindingFlags.Instance | BindingFlags.DeclaredOnly;
2108
2109                         if (m is ConstructorInfo) {
2110                                 foreach (ConstructorInfo c in t.GetConstructors (bf))
2111                                         if (c.MetadataToken == m.MetadataToken)
2112                                                 return c;
2113                         } else {
2114                                 foreach (MethodBase mb in t.GetMethods (bf))
2115                                         if (mb.MetadataToken == m.MetadataToken)
2116                                                 return mb;
2117                         }
2118
2119                         return m;
2120                 }
2121
2122                 public static FieldInfo GetGenericFieldDefinition (FieldInfo fi)
2123                 {
2124                         if (fi.DeclaringType.IsGenericTypeDefinition ||
2125                             !fi.DeclaringType.IsGenericType)
2126                                 return fi;
2127
2128                         Type t = fi.DeclaringType.GetGenericTypeDefinition ();
2129                         BindingFlags bf = BindingFlags.Public | BindingFlags.NonPublic |
2130                                 BindingFlags.Static | BindingFlags.Instance | BindingFlags.DeclaredOnly;
2131
2132                         foreach (FieldInfo f in t.GetFields (bf))
2133                                 if (f.MetadataToken == fi.MetadataToken)
2134                                         return f;
2135
2136                         return fi;
2137                 }
2138
2139                 public static bool IsEqual (Type a, Type b)
2140                 {
2141                         if (a.Equals (b))
2142                                 return true;
2143
2144                         if (a.IsGenericParameter && b.IsGenericParameter) {
2145                                 if (a.DeclaringMethod != b.DeclaringMethod &&
2146                                     (a.DeclaringMethod == null || b.DeclaringMethod == null))
2147                                         return false;
2148                                 return a.GenericParameterPosition == b.GenericParameterPosition;
2149                         }
2150
2151                         if (a.IsArray && b.IsArray) {
2152                                 if (a.GetArrayRank () != b.GetArrayRank ())
2153                                         return false;
2154                                 return IsEqual (a.GetElementType (), b.GetElementType ());
2155                         }
2156
2157                         if (a.IsByRef && b.IsByRef)
2158                                 return IsEqual (a.GetElementType (), b.GetElementType ());
2159
2160                         if (a.IsGenericType && b.IsGenericType) {
2161                                 if (a.GetGenericTypeDefinition () != b.GetGenericTypeDefinition ())
2162                                         return false;
2163
2164                                 Type[] aargs = a.GetGenericArguments ();
2165                                 Type[] bargs = b.GetGenericArguments ();
2166
2167                                 if (aargs.Length != bargs.Length)
2168                                         return false;
2169
2170                                 for (int i = 0; i < aargs.Length; i++) {
2171                                         if (!IsEqual (aargs [i], bargs [i]))
2172                                                 return false;
2173                                 }
2174
2175                                 return true;
2176                         }
2177
2178                         return false;
2179                 }
2180
2181                 /// <summary>
2182                 ///   Check whether `a' and `b' may become equal generic types.
2183                 ///   The algorithm to do that is a little bit complicated.
2184                 /// </summary>
2185                 public static bool MayBecomeEqualGenericTypes (Type a, Type b, Type[] class_infered,
2186                                                                Type[] method_infered)
2187                 {
2188                         if (a.IsGenericParameter) {
2189                                 //
2190                                 // If a is an array of a's type, they may never
2191                                 // become equal.
2192                                 //
2193                                 while (b.IsArray) {
2194                                         b = b.GetElementType ();
2195                                         if (a.Equals (b))
2196                                                 return false;
2197                                 }
2198
2199                                 //
2200                                 // If b is a generic parameter or an actual type,
2201                                 // they may become equal:
2202                                 //
2203                                 //    class X<T,U> : I<T>, I<U>
2204                                 //    class X<T> : I<T>, I<float>
2205                                 //
2206                                 if (b.IsGenericParameter || !b.IsGenericType) {
2207                                         int pos = a.GenericParameterPosition;
2208                                         Type[] args = a.DeclaringMethod != null ? method_infered : class_infered;
2209                                         if (args [pos] == null) {
2210                                                 args [pos] = b;
2211                                                 return true;
2212                                         }
2213
2214                                         return args [pos] == a;
2215                                 }
2216
2217                                 //
2218                                 // We're now comparing a type parameter with a
2219                                 // generic instance.  They may become equal unless
2220                                 // the type parameter appears anywhere in the
2221                                 // generic instance:
2222                                 //
2223                                 //    class X<T,U> : I<T>, I<X<U>>
2224                                 //        -> error because you could instanciate it as
2225                                 //           X<X<int>,int>
2226                                 //
2227                                 //    class X<T> : I<T>, I<X<T>> -> ok
2228                                 //
2229
2230                                 Type[] bargs = GetTypeArguments (b);
2231                                 for (int i = 0; i < bargs.Length; i++) {
2232                                         if (a.Equals (bargs [i]))
2233                                                 return false;
2234                                 }
2235
2236                                 return true;
2237                         }
2238
2239                         if (b.IsGenericParameter)
2240                                 return MayBecomeEqualGenericTypes (b, a, class_infered, method_infered);
2241
2242                         //
2243                         // At this point, neither a nor b are a type parameter.
2244                         //
2245                         // If one of them is a generic instance, let
2246                         // MayBecomeEqualGenericInstances() compare them (if the
2247                         // other one is not a generic instance, they can never
2248                         // become equal).
2249                         //
2250
2251                         if (a.IsGenericType || b.IsGenericType)
2252                                 return MayBecomeEqualGenericInstances (a, b, class_infered, method_infered);
2253
2254                         //
2255                         // If both of them are arrays.
2256                         //
2257
2258                         if (a.IsArray && b.IsArray) {
2259                                 if (a.GetArrayRank () != b.GetArrayRank ())
2260                                         return false;
2261
2262                                 a = a.GetElementType ();
2263                                 b = b.GetElementType ();
2264
2265                                 return MayBecomeEqualGenericTypes (a, b, class_infered, method_infered);
2266                         }
2267
2268                         //
2269                         // Ok, two ordinary types.
2270                         //
2271
2272                         return a.Equals (b);
2273                 }
2274
2275                 //
2276                 // Checks whether two generic instances may become equal for some
2277                 // particular instantiation (26.3.1).
2278                 //
2279                 public static bool MayBecomeEqualGenericInstances (Type a, Type b,
2280                                                                    Type[] class_infered,
2281                                                                    Type[] method_infered)
2282                 {
2283                         if (!a.IsGenericType || !b.IsGenericType)
2284                                 return false;
2285                         if (a.GetGenericTypeDefinition () != b.GetGenericTypeDefinition ())
2286                                 return false;
2287
2288                         return MayBecomeEqualGenericInstances (
2289                                 GetTypeArguments (a), GetTypeArguments (b), class_infered, method_infered);
2290                 }
2291
2292                 public static bool MayBecomeEqualGenericInstances (Type[] aargs, Type[] bargs,
2293                                                                    Type[] class_infered,
2294                                                                    Type[] method_infered)
2295                 {
2296                         if (aargs.Length != bargs.Length)
2297                                 return false;
2298
2299                         for (int i = 0; i < aargs.Length; i++) {
2300                                 if (!MayBecomeEqualGenericTypes (aargs [i], bargs [i], class_infered, method_infered))
2301                                         return false;
2302                         }
2303
2304                         return true;
2305                 }
2306
2307                 /// <summary>
2308                 ///   Whether `mb' is a generic method definition.
2309                 /// </summary>
2310                 public static bool IsGenericMethodDefinition (MethodBase mb)
2311                 {
2312                         if (mb.DeclaringType is TypeBuilder) {
2313                                 IMethodData method = (IMethodData) builder_to_method [mb];
2314                                 if (method == null)
2315                                         return false;
2316
2317                                 return method.GenericMethod != null;
2318                         }
2319
2320                         return mb.IsGenericMethodDefinition;
2321                 }
2322
2323                 /// <summary>
2324                 ///   Whether `mb' is a generic method definition.
2325                 /// </summary>
2326                 public static bool IsGenericMethod (MethodBase mb)
2327                 {
2328                         if (mb.DeclaringType is TypeBuilder) {
2329                                 IMethodData method = (IMethodData) builder_to_method [mb];
2330                                 if (method == null)
2331                                         return false;
2332
2333                                 return method.GenericMethod != null;
2334                         }
2335
2336                         return mb.IsGenericMethod;
2337                 }
2338
2339                 //
2340                 // Type inference.
2341                 //
2342
2343                 static bool InferType (Type pt, Type at, Type[] infered)
2344                 {
2345                         if (pt.IsGenericParameter) {
2346                                 if (pt.DeclaringMethod == null)
2347                                         return pt == at;
2348
2349                                 int pos = pt.GenericParameterPosition;
2350
2351                                 if (infered [pos] == null) {
2352                                         infered [pos] = at;
2353                                         return true;
2354                                 }
2355
2356                                 if (infered [pos] != at)
2357                                         return false;
2358
2359                                 return true;
2360                         }
2361
2362                         if (!pt.ContainsGenericParameters) {
2363                                 if (at.ContainsGenericParameters)
2364                                         return InferType (at, pt, infered);
2365                                 else
2366                                         return true;
2367                         }
2368
2369                         if (at.IsArray) {
2370                                 if (pt.IsArray) {
2371                                         if (at.GetArrayRank () != pt.GetArrayRank ())
2372                                                 return false;
2373
2374                                         return InferType (pt.GetElementType (), at.GetElementType (), infered);
2375                                 }
2376
2377                                 if (!pt.IsGenericType)
2378                                         return false;
2379
2380                                 Type gt = pt.GetGenericTypeDefinition ();
2381                                 if ((gt != generic_ilist_type) && (gt != generic_icollection_type) &&
2382                                     (gt != generic_ienumerable_type))
2383                                         return false;
2384
2385                                 Type[] args = GetTypeArguments (pt);
2386                                 return InferType (args [0], at.GetElementType (), infered);
2387                         }
2388
2389                         if (pt.IsArray) {
2390                                 if (!at.IsArray ||
2391                                     (pt.GetArrayRank () != at.GetArrayRank ()))
2392                                         return false;
2393
2394                                 return InferType (pt.GetElementType (), at.GetElementType (), infered);
2395                         }
2396
2397                         if (pt.IsByRef && at.IsByRef)
2398                                 return InferType (pt.GetElementType (), at.GetElementType (), infered);
2399                         ArrayList list = new ArrayList ();
2400                         if (at.IsGenericType)
2401                                 list.Add (at);
2402                         for (Type bt = at.BaseType; bt != null; bt = bt.BaseType)
2403                                 list.Add (bt);
2404
2405                         list.AddRange (TypeManager.GetInterfaces (at));
2406
2407                         bool found_one = false;
2408
2409                         foreach (Type type in list) {
2410                                 if (!type.IsGenericType)
2411                                         continue;
2412
2413                                 Type[] infered_types = new Type [infered.Length];
2414
2415                                 if (!InferGenericInstance (pt, type, infered_types))
2416                                         continue;
2417
2418                                 for (int i = 0; i < infered_types.Length; i++) {
2419                                         if (infered [i] == null) {
2420                                                 infered [i] = infered_types [i];
2421                                                 continue;
2422                                         }
2423
2424                                         if (infered [i] != infered_types [i])
2425                                                 return false;
2426                                 }
2427
2428                                 found_one = true;
2429                         }
2430
2431                         return found_one;
2432                 }
2433
2434                 static bool InferGenericInstance (Type pt, Type at, Type[] infered_types)
2435                 {
2436                         Type[] at_args = at.GetGenericArguments ();
2437                         Type[] pt_args = pt.GetGenericArguments ();
2438
2439                         if (at_args.Length != pt_args.Length)
2440                                 return false;
2441
2442                         for (int i = 0; i < at_args.Length; i++) {
2443                                 if (!InferType (pt_args [i], at_args [i], infered_types))
2444                                         return false;
2445                         }
2446
2447                         for (int i = 0; i < infered_types.Length; i++) {
2448                                 if (infered_types [i] == null)
2449                                         return false;
2450                         }
2451
2452                         return true;
2453                 }
2454
2455                 /// <summary>
2456                 ///   Type inference.  Try to infer the type arguments from the params method
2457                 ///   `method', which is invoked with the arguments `arguments'.  This is used
2458                 ///   when resolving an Invocation or a DelegateInvocation and the user
2459                 ///   did not explicitly specify type arguments.
2460                 /// </summary>
2461                 public static bool InferParamsTypeArguments (EmitContext ec, ArrayList arguments,
2462                                                              ref MethodBase method)
2463                 {
2464                         if (!TypeManager.IsGenericMethod (method))
2465                                 return true;
2466
2467                         // if there are no arguments, there's no way to infer the type-arguments
2468                         if (arguments == null || arguments.Count == 0)
2469                                 return false;
2470
2471                         ParameterData pd = TypeManager.GetParameterData (method);
2472                         int pd_count = pd.Count;
2473                         int arg_count = arguments.Count;
2474
2475                         if (pd_count == 0)
2476                                 return false;
2477
2478                         if (pd.ParameterModifier (pd_count - 1) != Parameter.Modifier.PARAMS)
2479                                 return false;
2480
2481                         if (pd_count - 1 > arg_count)
2482                                 return false;
2483
2484                         Type[] method_args = method.GetGenericArguments ();
2485                         Type[] infered_types = new Type [method_args.Length];
2486
2487                         //
2488                         // If we have come this far, the case which
2489                         // remains is when the number of parameters is
2490                         // less than or equal to the argument count.
2491                         //
2492                         for (int i = 0; i < pd_count - 1; ++i) {
2493                                 Argument a = (Argument) arguments [i];
2494
2495                                 if ((a.Expr is NullLiteral) || (a.Expr is MethodGroupExpr))
2496                                         continue;
2497
2498                                 Type pt = pd.ParameterType (i);
2499                                 Type at = a.Type;
2500
2501                                 if (!InferType (pt, at, infered_types))
2502                                         return false;
2503                         }
2504
2505                         Type element_type = TypeManager.GetElementType (pd.ParameterType (pd_count - 1));
2506
2507                         for (int i = pd_count - 1; i < arg_count; i++) {
2508                                 Argument a = (Argument) arguments [i];
2509
2510                                 if ((a.Expr is NullLiteral) || (a.Expr is MethodGroupExpr))
2511                                         continue;
2512
2513                                 if (!InferType (element_type, a.Type, infered_types))
2514                                         return false;
2515                         }
2516
2517                         for (int i = 0; i < infered_types.Length; i++)
2518                                 if (infered_types [i] == null)
2519                                         return false;
2520
2521                         method = ((MethodInfo)method).MakeGenericMethod (infered_types);
2522                         return true;
2523                 }
2524
2525                 static bool InferTypeArguments (Type[] param_types, Type[] arg_types,
2526                                                 Type[] infered_types)
2527                 {
2528                         if (infered_types == null)
2529                                 return false;
2530
2531                         for (int i = 0; i < arg_types.Length; i++) {
2532                                 if (arg_types [i] == null)
2533                                         continue;
2534
2535                                 if (!InferType (param_types [i], arg_types [i], infered_types))
2536                                         return false;
2537                         }
2538
2539                         for (int i = 0; i < infered_types.Length; i++)
2540                                 if (infered_types [i] == null)
2541                                         return false;
2542
2543                         return true;
2544                 }
2545
2546                 /// <summary>
2547                 ///   Type inference.  Try to infer the type arguments from `method',
2548                 ///   which is invoked with the arguments `arguments'.  This is used
2549                 ///   when resolving an Invocation or a DelegateInvocation and the user
2550                 ///   did not explicitly specify type arguments.
2551                 /// </summary>
2552                 public static bool InferTypeArguments (ArrayList arguments,
2553                                                        ref MethodBase method)
2554                 {
2555                         if (!TypeManager.IsGenericMethod (method))
2556                                 return true;
2557
2558                         int arg_count;
2559                         if (arguments != null)
2560                                 arg_count = arguments.Count;
2561                         else
2562                                 arg_count = 0;
2563
2564                         ParameterData pd = TypeManager.GetParameterData (method);
2565                         if (arg_count != pd.Count)
2566                                 return false;
2567
2568                         Type[] method_args = method.GetGenericArguments ();
2569
2570                         bool is_open = false;
2571                         for (int i = 0; i < method_args.Length; i++) {
2572                                 if (method_args [i].IsGenericParameter) {
2573                                         is_open = true;
2574                                         break;
2575                                 }
2576                         }
2577
2578                         // If none of the method parameters mention a generic parameter, we can't infer the generic parameters
2579                         if (!is_open)
2580                                 return !TypeManager.IsGenericMethodDefinition (method);
2581
2582                         Type[] infered_types = new Type [method_args.Length];
2583
2584                         Type[] param_types = new Type [pd.Count];
2585                         Type[] arg_types = new Type [pd.Count];
2586
2587                         for (int i = 0; i < arg_count; i++) {
2588                                 param_types [i] = pd.ParameterType (i);
2589
2590                                 Argument a = (Argument) arguments [i];
2591                                 if ((a.Expr is NullLiteral) || (a.Expr is MethodGroupExpr) ||
2592                                     (a.Expr is AnonymousMethod))
2593                                         continue;
2594
2595                                 arg_types [i] = a.Type;
2596                         }
2597
2598                         if (!InferTypeArguments (param_types, arg_types, infered_types))
2599                                 return false;
2600
2601                         method = ((MethodInfo)method).MakeGenericMethod (infered_types);
2602                         return true;
2603                 }
2604
2605                 /// <summary>
2606                 ///   Type inference.
2607                 /// </summary>
2608                 public static bool InferTypeArguments (ParameterData apd,
2609                                                        ref MethodBase method)
2610                 {
2611                         if (!TypeManager.IsGenericMethod (method))
2612                                 return true;
2613
2614                         ParameterData pd = TypeManager.GetParameterData (method);
2615                         if (apd.Count != pd.Count)
2616                                 return false;
2617
2618                         Type[] method_args = method.GetGenericArguments ();
2619                         Type[] infered_types = new Type [method_args.Length];
2620
2621                         Type[] param_types = new Type [pd.Count];
2622                         Type[] arg_types = new Type [pd.Count];
2623
2624                         for (int i = 0; i < apd.Count; i++) {
2625                                 param_types [i] = pd.ParameterType (i);
2626                                 arg_types [i] = apd.ParameterType (i);
2627                         }
2628
2629                         if (!InferTypeArguments (param_types, arg_types, infered_types))
2630                                 return false;
2631
2632                         method = ((MethodInfo)method).MakeGenericMethod (infered_types);
2633                         return true;
2634                 }
2635
2636                 public static bool IsNullableType (Type t)
2637                 {
2638                         return generic_nullable_type == DropGenericTypeArguments (t);
2639                 }
2640
2641                 public static bool IsNullableTypeOf (Type t, Type nullable)
2642                 {
2643                         if (!IsNullableType (t))
2644                                 return false;
2645
2646                         return GetTypeArguments (t) [0] == nullable;
2647                 }
2648
2649                 public static bool IsNullableValueType (Type t)
2650                 {
2651                         if (!IsNullableType (t))
2652                                 return false;
2653
2654                         return GetTypeArguments (t) [0].IsValueType;
2655                 }
2656         }
2657
2658         public abstract class Nullable
2659         {
2660                 public sealed class NullableInfo
2661                 {
2662                         public readonly Type Type;
2663                         public readonly Type UnderlyingType;
2664                         public readonly MethodInfo HasValue;
2665                         public readonly MethodInfo Value;
2666                         public readonly ConstructorInfo Constructor;
2667
2668                         public NullableInfo (Type type)
2669                         {
2670                                 Type = type;
2671                                 UnderlyingType = TypeManager.GetTypeArguments (type) [0];
2672
2673                                 PropertyInfo has_value_pi = TypeManager.GetProperty (type, "HasValue");
2674                                 PropertyInfo value_pi = TypeManager.GetProperty (type, "Value");
2675
2676                                 HasValue = has_value_pi.GetGetMethod (false);
2677                                 Value = value_pi.GetGetMethod (false);
2678                                 Constructor = type.GetConstructor (new Type[] { UnderlyingType });
2679                         }
2680                 }
2681
2682                 public class Unwrap : Expression, IMemoryLocation, IAssignMethod
2683                 {
2684                         Expression expr;
2685                         NullableInfo info;
2686
2687                         LocalTemporary temp;
2688                         bool has_temp;
2689
2690                         protected Unwrap (Expression expr)
2691                         {
2692                                 this.expr = expr;
2693                                 this.loc = expr.Location;
2694                         }
2695
2696                         public static Unwrap Create (Expression expr, EmitContext ec)
2697                         {
2698                                 return new Unwrap (expr).Resolve (ec) as Unwrap;
2699                         }
2700
2701                         public override Expression DoResolve (EmitContext ec)
2702                         {
2703                                 expr = expr.Resolve (ec);
2704                                 if (expr == null)
2705                                         return null;
2706
2707                                 temp = new LocalTemporary (expr.Type);
2708
2709                                 info = new NullableInfo (expr.Type);
2710                                 type = info.UnderlyingType;
2711                                 eclass = expr.eclass;
2712                                 return this;
2713                         }
2714
2715                         public override void Emit (EmitContext ec)
2716                         {
2717                                 AddressOf (ec, AddressOp.LoadStore);
2718                                 ec.ig.EmitCall (OpCodes.Call, info.Value, null);
2719                         }
2720
2721                         public void EmitCheck (EmitContext ec)
2722                         {
2723                                 AddressOf (ec, AddressOp.LoadStore);
2724                                 ec.ig.EmitCall (OpCodes.Call, info.HasValue, null);
2725                         }
2726
2727                         public void Store (EmitContext ec)
2728                         {
2729                                 create_temp (ec);
2730                         }
2731
2732                         void create_temp (EmitContext ec)
2733                         {
2734                                 if ((temp != null) && !has_temp) {
2735                                         expr.Emit (ec);
2736                                         temp.Store (ec);
2737                                         has_temp = true;
2738                                 }
2739                         }
2740
2741                         public void AddressOf (EmitContext ec, AddressOp mode)
2742                         {
2743                                 create_temp (ec);
2744                                 if (temp != null)
2745                                         temp.AddressOf (ec, AddressOp.LoadStore);
2746                                 else
2747                                         ((IMemoryLocation) expr).AddressOf (ec, AddressOp.LoadStore);
2748                         }
2749
2750                         public void Emit (EmitContext ec, bool leave_copy)
2751                         {
2752                                 create_temp (ec);
2753                                 if (leave_copy) {
2754                                         if (temp != null)
2755                                                 temp.Emit (ec);
2756                                         else
2757                                                 expr.Emit (ec);
2758                                 }
2759
2760                                 Emit (ec);
2761                         }
2762
2763                         public void EmitAssign (EmitContext ec, Expression source,
2764                                                 bool leave_copy, bool prepare_for_load)
2765                         {
2766                                 InternalWrap wrap = new InternalWrap (source, info, loc);
2767                                 ((IAssignMethod) expr).EmitAssign (ec, wrap, leave_copy, false);
2768                         }
2769
2770                         protected class InternalWrap : Expression
2771                         {
2772                                 public Expression expr;
2773                                 public NullableInfo info;
2774
2775                                 public InternalWrap (Expression expr, NullableInfo info, Location loc)
2776                                 {
2777                                         this.expr = expr;
2778                                         this.info = info;
2779                                         this.loc = loc;
2780
2781                                         type = info.Type;
2782                                         eclass = ExprClass.Value;
2783                                 }
2784
2785                                 public override Expression DoResolve (EmitContext ec)
2786                                 {
2787                                         return this;
2788                                 }
2789
2790                                 public override void Emit (EmitContext ec)
2791                                 {
2792                                         expr.Emit (ec);
2793                                         ec.ig.Emit (OpCodes.Newobj, info.Constructor);
2794                                 }
2795                         }
2796                 }
2797
2798                 public class Wrap : Expression
2799                 {
2800                         Expression expr;
2801                         NullableInfo info;
2802
2803                         protected Wrap (Expression expr)
2804                         {
2805                                 this.expr = expr;
2806                                 this.loc = expr.Location;
2807                         }
2808
2809                         public static Wrap Create (Expression expr, EmitContext ec)
2810                         {
2811                                 return new Wrap (expr).Resolve (ec) as Wrap;
2812                         }
2813
2814                         public override Expression DoResolve (EmitContext ec)
2815                         {
2816                                 expr = expr.Resolve (ec);
2817                                 if (expr == null)
2818                                         return null;
2819
2820                                 TypeExpr target_type = new NullableType (expr.Type, loc);
2821                                 target_type = target_type.ResolveAsTypeTerminal (ec, false);
2822                                 if (target_type == null)
2823                                         return null;
2824
2825                                 type = target_type.Type;
2826                                 info = new NullableInfo (type);
2827                                 eclass = ExprClass.Value;
2828                                 return this;
2829                         }
2830
2831                         public override void Emit (EmitContext ec)
2832                         {
2833                                 expr.Emit (ec);
2834                                 ec.ig.Emit (OpCodes.Newobj, info.Constructor);
2835                         }
2836                 }
2837
2838                 public class NullableLiteral : NullLiteral, IMemoryLocation {
2839                         public NullableLiteral (Type target_type, Location loc)
2840                                 : base (loc)
2841                         {
2842                                 this.type = target_type;
2843
2844                                 eclass = ExprClass.Value;
2845                         }
2846
2847                         public override Expression DoResolve (EmitContext ec)
2848                         {
2849                                 return this;
2850                         }
2851
2852                         public override void Emit (EmitContext ec)
2853                         {
2854                                 LocalTemporary value_target = new LocalTemporary (type);
2855
2856                                 value_target.AddressOf (ec, AddressOp.Store);
2857                                 ec.ig.Emit (OpCodes.Initobj, type);
2858                                 value_target.Emit (ec);
2859                         }
2860
2861                         public void AddressOf (EmitContext ec, AddressOp Mode)
2862                         {
2863                                 LocalTemporary value_target = new LocalTemporary (type);
2864
2865                                 value_target.AddressOf (ec, AddressOp.Store);
2866                                 ec.ig.Emit (OpCodes.Initobj, type);
2867                                 ((IMemoryLocation) value_target).AddressOf (ec, Mode);
2868                         }
2869                 }
2870
2871                 public abstract class Lifted : Expression, IMemoryLocation
2872                 {
2873                         Expression expr, underlying, wrap, null_value;
2874                         Unwrap unwrap;
2875
2876                         protected Lifted (Expression expr, Location loc)
2877                         {
2878                                 this.expr = expr;
2879                                 this.loc = loc;
2880                         }
2881
2882                         public override Expression DoResolve (EmitContext ec)
2883                         {
2884                                 expr = expr.Resolve (ec);
2885                                 if (expr == null)
2886                                         return null;
2887
2888                                 unwrap = Unwrap.Create (expr, ec);
2889                                 if (unwrap == null)
2890                                         return null;
2891
2892                                 underlying = ResolveUnderlying (unwrap, ec);
2893                                 if (underlying == null)
2894                                         return null;
2895
2896                                 wrap = Wrap.Create (underlying, ec);
2897                                 if (wrap == null)
2898                                         return null;
2899
2900                                 null_value = new NullableLiteral (wrap.Type, loc).Resolve (ec);
2901                                 if (null_value == null)
2902                                         return null;
2903
2904                                 type = wrap.Type;
2905                                 eclass = ExprClass.Value;
2906                                 return this;
2907                         }
2908
2909                         protected abstract Expression ResolveUnderlying (Expression unwrap, EmitContext ec);
2910
2911                         public override void Emit (EmitContext ec)
2912                         {
2913                                 ILGenerator ig = ec.ig;
2914                                 Label is_null_label = ig.DefineLabel ();
2915                                 Label end_label = ig.DefineLabel ();
2916
2917                                 unwrap.EmitCheck (ec);
2918                                 ig.Emit (OpCodes.Brfalse, is_null_label);
2919
2920                                 wrap.Emit (ec);
2921                                 ig.Emit (OpCodes.Br, end_label);
2922
2923                                 ig.MarkLabel (is_null_label);
2924                                 null_value.Emit (ec);
2925
2926                                 ig.MarkLabel (end_label);
2927                         }
2928
2929                         public void AddressOf (EmitContext ec, AddressOp mode)
2930                         {
2931                                 unwrap.AddressOf (ec, mode);
2932                         }
2933                 }
2934
2935                 public class LiftedConversion : Lifted
2936                 {
2937                         public readonly bool IsUser;
2938                         public readonly bool IsExplicit;
2939                         public readonly Type TargetType;
2940
2941                         public LiftedConversion (Expression expr, Type target_type, bool is_user,
2942                                                  bool is_explicit, Location loc)
2943                                 : base (expr, loc)
2944                         {
2945                                 this.IsUser = is_user;
2946                                 this.IsExplicit = is_explicit;
2947                                 this.TargetType = target_type;
2948                         }
2949
2950                         protected override Expression ResolveUnderlying (Expression unwrap, EmitContext ec)
2951                         {
2952                                 Type type = TypeManager.GetTypeArguments (TargetType) [0];
2953
2954                                 if (IsUser) {
2955                                         return Convert.UserDefinedConversion (ec, unwrap, type, loc, IsExplicit);
2956                                 } else {
2957                                         if (IsExplicit)
2958                                                 return Convert.ExplicitConversion (ec, unwrap, type, loc);
2959                                         else
2960                                                 return Convert.ImplicitConversion (ec, unwrap, type, loc);
2961                                 }
2962                         }
2963                 }
2964
2965                 public class LiftedUnaryOperator : Lifted
2966                 {
2967                         public readonly Unary.Operator Oper;
2968
2969                         public LiftedUnaryOperator (Unary.Operator op, Expression expr, Location loc)
2970                                 : base (expr, loc)
2971                         {
2972                                 this.Oper = op;
2973                         }
2974
2975                         protected override Expression ResolveUnderlying (Expression unwrap, EmitContext ec)
2976                         {
2977                                 return new Unary (Oper, unwrap, loc);
2978                         }
2979                 }
2980
2981                 public class LiftedConditional : Lifted
2982                 {
2983                         Expression true_expr, false_expr;
2984
2985                         public LiftedConditional (Expression expr, Expression true_expr, Expression false_expr,
2986                                                   Location loc)
2987                                 : base (expr, loc)
2988                         {
2989                                 this.true_expr = true_expr;
2990                                 this.false_expr = false_expr;
2991                         }
2992
2993                         protected override Expression ResolveUnderlying (Expression unwrap, EmitContext ec)
2994                         {
2995                                 return new Conditional (unwrap, true_expr, false_expr);
2996                         }
2997                 }
2998
2999                 public class LiftedBinaryOperator : Expression
3000                 {
3001                         public readonly Binary.Operator Oper;
3002
3003                         Expression left, right, original_left, original_right;
3004                         Expression underlying, null_value, bool_wrap;
3005                         Unwrap left_unwrap, right_unwrap;
3006                         bool is_equality, is_comparision, is_boolean;
3007
3008                         public LiftedBinaryOperator (Binary.Operator op, Expression left, Expression right,
3009                                                      Location loc)
3010                         {
3011                                 this.Oper = op;
3012                                 this.left = original_left = left;
3013                                 this.right = original_right = right;
3014                                 this.loc = loc;
3015                         }
3016
3017                         public override Expression DoResolve (EmitContext ec)
3018                         {
3019                                 if (TypeManager.IsNullableType (left.Type)) {
3020                                         left = left_unwrap = Unwrap.Create (left, ec);
3021                                         if (left == null)
3022                                                 return null;
3023                                 }
3024
3025                                 if (TypeManager.IsNullableType (right.Type)) {
3026                                         right = right_unwrap = Unwrap.Create (right, ec);
3027                                         if (right == null)
3028                                                 return null;
3029                                 }
3030
3031                                 if ((Oper == Binary.Operator.LogicalAnd) ||
3032                                     (Oper == Binary.Operator.LogicalOr)) {
3033                                         Binary.Error_OperatorCannotBeApplied (
3034                                                 loc, Binary.OperName (Oper),
3035                                                 original_left.GetSignatureForError (),
3036                                                 original_right.GetSignatureForError ());
3037                                         return null;
3038                                 }
3039
3040                                 if (((Oper == Binary.Operator.BitwiseAnd) || (Oper == Binary.Operator.BitwiseOr)) &&
3041                                     ((left.Type == TypeManager.bool_type) && (right.Type == TypeManager.bool_type))) {
3042                                         Expression empty = new EmptyExpression (TypeManager.bool_type);
3043                                         bool_wrap = Wrap.Create (empty, ec);
3044                                         null_value = new NullableLiteral (bool_wrap.Type, loc).Resolve (ec);
3045
3046                                         type = bool_wrap.Type;
3047                                         is_boolean = true;
3048                                 } else if ((Oper == Binary.Operator.Equality) || (Oper == Binary.Operator.Inequality)) {
3049                                         if (!(left is NullLiteral) && !(right is NullLiteral)) {
3050                                                 underlying = new Binary (Oper, left, right).Resolve (ec);
3051                                                 if (underlying == null)
3052                                                         return null;
3053                                         }
3054
3055                                         type = TypeManager.bool_type;
3056                                         is_equality = true;
3057                                 } else if ((Oper == Binary.Operator.LessThan) ||
3058                                            (Oper == Binary.Operator.GreaterThan) ||
3059                                            (Oper == Binary.Operator.LessThanOrEqual) ||
3060                                            (Oper == Binary.Operator.GreaterThanOrEqual)) {
3061                                         underlying = new Binary (Oper, left, right).Resolve (ec);
3062                                         if (underlying == null)
3063                                                 return null;
3064
3065                                         type = TypeManager.bool_type;
3066                                         is_comparision = true;
3067                                 } else {
3068                                         underlying = new Binary (Oper, left, right).Resolve (ec);
3069                                         if (underlying == null)
3070                                                 return null;
3071
3072                                         underlying = Wrap.Create (underlying, ec);
3073                                         if (underlying == null)
3074                                                 return null;
3075
3076                                         type = underlying.Type;
3077                                         null_value = new NullableLiteral (type, loc).Resolve (ec);
3078                                 }
3079
3080                                 eclass = ExprClass.Value;
3081                                 return this;
3082                         }
3083
3084                         void EmitBoolean (EmitContext ec)
3085                         {
3086                                 ILGenerator ig = ec.ig;
3087
3088                                 Label left_is_null_label = ig.DefineLabel ();
3089                                 Label right_is_null_label = ig.DefineLabel ();
3090                                 Label is_null_label = ig.DefineLabel ();
3091                                 Label wrap_label = ig.DefineLabel ();
3092                                 Label end_label = ig.DefineLabel ();
3093
3094                                 if (left_unwrap != null) {
3095                                         left_unwrap.EmitCheck (ec);
3096                                         ig.Emit (OpCodes.Brfalse, left_is_null_label);
3097                                 }
3098
3099                                 left.Emit (ec);
3100                                 ig.Emit (OpCodes.Dup);
3101                                 if ((Oper == Binary.Operator.BitwiseOr) || (Oper == Binary.Operator.LogicalOr))
3102                                         ig.Emit (OpCodes.Brtrue, wrap_label);
3103                                 else
3104                                         ig.Emit (OpCodes.Brfalse, wrap_label);
3105
3106                                 if (right_unwrap != null) {
3107                                         right_unwrap.EmitCheck (ec);
3108                                         ig.Emit (OpCodes.Brfalse, right_is_null_label);
3109                                 }
3110
3111                                 if ((Oper == Binary.Operator.LogicalAnd) || (Oper == Binary.Operator.LogicalOr))
3112                                         ig.Emit (OpCodes.Pop);
3113
3114                                 right.Emit (ec);
3115                                 if (Oper == Binary.Operator.BitwiseOr)
3116                                         ig.Emit (OpCodes.Or);
3117                                 else if (Oper == Binary.Operator.BitwiseAnd)
3118                                         ig.Emit (OpCodes.And);
3119                                 ig.Emit (OpCodes.Br, wrap_label);
3120
3121                                 ig.MarkLabel (left_is_null_label);
3122                                 if (right_unwrap != null) {
3123                                         right_unwrap.EmitCheck (ec);
3124                                         ig.Emit (OpCodes.Brfalse, is_null_label);
3125                                 }
3126
3127                                 right.Emit (ec);
3128                                 ig.Emit (OpCodes.Dup);
3129                                 if ((Oper == Binary.Operator.BitwiseOr) || (Oper == Binary.Operator.LogicalOr))
3130                                         ig.Emit (OpCodes.Brtrue, wrap_label);
3131                                 else
3132                                         ig.Emit (OpCodes.Brfalse, wrap_label);
3133
3134                                 ig.MarkLabel (right_is_null_label);
3135                                 ig.Emit (OpCodes.Pop);
3136                                 ig.MarkLabel (is_null_label);
3137                                 null_value.Emit (ec);
3138                                 ig.Emit (OpCodes.Br, end_label);
3139
3140                                 ig.MarkLabel (wrap_label);
3141                                 ig.Emit (OpCodes.Nop);
3142                                 bool_wrap.Emit (ec);
3143                                 ig.Emit (OpCodes.Nop);
3144
3145                                 ig.MarkLabel (end_label);
3146                         }
3147
3148                         void EmitEquality (EmitContext ec)
3149                         {
3150                                 ILGenerator ig = ec.ig;
3151
3152                                 // Given 'X? x;' for any value type X: 'x != null' is the same as 'x.HasValue'
3153                                 if (left is NullLiteral) {
3154                                         if (right_unwrap == null)
3155                                                 throw new InternalErrorException ();
3156                                         right_unwrap.EmitCheck (ec);
3157                                         if (Oper == Binary.Operator.Equality) {
3158                                                 ig.Emit (OpCodes.Ldc_I4_0);
3159                                                 ig.Emit (OpCodes.Ceq);
3160                                         }
3161                                         return;
3162                                 }
3163
3164                                 if (right is NullLiteral) {
3165                                         if (left_unwrap == null)
3166                                                 throw new InternalErrorException ();
3167                                         left_unwrap.EmitCheck (ec);
3168                                         if (Oper == Binary.Operator.Equality) {
3169                                                 ig.Emit (OpCodes.Ldc_I4_0);
3170                                                 ig.Emit (OpCodes.Ceq);
3171                                         }
3172                                         return;
3173                                 }
3174
3175                                 Label both_have_value_label = ig.DefineLabel ();
3176                                 Label end_label = ig.DefineLabel ();
3177
3178                                 if (left_unwrap != null && right_unwrap != null) {
3179                                         Label dissimilar_label = ig.DefineLabel ();
3180
3181                                         left_unwrap.EmitCheck (ec);
3182                                         ig.Emit (OpCodes.Dup);
3183                                         right_unwrap.EmitCheck (ec);
3184                                         ig.Emit (OpCodes.Bne_Un, dissimilar_label);
3185
3186                                         ig.Emit (OpCodes.Brtrue, both_have_value_label);
3187
3188                                         // both are null
3189                                         if (Oper == Binary.Operator.Equality)
3190                                                 ig.Emit (OpCodes.Ldc_I4_1);
3191                                         else
3192                                                 ig.Emit (OpCodes.Ldc_I4_0);
3193                                         ig.Emit (OpCodes.Br, end_label);
3194
3195                                         ig.MarkLabel (dissimilar_label);
3196                                         ig.Emit (OpCodes.Pop);
3197                                 } else if (left_unwrap != null) {
3198                                         left_unwrap.EmitCheck (ec);
3199                                         ig.Emit (OpCodes.Brtrue, both_have_value_label);
3200                                 } else if (right_unwrap != null) {
3201                                         right_unwrap.EmitCheck (ec);
3202                                         ig.Emit (OpCodes.Brtrue, both_have_value_label);
3203                                 } else {
3204                                         throw new InternalErrorException ("shouldn't get here");
3205                                 }
3206
3207                                 // one is null while the other isn't
3208                                 if (Oper == Binary.Operator.Equality)
3209                                         ig.Emit (OpCodes.Ldc_I4_0);
3210                                 else
3211                                         ig.Emit (OpCodes.Ldc_I4_1);
3212                                 ig.Emit (OpCodes.Br, end_label);
3213
3214                                 ig.MarkLabel (both_have_value_label);
3215                                 underlying.Emit (ec);
3216
3217                                 ig.MarkLabel (end_label);
3218                         }
3219
3220                         void EmitComparision (EmitContext ec)
3221                         {
3222                                 ILGenerator ig = ec.ig;
3223
3224                                 Label is_null_label = ig.DefineLabel ();
3225                                 Label end_label = ig.DefineLabel ();
3226
3227                                 if (left_unwrap != null) {
3228                                         left_unwrap.EmitCheck (ec);
3229                                         ig.Emit (OpCodes.Brfalse, is_null_label);
3230                                 }
3231
3232                                 if (right_unwrap != null) {
3233                                         right_unwrap.EmitCheck (ec);
3234                                         ig.Emit (OpCodes.Brfalse, is_null_label);
3235                                 }
3236
3237                                 underlying.Emit (ec);
3238                                 ig.Emit (OpCodes.Br, end_label);
3239
3240                                 ig.MarkLabel (is_null_label);
3241                                 ig.Emit (OpCodes.Ldc_I4_0);
3242
3243                                 ig.MarkLabel (end_label);
3244                         }
3245
3246                         public override void Emit (EmitContext ec)
3247                         {
3248                                 if (left_unwrap != null)
3249                                         left_unwrap.Store (ec);
3250                                 if (right_unwrap != null)
3251                                         right_unwrap.Store (ec);
3252
3253                                 if (is_boolean) {
3254                                         EmitBoolean (ec);
3255                                         return;
3256                                 } else if (is_equality) {
3257                                         EmitEquality (ec);
3258                                         return;
3259                                 } else if (is_comparision) {
3260                                         EmitComparision (ec);
3261                                         return;
3262                                 }
3263
3264                                 ILGenerator ig = ec.ig;
3265
3266                                 Label is_null_label = ig.DefineLabel ();
3267                                 Label end_label = ig.DefineLabel ();
3268
3269                                 if (left_unwrap != null) {
3270                                         left_unwrap.EmitCheck (ec);
3271                                         ig.Emit (OpCodes.Brfalse, is_null_label);
3272                                 }
3273
3274                                 if (right_unwrap != null) {
3275                                         right_unwrap.EmitCheck (ec);
3276                                         ig.Emit (OpCodes.Brfalse, is_null_label);
3277                                 }
3278
3279                                 underlying.Emit (ec);
3280                                 ig.Emit (OpCodes.Br, end_label);
3281
3282                                 ig.MarkLabel (is_null_label);
3283                                 null_value.Emit (ec);
3284
3285                                 ig.MarkLabel (end_label);
3286                         }
3287                 }
3288
3289                 public class OperatorTrueOrFalse : Expression
3290                 {
3291                         public readonly bool IsTrue;
3292
3293                         Expression expr;
3294                         Unwrap unwrap;
3295
3296                         public OperatorTrueOrFalse (Expression expr, bool is_true, Location loc)
3297                         {
3298                                 this.IsTrue = is_true;
3299                                 this.expr = expr;
3300                                 this.loc = loc;
3301                         }
3302
3303                         public override Expression DoResolve (EmitContext ec)
3304                         {
3305                                 unwrap = Unwrap.Create (expr, ec);
3306                                 if (unwrap == null)
3307                                         return null;
3308
3309                                 if (unwrap.Type != TypeManager.bool_type)
3310                                         return null;
3311
3312                                 type = TypeManager.bool_type;
3313                                 eclass = ExprClass.Value;
3314                                 return this;
3315                         }
3316
3317                         public override void Emit (EmitContext ec)
3318                         {
3319                                 ILGenerator ig = ec.ig;
3320
3321                                 Label is_null_label = ig.DefineLabel ();
3322                                 Label end_label = ig.DefineLabel ();
3323
3324                                 unwrap.EmitCheck (ec);
3325                                 ig.Emit (OpCodes.Brfalse, is_null_label);
3326
3327                                 unwrap.Emit (ec);
3328                                 if (!IsTrue) {
3329                                         ig.Emit (OpCodes.Ldc_I4_0);
3330                                         ig.Emit (OpCodes.Ceq);
3331                                 }
3332                                 ig.Emit (OpCodes.Br, end_label);
3333
3334                                 ig.MarkLabel (is_null_label);
3335                                 ig.Emit (OpCodes.Ldc_I4_0);
3336
3337                                 ig.MarkLabel (end_label);
3338                         }
3339                 }
3340
3341                 public class NullCoalescingOperator : Expression
3342                 {
3343                         Expression left, right;
3344                         Expression expr;
3345                         Unwrap unwrap;
3346
3347                         public NullCoalescingOperator (Expression left, Expression right, Location loc)
3348                         {
3349                                 this.left = left;
3350                                 this.right = right;
3351                                 this.loc = loc;
3352
3353                                 eclass = ExprClass.Value;
3354                         }
3355
3356                         public override Expression DoResolve (EmitContext ec)
3357                         {
3358                                 if (type != null)
3359                                         return this;
3360
3361                                 left = left.Resolve (ec);
3362                                 if (left == null)
3363                                         return null;
3364
3365                                 right = right.Resolve (ec);
3366                                 if (right == null)
3367                                         return null;
3368
3369                                 Type ltype = left.Type, rtype = right.Type;
3370
3371                                 if (!TypeManager.IsNullableType (ltype) && ltype.IsValueType) {
3372                                         Binary.Error_OperatorCannotBeApplied (loc, "??", ltype, rtype);
3373                                         return null;
3374                                 }
3375
3376                                 if (TypeManager.IsNullableType (ltype)) {
3377                                         NullableInfo info = new NullableInfo (ltype);
3378
3379                                         unwrap = Unwrap.Create (left, ec);
3380                                         if (unwrap == null)
3381                                                 return null;
3382
3383                                         expr = Convert.ImplicitConversion (ec, right, info.UnderlyingType, loc);
3384                                         if (expr != null) {
3385                                                 left = unwrap;
3386                                                 type = expr.Type;
3387                                                 return this;
3388                                         }
3389                                 }
3390
3391                                 expr = Convert.ImplicitConversion (ec, right, ltype, loc);
3392                                 if (expr != null) {
3393                                         type = expr.Type;
3394                                         return this;
3395                                 }
3396
3397                                 if (unwrap != null) {
3398                                         expr = Convert.ImplicitConversion (ec, unwrap, rtype, loc);
3399                                         if (expr != null) {
3400                                                 left = expr;
3401                                                 expr = right;
3402                                                 type = expr.Type;
3403                                                 return this;
3404                                         }
3405                                 }
3406
3407                                 Binary.Error_OperatorCannotBeApplied (loc, "??", ltype, rtype);
3408                                 return null;
3409                         }
3410
3411                         public override void Emit (EmitContext ec)
3412                         {
3413                                 ILGenerator ig = ec.ig;
3414
3415                                 Label is_null_label = ig.DefineLabel ();
3416                                 Label end_label = ig.DefineLabel ();
3417
3418                                 if (unwrap != null) {
3419                                         unwrap.EmitCheck (ec);
3420                                         ig.Emit (OpCodes.Brfalse, is_null_label);
3421
3422                                         left.Emit (ec);
3423                                         ig.Emit (OpCodes.Br, end_label);
3424
3425                                         ig.MarkLabel (is_null_label);
3426                                         expr.Emit (ec);
3427
3428                                         ig.MarkLabel (end_label);
3429                                 } else {
3430                                         left.Emit (ec);
3431                                         ig.Emit (OpCodes.Dup);
3432                                         ig.Emit (OpCodes.Brtrue, end_label);
3433
3434                                         ig.MarkLabel (is_null_label);
3435
3436                                         ig.Emit (OpCodes.Pop);
3437                                         expr.Emit (ec);
3438
3439                                         ig.MarkLabel (end_label);
3440                                 }
3441                         }
3442                 }
3443
3444                 public class LiftedUnaryMutator : ExpressionStatement
3445                 {
3446                         public readonly UnaryMutator.Mode Mode;
3447                         Expression expr, null_value;
3448                         UnaryMutator underlying;
3449                         Unwrap unwrap;
3450
3451                         public LiftedUnaryMutator (UnaryMutator.Mode mode, Expression expr, Location loc)
3452                         {
3453                                 this.expr = expr;
3454                                 this.Mode = mode;
3455                                 this.loc = loc;
3456
3457                                 eclass = ExprClass.Value;
3458                         }
3459
3460                         public override Expression DoResolve (EmitContext ec)
3461                         {
3462                                 expr = expr.Resolve (ec);
3463                                 if (expr == null)
3464                                         return null;
3465
3466                                 unwrap = Unwrap.Create (expr, ec);
3467                                 if (unwrap == null)
3468                                         return null;
3469
3470                                 underlying = (UnaryMutator) new UnaryMutator (Mode, unwrap, loc).Resolve (ec);
3471                                 if (underlying == null)
3472                                         return null;
3473
3474                                 null_value = new NullableLiteral (expr.Type, loc).Resolve (ec);
3475                                 if (null_value == null)
3476                                         return null;
3477
3478                                 type = expr.Type;
3479                                 return this;
3480                         }
3481
3482                         void DoEmit (EmitContext ec, bool is_expr)
3483                         {
3484                                 ILGenerator ig = ec.ig;
3485                                 Label is_null_label = ig.DefineLabel ();
3486                                 Label end_label = ig.DefineLabel ();
3487
3488                                 unwrap.EmitCheck (ec);
3489                                 ig.Emit (OpCodes.Brfalse, is_null_label);
3490
3491                                 if (is_expr)
3492                                         underlying.Emit (ec);
3493                                 else
3494                                         underlying.EmitStatement (ec);
3495                                 ig.Emit (OpCodes.Br, end_label);
3496
3497                                 ig.MarkLabel (is_null_label);
3498                                 if (is_expr)
3499                                         null_value.Emit (ec);
3500
3501                                 ig.MarkLabel (end_label);
3502                         }
3503
3504                         public override void Emit (EmitContext ec)
3505                         {
3506                                 DoEmit (ec, true);
3507                         }
3508
3509                         public override void EmitStatement (EmitContext ec)
3510                         {
3511                                 DoEmit (ec, false);
3512                         }
3513                 }
3514         }
3515 }