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