mcs/mcs/class.cs

   1 //
   2 // class.cs: Class and Struct handlers
   3 //
   4 // Authors: Miguel de Icaza (miguel@gnu.org)
   5 //          Martin Baulig (martin@ximian.com)
   6 //          Marek Safar (marek.safar@seznam.cz)
   7 //
   8 // Licensed under the terms of the GNU GPL
   9 //
  10 // (C) 2001, 2002, 2003 Ximian, Inc (http://www.ximian.com)
  11 // (C) 2004 Novell, Inc
  12 //
  13 //
  14 //  2002-10-11  Miguel de Icaza  <miguel@ximian.com>
  15 //
  16 //      * class.cs: Following the comment from 2002-09-26 to AddMethod, I
  17 //      have fixed a remaining problem: not every AddXXXX was adding a
  18 //      fully qualified name.
  19 //
  20 //      Now everyone registers a fully qualified name in the DeclSpace as
  21 //      being defined instead of the partial name.
  22 //
  23 //      Downsides: we are slower than we need to be due to the excess
  24 //      copies and the names being registered this way.
  25 //
  26 //      The reason for this is that we currently depend (on the corlib
  27 //      bootstrap for instance) that types are fully qualified, because
  28 //      we dump all the types in the namespace, and we should really have
  29 //      types inserted into the proper namespace, so we can only store the
  30 //      basenames in the defined_names array.
  31 //
  32 //
  33 #define CACHE
  34 using System;
  35 using System.Collections;
  36 using System.Collections.Specialized;
  37 using System.Reflection;
  38 using System.Reflection.Emit;
  39 using System.Runtime.CompilerServices;
  40 using System.Runtime.InteropServices;
  41 using System.Security;
  42 using System.Security.Permissions;
  43 using System.Text;
  44
  45 #if BOOTSTRAP_WITH_OLDLIB
  46 using XmlElement = System.Object;
  47 #else
  48 using System.Xml;
  49 #endif
  50
  51 using Mono.CompilerServices.SymbolWriter;
  52
  53 namespace Mono.CSharp {
  54
  55         public enum Kind {
  56                 Root,
  57                 Struct,
  58                 Class,
  59                 Interface
  60         }
  61
  62         /// <summary>
  63         ///   This is the base class for structs and classes.
  64         /// </summary>
  65         public abstract class TypeContainer : DeclSpace, IMemberContainer {
  66
  67                 public class MemberCoreArrayList: ArrayList
  68                 {
  69                         /// <summary>
  70                         ///   Defines the MemberCore objects that are in this array
  71                         /// </summary>
  72                         public virtual void DefineContainerMembers ()
  73                         {
  74                                 foreach (MemberCore mc in this) {
  75                                         mc.Define ();
  76                                 }
  77                         }
  78
  79                         public virtual void Emit ()
  80                         {
  81                                 foreach (MemberCore mc in this)
  82                                         mc.Emit ();
  83                         }
  84                 }
  85
  86                 public class MethodArrayList: MemberCoreArrayList
  87                 {
  88                         [Flags]
  89                         enum CachedMethods {
  90                                 Equals                  = 1,
  91                                 GetHashCode             = 1 << 1
  92                         }
  93
  94                         CachedMethods cached_method;
  95                         TypeContainer container;
  96
  97                         public MethodArrayList (TypeContainer container)
  98                         {
  99                                 this.container = container;
 100                         }
 101
 102                         /// <summary>
 103                         /// Method container contains Equals method
 104                         /// </summary>
 105                         public bool HasEquals {
 106                                 set {
 107                                         cached_method |= CachedMethods.Equals;
 108                                 }
 109
 110                                 get {
 111                                         return (cached_method & CachedMethods.Equals) != 0;
 112                                 }
 113                         }
 114
 115                         /// <summary>
 116                         /// Method container contains GetHashCode method
 117                         /// </summary>
 118                         public bool HasGetHashCode {
 119                                 set {
 120                                         cached_method |= CachedMethods.GetHashCode;
 121                                 }
 122
 123                                 get {
 124                                         return (cached_method & CachedMethods.GetHashCode) != 0;
 125                                 }
 126                         }
 127
 128                         public override void DefineContainerMembers ()
 129                         {
 130                                 base.DefineContainerMembers ();
 131
 132                                 if ((RootContext.WarningLevel >= 3) && HasEquals && !HasGetHashCode) {
 133                                         Report.Warning (659, container.Location, "`{0}' overrides Object.Equals(object) but does not override Object.GetHashCode()", container.GetSignatureForError ());
 134                                 }
 135                         }
 136
 137                 }
 138
 139                 public sealed class IndexerArrayList: MemberCoreArrayList
 140                 {
 141                         /// <summary>
 142                         /// The indexer name for this container
 143                         /// </summary>
 144                         public string IndexerName = DefaultIndexerName;
 145
 146                         bool seen_normal_indexers = false;
 147
 148                         TypeContainer container;
 149
 150                         public IndexerArrayList (TypeContainer container)
 151                         {
 152                                 this.container = container;
 153                         }
 154
 155                         /// <summary>
 156                         /// Defines the indexers, and also verifies that the IndexerNameAttribute in the
 157                         /// class is consistent.  Either it is `Item' or it is the name defined by all the
 158                         /// indexers with the `IndexerName' attribute.
 159                         ///
 160                         /// Turns out that the IndexerNameAttribute is applied to each indexer,
 161                         /// but it is never emitted, instead a DefaultMember attribute is attached
 162                         /// to the class.
 163                         /// </summary>
 164                         public override void DefineContainerMembers()
 165                         {
 166                                 base.DefineContainerMembers ();
 167
 168                                 string class_indexer_name = null;
 169
 170                                 //
 171                                 // If there's both an explicit and an implicit interface implementation, the
 172                                 // explicit one actually implements the interface while the other one is just
 173                                 // a normal indexer.  See bug #37714.
 174                                 //
 175
 176                                 // Invariant maintained by AddIndexer(): All explicit interface indexers precede normal indexers
 177                                 foreach (Indexer i in this) {
 178                                         if (i.InterfaceType != null) {
 179                                                 if (seen_normal_indexers)
 180                                                         throw new Exception ("Internal Error: 'Indexers' array not sorted properly.");
 181                                                 continue;
 182                                         }
 183
 184                                         seen_normal_indexers = true;
 185
 186                                         if (class_indexer_name == null) {
 187                                                 class_indexer_name = i.ShortName;
 188                                                 continue;
 189                                         }
 190
 191                                         if (i.ShortName != class_indexer_name)
 192                                                 Report.Error (668, i.Location, "Two indexers have different names; the IndexerName attribute must be used with the same name on every indexer within a type");
 193                                 }
 194
 195                                 if (class_indexer_name != null)
 196                                         IndexerName = class_indexer_name;
 197                         }
 198
 199                         public override void Emit ()
 200                         {
 201                                 base.Emit ();
 202
 203                                 if (!seen_normal_indexers)
 204                                         return;
 205
 206                                 CustomAttributeBuilder cb = new CustomAttributeBuilder (TypeManager.default_member_ctor, new string [] { IndexerName });
 207                                 container.TypeBuilder.SetCustomAttribute (cb);
 208                         }
 209                 }
 210
 211                 public class OperatorArrayList: MemberCoreArrayList
 212                 {
 213                         TypeContainer container;
 214
 215                         public OperatorArrayList (TypeContainer container)
 216                         {
 217                                 this.container = container;
 218                         }
 219
 220                         //
 221                         // Operator pair checking
 222                         //
 223                         class OperatorEntry
 224                         {
 225                                 public int flags;
 226                                 public Type ret_type;
 227                                 public Type type1, type2;
 228                                 public Operator op;
 229                                 public Operator.OpType ot;
 230
 231                                 public OperatorEntry (int f, Operator o)
 232                                 {
 233                                         flags = f;
 234
 235                                         ret_type = o.OperatorMethod.ReturnType;
 236                                         Type [] pt = o.OperatorMethod.ParameterTypes;
 237                                         type1 = pt [0];
 238                                         type2 = pt [1];
 239                                         op = o;
 240                                         ot = o.OperatorType;
 241                                 }
 242
 243                                 public override int GetHashCode ()
 244                                 {
 245                                         return ret_type.GetHashCode ();
 246                                 }
 247
 248                                 public override bool Equals (object o)
 249                                 {
 250                                         OperatorEntry other = (OperatorEntry) o;
 251
 252                                         if (other.ret_type != ret_type)
 253                                                 return false;
 254                                         if (other.type1 != type1)
 255                                                 return false;
 256                                         if (other.type2 != type2)
 257                                                 return false;
 258                                         return true;
 259                                 }
 260                         }
 261
 262                         //
 263                         // Checks that some operators come in pairs:
 264                         //  == and !=
 265                         // > and <
 266                         // >= and <=
 267                         // true and false
 268                         //
 269                         // They are matched based on the return type and the argument types
 270                         //
 271                         void CheckPairedOperators ()
 272                         {
 273                                 Hashtable pairs = new Hashtable (null, null);
 274                                 Operator true_op = null;
 275                                 Operator false_op = null;
 276                                 bool has_equality_or_inequality = false;
 277
 278                                 // Register all the operators we care about.
 279                                 foreach (Operator op in this){
 280                                         int reg = 0;
 281
 282                                         // Skip erroneous code.
 283                                         if (op.OperatorMethod == null)
 284                                                 continue;
 285
 286                                         switch (op.OperatorType){
 287                                         case Operator.OpType.Equality:
 288                                                 reg = 1;
 289                                                 has_equality_or_inequality = true;
 290                                                 break;
 291                                         case Operator.OpType.Inequality:
 292                                                 reg = 2;
 293                                                 has_equality_or_inequality = true;
 294                                                 break;
 295
 296                                         case Operator.OpType.True:
 297                                                 true_op = op;
 298                                                 break;
 299                                         case Operator.OpType.False:
 300                                                 false_op = op;
 301                                                 break;
 302
 303                                         case Operator.OpType.GreaterThan:
 304                                                 reg = 1; break;
 305                                         case Operator.OpType.LessThan:
 306                                                 reg = 2; break;
 307
 308                                         case Operator.OpType.GreaterThanOrEqual:
 309                                                 reg = 1; break;
 310                                         case Operator.OpType.LessThanOrEqual:
 311                                                 reg = 2; break;
 312                                         }
 313                                         if (reg == 0)
 314                                                 continue;
 315
 316                                         OperatorEntry oe = new OperatorEntry (reg, op);
 317
 318                                         object o = pairs [oe];
 319                                         if (o == null)
 320                                                 pairs [oe] = oe;
 321                                         else {
 322                                                 oe = (OperatorEntry) o;
 323                                                 oe.flags |= reg;
 324                                         }
 325                                 }
 326
 327                                 if (true_op != null){
 328                                         if (false_op == null)
 329                                                 Report.Error (216, true_op.Location, "The operator `{0}' requires a matching operator `false' to also be defined",
 330                                                         true_op.GetSignatureForError ());
 331                                 } else if (false_op != null)
 332                                         Report.Error (216, false_op.Location, "The operator `{0}' requires a matching operator `true' to also be defined",
 333                                                 false_op.GetSignatureForError ());
 334
 335                                 //
 336                                 // Look for the mistakes.
 337                                 //
 338                                 foreach (DictionaryEntry de in pairs){
 339                                         OperatorEntry oe = (OperatorEntry) de.Key;
 340
 341                                         if (oe.flags == 3)
 342                                                 continue;
 343
 344                                         string s = "";
 345                                         switch (oe.ot){
 346                                         case Operator.OpType.Equality:
 347                                                 s = "!=";
 348                                                 break;
 349                                         case Operator.OpType.Inequality:
 350                                                 s = "==";
 351                                                 break;
 352                                         case Operator.OpType.GreaterThan:
 353                                                 s = "<";
 354                                                 break;
 355                                         case Operator.OpType.LessThan:
 356                                                 s = ">";
 357                                                 break;
 358                                         case Operator.OpType.GreaterThanOrEqual:
 359                                                 s = "<=";
 360                                                 break;
 361                                         case Operator.OpType.LessThanOrEqual:
 362                                                 s = ">=";
 363                                                 break;
 364                                         }
 365                                         Report.Error (216, oe.op.Location,
 366                                                 "The operator `{0}' requires a matching operator `{1}' to also be defined",
 367                                                 oe.op.GetSignatureForError (), s);
 368                                 }
 369
 370                                 if (has_equality_or_inequality && (RootContext.WarningLevel > 2)) {
 371                                         if (container.Methods == null || !container.Methods.HasEquals)
 372                                                 Report.Warning (660, container.Location, "`{0}' defines operator == or operator != but does not override Object.Equals(object o)", container.GetSignatureForError ());
 373
 374                                         if (container.Methods == null || !container.Methods.HasGetHashCode)
 375                                                 Report.Warning (661, container.Location, "`{0}' defines operator == or operator != but does not override Object.GetHashCode()", container.GetSignatureForError ());
 376                                 }
 377                         }
 378
 379                         public override void DefineContainerMembers ()
 380                         {
 381                                 base.DefineContainerMembers ();
 382                                 CheckPairedOperators ();
 383                         }
 384                 }
 385
 386
 387                 // Whether this is a struct, class or interface
 388                 public readonly Kind Kind;
 389
 390                 // Holds a list of classes and structures
 391                 ArrayList types;
 392
 393                 // Holds the list of properties
 394                 MemberCoreArrayList properties;
 395
 396                 // Holds the list of enumerations
 397                 MemberCoreArrayList enums;
 398
 399                 // Holds the list of delegates
 400                 MemberCoreArrayList delegates;
 401
 402                 // Holds the list of constructors
 403                 protected MemberCoreArrayList instance_constructors;
 404
 405                 // Holds the list of fields
 406                 MemberCoreArrayList fields;
 407
 408                 // Holds a list of fields that have initializers
 409                 protected ArrayList initialized_fields;
 410
 411                 // Holds a list of static fields that have initializers
 412                 protected ArrayList initialized_static_fields;
 413
 414                 // Holds the list of constants
 415                 MemberCoreArrayList constants;
 416
 417                 // Holds the list of
 418                 MemberCoreArrayList interfaces;
 419
 420                 // Holds the methods.
 421                 MethodArrayList methods;
 422
 423                 // Holds the events
 424                 protected MemberCoreArrayList events;
 425
 426                 // Holds the indexers
 427                 IndexerArrayList indexers;
 428
 429                 // Holds the operators
 430                 MemberCoreArrayList operators;
 431
 432                 // Holds the iterators
 433                 ArrayList iterators;
 434
 435                 // Holds the parts of a partial class;
 436                 ArrayList parts;
 437
 438                 //
 439                 // Pointers to the default constructor and the default static constructor
 440                 //
 441                 protected Constructor default_constructor;
 442                 protected Constructor default_static_constructor;
 443
 444                 //
 445                 // Points to the first non-static field added to the container.
 446                 //
 447                 // This is an arbitrary choice.  We are interested in looking at _some_ non-static field,
 448                 // and the first one's as good as any.
 449                 //
 450                 FieldBase first_nonstatic_field = null;
 451
 452                 //
 453                 // This one is computed after we can distinguish interfaces
 454                 // from classes from the arraylist `type_bases'
 455                 //
 456                 string base_class_name;
 457                 TypeExpr base_type;
 458                 TypeExpr[] iface_exprs;
 459
 460                 ArrayList type_bases;
 461
 462                 bool members_defined;
 463                 bool members_defined_ok;
 464
 465                 // The interfaces we implement.
 466                 protected Type[] ifaces;
 467                 protected Type ptype;
 468
 469                 // The base member cache and our member cache
 470                 MemberCache base_cache;
 471                 MemberCache member_cache;
 472
 473                 public const string DefaultIndexerName = "Item";
 474
 475                 public TypeContainer (NamespaceEntry ns, TypeContainer parent, MemberName name,
 476                                       Attributes attrs, Kind kind, Location l)
 477                         : base (ns, parent, name, attrs, l)
 478                 {
 479                         if (parent != null && parent != RootContext.Tree.Types && parent.NamespaceEntry != ns)
 480                                 throw new InternalErrorException ("A nested type should be in the same NamespaceEntry as its enclosing class");
 481
 482                         this.Kind = kind;
 483
 484                         types = new ArrayList ();
 485
 486                         base_class_name = null;
 487                 }
 488
 489                 public bool AddToMemberContainer (MemberCore symbol)
 490                 {
 491                         return AddToContainer (symbol, symbol.Name);
 492                 }
 493
 494                 bool AddToTypeContainer (DeclSpace ds)
 495                 {
 496                         // Parent == null ==> this == RootContext.Tree.Types
 497                         return AddToContainer (ds, (Parent == null) ? ds.Name : ds.Basename);
 498                 }
 499
 500                 public void AddConstant (Const constant)
 501                 {
 502                         if (!AddToMemberContainer (constant))
 503                                 return;
 504
 505                         if (constants == null)
 506                                 constants = new MemberCoreArrayList ();
 507
 508                         constants.Add (constant);
 509                 }
 510
 511                 public void AddEnum (Mono.CSharp.Enum e)
 512                 {
 513                         if (!AddToTypeContainer (e))
 514                                 return;
 515
 516                         if (enums == null)
 517                                 enums = new MemberCoreArrayList ();
 518
 519                         enums.Add (e);
 520                 }
 521
 522                 public void AddClassOrStruct (TypeContainer c)
 523                 {
 524                         if (!AddToTypeContainer (c))
 525                                 return;
 526
 527                         types.Add (c);
 528                 }
 529
 530                 public void AddDelegate (Delegate d)
 531                 {
 532                         if (!AddToTypeContainer (d))
 533                                 return;
 534
 535                         if (delegates == null)
 536                                 delegates = new MemberCoreArrayList ();
 537
 538                         delegates.Add (d);
 539                 }
 540
 541                 public void AddMethod (Method method)
 542                 {
 543                         if (!AddToMemberContainer (method))
 544                                 return;
 545
 546                         if (methods == null)
 547                                 methods = new MethodArrayList (this);
 548
 549                         if (method.MemberName.Left != null)
 550                                 methods.Insert (0, method);
 551                         else
 552                                 methods.Add (method);
 553                 }
 554
 555                 public void AddConstructor (Constructor c)
 556                 {
 557                         if (c.Name != Basename)  {
 558                                 Report.Error (1520, c.Location, "Class, struct, or interface method must have a return type");
 559                         }
 560
 561                         bool is_static = (c.ModFlags & Modifiers.STATIC) != 0;
 562
 563                         if (is_static){
 564                                 if (default_static_constructor != null) {
 565                                         Report.SymbolRelatedToPreviousError (default_static_constructor);
 566                                         Report.Error (111, c.Location, Error111, c.GetSignatureForError ());
 567                                         return;
 568                                 }
 569
 570                                 default_static_constructor = c;
 571                         } else {
 572                                 if (c.IsDefault ()){
 573                                         if (default_constructor != null) {
 574                                                 Report.SymbolRelatedToPreviousError (default_constructor);
 575                                                 Report.Error (111, c.Location, Error111, c.Location, c.GetSignatureForError ());
 576                                                 return;
 577                                         }
 578                                         default_constructor = c;
 579                                 }
 580
 581                                 if (instance_constructors == null)
 582                                         instance_constructors = new MemberCoreArrayList ();
 583
 584                                 instance_constructors.Add (c);
 585                         }
 586                 }
 587
 588                 internal static string Error111 {
 589                         get {
 590                                 return "`{0}' is already defined. Rename this member or use different parameter types";
 591                         }
 592                 }
 593
 594                 public void AddInterface (TypeContainer iface)
 595                 {
 596                         if (!AddToTypeContainer (iface))
 597                                 return;
 598
 599                         if (interfaces == null) {
 600                                 interfaces = new MemberCoreArrayList ();
 601                         }
 602
 603                         interfaces.Add (iface);
 604                 }
 605
 606                 public void AddField (FieldMember field)
 607                 {
 608                         if (!AddToMemberContainer (field))
 609                                 return;
 610
 611                         if (fields == null)
 612                                 fields = new MemberCoreArrayList ();
 613
 614                         fields.Add (field);
 615
 616                         if (field.HasInitializer)
 617                                 RegisterFieldForInitialization (field);
 618
 619                         if ((field.ModFlags & Modifiers.STATIC) != 0)
 620                                 return;
 621
 622                         if (first_nonstatic_field == null) {
 623                                 first_nonstatic_field = field;
 624                                 return;
 625                         }
 626
 627                         if (Kind == Kind.Struct &&
 628                             first_nonstatic_field.Parent != field.Parent &&
 629                             RootContext.WarningLevel >= 3) {
 630                                 Report.SymbolRelatedToPreviousError (first_nonstatic_field.Parent);
 631                                 Report.Warning (282, field.Location,
 632                                         "struct instance field `{0}' found in different declaration from instance field `{1}'",
 633                                         field.GetSignatureForError (), first_nonstatic_field.GetSignatureForError ());
 634                         }
 635                 }
 636
 637                 public void AddProperty (Property prop)
 638                 {
 639                         if (!AddToMemberContainer (prop) ||
 640                                 !AddToMemberContainer (prop.Get) || !AddToMemberContainer (prop.Set))
 641                                 return;
 642
 643                         if (properties == null)
 644                                 properties = new MemberCoreArrayList ();
 645
 646                         if (prop.MemberName.Left != null)
 647                                 properties.Insert (0, prop);
 648                         else
 649                                 properties.Add (prop);
 650                 }
 651
 652                 public void AddEvent (Event e)
 653                 {
 654                         if (!AddToMemberContainer (e))
 655                                 return;
 656
 657                         if (e is EventProperty) {
 658                                 if (!AddToMemberContainer (e.Add))
 659                                         return;
 660
 661                                 if (!AddToMemberContainer (e.Remove))
 662                                         return;
 663                         }
 664
 665                         if (events == null)
 666                                 events = new MemberCoreArrayList ();
 667
 668                         events.Add (e);
 669                 }
 670
 671
 672                 /// <summary>
 673                 /// Indexer has special handling in constrast to other AddXXX because the name can be driven by IndexerNameAttribute
 674                 /// </summary>
 675                 public void AddIndexer (Indexer i)
 676                 {
 677                         if (indexers == null)
 678                                 indexers = new IndexerArrayList (this);
 679
 680                         if (i.IsExplicitImpl)
 681                                 indexers.Insert (0, i);
 682                         else
 683                                 indexers.Add (i);
 684                 }
 685
 686                 public void AddOperator (Operator op)
 687                 {
 688                         if (!AddToMemberContainer (op))
 689                                 return;
 690
 691                         if (operators == null)
 692                                 operators = new OperatorArrayList (this);
 693
 694                         operators.Add (op);
 695                 }
 696
 697                 public void AddIterator (Iterator i)
 698                 {
 699                         if (iterators == null)
 700                                 iterators = new ArrayList ();
 701
 702                         iterators.Add (i);
 703                 }
 704
 705                 public void AddType (TypeContainer tc)
 706                 {
 707                         types.Add (tc);
 708                 }
 709
 710                 public void AddPart (ClassPart part)
 711                 {
 712                         if (parts == null)
 713                                 parts = new ArrayList ();
 714
 715                         parts.Add (part);
 716                 }
 717
 718                 public override void ApplyAttributeBuilder (Attribute a, CustomAttributeBuilder cb)
 719                 {
 720                         if (a.Type == TypeManager.default_member_type) {
 721                                 if (Indexers != null) {
 722                                         Report.Error (646, a.Location, "Cannot specify the `DefaultMember' attribute on type containing an indexer");
 723                                         return;
 724                                 }
 725                         }
 726
 727                         base.ApplyAttributeBuilder (a, cb);
 728                 }
 729
 730                 public override AttributeTargets AttributeTargets {
 731                         get {
 732                                 switch (Kind) {
 733                                 case Kind.Class:
 734                                         return AttributeTargets.Class;
 735                                 case Kind.Struct:
 736                                         return AttributeTargets.Struct;
 737                                 case Kind.Interface:
 738                                         return AttributeTargets.Interface;
 739                                 default:
 740                                         throw new NotSupportedException ();
 741                                 }
 742                         }
 743                 }
 744
 745                 public ArrayList Types {
 746                         get {
 747                                 return types;
 748                         }
 749                 }
 750
 751                 public MethodArrayList Methods {
 752                         get {
 753                                 return methods;
 754                         }
 755                 }
 756
 757                 public ArrayList Constants {
 758                         get {
 759                                 return constants;
 760                         }
 761                 }
 762
 763                 public ArrayList Interfaces {
 764                         get {
 765                                 return interfaces;
 766                         }
 767                 }
 768
 769                 public ArrayList Iterators {
 770                         get {
 771                                 return iterators;
 772                         }
 773                 }
 774
 775                 public string Base {
 776                         get {
 777                                 return base_class_name;
 778                         }
 779                 }
 780
 781                 public ArrayList Bases {
 782                         get {
 783                                 return type_bases;
 784                         }
 785
 786                         set {
 787                                 type_bases = value;
 788                         }
 789                 }
 790
 791                 public ArrayList Fields {
 792                         get {
 793                                 return fields;
 794                         }
 795                 }
 796
 797                 public ArrayList InstanceConstructors {
 798                         get {
 799                                 return instance_constructors;
 800                         }
 801                 }
 802
 803                 public ArrayList Properties {
 804                         get {
 805                                 return properties;
 806                         }
 807                 }
 808
 809                 public ArrayList Events {
 810                         get {
 811                                 return events;
 812                         }
 813                 }
 814
 815                 public ArrayList Enums {
 816                         get {
 817                                 return enums;
 818                         }
 819                 }
 820
 821                 public ArrayList Indexers {
 822                         get {
 823                                 return indexers;
 824                         }
 825                 }
 826
 827                 public ArrayList Operators {
 828                         get {
 829                                 return operators;
 830                         }
 831                 }
 832
 833                 public ArrayList Delegates {
 834                         get {
 835                                 return delegates;
 836                         }
 837                 }
 838
 839                 public ArrayList Parts {
 840                         get {
 841                                 return parts;
 842                         }
 843                 }
 844
 845                 protected override TypeAttributes TypeAttr {
 846                         get {
 847                                 return Modifiers.TypeAttr (ModFlags, this) | base.TypeAttr;
 848                         }
 849                 }
 850
 851                 public string IndexerName {
 852                         get {
 853                                 return indexers == null ? DefaultIndexerName : indexers.IndexerName;
 854                         }
 855                 }
 856
 857                 public virtual void RegisterFieldForInitialization (FieldMember field)
 858                 {
 859                         if ((field.ModFlags & Modifiers.STATIC) != 0){
 860                                 if (initialized_static_fields == null)
 861                                         initialized_static_fields = new ArrayList ();
 862
 863                                 initialized_static_fields.Add (field);
 864                         } else {
 865                                 if (initialized_fields == null)
 866                                         initialized_fields = new ArrayList ();
 867
 868                                 initialized_fields.Add (field);
 869                         }
 870                 }
 871
 872                 //
 873                 // Emits the instance field initializers
 874                 //
 875                 public virtual bool EmitFieldInitializers (EmitContext ec)
 876                 {
 877                         ArrayList fields;
 878                         Expression instance_expr;
 879
 880                         if (ec.IsStatic){
 881                                 fields = initialized_static_fields;
 882                                 instance_expr = null;
 883                         } else {
 884                                 fields = initialized_fields;
 885                                 instance_expr = new This (Location.Null).Resolve (ec);
 886                         }
 887
 888                         if (fields == null)
 889                                 return true;
 890
 891                         foreach (FieldMember f in fields){
 892                                 Expression e = f.GetInitializerExpression (ec);
 893                                 if (e == null)
 894                                         return false;
 895
 896                                 Location l = f.Location;
 897                                 FieldExpr fe = new FieldExpr (f.FieldBuilder, l, true);
 898                                 fe.InstanceExpression = instance_expr;
 899                                 ExpressionStatement a = new Assign (fe, e, l);
 900
 901                                 a = a.ResolveStatement (ec);
 902                                 if (a == null)
 903                                         return false;
 904
 905                                 Constant c = e as Constant;
 906                                 if (c != null) {
 907                                         if (c.IsDefaultValue)
 908                                                 continue;
 909                                 }
 910
 911                                 a.EmitStatement (ec);
 912                         }
 913
 914                         return true;
 915                 }
 916
 917                 //
 918                 // Defines the default constructors
 919                 //
 920                 protected void DefineDefaultConstructor (bool is_static)
 921                 {
 922                         Constructor c;
 923
 924                         // The default constructor is public
 925                         // If the class is abstract, the default constructor is protected
 926                         // The default static constructor is private
 927
 928                         int mods = Modifiers.PUBLIC;
 929                         if (is_static)
 930                                 mods = Modifiers.STATIC | Modifiers.PRIVATE;
 931                         else if ((ModFlags & Modifiers.ABSTRACT) != 0)
 932                                 mods = Modifiers.PROTECTED;
 933
 934                         TypeContainer constructor_parent = this;
 935                         if (Parts != null)
 936                                 constructor_parent = (TypeContainer) Parts [0];
 937
 938                         c = new Constructor (constructor_parent, Basename, mods,
 939                                              Parameters.EmptyReadOnlyParameters,
 940                                              new ConstructorBaseInitializer (
 941                                                      null, Parameters.EmptyReadOnlyParameters,
 942                                                      Location),
 943                                              Location);
 944
 945                         AddConstructor (c);
 946
 947                         c.Block = new ToplevelBlock (null, Location);
 948
 949                 }
 950
 951                 /// <remarks>
 952                 ///  The pending methods that need to be implemented
 953                 //   (interfaces or abstract methods)
 954                 /// </remarks>
 955                 public PendingImplementation Pending;
 956
 957                 public abstract PendingImplementation GetPendingImplementations ();
 958
 959                 TypeExpr[] GetPartialBases (out TypeExpr base_class)
 960                 {
 961                         ArrayList ifaces = new ArrayList ();
 962
 963                         base_class = null;
 964                         Location base_loc = Location.Null;
 965
 966                         foreach (ClassPart part in parts) {
 967                                 TypeExpr new_base_class;
 968                                 TypeExpr[] new_ifaces;
 969
 970                                 new_ifaces = part.GetClassBases (out new_base_class);
 971                                 if (new_ifaces == null && new_base_class != null)
 972                                         return null;
 973
 974                                 if ((base_class != null) && (new_base_class != null) &&
 975                                     !base_class.Equals (new_base_class)) {
 976                                         Report.Error (263, part.Location,
 977                                                       "Partial declarations of `{0}' must " +
 978                                                       "not specify different base classes",
 979                                                       Name);
 980
 981                                         if (!Location.IsNull (base_loc))
 982                                                 Report.LocationOfPreviousError (base_loc);
 983
 984                                         return null;
 985                                 }
 986
 987                                 if ((base_class == null) && (new_base_class != null)) {
 988                                         base_class = new_base_class;
 989                                         base_loc = part.Location;
 990                                 }
 991
 992                                 if (new_ifaces == null)
 993                                         continue;
 994
 995                                 foreach (TypeExpr iface in new_ifaces) {
 996                                         bool found = false;
 997                                         foreach (TypeExpr old_iface in ifaces) {
 998                                                 if (old_iface.Equals (iface)) {
 999                                                         found = true;
1000                                                         break;
1001                                                 }
1002                                         }
1003
1004                                         if (!found)
1005                                                 ifaces.Add (iface);
1006                                 }
1007                         }
1008
1009                         TypeExpr[] retval = new TypeExpr [ifaces.Count];
1010                         ifaces.CopyTo (retval, 0);
1011                         return retval;
1012                 }
1013
1014                 TypeExpr[] GetNormalBases (out TypeExpr base_class)
1015                 {
1016                         base_class = null;
1017
1018                         int count = Bases.Count;
1019                         int start = 0, i, j;
1020
1021                         if (Kind == Kind.Class){
1022                                 TypeExpr name = ResolveBaseTypeExpr (
1023                                         (Expression) Bases [0], false, Location);
1024
1025                                 if (name == null){
1026                                         return null;
1027                                 }
1028
1029                                 if (!name.IsInterface) {
1030                                         // base_class could be a class, struct, enum, delegate.
1031                                         // This is validated in GetClassBases.
1032                                         base_class = name;
1033                                         start = 1;
1034                                 }
1035                         }
1036
1037                         TypeExpr [] ifaces = new TypeExpr [count-start];
1038
1039                         for (i = start, j = 0; i < count; i++, j++){
1040                                 TypeExpr resolved = ResolveBaseTypeExpr ((Expression) Bases [i], false, Location);
1041                                 if (resolved == null) {
1042                                         return null;
1043                                 }
1044
1045                                 ifaces [j] = resolved;
1046                         }
1047
1048                         return ifaces;
1049                 }
1050
1051                 /// <summary>
1052                 ///   This function computes the Base class and also the
1053                 ///   list of interfaces that the class or struct @c implements.
1054                 ///
1055                 ///   The return value is an array (might be null) of
1056                 ///   interfaces implemented (as Types).
1057                 ///
1058                 ///   The @base_class argument is set to the base object or null
1059                 ///   if this is `System.Object'.
1060                 /// </summary>
1061                 TypeExpr [] GetClassBases (out TypeExpr base_class)
1062                 {
1063                         int i;
1064
1065                         TypeExpr[] ifaces;
1066
1067                         if (parts != null)
1068                                 ifaces = GetPartialBases (out base_class);
1069                         else if (Bases == null){
1070                                 base_class = null;
1071                                 return null;
1072                         } else
1073                                 ifaces = GetNormalBases (out base_class);
1074
1075                         if (ifaces == null)
1076                                 return null;
1077
1078                         if ((base_class != null) && (Kind == Kind.Class)){
1079
1080                                 if (base_class.Type.IsArray || base_class.Type.IsPointer) {
1081                                         Report.Error (1521, base_class.Location, "Invalid base type");
1082                                         return null;
1083                                 }
1084
1085                                 if (base_class.IsSealed){
1086                                         Report.SymbolRelatedToPreviousError (base_class.Type);
1087                                         if (base_class.Type.IsAbstract) {
1088                                                 Report.Error (709, Location, "`{0}': Cannot derive from static class `{1}'",
1089                                                         GetSignatureForError (), TypeManager.CSharpName (base_class.Type));
1090                                         } else {
1091                                                 Report.Error (509, Location, "`{0}': cannot derive from sealed class `{1}'",
1092                                                         GetSignatureForError (), TypeManager.CSharpName (base_class.Type));
1093                                         }
1094                                         return null;
1095                                 }
1096
1097                                 if (!base_class.CanInheritFrom ()){
1098                                         Report.Error (644, Location, "`{0}' cannot derive from special class `{1}'",
1099                                                       GetSignatureForError (), base_class.GetSignatureForError ());
1100                                         return null;
1101                                 }
1102
1103                                 if (!base_class.AsAccessible (this, ModFlags)) {
1104                                         Report.SymbolRelatedToPreviousError (base_class.Type);
1105                                         Report.Error (60, Location, "Inconsistent accessibility: base class `{0}' is less accessible than class `{1}'",
1106                                                 TypeManager.CSharpName (base_class.Type), GetSignatureForError ());
1107                                 }
1108                         }
1109
1110                         if (base_class != null)
1111                                 base_class_name = base_class.Name;
1112
1113                         if (ifaces == null)
1114                                 return null;
1115
1116                         int count = ifaces != null ? ifaces.Length : 0;
1117
1118                         for (i = 0; i < count; i++) {
1119                                 TypeExpr iface = (TypeExpr) ifaces [i];
1120
1121                                 if (!iface.IsInterface) {
1122                                         if (Kind != Kind.Class) {
1123                                                 // TODO: location of symbol related ....
1124                                                 Error_TypeInListIsNotInterface (Location, iface.FullName);
1125                                         }
1126                                         else if (base_class != null)
1127                                                 Report.Error (1721, Location, "`{0}': Classes cannot have multiple base classes (`{1}' and `{2}')",
1128                                                         GetSignatureForError (), base_class.GetSignatureForError (), iface.GetSignatureForError ());
1129                                         else {
1130                                                 Report.Error (1722, Location, "`{0}': Base class `{1}' must be specified as first",
1131                                                         GetSignatureForError (), iface.GetSignatureForError ());
1132                                         }
1133                                         return null;
1134                                 }
1135
1136                                 for (int x = 0; x < i; x++) {
1137                                         if (iface.Equals (ifaces [x])) {
1138                                                 Report.Error (528, Location,
1139                                                               "`{0}' is already listed in " +
1140                                                               "interface list", iface.Name);
1141                                                 return null;
1142                                         }
1143                                 }
1144
1145                                 if ((Kind == Kind.Interface) &&
1146                                     !iface.AsAccessible (Parent, ModFlags)) {
1147                                         Report.Error (61, Location,
1148                                                       "Inconsistent accessibility: base " +
1149                                                       "interface `{0}' is less accessible " +
1150                                                       "than interface `{1}'", iface.Name,
1151                                                       Name);
1152                                         return null;
1153                                 }
1154                         }
1155                         return ifaces;
1156                 }
1157
1158                 bool error = false;
1159
1160                 protected void Error_TypeInListIsNotInterface (Location loc, string type)
1161                 {
1162                         Report.Error (527, loc, "Type `{0}' in interface list is not an interface", type);
1163                 }
1164
1165                 //
1166                 // Defines the type in the appropriate ModuleBuilder or TypeBuilder.
1167                 //
1168                 public override TypeBuilder DefineType ()
1169                 {
1170                         if (error)
1171                                 return null;
1172
1173                         if (TypeBuilder != null)
1174                                 return TypeBuilder;
1175
1176                         TypeAttributes type_attributes = TypeAttr;
1177
1178                         try {
1179                                 if (IsTopLevel){
1180                                         if (TypeManager.NamespaceClash (Name, Location)) {
1181                                                 error = true;
1182                                                 return null;
1183                                         }
1184
1185                                         ModuleBuilder builder = CodeGen.Module.Builder;
1186                                         TypeBuilder = builder.DefineType (
1187                                                 Name, type_attributes, null, null);
1188                                 } else {
1189                                         TypeBuilder builder = Parent.TypeBuilder;
1190                                         if (builder == null) {
1191                                                 error = true;
1192                                                 return null;
1193                                         }
1194
1195                                         TypeBuilder = builder.DefineNestedType (
1196                                                 Basename, type_attributes, ptype, null);
1197                                 }
1198                         } catch (ArgumentException) {
1199                                 Report.RuntimeMissingSupport (Location, "static classes");
1200                                 error = true;
1201                                 return null;
1202                         }
1203
1204                         TypeManager.AddUserType (Name, this);
1205
1206                         if (Parts != null) {
1207                                 ec = null;
1208                                 foreach (ClassPart part in Parts) {
1209                                         part.TypeBuilder = TypeBuilder;
1210                                         part.ptype = ptype;
1211                                         part.ec = new EmitContext (part, Mono.CSharp.Location.Null, null, null, ModFlags);
1212                                         part.ec.ContainerType = TypeBuilder;
1213                                 }
1214                         } else {
1215                                 //
1216                                 // Normally, we create the EmitContext here.
1217                                 // The only exception is if we're an Iterator - in this case,
1218                                 // we already have the `ec', so we don't want to create a new one.
1219                                 //
1220                                 if (ec == null)
1221                                         ec = new EmitContext (this, Mono.CSharp.Location.Null, null, null, ModFlags);
1222                                 ec.ContainerType = TypeBuilder;
1223                         }
1224
1225                         iface_exprs = GetClassBases (out base_type);
1226                         if (iface_exprs == null && base_type != null) {
1227                                 error = true;
1228                                 return null;
1229                         }
1230
1231                         if (base_type == null) {
1232                                 if (Kind == Kind.Class){
1233                                         if (RootContext.StdLib)
1234                                                 base_type = TypeManager.system_object_expr;
1235                                         else if (Name != "System.Object")
1236                                                 base_type = TypeManager.system_object_expr;
1237                                 } else if (Kind == Kind.Struct) {
1238                                         //
1239                                         // If we are compiling our runtime,
1240                                         // and we are defining ValueType, then our
1241                                         // base is `System.Object'.
1242                                         //
1243                                         if (!RootContext.StdLib && Name == "System.ValueType")
1244                                                 base_type = TypeManager.system_object_expr;
1245                                         else
1246                                                 base_type = TypeManager.system_valuetype_expr;
1247                                 }
1248                         }
1249
1250                         if ((Kind == Kind.Struct) && TypeManager.value_type == null)
1251                                 throw new Exception ();
1252
1253                         if (base_type != null) {
1254                                 // FIXME: I think this should be ...ResolveType (Parent.EmitContext).
1255                                 //        However, if Parent == RootContext.Tree.Types, its NamespaceEntry will be null.
1256                                 ptype = base_type.ResolveType (TypeResolveEmitContext);
1257                                 if (ptype == null) {
1258                                         error = true;
1259                                         return null;
1260                                 }
1261                         }
1262
1263                         if (!CheckRecursiveDefinition (this)) {
1264                                 error = true;
1265                                 return null;
1266                         }
1267
1268                         if (ptype != null)
1269                                 TypeBuilder.SetParent (ptype);
1270
1271                         // add interfaces that were not added at type creation
1272                         if (iface_exprs != null) {
1273                                 // FIXME: I think this should be ...ExpandInterfaces (Parent.EmitContext, ...).
1274                                 //        However, if Parent == RootContext.Tree.Types, its NamespaceEntry will be null.
1275                                 TypeResolveEmitContext.ContainerType = TypeBuilder;
1276                                 ifaces = TypeManager.ExpandInterfaces (TypeResolveEmitContext, iface_exprs);
1277                                 if (ifaces == null) {
1278                                         error = true;
1279                                         return null;
1280                                 }
1281
1282                                 foreach (Type itype in ifaces)
1283                                         TypeBuilder.AddInterfaceImplementation (itype);
1284
1285                                 TypeManager.RegisterBuilder (TypeBuilder, ifaces);
1286                         }
1287
1288                         if (!(this is Iterator))
1289                                 RootContext.RegisterOrder (this);
1290
1291                         if (!DefineNestedTypes ()) {
1292                                 error = true;
1293                                 return null;
1294                         }
1295
1296                         return TypeBuilder;
1297                 }
1298
1299                 protected virtual bool DefineNestedTypes ()
1300                 {
1301                         if (Interfaces != null) {
1302                                 foreach (TypeContainer iface in Interfaces)
1303                                         if (iface.DefineType () == null)
1304                                                 return false;
1305                         }
1306
1307                         if (Types != null) {
1308                                 foreach (TypeContainer tc in Types)
1309                                         if (tc.DefineType () == null)
1310                                                 return false;
1311                         }
1312
1313                         if (Delegates != null) {
1314                                 foreach (Delegate d in Delegates)
1315                                         if (d.DefineType () == null)
1316                                                 return false;
1317                         }
1318
1319                         if (Enums != null) {
1320                                 foreach (Enum en in Enums)
1321                                         if (en.DefineType () == null)
1322                                                 return false;
1323                         }
1324
1325                         return true;
1326                 }
1327
1328                 TypeContainer InTransit;
1329
1330                 protected bool CheckRecursiveDefinition (TypeContainer tc)
1331                 {
1332                         if (InTransit != null) {
1333                                 Report.SymbolRelatedToPreviousError (this);
1334                                 if (this is Interface)
1335                                         Report.Error (
1336                                                 529, tc.Location, "Inherited interface `{0}' causes a " +
1337                                                 "cycle in the interface hierarchy of `{1}'",
1338                                                 GetSignatureForError (), tc.GetSignatureForError ());
1339                                 else
1340                                         Report.Error (
1341                                                 146, tc.Location, "Circular base class dependency " +
1342                                                 "involving `{0}' and `{1}'",
1343                                                 tc.GetSignatureForError (), GetSignatureForError ());
1344                                 return false;
1345                         }
1346
1347                         InTransit = tc;
1348
1349                         Type parent = ptype;
1350                         if (parent != null) {
1351                                 TypeContainer ptc = TypeManager.LookupTypeContainer (parent);
1352                                 if ((ptc != null) && !ptc.CheckRecursiveDefinition (this))
1353                                         return false;
1354                         }
1355
1356                         if (iface_exprs != null) {
1357                                 foreach (TypeExpr iface in iface_exprs) {
1358                                         Type itype = iface.Type;
1359
1360                                         TypeContainer ptc = TypeManager.LookupTypeContainer (itype);
1361                                         if ((ptc != null) && !ptc.CheckRecursiveDefinition (this))
1362                                                 return false;
1363                                 }
1364                         }
1365
1366                         InTransit = null;
1367                         return true;
1368                 }
1369
1370                 public static void Error_KeywordNotAllowed (Location loc)
1371                 {
1372                         Report.Error (1530, loc, "Keyword `new' is not allowed on namespace elements");
1373                 }
1374
1375                 /// <summary>
1376                 ///   Populates our TypeBuilder with fields and methods
1377                 /// </summary>
1378                 public override bool DefineMembers (TypeContainer container)
1379                 {
1380                         if (members_defined)
1381                                 return members_defined_ok;
1382
1383                         if (!base.DefineMembers (container))
1384                                 return false;
1385
1386                         members_defined_ok = DoDefineMembers ();
1387                         members_defined = true;
1388
1389                         return members_defined_ok;
1390                 }
1391
1392                 protected virtual bool DoDefineMembers ()
1393                 {
1394                         if (!IsTopLevel) {
1395                                 MemberInfo conflict_symbol = Parent.MemberCache.FindMemberWithSameName (Basename, false, TypeBuilder);
1396                                 if (conflict_symbol == null) {
1397                                         if ((RootContext.WarningLevel >= 4) && ((ModFlags & Modifiers.NEW) != 0))
1398                                                 Report.Warning (109, Location, "The member `{0}' does not hide an inherited member. The new keyword is not required", GetSignatureForError ());
1399                                 } else {
1400                                         if ((ModFlags & Modifiers.NEW) == 0) {
1401                                                 Report.SymbolRelatedToPreviousError (conflict_symbol);
1402                                                 Report.Warning (108, Location, "`{0}' hides inherited member `{1}'. Use the new keyword if hiding was intended",
1403                                                         GetSignatureForError (), TypeManager.GetFullNameSignature (conflict_symbol));
1404                                         }
1405                                 }
1406                         }
1407
1408                         DefineContainerMembers (constants);
1409                         DefineContainerMembers (fields);
1410
1411                         if ((Kind == Kind.Class) && !(this is ClassPart)){
1412                                 if ((instance_constructors == null) &&
1413                                     !(this is StaticClass)) {
1414                                         if (default_constructor == null)
1415                                                 DefineDefaultConstructor (false);
1416                                 }
1417
1418                                 if (initialized_static_fields != null &&
1419                                     default_static_constructor == null)
1420                                         DefineDefaultConstructor (true);
1421                         }
1422
1423                         if (Kind == Kind.Struct){
1424                                 //
1425                                 // Structs can not have initialized instance
1426                                 // fields
1427                                 //
1428                                 if (initialized_static_fields != null &&
1429                                     default_static_constructor == null)
1430                                         DefineDefaultConstructor (true);
1431
1432                                 if (initialized_fields != null)
1433                                         ReportStructInitializedInstanceError ();
1434                         }
1435
1436                         Pending = GetPendingImplementations ();
1437
1438                         if (parts != null) {
1439                                 foreach (ClassPart part in parts) {
1440                                         if (!part.DefineMembers (this))
1441                                                 return false;
1442                                 }
1443                         }
1444
1445                         //
1446                         // Constructors are not in the defined_names array
1447                         //
1448                         DefineContainerMembers (instance_constructors);
1449
1450                         if (default_static_constructor != null)
1451                                 default_static_constructor.Define ();
1452
1453                         DefineContainerMembers (properties);
1454                         DefineContainerMembers (events);
1455                         DefineContainerMembers (indexers);
1456                         DefineContainerMembers (methods);
1457                         DefineContainerMembers (operators);
1458                         DefineContainerMembers (enums);
1459                         DefineContainerMembers (delegates);
1460
1461 #if CACHE
1462                         if (!(this is ClassPart))
1463                                 member_cache = new MemberCache (this);
1464 #endif
1465
1466                         if (parts != null) {
1467                                 foreach (ClassPart part in parts)
1468                                         part.member_cache = member_cache;
1469                         }
1470
1471                         if (iterators != null) {
1472                                 foreach (Iterator iterator in iterators) {
1473                                         if (iterator.DefineType () == null)
1474                                                 return false;
1475                                 }
1476
1477                                 foreach (Iterator iterator in iterators) {
1478                                         if (!iterator.DefineMembers (this))
1479                                                 return false;
1480                                 }
1481                         }
1482
1483                         return true;
1484                 }
1485
1486                 void ReportStructInitializedInstanceError ()
1487                 {
1488                         string n = TypeBuilder.FullName;
1489
1490                         foreach (Field f in initialized_fields){
1491                                 Report.Error (573, Location,
1492                                         "`{0}': Structs cannot have instance field initializers",
1493                                         f.GetSignatureForError ());
1494                         }
1495                 }
1496
1497                 protected virtual void DefineContainerMembers (MemberCoreArrayList mcal)
1498                 {
1499                         if (mcal != null)
1500                                 mcal.DefineContainerMembers ();
1501                 }
1502
1503                 public override bool Define ()
1504                 {
1505                         if (parts != null) {
1506                                 foreach (ClassPart part in parts) {
1507                                         if (!part.Define ())
1508                                                 return false;
1509                                 }
1510                         }
1511
1512                         if (iterators != null) {
1513                                 foreach (Iterator iterator in iterators) {
1514                                         if (!iterator.Define ())
1515                                                 return false;
1516                                 }
1517                         }
1518
1519                         return true;
1520                 }
1521
1522                 public MemberInfo FindBaseMemberWithSameName (string name, bool ignore_methods)
1523                 {
1524                         return BaseCache.FindMemberWithSameName (name, ignore_methods, null);
1525                 }
1526
1527                 /// <summary>
1528                 ///   This function is based by a delegate to the FindMembers routine
1529                 /// </summary>
1530                 static bool AlwaysAccept (MemberInfo m, object filterCriteria)
1531                 {
1532                         return true;
1533                 }
1534
1535                 /// <summary>
1536                 ///   This filter is used by FindMembers, and we just keep
1537                 ///   a global for the filter to `AlwaysAccept'
1538                 /// </summary>
1539                 static MemberFilter accepting_filter;
1540
1541
1542                 static TypeContainer ()
1543                 {
1544                         accepting_filter = new MemberFilter (AlwaysAccept);
1545                 }
1546
1547                 public MethodInfo[] GetMethods ()
1548                 {
1549                         ArrayList members = new ArrayList ();
1550
1551                         DefineMembers (null);
1552
1553                         if (methods != null) {
1554                                 int len = methods.Count;
1555                                 for (int i = 0; i < len; i++) {
1556                                         Method m = (Method) methods [i];
1557
1558                                         members.Add (m.MethodBuilder);
1559                                 }
1560                         }
1561
1562                         if (operators != null) {
1563                                 int len = operators.Count;
1564                                 for (int i = 0; i < len; i++) {
1565                                         Operator o = (Operator) operators [i];
1566
1567                                         members.Add (o.OperatorMethodBuilder);
1568                                 }
1569                         }
1570
1571                         if (properties != null) {
1572                                 int len = properties.Count;
1573                                 for (int i = 0; i < len; i++) {
1574                                         Property p = (Property) properties [i];
1575
1576                                         if (p.GetBuilder != null)
1577                                                 members.Add (p.GetBuilder);
1578                                         if (p.SetBuilder != null)
1579                                                 members.Add (p.SetBuilder);
1580                                 }
1581                         }
1582
1583                         if (indexers != null) {
1584                                 int len = indexers.Count;
1585                                 for (int i = 0; i < len; i++) {
1586                                         Indexer ix = (Indexer) indexers [i];
1587
1588                                         if (ix.GetBuilder != null)
1589                                                 members.Add (ix.GetBuilder);
1590                                         if (ix.SetBuilder != null)
1591                                                 members.Add (ix.SetBuilder);
1592                                 }
1593                         }
1594
1595                         if (events != null) {
1596                                 int len = events.Count;
1597                                 for (int i = 0; i < len; i++) {
1598                                         Event e = (Event) events [i];
1599
1600                                         if (e.AddBuilder != null)
1601                                                 members.Add (e.AddBuilder);
1602                                         if (e.RemoveBuilder != null)
1603                                                 members.Add (e.RemoveBuilder);
1604                                 }
1605                         }
1606
1607                         MethodInfo[] retMethods = new MethodInfo [members.Count];
1608                         members.CopyTo (retMethods, 0);
1609                         return retMethods;
1610                 }
1611
1612                 // Indicated whether container has StructLayout attribute set Explicit
1613                 public virtual bool HasExplicitLayout {
1614                         get {
1615                                 return false;
1616                         }
1617                 }
1618
1619                 public override Type FindNestedType (string name)
1620                 {
1621                         ArrayList [] lists = { types, enums, delegates, interfaces };
1622
1623                         for (int j = 0; j < lists.Length; ++j) {
1624                                 ArrayList list = lists [j];
1625                                 if (list == null)
1626                                         continue;
1627
1628                                 int len = list.Count;
1629                                 for (int i = 0; i < len; ++i) {
1630                                         DeclSpace ds = (DeclSpace) list [i];
1631                                         if (ds.Basename == name) {
1632                                                 ds.DefineType ();
1633                                                 return ds.TypeBuilder;
1634                                         }
1635                                 }
1636                         }
1637
1638                         return null;
1639                 }
1640
1641                 private void FindMembers_NestedTypes (int modflags,
1642                                                       BindingFlags bf, MemberFilter filter, object criteria,
1643                                                       ref ArrayList members)
1644                 {
1645                         ArrayList [] lists = { types, enums, delegates, interfaces };
1646
1647                         for (int j = 0; j < lists.Length; ++j) {
1648                                 ArrayList list = lists [j];
1649                                 if (list == null)
1650                                         continue;
1651
1652                                 int len = list.Count;
1653                                 for (int i = 0; i < len; i++) {
1654                                         DeclSpace ds = (DeclSpace) list [i];
1655
1656                                         if ((ds.ModFlags & modflags) == 0)
1657                                                 continue;
1658
1659                                         TypeBuilder tb = ds.TypeBuilder;
1660                                         if (tb == null) {
1661                                                 if (!(criteria is string) || ds.Basename.Equals (criteria))
1662                                                         tb = ds.DefineType ();
1663                                         }
1664
1665                                         if (tb != null && (filter (tb, criteria) == true)) {
1666                                                 if (members == null)
1667                                                         members = new ArrayList ();
1668
1669                                                 members.Add (tb);
1670                                         }
1671                                 }
1672                         }
1673                 }
1674
1675                 /// <summary>
1676                 ///   This method returns the members of this type just like Type.FindMembers would
1677                 ///   Only, we need to use this for types which are _being_ defined because MS'
1678                 ///   implementation can't take care of that.
1679                 /// </summary>
1680                 //
1681                 // FIXME: return an empty static array instead of null, that cleans up
1682                 // some code and is consistent with some coding conventions I just found
1683                 // out existed ;-)
1684                 //
1685                 //
1686                 // Notice that in various cases we check if our field is non-null,
1687                 // something that would normally mean that there was a bug elsewhere.
1688                 //
1689                 // The problem happens while we are defining p-invoke methods, as those
1690                 // will trigger a FindMembers, but this happens before things are defined
1691                 //
1692                 // Since the whole process is a no-op, it is fine to check for null here.
1693                 //
1694                 public override MemberList FindMembers (MemberTypes mt, BindingFlags bf,
1695                                                         MemberFilter filter, object criteria)
1696                 {
1697                         ArrayList members = null;
1698
1699                         int modflags = 0;
1700                         if ((bf & BindingFlags.Public) != 0)
1701                                 modflags |= Modifiers.PUBLIC | Modifiers.PROTECTED |
1702                                         Modifiers.INTERNAL;
1703                         if ((bf & BindingFlags.NonPublic) != 0)
1704                                 modflags |= Modifiers.PRIVATE;
1705
1706                         int static_mask = 0, static_flags = 0;
1707                         switch (bf & (BindingFlags.Static | BindingFlags.Instance)) {
1708                         case BindingFlags.Static:
1709                                 static_mask = static_flags = Modifiers.STATIC;
1710                                 break;
1711
1712                         case BindingFlags.Instance:
1713                                 static_mask = Modifiers.STATIC;
1714                                 static_flags = 0;
1715                                 break;
1716
1717                         default:
1718                                 static_mask = static_flags = 0;
1719                                 break;
1720                         }
1721
1722                         Timer.StartTimer (TimerType.TcFindMembers);
1723
1724                         if (filter == null)
1725                                 filter = accepting_filter;
1726
1727                         if ((mt & MemberTypes.Field) != 0) {
1728                                 if (fields != null) {
1729                                         int len = fields.Count;
1730                                         for (int i = 0; i < len; i++) {
1731                                                 FieldMember f = (FieldMember) fields [i];
1732
1733                                                 if ((f.ModFlags & modflags) == 0)
1734                                                         continue;
1735                                                 if ((f.ModFlags & static_mask) != static_flags)
1736                                                         continue;
1737
1738                                                 FieldBuilder fb = f.FieldBuilder;
1739                                                 if (fb != null && filter (fb, criteria) == true) {
1740                                                         if (members == null)
1741                                                                 members = new ArrayList ();
1742
1743                                                         members.Add (fb);
1744                                                 }
1745                                         }
1746                                 }
1747
1748                                 if (constants != null) {
1749                                         int len = constants.Count;
1750                                         for (int i = 0; i < len; i++) {
1751                                                 Const con = (Const) constants [i];
1752
1753                                                 if ((con.ModFlags & modflags) == 0)
1754                                                         continue;
1755                                                 if ((con.ModFlags & static_mask) != static_flags)
1756                                                         continue;
1757
1758                                                 FieldBuilder fb = con.FieldBuilder;
1759                                                 if (fb == null) {
1760                                                         if (con.Define ())
1761                                                                 fb = con.FieldBuilder;
1762                                                 }
1763                                                 if (fb != null && filter (fb, criteria) == true) {
1764                                                         if (members == null)
1765                                                                 members = new ArrayList ();
1766
1767                                                         members.Add (fb);
1768                                                 }
1769                                         }
1770                                 }
1771                         }
1772
1773                         if ((mt & MemberTypes.Method) != 0) {
1774                                 if (methods != null) {
1775                                         int len = methods.Count;
1776                                         for (int i = 0; i < len; i++) {
1777                                                 Method m = (Method) methods [i];
1778
1779                                                 if ((m.ModFlags & modflags) == 0)
1780                                                         continue;
1781                                                 if ((m.ModFlags & static_mask) != static_flags)
1782                                                         continue;
1783
1784                                                 MethodBuilder mb = m.MethodBuilder;
1785
1786                                                 if (mb != null && filter (mb, criteria) == true) {
1787                                                         if (members == null)
1788                                                                 members = new ArrayList ();
1789
1790                                                         members.Add (mb);
1791                                                 }
1792                                         }
1793                                 }
1794
1795                                 if (operators != null) {
1796                                         int len = operators.Count;
1797                                         for (int i = 0; i < len; i++) {
1798                                                 Operator o = (Operator) operators [i];
1799
1800                                                 if ((o.ModFlags & modflags) == 0)
1801                                                         continue;
1802                                                 if ((o.ModFlags & static_mask) != static_flags)
1803                                                         continue;
1804
1805                                                 MethodBuilder ob = o.OperatorMethodBuilder;
1806                                                 if (ob != null && filter (ob, criteria) == true) {
1807                                                         if (members == null)
1808                                                                 members = new ArrayList ();
1809
1810                                                         members.Add (ob);
1811                                                 }
1812                                         }
1813                                 }
1814
1815                                 if (properties != null) {
1816                                         int len = properties.Count;
1817                                         for (int i = 0; i < len; i++) {
1818                                                 Property p = (Property) properties [i];
1819
1820                                                 if ((p.ModFlags & modflags) == 0)
1821                                                         continue;
1822                                                 if ((p.ModFlags & static_mask) != static_flags)
1823                                                         continue;
1824
1825                                                 MethodBuilder b;
1826
1827                                                 b = p.GetBuilder;
1828                                                 if (b != null && filter (b, criteria) == true) {
1829                                                         if (members == null)
1830                                                                 members = new ArrayList ();
1831
1832                                                         members.Add (b);
1833                                                 }
1834
1835                                                 b = p.SetBuilder;
1836                                                 if (b != null && filter (b, criteria) == true) {
1837                                                         if (members == null)
1838                                                                 members = new ArrayList ();
1839
1840                                                         members.Add (b);
1841                                                 }
1842                                         }
1843                                 }
1844
1845                                 if (indexers != null) {
1846                                         int len = indexers.Count;
1847                                         for (int i = 0; i < len; i++) {
1848                                                 Indexer ix = (Indexer) indexers [i];
1849
1850                                                 if ((ix.ModFlags & modflags) == 0)
1851                                                         continue;
1852                                                 if ((ix.ModFlags & static_mask) != static_flags)
1853                                                         continue;
1854
1855                                                 MethodBuilder b;
1856
1857                                                 b = ix.GetBuilder;
1858                                                 if (b != null && filter (b, criteria) == true) {
1859                                                         if (members == null)
1860                                                                 members = new ArrayList ();
1861
1862                                                         members.Add (b);
1863                                                 }
1864
1865                                                 b = ix.SetBuilder;
1866                                                 if (b != null && filter (b, criteria) == true) {
1867                                                         if (members == null)
1868                                                                 members = new ArrayList ();
1869
1870                                                         members.Add (b);
1871                                                 }
1872                                         }
1873                                 }
1874                         }
1875
1876                         if ((mt & MemberTypes.Event) != 0) {
1877                                 if (events != null) {
1878                                         int len = events.Count;
1879                                         for (int i = 0; i < len; i++) {
1880                                                 Event e = (Event) events [i];
1881
1882                                                 if ((e.ModFlags & modflags) == 0)
1883                                                         continue;
1884                                                 if ((e.ModFlags & static_mask) != static_flags)
1885                                                         continue;
1886
1887                                                 MemberInfo eb = e.EventBuilder;
1888                                                 if (eb != null && filter (eb, criteria) == true) {
1889                                                         if (members == null)
1890                                                                 members = new ArrayList ();
1891
1892                                                         members.Add (e.EventBuilder);
1893                                                 }
1894                                         }
1895                                 }
1896                         }
1897
1898                         if ((mt & MemberTypes.Property) != 0){
1899                                 if (properties != null) {
1900                                         int len = properties.Count;
1901                                         for (int i = 0; i < len; i++) {
1902                                                 Property p = (Property) properties [i];
1903
1904                                                 if ((p.ModFlags & modflags) == 0)
1905                                                         continue;
1906                                                 if ((p.ModFlags & static_mask) != static_flags)
1907                                                         continue;
1908
1909                                                 MemberInfo pb = p.PropertyBuilder;
1910                                                 if (pb != null && filter (pb, criteria) == true) {
1911                                                         if (members == null)
1912                                                                 members = new ArrayList ();
1913
1914                                                         members.Add (p.PropertyBuilder);
1915                                                 }
1916                                         }
1917                                 }
1918
1919                                 if (indexers != null) {
1920                                         int len = indexers.Count;
1921                                         for (int i = 0; i < len; i++) {
1922                                                 Indexer ix = (Indexer) indexers [i];
1923
1924                                                 if ((ix.ModFlags & modflags) == 0)
1925                                                         continue;
1926                                                 if ((ix.ModFlags & static_mask) != static_flags)
1927                                                         continue;
1928
1929                                                 MemberInfo ib = ix.PropertyBuilder;
1930                                                 if (ib != null && filter (ib, criteria) == true) {
1931                                                         if (members == null)
1932                                                                 members = new ArrayList ();
1933
1934                                                         members.Add (ix.PropertyBuilder);
1935                                                 }
1936                                         }
1937                                 }
1938                         }
1939
1940                         if ((mt & MemberTypes.NestedType) != 0)
1941                                 FindMembers_NestedTypes (modflags, bf, filter, criteria, ref members);
1942
1943                         if ((mt & MemberTypes.Constructor) != 0){
1944                                 if (((bf & BindingFlags.Instance) != 0) && (instance_constructors != null)){
1945                                         int len = instance_constructors.Count;
1946                                         for (int i = 0; i < len; i++) {
1947                                                 Constructor c = (Constructor) instance_constructors [i];
1948
1949                                                 ConstructorBuilder cb = c.ConstructorBuilder;
1950                                                 if (cb != null && filter (cb, criteria) == true) {
1951                                                         if (members == null)
1952                                                                 members = new ArrayList ();
1953
1954                                                         members.Add (cb);
1955                                                 }
1956                                         }
1957                                 }
1958
1959                                 if (((bf & BindingFlags.Static) != 0) && (default_static_constructor != null)){
1960                                         ConstructorBuilder cb =
1961                                                 default_static_constructor.ConstructorBuilder;
1962
1963                                         if (cb != null && filter (cb, criteria) == true) {
1964                                                 if (members == null)
1965                                                         members = new ArrayList ();
1966
1967                                                 members.Add (cb);
1968                                         }
1969                                 }
1970                         }
1971
1972                         //
1973                         // Lookup members in base if requested.
1974                         //
1975                         if ((bf & BindingFlags.DeclaredOnly) == 0) {
1976                                 if (TypeBuilder.BaseType != null) {
1977                                         MemberList list = FindMembers (TypeBuilder.BaseType, mt, bf, filter, criteria);
1978                                         if (list.Count > 0) {
1979                                                 if (members == null)
1980                                                         members = new ArrayList ();
1981
1982                                                 members.AddRange (list);
1983                                         }
1984                                 }
1985                                 if (ifaces != null) {
1986                                         foreach (Type base_type in ifaces) {
1987                                                 MemberList list = TypeContainer.FindMembers (base_type, mt, bf, filter, criteria);
1988
1989                                                 if (list.Count > 0) {
1990                                                         if (members == null)
1991                                                                 members = new ArrayList ();
1992                                                         members.AddRange (list);
1993                                                 }
1994                                         }
1995                                 }
1996                         }
1997
1998                         Timer.StopTimer (TimerType.TcFindMembers);
1999
2000                         if (members == null)
2001                                 return MemberList.Empty;
2002                         else
2003                                 return new MemberList (members);
2004                 }
2005
2006                 public override MemberCache MemberCache {
2007                         get {
2008                                 return member_cache;
2009                         }
2010                 }
2011
2012                 public static MemberList FindMembers (Type t, MemberTypes mt, BindingFlags bf,
2013                                                       MemberFilter filter, object criteria)
2014                 {
2015                         DeclSpace ds = TypeManager.LookupDeclSpace (t);
2016
2017                         if (ds != null)
2018                                 return ds.FindMembers (mt, bf, filter, criteria);
2019                         else
2020                                 return new MemberList (t.FindMembers (mt, bf, filter, criteria));
2021
2022                 }
2023
2024                 //
2025                 // FindMethods will look for methods not only in the type `t', but in
2026                 // any interfaces implemented by the type.
2027                 //
2028                 public static MethodInfo [] FindMethods (Type t, BindingFlags bf,
2029                                                          MemberFilter filter, object criteria)
2030                 {
2031                         return null;
2032                 }
2033
2034                 /// <summary>
2035                 ///   Emits the values for the constants
2036                 /// </summary>
2037                 public void EmitConstants ()
2038                 {
2039                         if (constants != null)
2040                                 foreach (Const con in constants)
2041                                         con.Emit ();
2042                         return;
2043                 }
2044
2045                 void CheckMemberUsage (MemberCoreArrayList al, string member_type)
2046                 {
2047                         if (al == null)
2048                                 return;
2049
2050                         foreach (MemberCore mc in al) {
2051                                 if ((mc.ModFlags & Modifiers.Accessibility) != Modifiers.PRIVATE)
2052                                         continue;
2053
2054                                 if (!mc.IsUsed) {
2055                                         Report.Warning (169, mc.Location, "The private {0} `{1}' is never used", member_type, mc.GetSignatureForError ());
2056                                 }
2057                         }
2058                 }
2059
2060                 public virtual void VerifyMembers ()
2061                 {
2062                         //
2063                         // Check for internal or private fields that were never assigned
2064                         //
2065                         if (RootContext.WarningLevel >= 3) {
2066                                 CheckMemberUsage (properties, "property");
2067                                 CheckMemberUsage (methods, "method");
2068                                 CheckMemberUsage (constants, "constant");
2069
2070                                 if (fields != null){
2071                                         foreach (FieldMember f in fields) {
2072                                                 if ((f.ModFlags & Modifiers.Accessibility) != Modifiers.PRIVATE)
2073                                                         continue;
2074
2075                                                 if (!f.IsUsed){
2076                                                         if ((f.caching_flags & Flags.IsAssigned) == 0)
2077                                                                 Report.Warning (169, 3, f.Location, "The private field `{0}' is never used", f.GetSignatureForError ());
2078                                                         else
2079                                                                 Report.Warning (414, 3, f.Location, "The private field `{0}' is assigned but its value is never used",
2080                                                                         f.GetSignatureForError ());
2081                                                         continue;
2082                                                 }
2083
2084                                                 //
2085                                                 // Only report 649 on level 4
2086                                                 //
2087                                                 if (RootContext.WarningLevel < 4)
2088                                                         continue;
2089
2090                                                 if ((f.caching_flags & Flags.IsAssigned) != 0)
2091                                                         continue;
2092
2093                                                 Report.Warning (649, f.Location, "Field `{0}' is never assigned to, and will always have its default value `{1}'",
2094                                                         f.GetSignatureForError (), f.Type.Type.IsValueType ? Activator.CreateInstance (f.Type.Type).ToString() : "null");
2095                                         }
2096                                 }
2097                         }
2098                 }
2099
2100                 /// <summary>
2101                 ///   Emits the code, this step is performed after all
2102                 ///   the types, enumerations, constructors
2103                 /// </summary>
2104                 public void EmitType ()
2105                 {
2106                         if (OptAttributes != null)
2107                                 OptAttributes.Emit (ec, this);
2108
2109                         //
2110                         // Structs with no fields need to have at least one byte.
2111                         // The right thing would be to set the PackingSize in a DefineType
2112                         // but there are no functions that allow interfaces *and* the size to
2113                         // be specified.
2114                         //
2115
2116                         if (Kind == Kind.Struct && first_nonstatic_field == null){
2117                                 FieldBuilder fb = TypeBuilder.DefineField ("$PRIVATE$", TypeManager.byte_type,
2118                                                                            FieldAttributes.Private);
2119
2120                                 if (HasExplicitLayout){
2121                                         object [] ctor_args = new object [1];
2122                                         ctor_args [0] = 0;
2123
2124                                         CustomAttributeBuilder cba = new CustomAttributeBuilder (
2125                                                 TypeManager.field_offset_attribute_ctor, ctor_args);
2126                                         fb.SetCustomAttribute (cba);
2127                                 }
2128                         }
2129
2130                         Emit ();
2131
2132                         if (instance_constructors != null) {
2133                                 if (TypeBuilder.IsSubclassOf (TypeManager.attribute_type) && RootContext.VerifyClsCompliance && IsClsCompliaceRequired (this)) {
2134                                         bool has_compliant_args = false;
2135
2136                                         foreach (Constructor c in instance_constructors) {
2137                                                 c.Emit ();
2138
2139                                                 if (has_compliant_args)
2140                                                         continue;
2141
2142                                                 has_compliant_args = c.HasCompliantArgs;
2143                                         }
2144                                         if (!has_compliant_args)
2145                                                 Report.Error (3015, Location, "`{0}' has no accessible constructors which use only CLS-compliant types", GetSignatureForError ());
2146                                 } else {
2147                                         foreach (Constructor c in instance_constructors)
2148                                                 c.Emit ();
2149                                 }
2150                         }
2151
2152                         // Can not continue if constants are broken
2153                         EmitConstants ();
2154                         if (Report.Errors > 0)
2155                                 return;
2156
2157                         if (default_static_constructor != null)
2158                                 default_static_constructor.Emit ();
2159
2160                         if (methods != null)
2161                                 foreach (Method m in methods)
2162                                         m.Emit ();
2163
2164                         if (operators != null)
2165                                 foreach (Operator o in operators)
2166                                         o.Emit ();
2167
2168                         if (properties != null)
2169                                 foreach (Property p in properties)
2170                                         p.Emit ();
2171
2172                         if (indexers != null){
2173                                 indexers.Emit ();
2174                         }
2175
2176                         if (fields != null)
2177                                 foreach (FieldMember f in fields)
2178                                         f.Emit ();
2179
2180                         if (events != null){
2181                                 foreach (Event e in Events)
2182                                         e.Emit ();
2183                         }
2184
2185                         if (delegates != null) {
2186                                 foreach (Delegate d in Delegates) {
2187                                         d.Emit ();
2188                                 }
2189                         }
2190
2191                         if (enums != null) {
2192                                 foreach (Enum e in enums) {
2193                                         e.Emit ();
2194                                 }
2195                         }
2196
2197                         if (parts != null) {
2198                                 foreach (ClassPart part in parts)
2199                                         part.EmitType ();
2200                         }
2201
2202                         if ((Pending != null) && !(this is ClassPart))
2203                                 if (Pending.VerifyPendingMethods ())
2204                                         return;
2205
2206                         if (iterators != null)
2207                                 foreach (Iterator iterator in iterators)
2208                                         iterator.EmitType ();
2209
2210 //                      if (types != null)
2211 //                              foreach (TypeContainer tc in types)
2212 //                                      tc.Emit ();
2213                 }
2214
2215                 public override void CloseType ()
2216                 {
2217                         if ((caching_flags & Flags.CloseTypeCreated) != 0)
2218                                 return;
2219
2220                         try {
2221                                 caching_flags |= Flags.CloseTypeCreated;
2222                                 TypeBuilder.CreateType ();
2223                         } catch (TypeLoadException){
2224                                 //
2225                                 // This is fine, the code still created the type
2226                                 //
2227 //                              Report.Warning (-20, "Exception while creating class: " + TypeBuilder.Name);
2228 //                              Console.WriteLine (e.Message);
2229                         } catch {
2230                                 Console.WriteLine ("In type: " + Name);
2231                                 throw;
2232                         }
2233
2234                         if (Enums != null)
2235                                 foreach (Enum en in Enums)
2236                                         en.CloseType ();
2237
2238                         if (Types != null){
2239                                 foreach (TypeContainer tc in Types)
2240                                         if (tc.Kind == Kind.Struct)
2241                                                 tc.CloseType ();
2242
2243                                 foreach (TypeContainer tc in Types)
2244                                         if (tc.Kind != Kind.Struct)
2245                                                 tc.CloseType ();
2246                         }
2247
2248                         if (Delegates != null)
2249                                 foreach (Delegate d in Delegates)
2250                                         d.CloseType ();
2251
2252                         if (Iterators != null)
2253                                 foreach (Iterator i in Iterators)
2254                                         i.CloseType ();
2255
2256                         types = null;
2257                         properties = null;
2258                         enums = null;
2259                         delegates = null;
2260                         fields = null;
2261                         initialized_fields = null;
2262                         initialized_static_fields = null;
2263                         constants = null;
2264                         interfaces = null;
2265                         methods = null;
2266                         events = null;
2267                         indexers = null;
2268                         operators = null;
2269                         iterators = null;
2270                         ec = null;
2271                         default_constructor = null;
2272                         default_static_constructor = null;
2273                         type_bases = null;
2274                         OptAttributes = null;
2275                         ifaces = null;
2276                         base_cache = null;
2277                         member_cache = null;
2278                 }
2279
2280                 //
2281                 // Performs the validation on a Method's modifiers (properties have
2282                 // the same properties).
2283                 //
2284                 public bool MethodModifiersValid (MemberCore mc)
2285                 {
2286                         const int vao = (Modifiers.VIRTUAL | Modifiers.ABSTRACT | Modifiers.OVERRIDE);
2287                         const int va = (Modifiers.VIRTUAL | Modifiers.ABSTRACT);
2288                         const int nv = (Modifiers.NEW | Modifiers.VIRTUAL);
2289                         bool ok = true;
2290                         int flags = mc.ModFlags;
2291
2292                         //
2293                         // At most one of static, virtual or override
2294                         //
2295                         if ((flags & Modifiers.STATIC) != 0){
2296                                 if ((flags & vao) != 0){
2297                                         Report.Error (112, mc.Location, "A static member `{0}' cannot be marked as override, virtual or abstract",
2298                                                 mc.GetSignatureForError ());
2299                                         ok = false;
2300                                 }
2301                         }
2302
2303                         if (Kind == Kind.Struct){
2304                                 if ((flags & va) != 0){
2305                                         Modifiers.Error_InvalidModifier (mc.Location, "virtual or abstract");
2306                                         ok = false;
2307                                 }
2308                         }
2309
2310                         if ((flags & Modifiers.OVERRIDE) != 0 && (flags & nv) != 0){
2311                                 Report.Error (113, mc.Location, "A member `{0}' marked as override cannot be marked as new or virtual",
2312                                         mc.GetSignatureForError ());
2313                                 ok = false;
2314                         }
2315
2316                         //
2317                         // If the declaration includes the abstract modifier, then the
2318                         // declaration does not include static, virtual or extern
2319                         //
2320                         if ((flags & Modifiers.ABSTRACT) != 0){
2321                                 if ((flags & Modifiers.EXTERN) != 0){
2322                                         Report.Error (
2323                                                 180, mc.Location, "`{0}' cannot be both extern and abstract", mc.GetSignatureForError ());
2324                                         ok = false;
2325                                 }
2326
2327                                 if ((flags & Modifiers.SEALED) != 0) {
2328                                         Report.Error (502, mc.Location, "`{0}' cannot be both abstract and sealed", mc.GetSignatureForError ());
2329                                         ok = false;
2330                                 }
2331
2332                                 if ((flags & Modifiers.VIRTUAL) != 0){
2333                                         Report.Error (503, mc.Location, "The abstract method `{0}' cannot be marked virtual", mc.GetSignatureForError ());
2334                                         ok = false;
2335                                 }
2336
2337                                 if ((ModFlags & Modifiers.ABSTRACT) == 0){
2338                                         Report.Error (513, mc.Location, "`{0}' is abstract but it is contained in nonabstract class", mc.GetSignatureForError ());
2339                                         ok = false;
2340                                 }
2341                         }
2342
2343                         if ((flags & Modifiers.PRIVATE) != 0){
2344                                 if ((flags & vao) != 0){
2345                                         Report.Error (621, mc.Location, "`{0}': virtual or abstract members cannot be private", mc.GetSignatureForError ());
2346                                         ok = false;
2347                                 }
2348                         }
2349
2350                         if ((flags & Modifiers.SEALED) != 0){
2351                                 if ((flags & Modifiers.OVERRIDE) == 0){
2352                                         Report.Error (238, mc.Location, "`{0}' cannot be sealed because it is not an override", mc.GetSignatureForError ());
2353                                         ok = false;
2354                                 }
2355                         }
2356
2357                         return ok;
2358                 }
2359
2360                 public bool UserDefinedStaticConstructor {
2361                         get {
2362                                 return default_static_constructor != null;
2363                         }
2364                 }
2365
2366                 public Constructor DefaultStaticConstructor {
2367                         get { return default_static_constructor; }
2368                 }
2369
2370                 protected override bool VerifyClsCompliance (DeclSpace ds)
2371                 {
2372                         if (!base.VerifyClsCompliance (ds))
2373                                 return false;
2374
2375                         VerifyClsName ();
2376
2377                         Type base_type = TypeBuilder.BaseType;
2378                         if (base_type != null && !AttributeTester.IsClsCompliant (base_type)) {
2379                                 Report.Error (3009, Location, "`{0}': base type `{1}' is not CLS-compliant", GetSignatureForError (), TypeManager.CSharpName (base_type));
2380                         }
2381
2382                         if (!Parent.IsClsCompliaceRequired (ds)) {
2383                                 Report.Error (3018, Location, "`{0}' cannot be marked as CLS-Compliant because it is a member of non CLS-Compliant type `{1}'",
2384                                         GetSignatureForError (), Parent.GetSignatureForError ());
2385                         }
2386                         return true;
2387                 }
2388
2389
2390                 /// <summary>
2391                 /// Checks whether container name is CLS Compliant
2392                 /// </summary>
2393                 void VerifyClsName ()
2394                 {
2395                         Hashtable base_members = base_cache == null ?
2396                                 new Hashtable () :
2397                                 base_cache.GetPublicMembers ();
2398                         Hashtable this_members = new Hashtable ();
2399
2400                         foreach (DictionaryEntry entry in defined_names) {
2401                                 MemberCore mc = (MemberCore)entry.Value;
2402                                 if (!mc.IsClsCompliaceRequired (this))
2403                                         continue;
2404
2405                                 string name = (string)entry.Key;
2406                                 string basename = name.Substring (name.LastIndexOf ('.') + 1);
2407
2408                                 string lcase = basename.ToLower (System.Globalization.CultureInfo.InvariantCulture);
2409                                 object found = base_members [lcase];
2410                                 if (found == null) {
2411                                         found = this_members [lcase];
2412                                         if (found == null) {
2413                                                 this_members.Add (lcase, mc);
2414                                                 continue;
2415                                         }
2416                                 }
2417
2418                                 if ((mc.ModFlags & Modifiers.OVERRIDE) != 0)
2419                                         continue;
2420
2421                                 if (found is MemberInfo) {
2422                                         if (basename == ((MemberInfo)found).Name)
2423                                                 continue;
2424                                         Report.SymbolRelatedToPreviousError ((MemberInfo)found);
2425                                 } else {
2426                                         Report.SymbolRelatedToPreviousError ((MemberCore) found);
2427                                 }
2428                                 Report.Error (3005, mc.Location, "Identifier `{0}' differing only in case is not CLS-compliant", mc.GetSignatureForError ());
2429                         }
2430                 }
2431
2432
2433                 /// <summary>
2434                 ///   Performs checks for an explicit interface implementation.  First it
2435                 ///   checks whether the `interface_type' is a base inteface implementation.
2436                 ///   Then it checks whether `name' exists in the interface type.
2437                 /// </summary>
2438                 public virtual bool VerifyImplements (MemberBase mb)
2439                 {
2440                         if (ifaces != null) {
2441                                 foreach (Type t in ifaces){
2442                                         if (t == mb.InterfaceType)
2443                                                 return true;
2444                                 }
2445                         }
2446
2447                         Report.Error (540, mb.Location, "`{0}': containing type does not implement interface `{1}'",
2448                                 mb.GetSignatureForError (), TypeManager.CSharpName (mb.InterfaceType));
2449                         return false;
2450                 }
2451
2452                 protected override void VerifyObsoleteAttribute()
2453                 {
2454                         CheckUsageOfObsoleteAttribute (ptype);
2455
2456                         if (ifaces == null)
2457                                 return;
2458
2459                         foreach (Type iface in ifaces) {
2460                                 CheckUsageOfObsoleteAttribute (iface);
2461                         }
2462                 }
2463
2464
2465                 //
2466                 // IMemberContainer
2467                 //
2468
2469                 string IMemberContainer.Name {
2470                         get {
2471                                 return Name;
2472                         }
2473                 }
2474
2475                 Type IMemberContainer.Type {
2476                         get {
2477                                 return TypeBuilder;
2478                         }
2479                 }
2480
2481                 MemberCache IMemberContainer.MemberCache {
2482                         get {
2483                                 return member_cache;
2484                         }
2485                 }
2486
2487                 bool IMemberContainer.IsInterface {
2488                         get {
2489                                 return Kind == Kind.Interface;
2490                         }
2491                 }
2492
2493                 MemberList IMemberContainer.GetMembers (MemberTypes mt, BindingFlags bf)
2494                 {
2495                         return FindMembers (mt, bf | BindingFlags.DeclaredOnly, null, null);
2496                 }
2497
2498                 //
2499                 // Generates xml doc comments (if any), and if required,
2500                 // handle warning report.
2501                 //
2502                 internal override void GenerateDocComment (DeclSpace ds)
2503                 {
2504                         DocUtil.GenerateTypeDocComment (this, ds);
2505                 }
2506
2507                 public override string DocCommentHeader {
2508                         get { return "T:"; }
2509                 }
2510
2511                 public virtual MemberCache BaseCache {
2512                         get {
2513                                 if (base_cache != null)
2514                                         return base_cache;
2515                                 if (TypeBuilder.BaseType != null)
2516                                         base_cache = TypeManager.LookupMemberCache (TypeBuilder.BaseType);
2517                                 if (TypeBuilder.IsInterface)
2518                                         base_cache = TypeManager.LookupBaseInterfacesCache (TypeBuilder);
2519                                 return base_cache;
2520                         }
2521                 }
2522         }
2523
2524         public class PartialContainer : TypeContainer {
2525
2526                 public readonly Namespace Namespace;
2527                 public readonly int OriginalModFlags;
2528                 public readonly int AllowedModifiers;
2529                 public readonly TypeAttributes DefaultTypeAttributes;
2530
2531                 static PartialContainer Create (NamespaceEntry ns, TypeContainer parent,
2532                                                 MemberName member_name, int mod_flags, Kind kind,
2533                                                 Location loc)
2534                 {
2535                         PartialContainer pc;
2536                         DeclSpace ds = RootContext.Tree.GetDecl (member_name);
2537                         if (ds != null) {
2538                                 pc = ds as PartialContainer;
2539
2540                                 if (pc == null) {
2541                                         Report.LocationOfPreviousError (loc);
2542                                         Report.Error (260, ds.Location,
2543                                                 "Missing partial modifier on declaration of type `{0}'. Another partial declaration of this type exists",
2544                                                 member_name.GetPartialName());
2545
2546                                         return null;
2547                                 }
2548
2549                                 if (pc.Kind != kind) {
2550                                         Report.Error (
2551                                                 261, loc, "Partial declarations of `{0}' " +
2552                                                 "must be all classes, all structs or " +
2553                                                 "all interfaces", member_name.GetPartialName ());
2554                                         return null;
2555                                 }
2556
2557                                 if (pc.OriginalModFlags != mod_flags) {
2558                                         Report.Error (
2559                                                 262, loc, "Partial declarations of `{0}' " +
2560                                                 "have conflicting accessibility modifiers",
2561                                                 member_name.GetPartialName ());
2562                                         return null;
2563                                 }
2564
2565                                 return pc;
2566                         }
2567
2568                         if (parent is ClassPart)
2569                                 parent = ((ClassPart) parent).PartialContainer;
2570
2571                         pc = new PartialContainer (ns.NS, parent, member_name, mod_flags, kind, loc);
2572                         RootContext.Tree.RecordDecl (ns.NS, member_name, pc);
2573
2574                         if (kind == Kind.Interface)
2575                                 parent.AddInterface (pc);
2576                         else if (kind == Kind.Class || kind == Kind.Struct)
2577                                 parent.AddClassOrStruct (pc);
2578                         else
2579                                 throw new InvalidOperationException ();
2580
2581                         return pc;
2582                 }
2583
2584                 public static ClassPart CreatePart (NamespaceEntry ns, TypeContainer parent,
2585                                                     MemberName name, int mod, Attributes attrs,
2586                                                     Kind kind, Location loc)
2587                 {
2588                         PartialContainer pc = Create (ns, parent, name, mod, kind, loc);
2589                         if (pc == null) {
2590                                 // An error occured; create a dummy container, but don't
2591                                 // register it.
2592                                 pc = new PartialContainer (ns.NS, parent, name, mod, kind, loc);
2593                         }
2594
2595                         ClassPart part = new ClassPart (ns, pc, parent, mod, attrs, kind, loc);
2596                         pc.AddPart (part);
2597                         return part;
2598                 }
2599
2600                 protected PartialContainer (Namespace ns, TypeContainer parent,
2601                                             MemberName name, int mod, Kind kind, Location l)
2602                         : base (null, parent, name, null, kind, l)
2603                 {
2604                         this.Namespace = ns;
2605
2606                         switch (kind) {
2607                         case Kind.Class:
2608                                 AllowedModifiers = Class.AllowedModifiers;
2609                                 DefaultTypeAttributes = Class.DefaultTypeAttributes;
2610                                 break;
2611
2612                         case Kind.Struct:
2613                                 AllowedModifiers = Struct.AllowedModifiers;
2614                                 DefaultTypeAttributes = Struct.DefaultTypeAttributes;
2615                                 break;
2616
2617                         case Kind.Interface:
2618                                 AllowedModifiers = Interface.AllowedModifiers;
2619                                 DefaultTypeAttributes = Interface.DefaultTypeAttributes;
2620                                 break;
2621
2622                         default:
2623                                 throw new InvalidOperationException ();
2624                         }
2625
2626                         int accmods;
2627                         if (parent.Parent == null)
2628                                 accmods = Modifiers.INTERNAL;
2629                         else
2630                                 accmods = Modifiers.PRIVATE;
2631
2632                         this.ModFlags = Modifiers.Check (AllowedModifiers, mod, accmods, l);
2633                         this.OriginalModFlags = mod;
2634                 }
2635
2636                 public override PendingImplementation GetPendingImplementations ()
2637                 {
2638                         return PendingImplementation.GetPendingImplementations (this);
2639                 }
2640
2641                 protected override TypeAttributes TypeAttr {
2642                         get {
2643                                 return base.TypeAttr | DefaultTypeAttributes;
2644                         }
2645                 }
2646         }
2647
2648         public class ClassPart : TypeContainer, IMemberContainer {
2649                 public readonly PartialContainer PartialContainer;
2650                 public readonly bool IsPartial;
2651
2652                 public ClassPart (NamespaceEntry ns, PartialContainer pc, TypeContainer parent,
2653                                   int mod, Attributes attrs, Kind kind, Location l)
2654                         : base (ns, parent, pc.MemberName, attrs, kind, l)
2655                 {
2656                         this.PartialContainer = pc;
2657                         this.IsPartial = true;
2658
2659                         int accmods;
2660                         if (parent == null || parent == RootContext.Tree.Types)
2661                                 accmods = Modifiers.INTERNAL;
2662                         else
2663                                 accmods = Modifiers.PRIVATE;
2664
2665                         this.ModFlags = Modifiers.Check (pc.AllowedModifiers, mod, accmods, l);
2666                 }
2667
2668                 public override PendingImplementation GetPendingImplementations ()
2669                 {
2670                         return PartialContainer.Pending;
2671                 }
2672
2673                 public override bool VerifyImplements (MemberBase mb)
2674                 {
2675                         return PartialContainer.VerifyImplements (mb);
2676                 }
2677
2678
2679                 public override void RegisterFieldForInitialization (FieldMember field)
2680                 {
2681                         PartialContainer.RegisterFieldForInitialization (field);
2682                 }
2683
2684                 public override bool EmitFieldInitializers (EmitContext ec)
2685                 {
2686                         return PartialContainer.EmitFieldInitializers (ec);
2687                 }
2688
2689                 public override Type FindNestedType (string name)
2690                 {
2691                         return PartialContainer.FindNestedType (name);
2692                 }
2693
2694                 public override MemberCache BaseCache {
2695                         get {
2696                                 return PartialContainer.BaseCache;
2697                         }
2698                 }
2699
2700                 public override TypeBuilder DefineType ()
2701                 {
2702                         throw new InternalErrorException ("Should not get here");
2703                 }
2704
2705         }
2706
2707         public abstract class ClassOrStruct : TypeContainer {
2708                 bool has_explicit_layout = false;
2709                 ListDictionary declarative_security;
2710
2711                 public ClassOrStruct (NamespaceEntry ns, TypeContainer parent,
2712                                       MemberName name, Attributes attrs, Kind kind,
2713                                       Location l)
2714                         : base (ns, parent, name, attrs, kind, l)
2715                 {
2716                 }
2717
2718                 public override PendingImplementation GetPendingImplementations ()
2719                 {
2720                         return PendingImplementation.GetPendingImplementations (this);
2721                 }
2722
2723                 public override bool HasExplicitLayout {
2724                         get {
2725                                 return has_explicit_layout;
2726                         }
2727                 }
2728
2729                 public override void VerifyMembers ()
2730                 {
2731                         base.VerifyMembers ();
2732
2733                         if ((events != null) && (RootContext.WarningLevel >= 3)) {
2734                                 foreach (Event e in events){
2735                                         if ((e.caching_flags & Flags.IsAssigned) == 0)
2736                                                 Report.Warning (67, 3, e.Location, "The event `{0}' is never used", e.GetSignatureForError ());
2737                                 }
2738                         }
2739                 }
2740
2741                 public override void ApplyAttributeBuilder (Attribute a, CustomAttributeBuilder cb)
2742                 {
2743                         if (a.Type.IsSubclassOf (TypeManager.security_attr_type) && a.CheckSecurityActionValidity (false)) {
2744                                 if (declarative_security == null)
2745                                         declarative_security = new ListDictionary ();
2746
2747                                 a.ExtractSecurityPermissionSet (declarative_security);
2748                                 return;
2749                         }
2750
2751                         if (a.Type == TypeManager.struct_layout_attribute_type && a.GetLayoutKindValue () == LayoutKind.Explicit)
2752                                 has_explicit_layout = true;
2753
2754                         base.ApplyAttributeBuilder (a, cb);
2755                 }
2756
2757                 public override void Emit()
2758                 {
2759                         base.Emit ();
2760
2761                         if (declarative_security != null) {
2762                                 foreach (DictionaryEntry de in declarative_security) {
2763                                         TypeBuilder.AddDeclarativeSecurity ((SecurityAction)de.Key, (PermissionSet)de.Value);
2764                                 }
2765                         }
2766                 }
2767         }
2768
2769         /// <summary>
2770         /// Class handles static classes declaration
2771         /// </summary>
2772         public sealed class StaticClass: Class {
2773                 public StaticClass (NamespaceEntry ns, TypeContainer parent, MemberName name, int mod,
2774                         Attributes attrs, Location l)
2775                         : base (ns, parent, name, mod, attrs, l)
2776                 {
2777                         if (RootContext.Version == LanguageVersion.ISO_1) {
2778                                 Report.FeatureIsNotStandardized (l, "static classes");
2779                         }
2780                 }
2781
2782                 protected override int AllowedModifiersProp {
2783                         get {
2784                                 return Modifiers.NEW | Modifiers.PUBLIC | Modifiers.PROTECTED | Modifiers.INTERNAL | Modifiers.PRIVATE |
2785                                         Modifiers.STATIC | Modifiers.UNSAFE;
2786                         }
2787                 }
2788
2789                 protected override void DefineContainerMembers (MemberCoreArrayList list)
2790                 {
2791                         if (list == null)
2792                                 return;
2793
2794                         foreach (MemberCore m in list) {
2795                                 if (m is Operator) {
2796                                         Report.Error (715, m.Location, "`{0}': static classes cannot contain user-defined operators", m.GetSignatureForError ());
2797                                         continue;
2798                                 }
2799
2800                                 if ((m.ModFlags & Modifiers.PROTECTED) != 0)
2801                                         Report.Warning (-628, 4, m.Location, "`{0}': new protected member declared in static class", m.GetSignatureForError ());
2802
2803                                 if (m is Indexer) {
2804                                         Report.Error (720, m.Location, "`{0}': cannot declare indexers in a static class", m.GetSignatureForError ());
2805                                         continue;
2806                                 }
2807
2808                                 if ((m.ModFlags & Modifiers.STATIC) != 0 || m is Enum || m is Delegate)
2809                                         continue;
2810
2811                                 if (m is Constructor) {
2812                                         Report.Error (710, m.Location, "`{0}': Static classes cannot have instance constructors", GetSignatureForError ());
2813                                         continue;
2814                                 }
2815
2816                                 if (m is Destructor) {
2817                                         Report.Error (711, m.Location, "`{0}': Static classes cannot contain destructor", GetSignatureForError ());
2818                                         continue;
2819                                 }
2820
2821                                 Report.Error (708, m.Location, "`{0}': cannot declare instance members in a static class", m.GetSignatureForError ());
2822                         }
2823
2824                         base.DefineContainerMembers (list);
2825                 }
2826
2827                 public override TypeBuilder DefineType()
2828                 {
2829                         if ((ModFlags & (Modifiers.SEALED | Modifiers.STATIC)) == (Modifiers.SEALED | Modifiers.STATIC)) {
2830                                 Report.Error (441, Location, "`{0}': a class cannot be both static and sealed", GetSignatureForError ());
2831                                 return null;
2832                         }
2833
2834                         TypeBuilder tb = base.DefineType ();
2835                         if (tb == null)
2836                                 return null;
2837
2838                         if (ptype != TypeManager.object_type) {
2839                                 Report.Error (713, Location, "Static class `{0}' cannot derive from type `{1}'. Static classes must derive from object", GetSignatureForError (), TypeManager.CSharpName (ptype));
2840                                 return null;
2841                         }
2842
2843                         if (ifaces != null) {
2844                                 foreach (Type t in ifaces)
2845                                         Report.SymbolRelatedToPreviousError (t);
2846                                 Report.Error (714, Location, "`{0}': static classes cannot implement interfaces", GetSignatureForError ());
2847                         }
2848                         return tb;
2849                 }
2850
2851                 protected override TypeAttributes TypeAttr {
2852                         get {
2853                                 return base.TypeAttr | TypeAttributes.Abstract | TypeAttributes.Sealed;
2854                         }
2855                 }
2856         }
2857
2858         public class Class : ClassOrStruct {
2859                 // TODO: remove this and use only AllowedModifiersProp to fix partial classes bugs
2860                 public const int AllowedModifiers =
2861                         Modifiers.NEW |
2862                         Modifiers.PUBLIC |
2863                         Modifiers.PROTECTED |
2864                         Modifiers.INTERNAL |
2865                         Modifiers.PRIVATE |
2866                         Modifiers.ABSTRACT |
2867                         Modifiers.SEALED |
2868                         Modifiers.UNSAFE;
2869
2870                 public Class (NamespaceEntry ns, TypeContainer parent, MemberName name, int mod,
2871                               Attributes attrs, Location l)
2872                         : base (ns, parent, name, attrs, Kind.Class, l)
2873                 {
2874                         this.ModFlags = mod;
2875                 }
2876
2877                 virtual protected int AllowedModifiersProp {
2878                         get {
2879                                 return AllowedModifiers;
2880                         }
2881                 }
2882
2883                 public override void ApplyAttributeBuilder(Attribute a, CustomAttributeBuilder cb)
2884                 {
2885                         if (a.Type == TypeManager.attribute_usage_type) {
2886                                 if (ptype != TypeManager.attribute_type && !ptype.IsSubclassOf (TypeManager.attribute_type) &&
2887                                         TypeBuilder.FullName != "System.Attribute") {
2888                                         Report.Error (641, a.Location, "Attribute `{0}' is only valid on classes derived from System.Attribute", a.GetSignatureForError ());
2889                                 }
2890                         }
2891
2892                         if (a.Type == TypeManager.conditional_attribute_type &&
2893                                 !(ptype == TypeManager.attribute_type || ptype.IsSubclassOf (TypeManager.attribute_type))) {
2894                                 Report.Error (1689, a.Location, "Attribute 'System.Diagnostics.ConditionalAttribute' is only valid on methods or attribute classes");
2895                                 return;
2896                         }
2897
2898                         if (AttributeTester.IsAttributeExcluded (a.Type))
2899                                 return;
2900
2901                         base.ApplyAttributeBuilder (a, cb);
2902                 }
2903
2904                 public const TypeAttributes DefaultTypeAttributes =
2905                         TypeAttributes.AutoLayout | TypeAttributes.Class;
2906
2907                 public override TypeBuilder DefineType()
2908                 {
2909                         if ((ModFlags & Modifiers.ABSTRACT) == Modifiers.ABSTRACT && (ModFlags & (Modifiers.SEALED | Modifiers.STATIC)) != 0) {
2910                                 Report.Error (418, Location, "`{0}': an abstract class cannot be sealed or static", GetSignatureForError ());
2911                                 return null;
2912                         }
2913
2914                         int accmods = Parent.Parent == null ? Modifiers.INTERNAL : Modifiers.PRIVATE;
2915                         ModFlags = Modifiers.Check (AllowedModifiersProp, ModFlags, accmods, Location);
2916
2917                         return base.DefineType ();
2918                 }
2919
2920                 /// Search for at least one defined condition in ConditionalAttribute of attribute class
2921                 /// Valid only for attribute classes.
2922                 public bool IsExcluded ()
2923                 {
2924                         if ((caching_flags & Flags.Excluded_Undetected) == 0)
2925                                 return (caching_flags & Flags.Excluded) != 0;
2926
2927                         caching_flags &= ~Flags.Excluded_Undetected;
2928
2929                         if (OptAttributes == null)
2930                                 return false;
2931
2932                         Attribute[] attrs = OptAttributes.SearchMulti (TypeManager.conditional_attribute_type, ec);
2933
2934                         if (attrs == null)
2935                                 return false;
2936
2937                         foreach (Attribute a in attrs) {
2938                                 string condition = a.GetConditionalAttributeValue (Parent.EmitContext);
2939                                 if (RootContext.AllDefines.Contains (condition))
2940                                         return false;
2941                         }
2942
2943                         caching_flags |= Flags.Excluded;
2944                         return true;
2945                 }
2946
2947                 //
2948                 // FIXME: How do we deal with the user specifying a different
2949                 // layout?
2950                 //
2951                 protected override TypeAttributes TypeAttr {
2952                         get {
2953                                 return base.TypeAttr | DefaultTypeAttributes;
2954                         }
2955                 }
2956         }
2957
2958         public class Struct : ClassOrStruct {
2959                 // <summary>
2960                 //   Modifiers allowed in a struct declaration
2961                 // </summary>
2962                 public const int AllowedModifiers =
2963                         Modifiers.NEW       |
2964                         Modifiers.PUBLIC    |
2965                         Modifiers.PROTECTED |
2966                         Modifiers.INTERNAL  |
2967                         Modifiers.UNSAFE    |
2968                         Modifiers.PRIVATE;
2969
2970                 public Struct (NamespaceEntry ns, TypeContainer parent, MemberName name,
2971                                int mod, Attributes attrs, Location l)
2972                         : base (ns, parent, name, attrs, Kind.Struct, l)
2973                 {
2974                         int accmods;
2975
2976                         if (parent.Parent == null)
2977                                 accmods = Modifiers.INTERNAL;
2978                         else
2979                                 accmods = Modifiers.PRIVATE;
2980
2981                         this.ModFlags = Modifiers.Check (AllowedModifiers, mod, accmods, l);
2982
2983                         this.ModFlags |= Modifiers.SEALED;
2984                 }
2985
2986                 public const TypeAttributes DefaultTypeAttributes =
2987                         TypeAttributes.SequentialLayout |
2988                         TypeAttributes.Sealed |
2989                         TypeAttributes.BeforeFieldInit;
2990
2991                 //
2992                 // FIXME: Allow the user to specify a different set of attributes
2993                 // in some cases (Sealed for example is mandatory for a class,
2994                 // but what SequentialLayout can be changed
2995                 //
2996                 protected override TypeAttributes TypeAttr {
2997                         get {
2998                                 return base.TypeAttr | DefaultTypeAttributes;
2999                         }
3000                 }
3001         }
3002
3003         /// <summary>
3004         ///   Interfaces
3005         /// </summary>
3006         public class Interface : TypeContainer, IMemberContainer {
3007
3008                 /// <summary>
3009                 ///   Modifiers allowed in a class declaration
3010                 /// </summary>
3011                 public const int AllowedModifiers =
3012                         Modifiers.NEW       |
3013                         Modifiers.PUBLIC    |
3014                         Modifiers.PROTECTED |
3015                         Modifiers.INTERNAL  |
3016                         Modifiers.UNSAFE    |
3017                         Modifiers.PRIVATE;
3018
3019                 public Interface (NamespaceEntry ns, TypeContainer parent, MemberName name, int mod,
3020                                   Attributes attrs, Location l)
3021                         : base (ns, parent, name, attrs, Kind.Interface, l)
3022                 {
3023                         int accmods;
3024
3025                         if (parent.Parent == null)
3026                                 accmods = Modifiers.INTERNAL;
3027                         else
3028                                 accmods = Modifiers.PRIVATE;
3029
3030                         this.ModFlags = Modifiers.Check (AllowedModifiers, mod, accmods, l);
3031                 }
3032
3033                 public override PendingImplementation GetPendingImplementations ()
3034                 {
3035                         return null;
3036                 }
3037
3038                 public const TypeAttributes DefaultTypeAttributes =
3039                         TypeAttributes.AutoLayout |
3040                         TypeAttributes.Abstract |
3041                         TypeAttributes.Interface;
3042
3043                 protected override TypeAttributes TypeAttr {
3044                         get {
3045                                 return base.TypeAttr | DefaultTypeAttributes;
3046                         }
3047                 }
3048
3049                 protected override bool VerifyClsCompliance (DeclSpace ds)
3050                 {
3051                         if (!base.VerifyClsCompliance (ds))
3052                                 return false;
3053
3054                         if (ifaces != null) {
3055                                 foreach (Type t in ifaces) {
3056                                         if (AttributeTester.IsClsCompliant (t))
3057                                                 continue;
3058
3059                                         Report.SymbolRelatedToPreviousError (t);
3060                                         Report.Warning (3027, 1, Location, "`{0}' is not CLS-compliant because base interface `{1}' is not CLS-compliant",
3061                                                 GetSignatureForError (), TypeManager.CSharpName (t));
3062                                 }
3063                         }
3064
3065                         return true;
3066                 }
3067         }
3068
3069         public abstract class MethodCore : MemberBase {
3070                 public readonly Parameters Parameters;
3071                 protected ToplevelBlock block;
3072
3073                 //
3074                 // Parameters, cached for semantic analysis.
3075                 //
3076                 protected InternalParameters parameter_info;
3077                 protected Type [] parameter_types;
3078
3079                 // Whether this is an operator method.
3080                 public Operator IsOperator;
3081
3082                 //
3083                 // The method we're overriding if this is an override method.
3084                 //
3085                 protected MethodInfo base_method = null;
3086
3087                 static string[] attribute_targets = new string [] { "method", "return" };
3088
3089                 public MethodCore (TypeContainer parent, Expression type, int mod,
3090                                    int allowed_mod, bool is_interface, MemberName name,
3091                                    Attributes attrs, Parameters parameters, Location loc)
3092                         : base (parent, type, mod, allowed_mod, Modifiers.PRIVATE, name,
3093                                 attrs, loc)
3094                 {
3095                         Parameters = parameters;
3096                         IsInterface = is_interface;
3097                 }
3098
3099                 //
3100                 //  Returns the System.Type array for the parameters of this method
3101                 //
3102                 public Type [] ParameterTypes {
3103                         get {
3104                                 return parameter_types;
3105                         }
3106                 }
3107
3108                 public InternalParameters ParameterInfo
3109                 {
3110                         get {
3111                                 return parameter_info;
3112                         }
3113                 }
3114
3115                 public ToplevelBlock Block {
3116                         get {
3117                                 return block;
3118                         }
3119
3120                         set {
3121                                 block = value;
3122                         }
3123                 }
3124
3125                 public void SetYields ()
3126                 {
3127                         ModFlags |= Modifiers.METHOD_YIELDS;
3128                 }
3129
3130                 protected override bool CheckBase ()
3131                 {
3132                         if (!base.CheckBase ())
3133                                 return false;
3134
3135                         // Check whether arguments were correct.
3136                         if (!DoDefineParameters ())
3137                                 return false;
3138
3139                         if ((caching_flags & Flags.TestMethodDuplication) != 0 && !CheckForDuplications ())
3140                                 return false;
3141
3142                         if (IsExplicitImpl)
3143                                 return true;
3144
3145                         // Is null for System.Object while compiling corlib and base interfaces
3146                         if (Parent.BaseCache == null) {
3147                                 if ((RootContext.WarningLevel >= 4) && ((ModFlags & Modifiers.NEW) != 0)) {
3148                                         Report.Warning (109, Location, "The member `{0}' does not hide an inherited member. The new keyword is not required", GetSignatureForError ());
3149                                 }
3150                                 return true;
3151                         }
3152
3153                         Type base_ret_type = null;
3154                         base_method = FindOutBaseMethod (Parent, ref base_ret_type);
3155
3156                         // method is override
3157                         if (base_method != null) {
3158
3159                                 if (!CheckMethodAgainstBase ())
3160                                         return false;
3161
3162                                 if ((ModFlags & Modifiers.NEW) == 0) {
3163                                         if (MemberType != TypeManager.TypeToCoreType (base_ret_type)) {
3164                                                 Report.SymbolRelatedToPreviousError (base_method);
3165                                                 if (this is PropertyBase) {
3166                                                         Report.Error (1715, Location, "`{0}': type must be `{1}' to match overridden member `{2}'",
3167                                                                 GetSignatureForError (), TypeManager.CSharpName (base_ret_type), TypeManager.CSharpSignature (base_method));
3168                                                 }
3169                                                 else {
3170                                                         Report.Error (508, Location, "`{0}': return type must be `{1}' to match overridden member `{2}'",
3171                                                                 GetSignatureForError (), TypeManager.CSharpName (base_ret_type), TypeManager.CSharpSignature (base_method));
3172                                                 }
3173                                                 return false;
3174                                         }
3175                                 } else {
3176                                         if (base_method.IsAbstract && !IsInterface) {
3177                                                 Report.SymbolRelatedToPreviousError (base_method);
3178                                                 Report.Error (533, Location, "`{0}' hides inherited abstract member `{1}'",
3179                                                         GetSignatureForError (), TypeManager.CSharpSignature (base_method));
3180                                                 return false;
3181                                         }
3182                                 }
3183
3184                                 if (base_method.IsSpecialName && !(this is PropertyBase)) {
3185                                         Report.Error (115, Location, "`{0}': no suitable method found to override", GetSignatureForError ());
3186                                         return false;
3187                                 }
3188
3189                                 if (RootContext.WarningLevel > 2) {
3190                                         if (Name == "Equals" && parameter_types.Length == 1 && parameter_types [0] == TypeManager.object_type)
3191                                                 Parent.Methods.HasEquals = true;
3192                                         else if (Name == "GetHashCode" && parameter_types.Length == 0)
3193                                                 Parent.Methods.HasGetHashCode = true;
3194                                 }
3195
3196                                 if ((ModFlags & Modifiers.OVERRIDE) != 0) {
3197                                         ObsoleteAttribute oa = AttributeTester.GetMethodObsoleteAttribute (base_method);
3198                                         if (oa != null) {
3199                                                 EmitContext ec = new EmitContext (this.Parent, this.Parent, Location, null, null, ModFlags, false);
3200                                                 if (OptAttributes == null || !OptAttributes.Contains (TypeManager.obsolete_attribute_type, ec)) {
3201                                                         Report.SymbolRelatedToPreviousError (base_method);
3202                                                         Report.Warning (672, 1, Location, "Member `{0}' overrides obsolete member `{1}'. Add the Obsolete attribute to `{0}'",
3203                                                                 GetSignatureForError (), TypeManager.CSharpSignature (base_method) );
3204                                                 }
3205                                         }
3206                                 }
3207                                 return true;
3208                         }
3209
3210                         MemberInfo conflict_symbol = Parent.FindBaseMemberWithSameName (Name, !(this is Property));
3211                         if ((ModFlags & Modifiers.OVERRIDE) != 0) {
3212                                 if (conflict_symbol != null) {
3213                                         Report.SymbolRelatedToPreviousError (conflict_symbol);
3214                                         if (this is PropertyBase)
3215                                                 Report.Error (544, Location, "`{0}': cannot override because `{1}' is not a property", GetSignatureForError (), TypeManager.GetFullNameSignature (conflict_symbol));
3216                                         else
3217                                                 Report.Error (505, Location, "`{0}': cannot override because `{1}' is not a method", GetSignatureForError (), TypeManager.GetFullNameSignature (conflict_symbol));
3218                                 } else
3219                                         Report.Error (115, Location, "`{0}': no suitable method found to override", GetSignatureForError ());
3220                                 return false;
3221                         }
3222
3223                         if (conflict_symbol == null) {
3224                                 if ((RootContext.WarningLevel >= 4) && ((ModFlags & Modifiers.NEW) != 0)) {
3225                                         Report.Warning (109, Location, "The member `{0}' does not hide an inherited member. The new keyword is not required", GetSignatureForError ());
3226                                 }
3227                                 return true;
3228                         }
3229
3230                         if ((ModFlags & Modifiers.NEW) == 0) {
3231                                 if (this is Method && conflict_symbol is MethodBase)
3232                                         return true;
3233
3234                                 Report.SymbolRelatedToPreviousError (conflict_symbol);
3235                                 Report.Warning (108, Location, "`{0}' hides inherited member `{1}'. Use the new keyword if hiding was intended",
3236                                         GetSignatureForError (), TypeManager.GetFullNameSignature (conflict_symbol));
3237                         }
3238
3239                         return true;
3240                 }
3241
3242                 //
3243                 // Performs various checks on the MethodInfo `mb' regarding the modifier flags
3244                 // that have been defined.
3245                 //
3246                 // `name' is the user visible name for reporting errors (this is used to
3247                 // provide the right name regarding method names and properties)
3248                 //
3249                 bool CheckMethodAgainstBase ()
3250                 {
3251                         bool ok = true;
3252
3253                         if ((ModFlags & Modifiers.OVERRIDE) != 0){
3254                                 if (!(base_method.IsAbstract || base_method.IsVirtual)){
3255                                         Report.Error (506, Location,
3256                                                 "`{0}': cannot override inherited member `{1}' because it is not marked virtual, abstract or override",
3257                                                  GetSignatureForError (), TypeManager.CSharpSignature (base_method));
3258                                         ok = false;
3259                                 }
3260
3261                                 // Now we check that the overriden method is not final
3262
3263                                 if (base_method.IsFinal) {
3264                                         Report.SymbolRelatedToPreviousError (base_method);
3265                                         Report.Error (239, Location, "`{0}': cannot override inherited member `{1}' because it is sealed",
3266                                                               GetSignatureForError (), TypeManager.CSharpSignature (base_method));
3267                                         ok = false;
3268                                 }
3269                                 //
3270                                 // Check that the permissions are not being changed
3271                                 //
3272                                 MethodAttributes thisp = flags & MethodAttributes.MemberAccessMask;
3273                                 MethodAttributes base_classp = base_method.Attributes & MethodAttributes.MemberAccessMask;
3274
3275                                 if (!CheckAccessModifiers (thisp, base_classp, base_method)) {
3276                                         Error_CannotChangeAccessModifiers (base_method, base_classp, null);
3277                                         ok = false;
3278                                 }
3279                         }
3280
3281                         if ((ModFlags & (Modifiers.NEW | Modifiers.OVERRIDE)) == 0 && Name != "Finalize") {
3282                                 ModFlags |= Modifiers.NEW;
3283                                 Report.SymbolRelatedToPreviousError (base_method);
3284                                 if (!IsInterface && (base_method.IsVirtual || base_method.IsAbstract)) {
3285                                         if (RootContext.WarningLevel >= 2)
3286                                                 Report.Warning (114, Location, "`{0}' hides inherited member `{1}'. To make the current member override that implementation, add the override keyword. Otherwise add the new keyword", GetSignatureForError (), TypeManager.CSharpSignature (base_method));
3287                                 } else {
3288                                         Report.Warning (108, Location, "`{0}' hides inherited member `{1}'. Use the new keyword if hiding was intended",
3289                                                 GetSignatureForError (), TypeManager.CSharpSignature (base_method));
3290                                 }
3291                         }
3292
3293                         return ok;
3294                 }
3295
3296                 protected bool CheckAccessModifiers (MethodAttributes thisp, MethodAttributes base_classp, MethodInfo base_method)
3297                 {
3298                         if ((base_classp & MethodAttributes.FamORAssem) == MethodAttributes.FamORAssem){
3299                                 //
3300                                 // when overriding protected internal, the method can be declared
3301                                 // protected internal only within the same assembly
3302                                 //
3303
3304                                 if ((thisp & MethodAttributes.FamORAssem) == MethodAttributes.FamORAssem){
3305                                         if (Parent.TypeBuilder.Assembly != base_method.DeclaringType.Assembly){
3306                                                 //
3307                                                 // assemblies differ - report an error
3308                                                 //
3309
3310                                                 return false;
3311                                         } else if (thisp != base_classp) {
3312                                                 //
3313                                                 // same assembly, but other attributes differ - report an error
3314                                                 //
3315
3316                                                 return false;
3317                                         };
3318                                 } else if ((thisp & MethodAttributes.Family) != MethodAttributes.Family) {
3319                                         //
3320                                         // if it's not "protected internal", it must be "protected"
3321                                         //
3322
3323                                         return false;
3324                                 } else if (Parent.TypeBuilder.Assembly == base_method.DeclaringType.Assembly) {
3325                                         //
3326                                         // protected within the same assembly - an error
3327                                         //
3328                                         return false;
3329                                 } else if ((thisp & ~(MethodAttributes.Family | MethodAttributes.FamORAssem)) !=
3330                                            (base_classp & ~(MethodAttributes.Family | MethodAttributes.FamORAssem))) {
3331                                         //
3332                                         // protected ok, but other attributes differ - report an error
3333                                         //
3334                                         return false;
3335                                 }
3336                                 return true;
3337                         } else {
3338                                 return (thisp == base_classp);
3339                         }
3340                 }
3341
3342                 public bool CheckAbstractAndExtern (bool has_block)
3343                 {
3344                         if (Parent.Kind == Kind.Interface)
3345                                 return true;
3346
3347                         if (has_block) {
3348                                 if ((ModFlags & Modifiers.EXTERN) != 0) {
3349                                         Report.Error (179, Location, "`{0}' cannot declare a body because it is marked extern",
3350                                                 GetSignatureForError ());
3351                                         return false;
3352                                 }
3353
3354                                 if ((ModFlags & Modifiers.ABSTRACT) != 0) {
3355                                         Report.Error (500, Location, "`{0}' cannot declare a body because it is marked abstract",
3356                                                 GetSignatureForError ());
3357                                         return false;
3358                                 }
3359                         } else {
3360                                 if ((ModFlags & (Modifiers.ABSTRACT | Modifiers.EXTERN)) == 0) {
3361                                         Report.Error (501, Location, "`{0}' must declare a body because it is not marked abstract or extern",
3362                                                 GetSignatureForError ());
3363                                         return false;
3364                                 }
3365                         }
3366
3367                         return true;
3368                 }
3369
3370                 protected void Error_CannotChangeAccessModifiers (MemberInfo base_method, MethodAttributes ma, string suffix)
3371                 {
3372                         Report.SymbolRelatedToPreviousError (base_method);
3373                         string base_name = TypeManager.GetFullNameSignature (base_method);
3374                         string this_name = GetSignatureForError ();
3375                         if (suffix != null) {
3376                                 base_name += suffix;
3377                                 this_name += suffix;
3378                         }
3379
3380                         Report.Error (507, Location, "`{0}': cannot change access modifiers when overriding `{1}' inherited member `{2}'",
3381                                 this_name, Modifiers.GetDescription (ma), base_name);
3382                 }
3383
3384                 protected static string Error722 {
3385                         get {
3386                                 return "`{0}': static types cannot be used as return types";
3387                         }
3388                 }
3389
3390                 /// <summary>
3391                 /// For custom member duplication search in a container
3392                 /// </summary>
3393                 protected abstract bool CheckForDuplications ();
3394
3395                 /// <summary>
3396                 /// Gets base method and its return type
3397                 /// </summary>
3398                 protected abstract MethodInfo FindOutBaseMethod (TypeContainer container, ref Type base_ret_type);
3399
3400                 protected virtual bool DoDefineParameters ()
3401                 {
3402                         EmitContext ec = Parent.EmitContext;
3403                         if (ec == null)
3404                                 throw new InternalErrorException ("DoDefineParameters invoked too early");
3405
3406                         bool old_unsafe = ec.InUnsafe;
3407                         ec.InUnsafe = InUnsafe;
3408                         // Check if arguments were correct
3409                         parameter_types = Parameters.GetParameterInfo (ec);
3410                         ec.InUnsafe = old_unsafe;
3411
3412                         if ((parameter_types == null) ||
3413                             !CheckParameters (Parent, parameter_types))
3414                                 return false;
3415
3416                         parameter_info = new InternalParameters (parameter_types, Parameters);
3417
3418                         Parameter array_param = Parameters.ArrayParameter;
3419                         if ((array_param != null) &&
3420                             (!array_param.ParameterType.IsArray ||
3421                              (array_param.ParameterType.GetArrayRank () != 1))) {
3422                                 Report.Error (225, Location, "The params parameter must be a single dimensional array");
3423                                 return false;
3424                         }
3425
3426                         return true;
3427                 }
3428
3429                 public override string[] ValidAttributeTargets {
3430                         get {
3431                                 return attribute_targets;
3432                         }
3433                 }
3434
3435                 protected override bool VerifyClsCompliance (DeclSpace ds)
3436                 {
3437                         if (!base.VerifyClsCompliance (ds)) {
3438                                 if ((ModFlags & Modifiers.ABSTRACT) != 0 && IsExposedFromAssembly (ds) && ds.IsClsCompliaceRequired (ds)) {
3439                                         Report.Error (3011, Location, "`{0}': only CLS-compliant members can be abstract", GetSignatureForError ());
3440                                 }
3441                                 return false;
3442                         }
3443
3444                         if (Parameters.HasArglist) {
3445                                 Report.Error (3000, Location, "Methods with variable arguments are not CLS-compliant");
3446                         }
3447
3448                         if (!AttributeTester.IsClsCompliant (MemberType)) {
3449                                 if (this is PropertyBase)
3450                                         Report.Error (3003, Location, "Type of `{0}' is not CLS-compliant",
3451                                                       GetSignatureForError ());
3452                                 else
3453                                         Report.Error (3002, Location, "Return type of `{0}' is not CLS-compliant",
3454                                                       GetSignatureForError ());
3455                         }
3456
3457                         AttributeTester.AreParametersCompliant (Parameters.FixedParameters, Location);
3458
3459                         return true;
3460                 }
3461
3462                 protected bool IsDuplicateImplementation (MethodCore method)
3463                 {
3464                         if (method == this || !(method.MemberName.Equals (MemberName)))
3465                                 return false;
3466
3467                         Type[] param_types = method.ParameterTypes;
3468                         if (param_types == null && ParameterTypes == null)
3469                                 return true;
3470                         if (param_types == null || ParameterTypes == null)
3471                                 return false;
3472
3473                         if (param_types.Length != ParameterTypes.Length)
3474                                 return false;
3475
3476                         for (int i = 0; i < param_types.Length; i++)
3477                                 if (param_types [i] != ParameterTypes [i])
3478                                         return false;
3479
3480                         // TODO: make operator compatible with MethodCore to avoid this
3481                         if (this is Operator && method is Operator) {
3482                                 if (MemberType != method.MemberType)
3483                                         return false;
3484                         }
3485
3486                         //
3487                         // Try to report 663: method only differs on out/ref
3488                         //
3489                         ParameterData info = ParameterInfo;
3490                         ParameterData other_info = method.ParameterInfo;
3491                         for (int i = 0; i < info.Count; i++){
3492                                 if (info.ParameterModifier (i) != other_info.ParameterModifier (i)){
3493                                         Report.SymbolRelatedToPreviousError (method);
3494                                         Report.Error (663, Location, "`{0}': Methods cannot differ only on their use of ref and out on a parameters",
3495                                                 GetSignatureForError ());
3496                                         return false;
3497                                 }
3498                         }
3499
3500                         Report.SymbolRelatedToPreviousError (method);
3501                         if (this is Operator && method is Operator)
3502                                 Report.Error (557, Location, "Duplicate user-defined conversion in type `{0}'", Parent.Name);
3503                         else
3504                                 Report.Error (111, Location, TypeContainer.Error111, GetSignatureForError ());
3505                         return true;
3506                 }
3507
3508                 public override bool IsUsed {
3509                         get { return IsExplicitImpl || base.IsUsed; }
3510                 }
3511
3512                 //
3513                 // Returns a string that represents the signature for this
3514                 // member which should be used in XML documentation.
3515                 //
3516                 public override string GetDocCommentName (DeclSpace ds)
3517                 {
3518                         return DocUtil.GetMethodDocCommentName (this, ds);
3519                 }
3520
3521                 //
3522                 // Raised (and passed an XmlElement that contains the comment)
3523                 // when GenerateDocComment is writing documentation expectedly.
3524                 //
3525                 // FIXME: with a few effort, it could be done with XmlReader,
3526                 // that means removal of DOM use.
3527                 //
3528                 internal override void OnGenerateDocComment (DeclSpace ds, XmlElement el)
3529                 {
3530                         DocUtil.OnMethodGenerateDocComment (this, ds, el);
3531                 }
3532
3533                 //
3534                 //   Represents header string for documentation comment.
3535                 //
3536                 public override string DocCommentHeader {
3537                         get { return "M:"; }
3538                 }
3539
3540                 protected override void VerifyObsoleteAttribute()
3541                 {
3542                         base.VerifyObsoleteAttribute ();
3543
3544                         if (parameter_types == null)
3545                                 return;
3546
3547                         foreach (Type type in parameter_types) {
3548                                 CheckUsageOfObsoleteAttribute (type);
3549                         }
3550                 }
3551         }
3552
3553         public class SourceMethod : ISourceMethod
3554         {
3555                 TypeContainer container;
3556                 MethodBase builder;
3557
3558                 protected SourceMethod (TypeContainer container, MethodBase builder,
3559                                         ISourceFile file, Location start, Location end)
3560                 {
3561                         this.container = container;
3562                         this.builder = builder;
3563
3564                         CodeGen.SymbolWriter.OpenMethod (
3565                                 file, this, start.Row, 0, end.Row, 0);
3566                 }
3567
3568                 public string Name {
3569                         get { return builder.Name; }
3570                 }
3571
3572                 public int NamespaceID {
3573                         get { return container.NamespaceEntry.SymbolFileID; }
3574                 }
3575
3576                 public int Token {
3577                         get {
3578                                 if (builder is MethodBuilder)
3579                                         return ((MethodBuilder) builder).GetToken ().Token;
3580                                 else if (builder is ConstructorBuilder)
3581                                         return ((ConstructorBuilder) builder).GetToken ().Token;
3582                                 else
3583                                         throw new NotSupportedException ();
3584                         }
3585                 }
3586
3587                 public void CloseMethod ()
3588                 {
3589                         if (CodeGen.SymbolWriter != null)
3590                                 CodeGen.SymbolWriter.CloseMethod ();
3591                 }
3592
3593                 public static SourceMethod Create (TypeContainer parent,
3594                                                    MethodBase builder, Block block)
3595                 {
3596                         if (CodeGen.SymbolWriter == null)
3597                                 return null;
3598                         if (block == null)
3599                                 return null;
3600
3601                         Location start_loc = block.StartLocation;
3602                         if (Location.IsNull (start_loc))
3603                                 return null;
3604
3605                         Location end_loc = block.EndLocation;
3606                         if (Location.IsNull (end_loc))
3607                                 return null;
3608
3609                         ISourceFile file = start_loc.SourceFile;
3610                         if (file == null)
3611                                 return null;
3612
3613                         return new SourceMethod (
3614                                 parent, builder, file, start_loc, end_loc);
3615                 }
3616         }
3617
3618         public class Method : MethodCore, IIteratorContainer, IMethodData {
3619                 public MethodBuilder MethodBuilder;
3620                 public MethodData MethodData;
3621                 ReturnParameter return_attributes;
3622                 ListDictionary declarative_security;
3623
3624                 /// <summary>
3625                 ///   Modifiers allowed in a class declaration
3626                 /// </summary>
3627                 const int AllowedModifiers =
3628                         Modifiers.NEW |
3629                         Modifiers.PUBLIC |
3630                         Modifiers.PROTECTED |
3631                         Modifiers.INTERNAL |
3632                         Modifiers.PRIVATE |
3633                         Modifiers.STATIC |
3634                         Modifiers.VIRTUAL |
3635                         Modifiers.SEALED |
3636                         Modifiers.OVERRIDE |
3637                         Modifiers.ABSTRACT |
3638                         Modifiers.UNSAFE |
3639                         Modifiers.METHOD_YIELDS |
3640                         Modifiers.EXTERN;
3641
3642                 const int AllowedInterfaceModifiers =
3643                         Modifiers.NEW | Modifiers.UNSAFE;
3644
3645                 //
3646                 // return_type can be "null" for VOID values.
3647                 //
3648                 public Method (TypeContainer ds, Expression return_type, int mod, bool is_iface,
3649                                MemberName name, Parameters parameters, Attributes attrs,
3650                                Location l)
3651                         : base (ds, return_type, mod,
3652                                 is_iface ? AllowedInterfaceModifiers : AllowedModifiers,
3653                                 is_iface, name, attrs, parameters, l)
3654                 {
3655                 }
3656
3657                 public override AttributeTargets AttributeTargets {
3658                         get {
3659                                 return AttributeTargets.Method;
3660                         }
3661                 }
3662
3663                 public override string GetSignatureForError()
3664                 {
3665                         if (IsOperator != null)
3666                                 return IsOperator.GetSignatureForError ();
3667
3668                         return base.GetSignatureForError () + Parameters.GetSignatureForError ();
3669                 }
3670
3671                 void DuplicateEntryPoint (MethodInfo b, Location location)
3672                 {
3673                         Report.Error (
3674                                 17, location,
3675                                 "Program `" + CodeGen.FileName +
3676                                 "' has more than one entry point defined: `" +
3677                                 TypeManager.CSharpSignature(b) + "'");
3678                 }
3679
3680                 public bool IsEntryPoint (MethodBuilder b, InternalParameters pinfo)
3681                 {
3682                         if (b.ReturnType != TypeManager.void_type &&
3683                             b.ReturnType != TypeManager.int32_type)
3684                                 return false;
3685
3686                         if (pinfo.Count == 0)
3687                                 return true;
3688
3689                         if (pinfo.Count > 1)
3690                                 return false;
3691
3692                         Type t = pinfo.ParameterType(0);
3693                         if (t.IsArray &&
3694                             (t.GetArrayRank() == 1) &&
3695                             (TypeManager.GetElementType(t) == TypeManager.string_type) &&
3696                             (pinfo.ParameterModifier(0) == Parameter.Modifier.NONE))
3697                                 return true;
3698                         else
3699                                 return false;
3700                 }
3701
3702                 public override void ApplyAttributeBuilder (Attribute a, CustomAttributeBuilder cb)
3703                 {
3704                         if (a.Target == AttributeTargets.ReturnValue) {
3705                                 if (return_attributes == null)
3706                                         return_attributes = new ReturnParameter (MethodBuilder, Location);
3707
3708                                 return_attributes.ApplyAttributeBuilder (a, cb);
3709                                 return;
3710                         }
3711
3712                         if (a.Type == TypeManager.methodimpl_attr_type &&
3713                                 (a.GetMethodImplOptions () & MethodImplOptions.InternalCall) != 0) {
3714                                 MethodBuilder.SetImplementationFlags (MethodImplAttributes.InternalCall | MethodImplAttributes.Runtime);
3715                         }
3716
3717                         if (a.Type == TypeManager.dllimport_type) {
3718                                 const int extern_static = Modifiers.EXTERN | Modifiers.STATIC;
3719                                 if ((ModFlags & extern_static) != extern_static) {
3720                                         Report.Error (601, a.Location, "The DllImport attribute must be specified on a method marked `static' and `extern'");
3721                                 }
3722
3723                                 return;
3724                         }
3725
3726                         if (a.Type.IsSubclassOf (TypeManager.security_attr_type) && a.CheckSecurityActionValidity (false)) {
3727                                 if (declarative_security == null)
3728                                         declarative_security = new ListDictionary ();
3729                                 a.ExtractSecurityPermissionSet (declarative_security);
3730                                 return;
3731                         }
3732
3733                         if (a.Type == TypeManager.conditional_attribute_type) {
3734                                 if (IsOperator != null || IsExplicitImpl) {
3735                                         Report.Error (577, Location, "Conditional not valid on `{0}' because it is a constructor, destructor, operator or explicit interface implementation",
3736                                                 GetSignatureForError ());
3737                                         return;
3738                                 }
3739
3740                                 if (ReturnType != TypeManager.void_type) {
3741                                         Report.Error (578, Location, "Conditional not valid on `{0}' because its return type is not void", GetSignatureForError ());
3742                                         return;
3743                                 }
3744
3745                                 if ((ModFlags & Modifiers.OVERRIDE) != 0) {
3746                                         Report.Error (243, Location, "Conditional not valid on `{0}' because it is an override method", GetSignatureForError ());
3747                                         return;
3748                                 }
3749
3750                                 if (IsInterface) {
3751                                         Report.Error (582, Location, "Conditional not valid on interface members");
3752                                         return;
3753                                 }
3754
3755                                 if (MethodData.implementing != null) {
3756                                         Report.Error (629, Location, "Conditional member `{0}' cannot implement interface member `{1}'",
3757                                                 GetSignatureForError (), TypeManager.CSharpSignature (MethodData.implementing));
3758                                         return;
3759                                 }
3760
3761                                 for (int i = 0; i < parameter_info.Count; ++i) {
3762                                         if ((parameter_info.ParameterModifier (i) & Parameter.Modifier.OUT) != 0) {
3763                                                 Report.Error (685, Location, "Conditional method `{0}' cannot have an out parameter", GetSignatureForError ());
3764                                                 return;
3765                                         }
3766                                 }
3767                         }
3768
3769                         MethodBuilder.SetCustomAttribute (cb);
3770                 }
3771
3772                 protected override bool CheckForDuplications ()
3773                 {
3774                         ArrayList ar = Parent.Methods;
3775                         if (ar != null) {
3776                                 int arLen = ar.Count;
3777
3778                                 for (int i = 0; i < arLen; i++) {
3779                                         Method m = (Method) ar [i];
3780                                         if (IsDuplicateImplementation (m))
3781                                                 return false;
3782                                 }
3783                         }
3784
3785                         ar = Parent.Properties;
3786                         if (ar != null) {
3787                                 for (int i = 0; i < ar.Count; ++i) {
3788                                         PropertyBase pb = (PropertyBase) ar [i];
3789                                         if (pb.AreAccessorsDuplicateImplementation (this))
3790                                                 return false;
3791                                 }
3792                         }
3793
3794                         ar = Parent.Indexers;
3795                         if (ar != null) {
3796                                 for (int i = 0; i < ar.Count; ++i) {
3797                                         PropertyBase pb = (PropertyBase) ar [i];
3798                                         if (pb.AreAccessorsDuplicateImplementation (this))
3799                                                 return false;
3800                                 }
3801                         }
3802
3803                         ar = Parent.Events;
3804                         if (ar != null) {
3805                                 for (int i = 0; i < ar.Count; ++i) {
3806                                         Event ev = (Event) ar [i];
3807                                         if (ev.AreAccessorsDuplicateImplementation (this))
3808                                                 return false;
3809                                 }
3810                         }
3811
3812                         return true;
3813                 }
3814
3815                 //
3816                 // Creates the type
3817                 //
3818                 public override bool Define ()
3819                 {
3820                         if (!DoDefine ())
3821                                 return false;
3822
3823                         if (!CheckAbstractAndExtern (block != null))
3824                                 return false;
3825
3826                         if (RootContext.StdLib && (ReturnType == TypeManager.arg_iterator_type || ReturnType == TypeManager.typed_reference_type)) {
3827                                 Error1599 (Location, ReturnType);
3828                                 return false;
3829                         }
3830
3831                         if (!CheckBase ())
3832                                 return false;
3833
3834                         if (IsOperator != null)
3835                                 flags |= MethodAttributes.SpecialName | MethodAttributes.HideBySig;
3836
3837                         MethodData = new MethodData (this, ParameterInfo, ModFlags, flags, this);
3838
3839                         if (!MethodData.Define (Parent))
3840                                 return false;
3841
3842                         if (ReturnType == TypeManager.void_type && ParameterTypes.Length == 0 &&
3843                                 Name == "Finalize" && !(this is Destructor)) {
3844                                 Report.Warning (465, 1, Location, "Introducing a 'Finalize' method can interfere with destructor invocation. Did you intend to declare a destructor?");
3845                         }
3846
3847                         //
3848                         // Setup iterator if we are one
3849                         //
3850                         if ((ModFlags & Modifiers.METHOD_YIELDS) != 0){
3851                                 Iterator iterator = new Iterator (this,
3852                                         Parent,
3853                                         ParameterInfo, ModFlags);
3854
3855                                 if (!iterator.DefineIterator ())
3856                                         return false;
3857                         }
3858
3859                         MethodBuilder = MethodData.MethodBuilder;
3860
3861                         //
3862                         // This is used to track the Entry Point,
3863                         //
3864                         if (Name == "Main" &&
3865                             ((ModFlags & Modifiers.STATIC) != 0) && RootContext.NeedsEntryPoint &&
3866                             (RootContext.MainClass == null ||
3867                              RootContext.MainClass == Parent.TypeBuilder.FullName)){
3868                                 if (IsEntryPoint (MethodBuilder, ParameterInfo)) {
3869                                         IMethodData md = TypeManager.GetMethod (MethodBuilder);
3870                                         md.SetMemberIsUsed ();
3871
3872                                         if (RootContext.EntryPoint == null) {
3873                                                 RootContext.EntryPoint = MethodBuilder;
3874                                                 RootContext.EntryPointLocation = Location;
3875                                         } else {
3876                                                 DuplicateEntryPoint (RootContext.EntryPoint, RootContext.EntryPointLocation);
3877                                                 DuplicateEntryPoint (MethodBuilder, Location);
3878                                         }
3879                                 } else {
3880                                         if (RootContext.WarningLevel >= 4)
3881                                                 Report.Warning (28, Location, "`{0}' has the wrong signature to be an entry point", TypeManager.CSharpSignature(MethodBuilder));
3882                                 }
3883                         }
3884
3885                         if (MemberType.IsAbstract && MemberType.IsSealed) {
3886                                 Report.Error (722, Location, Error722, TypeManager.CSharpName (MemberType));
3887                                 return false;
3888                         }
3889
3890                         return true;
3891                 }
3892
3893                 //
3894                 // Emits the code
3895                 //
3896                 public override void Emit ()
3897                 {
3898                         MethodData.Emit (Parent, this);
3899                         base.Emit ();
3900
3901                         if (declarative_security != null) {
3902                                 foreach (DictionaryEntry de in declarative_security) {
3903                                         MethodBuilder.AddDeclarativeSecurity ((SecurityAction)de.Key, (PermissionSet)de.Value);
3904                                 }
3905                         }
3906
3907                         Block = null;
3908                         MethodData = null;
3909                 }
3910
3911                 public static void Error1599 (Location loc, Type t)
3912                 {
3913                         Report.Error (1599, loc, "Method or delegate cannot return type `{0}'", TypeManager.CSharpName (t));
3914                 }
3915
3916                 protected override MethodInfo FindOutBaseMethod (TypeContainer container, ref Type base_ret_type)
3917                 {
3918                         MethodInfo mi = (MethodInfo) container.BaseCache.FindMemberToOverride (
3919                                 container.TypeBuilder, Name, ParameterTypes, false);
3920
3921                         if (mi == null)
3922                                 return null;
3923
3924                         base_ret_type = mi.ReturnType;
3925                         return mi;
3926                 }
3927
3928                 public override bool MarkForDuplicationCheck ()
3929                 {
3930                         caching_flags |= Flags.TestMethodDuplication;
3931                         return true;
3932                 }
3933
3934                 protected override bool VerifyClsCompliance(DeclSpace ds)
3935                 {
3936                         if (!base.VerifyClsCompliance (ds))
3937                                 return false;
3938
3939                         if (parameter_types.Length > 0) {
3940                                 ArrayList al = (ArrayList)ds.MemberCache.Members [Name];
3941                                 if (al.Count > 1)
3942                                         ds.MemberCache.VerifyClsParameterConflict (al, this, MethodBuilder);
3943                         }
3944
3945                         return true;
3946                 }
3947
3948                 #region IMethodData Members
3949
3950                 public CallingConventions CallingConventions {
3951                         get {
3952                                 CallingConventions cc = Parameters.GetCallingConvention ();
3953                                 if (Parameters.HasArglist)
3954                                         block.HasVarargs = true;
3955
3956                                 if (!IsInterface)
3957                                         if ((ModFlags & Modifiers.STATIC) == 0)
3958                                                 cc |= CallingConventions.HasThis;
3959
3960                                 // FIXME: How is `ExplicitThis' used in C#?
3961
3962                                 return cc;
3963                         }
3964                 }
3965
3966                 public Type ReturnType {
3967                         get {
3968                                 return MemberType;
3969                         }
3970                 }
3971
3972                 public MemberName MethodName {
3973                         get {
3974                                 return MemberName;
3975                         }
3976                 }
3977
3978                 public new Location Location {
3979                         get {
3980                                 return base.Location;
3981                         }
3982                 }
3983
3984                 protected override bool CheckBase() {
3985                         if (!base.CheckBase ())
3986                                 return false;
3987
3988                         // TODO: Destructor should derive from MethodCore
3989                         if (base_method != null && (ModFlags & Modifiers.OVERRIDE) != 0 && Name == "Finalize" &&
3990                                 base_method.DeclaringType == TypeManager.object_type && !(this is Destructor)) {
3991                                 Report.Error (249, Location, "Do not override object.Finalize. Instead, provide a destructor");
3992                                 return false;
3993                         }
3994
3995                         return true;
3996                 }
3997
3998                 public EmitContext CreateEmitContext (TypeContainer tc, ILGenerator ig)
3999                 {
4000                         EmitContext ec = new EmitContext (
4001                                 tc, Parent, Location, ig, ReturnType, ModFlags, false);
4002
4003                         ec.CurrentIterator = tc as Iterator;
4004                         if (ec.CurrentIterator != null)
4005                                 ec.CurrentAnonymousMethod = ec.CurrentIterator.Host;
4006
4007                         return ec;
4008                 }
4009
4010                 public ObsoleteAttribute GetObsoleteAttribute ()
4011                 {
4012                         return GetObsoleteAttribute (Parent);
4013                 }
4014
4015                 /// <summary>
4016                 /// Returns true if method has conditional attribute and the conditions is not defined (method is excluded).
4017                 /// </summary>
4018                 public bool IsExcluded (EmitContext ec)
4019                 {
4020                         if ((caching_flags & Flags.Excluded_Undetected) == 0)
4021                                 return (caching_flags & Flags.Excluded) != 0;
4022
4023                         caching_flags &= ~Flags.Excluded_Undetected;
4024
4025                         if (base_method == null) {
4026                                 if (OptAttributes == null)
4027                                         return false;
4028
4029                                 Attribute[] attrs = OptAttributes.SearchMulti (TypeManager.conditional_attribute_type, ec);
4030
4031                                 if (attrs == null)
4032                                         return false;
4033
4034                                 foreach (Attribute a in attrs) {
4035                                         string condition = a.GetConditionalAttributeValue (Parent.EmitContext);
4036                                         if (RootContext.AllDefines.Contains (condition))
4037                                                 return false;
4038                                 }
4039
4040                                 caching_flags |= Flags.Excluded;
4041                                 return true;
4042                         }
4043
4044                         IMethodData md = TypeManager.GetMethod (base_method);
4045                         if (md == null) {
4046                                 if (AttributeTester.IsConditionalMethodExcluded (base_method)) {
4047                                         caching_flags |= Flags.Excluded;
4048                                         return true;
4049                                 }
4050                                 return false;
4051                         }
4052
4053                         if (md.IsExcluded (ec)) {
4054                                 caching_flags |= Flags.Excluded;
4055                                 return true;
4056                         }
4057                         return false;
4058                 }
4059
4060                 #endregion
4061         }
4062
4063         public abstract class ConstructorInitializer {
4064                 ArrayList argument_list;
4065                 protected ConstructorInfo base_constructor;
4066                 Parameters parameters;
4067                 Location loc;
4068
4069                 public ConstructorInitializer (ArrayList argument_list, Parameters parameters,
4070                                                Location loc)
4071                 {
4072                         this.argument_list = argument_list;
4073                         this.parameters = parameters;
4074                         this.loc = loc;
4075                 }
4076
4077                 public ArrayList Arguments {
4078                         get {
4079                                 return argument_list;
4080                         }
4081                 }
4082
4083                 public bool Resolve (ConstructorBuilder caller_builder, Block block, EmitContext ec)
4084                 {
4085                         Expression base_constructor_group;
4086                         Type t;
4087                         bool error = false;
4088
4089                         ec.CurrentBlock = block;
4090
4091                         if (argument_list != null){
4092                                 foreach (Argument a in argument_list){
4093                                         if (!a.Resolve (ec, loc))
4094                                                 return false;
4095                                 }
4096                         }
4097                         ec.CurrentBlock = null;
4098
4099                         if (this is ConstructorBaseInitializer) {
4100                                 if (ec.ContainerType.BaseType == null)
4101                                         return true;
4102
4103                                 t = ec.ContainerType.BaseType;
4104                                 if (ec.ContainerType.IsValueType) {
4105                                         Report.Error (522, loc,
4106                                                 "`{0}': Struct constructors cannot call base constructors", TypeManager.CSharpSignature (caller_builder));
4107                                         return false;
4108                                 }
4109                         } else
4110                                 t = ec.ContainerType;
4111
4112                         base_constructor_group = Expression.MemberLookup (
4113                                 ec, t, ".ctor", MemberTypes.Constructor,
4114                                 BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly,
4115                                 loc);
4116
4117                         if (base_constructor_group == null){
4118                                 error = true;
4119                                 base_constructor_group = Expression.MemberLookup (
4120                                         ec, t, null, t, ".ctor", MemberTypes.Constructor,
4121                                         BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly,
4122                                         loc);
4123                         }
4124
4125                         int errors = Report.Errors;
4126                         if (base_constructor_group != null)
4127                                 base_constructor = (ConstructorInfo) Invocation.OverloadResolve (
4128                                         ec, (MethodGroupExpr) base_constructor_group, argument_list,
4129                                         false, loc);
4130
4131                         if (base_constructor == null) {
4132                                 if (errors == Report.Errors)
4133                                         Invocation.Error_WrongNumArguments (loc, TypeManager.CSharpSignature (caller_builder),
4134                                                 argument_list.Count);
4135                                 return false;
4136                         }
4137
4138                         if (error) {
4139                                 Expression.ErrorIsInaccesible (loc, TypeManager.CSharpSignature (base_constructor));
4140                                 base_constructor = null;
4141                                 return false;
4142                         }
4143
4144                         if (base_constructor == caller_builder){
4145                                 Report.Error (516, loc, "Constructor `{0}' cannot call itself", TypeManager.CSharpSignature (caller_builder));
4146                                 return false;
4147                         }
4148
4149                         return true;
4150                 }
4151
4152                 public void Emit (EmitContext ec)
4153                 {
4154                         if (base_constructor != null){
4155                                 ec.Mark (loc, false);
4156                                 if (ec.IsStatic)
4157                                         Invocation.EmitCall (ec, true, true, null, base_constructor, argument_list, loc);
4158                                 else
4159                                         Invocation.EmitCall (ec, true, false, ec.GetThis (loc), base_constructor, argument_list, loc);
4160                         }
4161                 }
4162         }
4163
4164         public class ConstructorBaseInitializer : ConstructorInitializer {
4165                 public ConstructorBaseInitializer (ArrayList argument_list, Parameters pars, Location l) :
4166                         base (argument_list, pars, l)
4167                 {
4168                 }
4169         }
4170
4171         public class ConstructorThisInitializer : ConstructorInitializer {
4172                 public ConstructorThisInitializer (ArrayList argument_list, Parameters pars, Location l) :
4173                         base (argument_list, pars, l)
4174                 {
4175                 }
4176         }
4177
4178         public class Constructor : MethodCore, IMethodData {
4179                 public ConstructorBuilder ConstructorBuilder;
4180                 public ConstructorInitializer Initializer;
4181                 ListDictionary declarative_security;
4182
4183                 // <summary>
4184                 //   Modifiers allowed for a constructor.
4185                 // </summary>
4186                 public const int AllowedModifiers =
4187                         Modifiers.PUBLIC |
4188                         Modifiers.PROTECTED |
4189                         Modifiers.INTERNAL |
4190                         Modifiers.STATIC |
4191                         Modifiers.UNSAFE |
4192                         Modifiers.EXTERN |
4193                         Modifiers.PRIVATE;
4194
4195                 bool has_compliant_args = false;
4196                 //
4197                 // The spec claims that static is not permitted, but
4198                 // my very own code has static constructors.
4199                 //
4200                 public Constructor (TypeContainer ds, string name, int mod, Parameters args,
4201                                     ConstructorInitializer init, Location l)
4202                         : base (ds, null, mod, AllowedModifiers, false, new MemberName (name),
4203                                 null, args, l)
4204                 {
4205                         Initializer = init;
4206                 }
4207
4208                 public bool HasCompliantArgs {
4209                         get {
4210                                 return has_compliant_args;
4211                         }
4212                 }
4213
4214                 public override AttributeTargets AttributeTargets {
4215                         get {
4216                                 return AttributeTargets.Constructor;
4217                         }
4218                 }
4219
4220
4221                 //
4222                 // Returns true if this is a default constructor
4223                 //
4224                 public bool IsDefault ()
4225                 {
4226                         if ((ModFlags & Modifiers.STATIC) != 0)
4227                                 return  (Parameters.FixedParameters == null ? true : Parameters.Empty) &&
4228                                         (Parameters.ArrayParameter == null ? true : Parameters.Empty);
4229
4230                         else
4231                                 return  (Parameters.FixedParameters == null ? true : Parameters.Empty) &&
4232                                         (Parameters.ArrayParameter == null ? true : Parameters.Empty) &&
4233                                         (Initializer is ConstructorBaseInitializer) &&
4234                                         (Initializer.Arguments == null);
4235                 }
4236
4237                 public override void ApplyAttributeBuilder (Attribute a, CustomAttributeBuilder cb)
4238                 {
4239                         if (a.Type.IsSubclassOf (TypeManager.security_attr_type) && a.CheckSecurityActionValidity (false)) {
4240                                 if (declarative_security == null) {
4241                                         declarative_security = new ListDictionary ();
4242                                 }
4243                                 a.ExtractSecurityPermissionSet (declarative_security);
4244                                 return;
4245                         }
4246
4247                         ConstructorBuilder.SetCustomAttribute (cb);
4248                 }
4249
4250                 protected override bool CheckForDuplications ()
4251                 {
4252                         ArrayList ar = Parent.InstanceConstructors;
4253                         if (ar != null) {
4254                                 int arLen = ar.Count;
4255
4256                                 for (int i = 0; i < arLen; i++) {
4257                                         Constructor m = (Constructor) ar [i];
4258                                         if (IsDuplicateImplementation (m))
4259                                                 return false;
4260                                 }
4261                         }
4262                         return true;
4263                 }
4264
4265                 protected override bool CheckBase ()
4266                 {
4267                         // Check whether arguments were correct.
4268                         if (!DoDefineParameters ())
4269                                 return false;
4270
4271                         // TODO: skip the rest for generated ctor
4272                         if ((ModFlags & Modifiers.STATIC) != 0)
4273                                 return true;
4274
4275                         if (!CheckForDuplications ())
4276                                 return false;
4277
4278                         if (Parent.Kind == Kind.Struct) {
4279                                 if (ParameterTypes.Length == 0) {
4280                                         Report.Error (568, Location,
4281                                                 "Structs cannot contain explicit parameterless constructors");
4282                                         return false;
4283                                 }
4284
4285                                 if ((ModFlags & Modifiers.PROTECTED) != 0) {
4286                                         Report.Error (666, Location, "`{0}': new protected member declared in struct", GetSignatureForError ());
4287                                         return false;
4288                                 }
4289                         }
4290
4291                         if ((RootContext.WarningLevel >= 4) && ((Parent.ModFlags & Modifiers.SEALED) != 0 && (ModFlags & Modifiers.PROTECTED) != 0)) {
4292                                 Report.Warning (628, Location, "`{0}': new protected member declared in sealed class", GetSignatureForError ());
4293                         }
4294
4295                         return true;
4296                 }
4297
4298                 //
4299                 // Creates the ConstructorBuilder
4300                 //
4301                 public override bool Define ()
4302                 {
4303                         if (ConstructorBuilder != null)
4304                                 return true;
4305
4306                         MethodAttributes ca = (MethodAttributes.RTSpecialName |
4307                                                MethodAttributes.SpecialName);
4308
4309                         if ((ModFlags & Modifiers.STATIC) != 0) {
4310                                 ca |= MethodAttributes.Static | MethodAttributes.Private;
4311                         } else {
4312                                 ca |= MethodAttributes.HideBySig;
4313
4314                                 if ((ModFlags & Modifiers.PUBLIC) != 0)
4315                                         ca |= MethodAttributes.Public;
4316                                 else if ((ModFlags & Modifiers.PROTECTED) != 0){
4317                                         if ((ModFlags & Modifiers.INTERNAL) != 0)
4318                                                 ca |= MethodAttributes.FamORAssem;
4319                                         else
4320                                                 ca |= MethodAttributes.Family;
4321                                 } else if ((ModFlags & Modifiers.INTERNAL) != 0)
4322                                         ca |= MethodAttributes.Assembly;
4323                                 else if (IsDefault ())
4324                                         ca |= MethodAttributes.Public;
4325                                 else
4326                                         ca |= MethodAttributes.Private;
4327                         }
4328
4329                         if (!CheckAbstractAndExtern (block != null))
4330                                 return false;
4331
4332                         // Check if arguments were correct.
4333                         if (!CheckBase ())
4334                                 return false;
4335
4336                         ConstructorBuilder = Parent.TypeBuilder.DefineConstructor (
4337                                 ca, CallingConventions,
4338                                 ParameterTypes);
4339
4340                         if ((ModFlags & Modifiers.UNSAFE) != 0)
4341                                 ConstructorBuilder.InitLocals = false;
4342
4343                         TypeManager.AddMethod (ConstructorBuilder, this);
4344
4345                         //
4346                         // HACK because System.Reflection.Emit is lame
4347                         //
4348                         TypeManager.RegisterMethod (ConstructorBuilder, ParameterInfo, ParameterTypes);
4349
4350                         return true;
4351                 }
4352
4353                 //
4354                 // Emits the code
4355                 //
4356                 public override void Emit ()
4357                 {
4358                         EmitContext ec = CreateEmitContext (null, null);
4359
4360                         // If this is a non-static `struct' constructor and doesn't have any
4361                         // initializer, it must initialize all of the struct's fields.
4362                         if ((Parent.Kind == Kind.Struct) &&
4363                             ((ModFlags & Modifiers.STATIC) == 0) && (Initializer == null))
4364                                 Block.AddThisVariable (Parent, Location);
4365
4366                         if (block != null)
4367                                 block.ResolveMeta (ec, ParameterInfo);
4368
4369                         if ((ModFlags & Modifiers.STATIC) == 0){
4370                                 if (Parent.Kind == Kind.Class && Initializer == null)
4371                                         Initializer = new ConstructorBaseInitializer (
4372                                                 null, Parameters.EmptyReadOnlyParameters, Location);
4373
4374
4375                                 //
4376                                 // Spec mandates that Initializers will not have
4377                                 // `this' access
4378                                 //
4379                                 ec.IsStatic = true;
4380                                 if ((Initializer != null) &&
4381                                     !Initializer.Resolve (ConstructorBuilder, block, ec))
4382                                         return;
4383                                 ec.IsStatic = false;
4384                         }
4385
4386                         Parameters.LabelParameters (ec, ConstructorBuilder);
4387
4388                         SourceMethod source = SourceMethod.Create (
4389                                 Parent, ConstructorBuilder, block);
4390
4391                         //
4392                         // Classes can have base initializers and instance field initializers.
4393                         //
4394                         if (Parent.Kind == Kind.Class){
4395                                 if ((ModFlags & Modifiers.STATIC) == 0){
4396
4397                                         //
4398                                         // If we use a "this (...)" constructor initializer, then
4399                                         // do not emit field initializers, they are initialized in the other constructor
4400                                         //
4401                                         if (!(Initializer != null && Initializer is ConstructorThisInitializer))
4402                                                 Parent.EmitFieldInitializers (ec);
4403                                 }
4404                         }
4405                         if (Initializer != null) {
4406                                 if (GetObsoleteAttribute () != null || Parent.GetObsoleteAttribute (Parent) != null)
4407                                         ec.TestObsoleteMethodUsage = false;
4408
4409                                 Initializer.Emit (ec);
4410                         }
4411
4412                         if ((ModFlags & Modifiers.STATIC) != 0)
4413                                 Parent.EmitFieldInitializers (ec);
4414
4415                         if (OptAttributes != null)
4416                                 OptAttributes.Emit (ec, this);
4417
4418                         ec.EmitTopBlock (this, block, ParameterInfo);
4419
4420                         if (source != null)
4421                                 source.CloseMethod ();
4422
4423                         base.Emit ();
4424
4425                         if (declarative_security != null) {
4426                                 foreach (DictionaryEntry de in declarative_security) {
4427                                         ConstructorBuilder.AddDeclarativeSecurity ((SecurityAction)de.Key, (PermissionSet)de.Value);
4428                                 }
4429                         }
4430
4431                         block = null;
4432                 }
4433
4434                 // Is never override
4435                 protected override MethodInfo FindOutBaseMethod (TypeContainer container, ref Type base_ret_type)
4436                 {
4437                         return null;
4438                 }
4439
4440                 public override string GetSignatureForError()
4441                 {
4442                         return base.GetSignatureForError () + Parameters.GetSignatureForError ();
4443                 }
4444
4445                 protected override bool VerifyClsCompliance (DeclSpace ds)
4446                 {
4447                         if (!base.VerifyClsCompliance (ds) || !IsExposedFromAssembly (ds)) {
4448                                 return false;
4449                         }
4450
4451                         if (parameter_types.Length > 0) {
4452                                 ArrayList al = (ArrayList)ds.MemberCache.Members [".ctor"];
4453                                 if (al.Count > 3)
4454                                         ds.MemberCache.VerifyClsParameterConflict (al, this, ConstructorBuilder);
4455
4456                                 if (ds.TypeBuilder.IsSubclassOf (TypeManager.attribute_type)) {
4457                                         foreach (Type param in parameter_types) {
4458                                                 if (param.IsArray) {
4459                                                         return true;
4460                                                 }
4461                                         }
4462                                 }
4463                         }
4464                         has_compliant_args = true;
4465                         return true;
4466                 }
4467
4468                 #region IMethodData Members
4469
4470                 public System.Reflection.CallingConventions CallingConventions {
4471                         get {
4472                                 CallingConventions cc = Parameters.GetCallingConvention ();
4473
4474                                 if (Parent.Kind == Kind.Class)
4475                                         if ((ModFlags & Modifiers.STATIC) == 0)
4476                                                 cc |= CallingConventions.HasThis;
4477
4478                                 // FIXME: How is `ExplicitThis' used in C#?
4479
4480                                 return cc;
4481                         }
4482                 }
4483
4484                 public new Location Location {
4485                         get {
4486                                 return base.Location;
4487                         }
4488                 }
4489
4490                 public MemberName MethodName {
4491                         get {
4492                                 return MemberName;
4493                         }
4494                 }
4495
4496                 public Type ReturnType {
4497                         get {
4498                                 return MemberType;
4499                         }
4500                 }
4501
4502                 public EmitContext CreateEmitContext (TypeContainer tc, ILGenerator ig)
4503                 {
4504                         ILGenerator ig_ = ConstructorBuilder.GetILGenerator ();
4505                         return new EmitContext (Parent, Location, ig_, null, ModFlags, true);
4506                 }
4507
4508                 public ObsoleteAttribute GetObsoleteAttribute ()
4509                 {
4510                         return GetObsoleteAttribute (Parent);
4511                 }
4512
4513                 public bool IsExcluded(EmitContext ec)
4514                 {
4515                         return false;
4516                 }
4517
4518                 #endregion
4519         }
4520
4521         /// <summary>
4522         /// Interface for MethodData class. Holds links to parent members to avoid member duplication.
4523         /// </summary>
4524         public interface IMethodData
4525         {
4526                 CallingConventions CallingConventions { get; }
4527                 Location Location { get; }
4528                 MemberName MethodName { get; }
4529                 Type[] ParameterTypes { get; }
4530                 Type ReturnType { get; }
4531
4532                 Attributes OptAttributes { get; }
4533                 ToplevelBlock Block { get; set; }
4534
4535                 EmitContext CreateEmitContext (TypeContainer tc, ILGenerator ig);
4536                 ObsoleteAttribute GetObsoleteAttribute ();
4537                 string GetSignatureForError ();
4538                 bool IsExcluded (EmitContext ec);
4539                 bool IsClsCompliaceRequired (DeclSpace ds);
4540                 void SetMemberIsUsed ();
4541         }
4542
4543         //
4544         // Encapsulates most of the Method's state
4545         //
4546         public class MethodData {
4547
4548                 readonly IMethodData method;
4549
4550                 //
4551                 // The return type of this method
4552                 //
4553                 public readonly InternalParameters ParameterInfo;
4554
4555                 //
4556                 // Are we implementing an interface ?
4557                 //
4558                 public MethodInfo implementing;
4559
4560                 //
4561                 // Protected data.
4562                 //
4563                 protected MemberBase member;
4564                 protected int modifiers;
4565                 protected MethodAttributes flags;
4566
4567                 MethodBuilder builder = null;
4568                 public MethodBuilder MethodBuilder {
4569                         get {
4570                                 return builder;
4571                         }
4572                 }
4573
4574                 public MethodData (MemberBase member, InternalParameters parameters,
4575                                    int modifiers, MethodAttributes flags, IMethodData method)
4576                 {
4577                         this.member = member;
4578                         this.ParameterInfo = parameters;
4579                         this.modifiers = modifiers;
4580                         this.flags = flags;
4581
4582                         this.method = method;
4583                 }
4584
4585                 public bool Define (TypeContainer container)
4586                 {
4587                         string name = method.MethodName.Name;
4588                         string method_name = name;
4589
4590                         Type[] ParameterTypes = method.ParameterTypes;
4591
4592                         if (container.Pending != null){
4593                                 if (member is Indexer) // TODO: test it, but it should work without this IF
4594                                         implementing = container.Pending.IsInterfaceIndexer (
4595                                                 member.InterfaceType, method.ReturnType, ParameterInfo);
4596                                 else
4597                                         implementing = container.Pending.IsInterfaceMethod (
4598                                                 member.InterfaceType, name, method.ReturnType, ParameterInfo);
4599
4600                                 if (member.InterfaceType != null){
4601                                         if (implementing == null){
4602                                                 if (member is PropertyBase) {
4603                                                         Report.Error (550, method.Location, "`{0}' is an accessor not found in interface member `{1}{2}'",
4604                                                                 method.GetSignatureForError (), TypeManager.CSharpName (member.InterfaceType),
4605                                                                 member.GetSignatureForError ().Substring (member.GetSignatureForError ().LastIndexOf ('.')));
4606
4607                                                 } else {
4608                                                         Report.Error (539, method.Location,
4609                                                                 "`{0}.{1}' in explicit interface declaration is not a member of interface",
4610                                                                 TypeManager.CSharpName (member.InterfaceType), member.ShortName);
4611                                                 }
4612                                                 return false;
4613                                         }
4614                                         if (implementing.IsSpecialName && !((member is PropertyBase || member is EventProperty))) {
4615                                                 Report.SymbolRelatedToPreviousError (implementing);
4616                                                 Report.Error (683, method.Location, "`{0}' explicit method implementation cannot implement `{1}' because it is an accessor",
4617                                                         member.GetSignatureForError (), TypeManager.CSharpSignature (implementing));
4618                                                 return false;
4619                                         }
4620                                         method_name = member.InterfaceType.FullName + "." + name;
4621                                 } else {
4622                                         if (implementing != null && method is AbstractPropertyEventMethod && !implementing.IsSpecialName) {
4623                                                 Report.SymbolRelatedToPreviousError (implementing);
4624                                                 Report.Error (686, method.Location, "Accessor `{0}' cannot implement interface member `{1}' for type `{2}'. Use an explicit interface implementation",
4625                                                         method.GetSignatureForError (), TypeManager.CSharpSignature (implementing), container.GetSignatureForError ());
4626                                                 return false;
4627                                         }
4628                                 }
4629                         }
4630
4631                         //
4632                         // For implicit implementations, make sure we are public, for
4633                         // explicit implementations, make sure we are private.
4634                         //
4635                         if (implementing != null){
4636                                 //
4637                                 // Setting null inside this block will trigger a more
4638                                 // verbose error reporting for missing interface implementations
4639                                 //
4640                                 // The "candidate" function has been flagged already
4641                                 // but it wont get cleared
4642                                 //
4643                                 if (member.IsExplicitImpl){
4644                                         if ((modifiers & (Modifiers.PUBLIC | Modifiers.ABSTRACT | Modifiers.VIRTUAL)) != 0){
4645                                                 Modifiers.Error_InvalidModifier (method.Location, "public, virtual or abstract");
4646                                                 implementing = null;
4647                                         }
4648                                 } else if ((flags & MethodAttributes.MemberAccessMask) != MethodAttributes.Public){
4649                                         if (TypeManager.IsInterfaceType (implementing.DeclaringType)){
4650                                                 //
4651                                                 // If this is an interface method implementation,
4652                                                 // check for public accessibility
4653                                                 //
4654                                                 implementing = null;
4655                                         } else if ((flags & MethodAttributes.MemberAccessMask) == MethodAttributes.Private){
4656                                                 // We may never be private.
4657                                                 implementing = null;
4658                                         } else if ((modifiers & Modifiers.OVERRIDE) == 0){
4659                                                 //
4660                                                 // We may be protected if we're overriding something.
4661                                                 //
4662                                                 implementing = null;
4663                                         }
4664                                 }
4665
4666                                 //
4667                                 // Static is not allowed
4668                                 //
4669                                 if ((modifiers & Modifiers.STATIC) != 0){
4670                                         implementing = null;
4671                                         Modifiers.Error_InvalidModifier (method.Location, "static");
4672                                 }
4673                         }
4674
4675                         //
4676                         // If implementing is still valid, set flags
4677                         //
4678                         if (implementing != null){
4679                                 //
4680                                 // When implementing interface methods, set NewSlot
4681                                 // unless, we are overwriting a method.
4682                                 //
4683                                 if (implementing.DeclaringType.IsInterface){
4684                                         if ((modifiers & Modifiers.OVERRIDE) == 0)
4685                                                 flags |= MethodAttributes.NewSlot;
4686                                 }
4687                                 flags |=
4688                                         MethodAttributes.Virtual |
4689                                         MethodAttributes.HideBySig;
4690
4691                                 // Set Final unless we're virtual, abstract or already overriding a method.
4692                                 if ((modifiers & (Modifiers.VIRTUAL | Modifiers.ABSTRACT | Modifiers.OVERRIDE)) == 0)
4693                                         flags |= MethodAttributes.Final;
4694                         }
4695
4696                         EmitContext ec = method.CreateEmitContext (container, null);
4697
4698                         DefineMethodBuilder (ec, container, method_name, ParameterTypes);
4699
4700                         if (builder == null)
4701                                 return false;
4702
4703                         if ((modifiers & Modifiers.UNSAFE) != 0)
4704                                 builder.InitLocals = false;
4705
4706                         if (implementing != null){
4707                                 //
4708                                 // clear the pending implemntation flag
4709                                 //
4710                                 if (member is Indexer) {
4711                                         container.Pending.ImplementIndexer (
4712                                                 member.InterfaceType, builder, method.ReturnType,
4713                                                 ParameterInfo, member.IsExplicitImpl);
4714                                 } else
4715                                         container.Pending.ImplementMethod (
4716                                                 member.InterfaceType, name, method.ReturnType,
4717                                                 ParameterInfo, member.IsExplicitImpl);
4718
4719                                 if (member.IsExplicitImpl)
4720                                         container.TypeBuilder.DefineMethodOverride (
4721                                                 builder, implementing);
4722
4723                         }
4724
4725                         TypeManager.RegisterMethod (builder, ParameterInfo, ParameterTypes);
4726                         TypeManager.AddMethod (builder, method);
4727
4728                         return true;
4729                 }
4730
4731
4732                 /// <summary>
4733                 /// Create the MethodBuilder for the method
4734                 /// </summary>
4735                 void DefineMethodBuilder (EmitContext ec, TypeContainer container, string method_name, Type[] ParameterTypes)
4736                 {
4737                         const int extern_static = Modifiers.EXTERN | Modifiers.STATIC;
4738
4739                         if ((modifiers & extern_static) == extern_static) {
4740
4741                                 if (method.OptAttributes != null) {
4742                                         Attribute dllimport_attribute = method.OptAttributes.Search (TypeManager.dllimport_type, ec);
4743                                         if (dllimport_attribute != null) {
4744                                                 flags |= MethodAttributes.PinvokeImpl;
4745                                                 builder = dllimport_attribute.DefinePInvokeMethod (
4746                                                         ec, container.TypeBuilder, method_name, flags,
4747                                                         method.ReturnType, ParameterTypes);
4748
4749                                                 return;
4750                                         }
4751                                 }
4752
4753                                 // for extern static method must be specified either DllImport attribute or MethodImplAttribute.
4754                                 // We are more strict than Microsoft and report CS0626 like error
4755                                 if (method.OptAttributes == null ||
4756                                         !method.OptAttributes.Contains (TypeManager.methodimpl_attr_type, ec)) {
4757                                         Report.Error (626, method.Location, "Method, operator, or accessor `{0}' is marked external and has no attributes on it. Consider adding a DllImport attribute to specify the external implementation",
4758                                                 method.GetSignatureForError ());
4759                                         return;
4760                                 }
4761                         }
4762
4763                         builder = container.TypeBuilder.DefineMethod (
4764                                 method_name, flags, method.CallingConventions,
4765                                 method.ReturnType, ParameterTypes);
4766                 }
4767
4768                 //
4769                 // Emits the code
4770                 //
4771                 public void Emit (TypeContainer container, Attributable kind)
4772                 {
4773                         EmitContext ec;
4774                         if ((flags & MethodAttributes.PinvokeImpl) == 0)
4775                                 ec = method.CreateEmitContext (container, builder.GetILGenerator ());
4776                         else
4777                                 ec = method.CreateEmitContext (container, null);
4778
4779                         if (method.GetObsoleteAttribute () != null || container.GetObsoleteAttribute (container) != null)
4780                                 ec.TestObsoleteMethodUsage = false;
4781
4782                         Attributes OptAttributes = method.OptAttributes;
4783
4784                         if (OptAttributes != null)
4785                                 OptAttributes.Emit (ec, kind);
4786
4787                         if (member is MethodCore)
4788                                 ((MethodCore) member).Parameters.LabelParameters (ec, MethodBuilder);
4789
4790                         ToplevelBlock block = method.Block;
4791
4792                         SourceMethod source = SourceMethod.Create (
4793                                 container, MethodBuilder, method.Block);
4794
4795                         //
4796                         // Handle destructors specially
4797                         //
4798                         // FIXME: This code generates buggy code
4799                         //
4800                         if (member is Destructor)
4801                                 EmitDestructor (ec, block);
4802                         else
4803                                 ec.EmitTopBlock (method, block, ParameterInfo);
4804
4805                         if (source != null)
4806                                 source.CloseMethod ();
4807                 }
4808
4809                 void EmitDestructor (EmitContext ec, ToplevelBlock block)
4810                 {
4811                         ILGenerator ig = ec.ig;
4812
4813                         Label finish = ig.DefineLabel ();
4814
4815                         block.SetDestructor ();
4816
4817                         ig.BeginExceptionBlock ();
4818                         ec.ReturnLabel = finish;
4819                         ec.HasReturnLabel = true;
4820                         ec.EmitTopBlock (method, block, null);
4821
4822                         // ig.MarkLabel (finish);
4823                         ig.BeginFinallyBlock ();
4824
4825                         if (ec.ContainerType.BaseType != null) {
4826                                 Expression member_lookup = Expression.MemberLookup (
4827                                         ec, ec.ContainerType.BaseType, null, ec.ContainerType.BaseType,
4828                                         "Finalize", MemberTypes.Method, Expression.AllBindingFlags, method.Location);
4829
4830                                 if (member_lookup != null){
4831                                         MethodGroupExpr base_destructor = ((MethodGroupExpr) member_lookup);
4832
4833                                         ig.Emit (OpCodes.Ldarg_0);
4834                                         ig.Emit (OpCodes.Call, (MethodInfo) base_destructor.Methods [0]);
4835                                 }
4836                         }
4837
4838                         ig.EndExceptionBlock ();
4839                         //ig.MarkLabel (ec.ReturnLabel);
4840                         ig.Emit (OpCodes.Ret);
4841                 }
4842         }
4843
4844         // TODO: Should derive from MethodCore
4845         public class Destructor : Method {
4846
4847                 public Destructor (TypeContainer ds, Expression return_type, int mod,
4848                                    string name, Parameters parameters, Attributes attrs,
4849                                    Location l)
4850                         : base (ds, return_type, mod, false, new MemberName (name),
4851                                 parameters, attrs, l)
4852                 { }
4853
4854                 public override void ApplyAttributeBuilder(Attribute a, CustomAttributeBuilder cb)
4855                 {
4856                         if (a.Type == TypeManager.conditional_attribute_type) {
4857                                 Report.Error (577, Location, "Conditional not valid on `{0}' because it is a constructor, destructor, operator or explicit interface implementation",
4858                                         GetSignatureForError ());
4859                                 return;
4860                         }
4861
4862                         base.ApplyAttributeBuilder (a, cb);
4863                 }
4864
4865                 public override string GetSignatureForError ()
4866                 {
4867                         return Parent.GetSignatureForError () + ".~" + Parent.MemberName.Name + "()";
4868                 }
4869
4870         }
4871
4872         abstract public class MemberBase : MemberCore {
4873                 public Expression Type;
4874
4875                 public MethodAttributes flags;
4876
4877                 protected readonly int explicit_mod_flags;
4878
4879                 //
4880                 // The "short" name of this property / indexer / event.  This is the
4881                 // name without the explicit interface.
4882                 //
4883                 public string ShortName {
4884                         get { return MemberName.Name; }
4885                         set {
4886                                 SetMemberName (new MemberName (MemberName.Left, value));
4887                         }
4888                 }
4889
4890                 //
4891                 // The type of this property / indexer / event
4892                 //
4893                 Type member_type;
4894                 public Type MemberType {
4895                         get {
4896                                 if (member_type == null && Type != null) {
4897                                         EmitContext ec = Parent.EmitContext;
4898                                         bool old_unsafe = ec.InUnsafe;
4899                                         ec.InUnsafe = InUnsafe;
4900                                         Type = Type.ResolveAsTypeTerminal (ec, false);
4901                                         ec.InUnsafe = old_unsafe;
4902
4903                                         member_type = Type == null ? null : Type.Type;
4904                                 }
4905                                 return member_type;
4906                         }
4907                 }
4908
4909                 //
4910                 // Whether this is an interface member.
4911                 //
4912                 public bool IsInterface;
4913
4914                 //
4915                 // If true, this is an explicit interface implementation
4916                 //
4917                 public bool IsExplicitImpl;
4918
4919                 //
4920                 // The interface type we are explicitly implementing
4921                 //
4922                 public Type InterfaceType = null;
4923
4924                 //
4925                 // The constructor is only exposed to our children
4926                 //
4927                 protected MemberBase (TypeContainer parent, Expression type, int mod,
4928                                       int allowed_mod, int def_mod, MemberName name,
4929                                       Attributes attrs, Location loc)
4930                         : base (parent, name, attrs, loc)
4931                 {
4932                         explicit_mod_flags = mod;
4933                         Type = type;
4934                         ModFlags = Modifiers.Check (allowed_mod, mod, def_mod, loc);
4935                         IsExplicitImpl = (MemberName.Left != null);
4936                 }
4937
4938                 protected virtual bool CheckBase ()
4939                 {
4940                         if ((ModFlags & Modifiers.PROTECTED) != 0 && Parent.Kind == Kind.Struct) {
4941                                 Report.Error (666, Location, "`{0}': new protected member declared in struct", GetSignatureForError ());
4942                                 return false;
4943                         }
4944
4945                         if ((RootContext.WarningLevel >= 4) &&
4946                             ((Parent.ModFlags & Modifiers.SEALED) != 0) &&
4947                             ((ModFlags & Modifiers.PROTECTED) != 0) &&
4948                             ((ModFlags & Modifiers.OVERRIDE) == 0) && (Name != "Finalize")) {
4949                                 Report.Warning (628, Location, "`{0}': new protected member declared in sealed class", GetSignatureForError ());
4950                         }
4951                         return true;
4952                 }
4953
4954                 protected virtual bool CheckParameters (DeclSpace ds, Type [] parameters)
4955                 {
4956                         bool error = false;
4957
4958                         foreach (Type partype in parameters){
4959                                 if (partype == TypeManager.void_type) {
4960                                         Report.Error (
4961                                                 1547, Location, "Keyword 'void' cannot " +
4962                                                 "be used in this context");
4963                                         return false;
4964                                 }
4965
4966                                 if (partype.IsPointer){
4967                                         if (!UnsafeOK (ds))
4968                                                 error = true;
4969                                         if (!TypeManager.VerifyUnManaged (TypeManager.GetElementType (partype), Location))
4970                                                 error = true;
4971                                 }
4972
4973                                 if (ds.AsAccessible (partype, ModFlags))
4974                                         continue;
4975
4976                                 if (this is Indexer)
4977                                         Report.Error (55, Location,
4978                                                       "Inconsistent accessibility: parameter type `" +
4979                                                       TypeManager.CSharpName (partype) + "' is less " +
4980                                                       "accessible than indexer `" + GetSignatureForError () + "'");
4981                                 else if ((this is Method) && ((Method) this).IsOperator != null)
4982                                         Report.Error (57, Location,
4983                                                       "Inconsistent accessibility: parameter type `" +
4984                                                       TypeManager.CSharpName (partype) + "' is less " +
4985                                                       "accessible than operator `" + GetSignatureForError () + "'");
4986                                 else
4987                                         Report.Error (51, Location,
4988                                                       "Inconsistent accessibility: parameter type `" +
4989                                                       TypeManager.CSharpName (partype) + "' is less " +
4990                                                       "accessible than method `" + GetSignatureForError () + "'");
4991                                 error = true;
4992                         }
4993
4994                         return !error;
4995                 }
4996
4997                 protected virtual bool DoDefine ()
4998                 {
4999                         EmitContext ec = Parent.EmitContext;
5000                         if (ec == null)
5001                                 throw new InternalErrorException ("MemberBase.DoDefine called too early");
5002
5003                         if (Name == null)
5004                                 throw new InternalErrorException ();
5005
5006                         if (IsInterface) {
5007                                 ModFlags = Modifiers.PUBLIC |
5008                                         Modifiers.ABSTRACT |
5009                                         Modifiers.VIRTUAL | (ModFlags & Modifiers.UNSAFE) | (ModFlags & Modifiers.NEW);
5010
5011                                 flags = MethodAttributes.Public |
5012                                         MethodAttributes.Abstract |
5013                                         MethodAttributes.HideBySig |
5014                                         MethodAttributes.NewSlot |
5015                                         MethodAttributes.Virtual;
5016                         } else {
5017                                 if (!Parent.MethodModifiersValid (this))
5018                                         return false;
5019
5020                                 flags = Modifiers.MethodAttr (ModFlags);
5021                         }
5022
5023                         if (MemberType == null)
5024                                 return false;
5025
5026                         if ((Parent.ModFlags & Modifiers.SEALED) != 0 &&
5027                                 (ModFlags & (Modifiers.VIRTUAL|Modifiers.ABSTRACT)) != 0) {
5028                                         Report.Error (549, Location, "New virtual member `{0}' is declared in a sealed class `{1}'",
5029                                                 GetSignatureForError (), Parent.GetSignatureForError ());
5030                                         return false;
5031                         }
5032
5033                         // verify accessibility
5034                         if (!Parent.AsAccessible (MemberType, ModFlags)) {
5035                                 Report.SymbolRelatedToPreviousError (MemberType);
5036                                 if (this is Property)
5037                                         Report.Error (53, Location,
5038                                                       "Inconsistent accessibility: property type `" +
5039                                                       TypeManager.CSharpName (MemberType) + "' is less " +
5040                                                       "accessible than property `" + GetSignatureForError () + "'");
5041                                 else if (this is Indexer)
5042                                         Report.Error (54, Location,
5043                                                       "Inconsistent accessibility: indexer return type `" +
5044                                                       TypeManager.CSharpName (MemberType) + "' is less " +
5045                                                       "accessible than indexer `" + GetSignatureForError () + "'");
5046                                 else if (this is MethodCore) {
5047                                         if (this is Operator)
5048                                                 Report.Error (56, Location,
5049                                                               "Inconsistent accessibility: return type `" +
5050                                                               TypeManager.CSharpName (MemberType) + "' is less " +
5051                                                               "accessible than operator `" + GetSignatureForError () + "'");
5052                                         else
5053                                                 Report.Error (50, Location,
5054                                                               "Inconsistent accessibility: return type `" +
5055                                                               TypeManager.CSharpName (MemberType) + "' is less " +
5056                                                               "accessible than method `" + GetSignatureForError () + "'");
5057                                 } else {
5058                                         Report.Error (52, Location,
5059                                                       "Inconsistent accessibility: field type `" +
5060                                                       TypeManager.CSharpName (MemberType) + "' is less " +
5061                                                       "accessible than field `" + GetSignatureForError () + "'");
5062                                 }
5063                                 return false;
5064                         }
5065
5066                         if (MemberType.IsPointer && !UnsafeOK (Parent))
5067                                 return false;
5068
5069                         if (IsExplicitImpl) {
5070                                 Expression expr = MemberName.Left.GetTypeExpression (Location);
5071                                 TypeExpr texpr = expr.ResolveAsTypeTerminal (ec, false);
5072                                 if (texpr == null)
5073                                         return false;
5074
5075                                 InterfaceType = texpr.ResolveType (ec);
5076
5077                                 if (!InterfaceType.IsInterface) {
5078                                         Report.Error (538, Location, "`{0}' in explicit interface declaration is not an interface", TypeManager.CSharpName (InterfaceType));
5079                                         return false;
5080                                 }
5081
5082                                 if (!Parent.VerifyImplements (this))
5083                                         return false;
5084
5085                                 Modifiers.Check (Modifiers.AllowedExplicitImplFlags, explicit_mod_flags, 0, Location);
5086
5087                         }
5088                         return true;
5089                 }
5090
5091                 protected bool IsTypePermitted ()
5092                 {
5093                         if (MemberType == TypeManager.arg_iterator_type || MemberType == TypeManager.typed_reference_type) {
5094                                 Report.Error (610, Location, "Field or property cannot be of type `{0}'", TypeManager.CSharpName (MemberType));
5095                                 return false;
5096                         }
5097                         return true;
5098                 }
5099
5100                 protected override bool VerifyClsCompliance(DeclSpace ds)
5101                 {
5102                         if (base.VerifyClsCompliance (ds)) {
5103                                 return true;
5104                         }
5105
5106                         if (IsInterface && HasClsCompliantAttribute && ds.IsClsCompliaceRequired (ds)) {
5107                                 Report.Error (3010, Location, "`{0}': CLS-compliant interfaces must have only CLS-compliant members", GetSignatureForError ());
5108                         }
5109                         return false;
5110                 }
5111
5112                 protected override void VerifyObsoleteAttribute()
5113                 {
5114                         CheckUsageOfObsoleteAttribute (MemberType);
5115                 }
5116         }
5117
5118         //
5119         // Fields and Events both generate FieldBuilders, we use this to share
5120         // their common bits.  This is also used to flag usage of the field
5121         //
5122         abstract public class FieldBase : MemberBase {
5123                 public FieldBuilder  FieldBuilder;
5124                 public Status status;
5125
5126                 [Flags]
5127                 public enum Status : byte {
5128                         HAS_OFFSET = 4          // Used by FieldMember.
5129                 }
5130
5131                 static string[] attribute_targets = new string [] { "field" };
5132
5133                 /// <summary>
5134                 ///  Symbol with same name in base class/struct
5135                 /// </summary>
5136                 public MemberInfo conflict_symbol;
5137
5138                 //
5139                 // The constructor is only exposed to our children
5140                 //
5141                 protected FieldBase (TypeContainer parent, Expression type, int mod,
5142                                      int allowed_mod, MemberName name, object init,
5143                                      Attributes attrs, Location loc)
5144                         : base (parent, type, mod, allowed_mod, Modifiers.PRIVATE,
5145                                 name, attrs, loc)
5146                 {
5147                         this.init = init;
5148                 }
5149
5150                 public override AttributeTargets AttributeTargets {
5151                         get {
5152                                 return AttributeTargets.Field;
5153                         }
5154                 }
5155
5156                 public override void ApplyAttributeBuilder (Attribute a, CustomAttributeBuilder cb)
5157                 {
5158                         if (a.Type == TypeManager.marshal_as_attr_type) {
5159                                 UnmanagedMarshal marshal = a.GetMarshal (this);
5160                                 if (marshal != null) {
5161                                         FieldBuilder.SetMarshal (marshal);
5162                                 }
5163                                 return;
5164                         }
5165
5166                         if (a.Type.IsSubclassOf (TypeManager.security_attr_type)) {
5167                                 a.Error_InvalidSecurityParent ();
5168                                 return;
5169                         }
5170
5171                         FieldBuilder.SetCustomAttribute (cb);
5172                 }
5173
5174                 //
5175                 // Whether this field has an initializer.
5176                 //
5177                 public bool HasInitializer {
5178                         get {
5179                                 return init != null;
5180                         }
5181                 }
5182
5183                 protected readonly Object init;
5184
5185                 // Private.
5186                 Expression init_expr;
5187                 bool init_expr_initialized = false;
5188
5189                 //
5190                 // Resolves and returns the field initializer.
5191                 //
5192                 public Expression GetInitializerExpression (EmitContext ec)
5193                 {
5194                         if (init_expr_initialized)
5195                                 return init_expr;
5196
5197                         Expression e;
5198                         if (init is Expression)
5199                                 e = (Expression) init;
5200                         else
5201                                 e = new ArrayCreation (Type, "", (ArrayList)init, Location);
5202
5203                         // TODO: Any reason why we are using parent EC ?
5204                         EmitContext parent_ec = Parent.EmitContext;
5205
5206                         bool old_is_static = parent_ec.IsStatic;
5207                         bool old_is_ctor = parent_ec.IsConstructor;
5208                         parent_ec.IsStatic = ec.IsStatic;
5209                         parent_ec.IsConstructor = ec.IsConstructor;
5210                         parent_ec.IsFieldInitializer = true;
5211                         e = e.DoResolve (parent_ec);
5212                         parent_ec.IsFieldInitializer = false;
5213                         parent_ec.IsStatic = old_is_static;
5214                         parent_ec.IsConstructor = old_is_ctor;
5215
5216                         init_expr = e;
5217                         init_expr_initialized = true;
5218
5219                         return init_expr;
5220                 }
5221
5222                 protected override bool CheckBase ()
5223                 {
5224                         if (!base.CheckBase ())
5225                                 return false;
5226
5227                         // TODO: Implement
5228                         if (IsInterface)
5229                                 return true;
5230
5231                         conflict_symbol = Parent.FindBaseMemberWithSameName (Name, false);
5232                         if (conflict_symbol == null) {
5233                                 if ((RootContext.WarningLevel >= 4) && ((ModFlags & Modifiers.NEW) != 0)) {
5234                                         Report.Warning (109, Location, "The member `{0}' does not hide an inherited member. The new keyword is not required", GetSignatureForError ());
5235                                 }
5236                                 return true;
5237                         }
5238
5239                         if ((ModFlags & (Modifiers.NEW | Modifiers.OVERRIDE)) == 0) {
5240                                 Report.SymbolRelatedToPreviousError (conflict_symbol);
5241                                 Report.Warning (108, Location, "`{0}' hides inherited member `{1}'. Use the new keyword if hiding was intended",
5242                                         GetSignatureForError (), TypeManager.GetFullNameSignature (conflict_symbol));
5243                         }
5244
5245                         return true;
5246                 }
5247
5248                 protected virtual bool IsFieldClsCompliant {
5249                         get {
5250                                 if (FieldBuilder == null)
5251                                         return true;
5252
5253                                 return AttributeTester.IsClsCompliant (FieldBuilder.FieldType);
5254                         }
5255                 }
5256
5257                 public override string[] ValidAttributeTargets {
5258                         get {
5259                                 return attribute_targets;
5260                         }
5261                 }
5262
5263                 protected override bool VerifyClsCompliance (DeclSpace ds)
5264                 {
5265                         if (!base.VerifyClsCompliance (ds))
5266                                 return false;
5267
5268                         if (!IsFieldClsCompliant) {
5269                                 Report.Error (3003, Location, "Type of `{0}' is not CLS-compliant", GetSignatureForError ());
5270                         }
5271                         return true;
5272                 }
5273
5274
5275                 public void SetAssigned ()
5276                 {
5277                         caching_flags |= Flags.IsAssigned;
5278                 }
5279         }
5280
5281         public abstract class FieldMember: FieldBase
5282         {
5283                 protected FieldMember (TypeContainer parent, Expression type, int mod,
5284                         int allowed_mod, MemberName name, object init, Attributes attrs, Location loc)
5285                         : base (parent, type, mod, allowed_mod | Modifiers.ABSTRACT, name, init, attrs, loc)
5286                 {
5287                         if ((mod & Modifiers.ABSTRACT) != 0)
5288                                 Report.Error (681, loc, "The modifier 'abstract' is not valid on fields. Try using a property instead");
5289                 }
5290
5291                 public override void ApplyAttributeBuilder(Attribute a, CustomAttributeBuilder cb)
5292                 {
5293                         if (a.Type == TypeManager.field_offset_attribute_type)
5294                         {
5295                                 status |= Status.HAS_OFFSET;
5296
5297                                 if (!Parent.HasExplicitLayout) {
5298                                         Report.Error (636, Location, "The FieldOffset attribute can only be placed on members of types marked with the StructLayout(LayoutKind.Explicit)");
5299                                         return;
5300                                 }
5301
5302                                 if ((ModFlags & Modifiers.STATIC) != 0 || this is Const) {
5303                                         Report.Error (637, Location, "The FieldOffset attribute is not allowed on static or const fields");
5304                                         return;
5305                                 }
5306                         }
5307
5308 #if NET_2_0
5309                         if (a.Type == TypeManager.fixed_buffer_attr_type) {
5310                                 Report.Error (1716, Location, "Do not use 'System.Runtime.CompilerServices.FixedBuffer' attribute. Use the 'fixed' field modifier instead");
5311                                 return;
5312                         }
5313 #endif
5314
5315                         base.ApplyAttributeBuilder (a, cb);
5316                 }
5317
5318
5319                 public override bool Define()
5320                 {
5321                         EmitContext ec = Parent.EmitContext;
5322                         if (ec == null)
5323                                 throw new InternalErrorException ("FieldMember.Define called too early");
5324
5325                         if (MemberType == null)
5326                                 return false;
5327
5328                         if (MemberType == TypeManager.void_type) {
5329                                 Report.Error (1547, Location, "Keyword 'void' cannot be used in this context");
5330                                 return false;
5331                         }
5332
5333                         if (!CheckBase ())
5334                                 return false;
5335
5336                         if (!Parent.AsAccessible (MemberType, ModFlags)) {
5337                                 Report.Error (52, Location,
5338                                         "Inconsistent accessibility: field type `" +
5339                                         TypeManager.CSharpName (MemberType) + "' is less " +
5340                                         "accessible than field `" + GetSignatureForError () + "'");
5341                                 return false;
5342                         }
5343
5344                         if (!IsTypePermitted ())
5345                                 return false;
5346
5347                         if (MemberType.IsPointer && !UnsafeOK (Parent))
5348                                 return false;
5349
5350                         return true;
5351                 }
5352
5353                 public override void Emit ()
5354                 {
5355                         if (OptAttributes != null) {
5356                                 EmitContext ec = new EmitContext (Parent, Location, null, FieldBuilder.FieldType, ModFlags);
5357                                 OptAttributes.Emit (ec, this);
5358                         }
5359
5360                         if (Parent.HasExplicitLayout && ((status & Status.HAS_OFFSET) == 0) && (ModFlags & Modifiers.STATIC) == 0) {
5361                                 Report.Error (625, Location, "`{0}': Instance field types marked with StructLayout(LayoutKind.Explicit) must have a FieldOffset attribute.", GetSignatureForError ());
5362                         }
5363
5364                         base.Emit ();
5365                 }
5366
5367                 //
5368                 //   Represents header string for documentation comment.
5369                 //
5370                 public override string DocCommentHeader {
5371                         get { return "F:"; }
5372                 }
5373         }
5374
5375         interface IFixedBuffer
5376         {
5377                 FieldInfo Element { get; }
5378                 Type ElementType { get; }
5379         }
5380
5381         public class FixedFieldExternal: IFixedBuffer
5382         {
5383                 FieldInfo element_field;
5384
5385                 public FixedFieldExternal (FieldInfo fi)
5386                 {
5387                         element_field = fi.FieldType.GetField (FixedField.FixedElementName);
5388                 }
5389
5390                 #region IFixedField Members
5391
5392                 public FieldInfo Element {
5393                         get {
5394                                 return element_field;
5395                         }
5396                 }
5397
5398                 public Type ElementType {
5399                         get {
5400                                 return element_field.FieldType;
5401                         }
5402                 }
5403
5404                 #endregion
5405         }
5406
5407         /// <summary>
5408         /// Fixed buffer implementation
5409         /// </summary>
5410         public class FixedField: FieldMember, IFixedBuffer
5411         {
5412                 public const string FixedElementName = "FixedElementField";
5413                 static int GlobalCounter = 0;
5414                 static object[] ctor_args = new object[] { (short)LayoutKind.Sequential };
5415                 static FieldInfo[] fi;
5416
5417                 TypeBuilder fixed_buffer_type;
5418                 FieldBuilder element;
5419                 Expression size_expr;
5420                 int buffer_size;
5421
5422                 const int AllowedModifiers =
5423                         Modifiers.NEW |
5424                         Modifiers.PUBLIC |
5425                         Modifiers.PROTECTED |
5426                         Modifiers.INTERNAL |
5427                         Modifiers.PRIVATE;
5428
5429                 public FixedField (TypeContainer parent, Expression type, int mod, string name,
5430                         Expression size_expr, Attributes attrs, Location loc):
5431                         base (parent, type, mod, AllowedModifiers, new MemberName (name), null, attrs, loc)
5432                 {
5433                         if (RootContext.Version == LanguageVersion.ISO_1)
5434                                 Report.FeatureIsNotStandardized (loc, "fixed size buffers");
5435
5436                         this.size_expr = size_expr;
5437                 }
5438
5439                 public override bool Define()
5440                 {
5441 #if !NET_2_0
5442                         if ((ModFlags & (Modifiers.PUBLIC | Modifiers.PROTECTED)) != 0)
5443                                 Report.Warning (-23, Location, "Only private or internal fixed sized buffers are supported by .NET 1.x");
5444 #endif
5445
5446                         if (Parent.Kind != Kind.Struct) {
5447                                 Report.Error (1642, Location, "`{0}': Fixed size buffer fields may only be members of structs",
5448                                         GetSignatureForError ());
5449                                 return false;
5450                         }
5451
5452                         if (!base.Define ())
5453                                 return false;
5454
5455                         if (!TypeManager.IsPrimitiveType (MemberType)) {
5456                                 Report.Error (1663, Location, "`{0}': Fixed size buffers type must be one of the following: bool, byte, short, int, long, char, sbyte, ushort, uint, ulong, float or double",
5457                                         GetSignatureForError ());
5458                                 return false;
5459                         }
5460
5461                         Expression e = size_expr.Resolve (Parent.EmitContext);
5462                         if (e == null)
5463                                 return false;
5464
5465                         Constant c = e as Constant;
5466                         if (c == null) {
5467                                 Const.Error_ExpressionMustBeConstant (e.Location, GetSignatureForError ());
5468                                 return false;
5469                         }
5470
5471                         IntConstant buffer_size_const = c.ToInt (Location);
5472                         if (buffer_size_const == null)
5473                                 return false;
5474
5475                         buffer_size = buffer_size_const.Value;
5476
5477                         if (buffer_size <= 0) {
5478                                 Report.Error (1665, Location, "`{0}': Fixed size buffers must have a length greater than zero", GetSignatureForError ());
5479                                 return false;
5480                         }
5481
5482                         int type_size = Expression.GetTypeSize (MemberType);
5483
5484                         if (buffer_size > int.MaxValue / type_size) {
5485                                 Report.Error (1664, Location, "Fixed size buffer `{0}' of length `{1}' and type `{2}' exceeded 2^31 limit",
5486                                         GetSignatureForError (), buffer_size.ToString (), TypeManager.CSharpName (MemberType));
5487                                 return false;
5488                         }
5489
5490                         buffer_size *= type_size;
5491
5492                         // Define nested
5493                         string name = String.Format ("<{0}>__FixedBuffer{1}", Name, GlobalCounter++);
5494
5495                         fixed_buffer_type = Parent.TypeBuilder.DefineNestedType (name,
5496                                 TypeAttributes.NestedPublic | TypeAttributes.Sealed | TypeAttributes.BeforeFieldInit, TypeManager.value_type);
5497                         element = fixed_buffer_type.DefineField (FixedElementName, MemberType, FieldAttributes.Public);
5498                         RootContext.RegisterCompilerGeneratedType (fixed_buffer_type);
5499
5500                         FieldBuilder = Parent.TypeBuilder.DefineField (Name, fixed_buffer_type, Modifiers.FieldAttr (ModFlags));
5501                         TypeManager.RegisterFieldBase (FieldBuilder, this);
5502
5503                         return true;
5504                 }
5505
5506                 public override void Emit()
5507                 {
5508                         if (fi == null)
5509                                 fi = new FieldInfo [] { TypeManager.struct_layout_attribute_type.GetField ("Size") };
5510
5511                         object[] fi_val = new object[1];
5512                         fi_val [0] = buffer_size;
5513
5514                         CustomAttributeBuilder cab = new CustomAttributeBuilder (TypeManager.struct_layout_attribute_ctor,
5515                                 ctor_args, fi, fi_val);
5516                         fixed_buffer_type.SetCustomAttribute (cab);
5517
5518 #if NET_2_0
5519                         cab = new CustomAttributeBuilder (TypeManager.fixed_buffer_attr_ctor, new object[] { MemberType, buffer_size } );
5520                         FieldBuilder.SetCustomAttribute (cab);
5521 #endif
5522                         base.Emit ();
5523                 }
5524
5525                 protected override bool IsFieldClsCompliant {
5526                         get {
5527                                 return false;
5528                         }
5529                 }
5530
5531                 #region IFixedField Members
5532
5533                 public FieldInfo Element {
5534                         get {
5535                                 return element;
5536                         }
5537                 }
5538
5539                 public Type ElementType {
5540                         get {
5541                                 return MemberType;
5542                         }
5543                 }
5544
5545                 #endregion
5546         }
5547
5548         //
5549         // The Field class is used to represents class/struct fields during parsing.
5550         //
5551         public class Field : FieldMember {
5552                 // <summary>
5553                 //   Modifiers allowed in a class declaration
5554                 // </summary>
5555                 const int AllowedModifiers =
5556                         Modifiers.NEW |
5557                         Modifiers.PUBLIC |
5558                         Modifiers.PROTECTED |
5559                         Modifiers.INTERNAL |
5560                         Modifiers.PRIVATE |
5561                         Modifiers.STATIC |
5562                         Modifiers.VOLATILE |
5563                         Modifiers.UNSAFE |
5564                         Modifiers.READONLY;
5565
5566                 public Field (TypeContainer parent, Expression type, int mod, string name,
5567                               Object expr_or_array_init, Attributes attrs, Location loc)
5568                         : base (parent, type, mod, AllowedModifiers, new MemberName (name),
5569                                 expr_or_array_init, attrs, loc)
5570                 {
5571                 }
5572
5573                 public override bool Define ()
5574                 {
5575                         if (!base.Define ())
5576                                 return false;
5577
5578                         if (RootContext.WarningLevel > 1){
5579                                 Type ptype = Parent.TypeBuilder.BaseType;
5580
5581                                 // ptype is only null for System.Object while compiling corlib.
5582                                 if (ptype != null){
5583                                         TypeContainer.FindMembers (
5584                                                 ptype, MemberTypes.Method,
5585                                                 BindingFlags.Public |
5586                                                 BindingFlags.Static | BindingFlags.Instance,
5587                                                 System.Type.FilterName, Name);
5588                                 }
5589                         }
5590
5591                         if ((ModFlags & Modifiers.VOLATILE) != 0){
5592                                 if (!MemberType.IsClass){
5593                                         Type vt = MemberType;
5594
5595                                         if (TypeManager.IsEnumType (vt))
5596                                                 vt = TypeManager.EnumToUnderlying (MemberType);
5597
5598                                         if (!((vt == TypeManager.bool_type) ||
5599                                               (vt == TypeManager.sbyte_type) ||
5600                                               (vt == TypeManager.byte_type) ||
5601                                               (vt == TypeManager.short_type) ||
5602                                               (vt == TypeManager.ushort_type) ||
5603                                               (vt == TypeManager.int32_type) ||
5604                                               (vt == TypeManager.uint32_type) ||
5605                                               (vt == TypeManager.char_type) ||
5606                                               (vt == TypeManager.float_type) ||
5607                                               (!vt.IsValueType))){
5608                                                 Report.Error (677, Location, "`{0}': A volatile field cannot be of the type `{1}'",
5609                                                         GetSignatureForError (), TypeManager.CSharpName (vt));
5610                                                 return false;
5611                                         }
5612                                 }
5613
5614                                 if ((ModFlags & Modifiers.READONLY) != 0){
5615                                         Report.Error (678, Location, "`{0}': A field cannot be both volatile and readonly",
5616                                                 GetSignatureForError ());
5617                                         return false;
5618                                 }
5619                         }
5620
5621                         FieldAttributes fa = Modifiers.FieldAttr (ModFlags);
5622
5623                         if (Parent.Kind == Kind.Struct &&
5624                             ((fa & FieldAttributes.Static) == 0) &&
5625                             MemberType == Parent.TypeBuilder &&
5626                             !TypeManager.IsBuiltinType (MemberType)){
5627                                 Report.Error (523, Location, "Struct member `" + Parent.Name + "." + Name +
5628                                               "' causes a cycle in the structure layout");
5629                                 return false;
5630                         }
5631
5632                         try {
5633                                 FieldBuilder = Parent.TypeBuilder.DefineField (
5634                                         Name, MemberType, Modifiers.FieldAttr (ModFlags));
5635
5636                                 TypeManager.RegisterFieldBase (FieldBuilder, this);
5637                         }
5638                         catch (ArgumentException) {
5639                                 Report.Warning (-24, Location, "The Microsoft runtime is unable to use [void|void*] as a field type, try using the Mono runtime.");
5640                                 return false;
5641                         }
5642
5643                         return true;
5644                 }
5645
5646                 protected override bool VerifyClsCompliance (DeclSpace ds)
5647                 {
5648                         if (!base.VerifyClsCompliance (ds))
5649                                 return false;
5650
5651                         if ((ModFlags & Modifiers.VOLATILE) != 0) {
5652                                 Report.Warning (3026, 1, Location, "CLS-compliant field `{0}' cannot be volatile", GetSignatureForError ());
5653                         }
5654
5655                         return true;
5656                 }
5657         }
5658
5659         //
5660         // `set' and `get' accessors are represented with an Accessor.
5661         //
5662         public class Accessor : IIteratorContainer {
5663                 //
5664                 // Null if the accessor is empty, or a Block if not
5665                 //
5666                 public const int AllowedModifiers =
5667                         Modifiers.PUBLIC |
5668                         Modifiers.PROTECTED |
5669                         Modifiers.INTERNAL |
5670                         Modifiers.PRIVATE;
5671
5672                 public ToplevelBlock Block;
5673                 public Attributes Attributes;
5674                 public Location Location;
5675                 public int ModFlags;
5676                 public bool Yields;
5677
5678                 public Accessor (ToplevelBlock b, int mod, Attributes attrs, Location loc)
5679                 {
5680                         Block = b;
5681                         Attributes = attrs;
5682                         Location = loc;
5683                         ModFlags = Modifiers.Check (AllowedModifiers, mod, 0, loc);
5684                 }
5685
5686                 public void SetYields ()
5687                 {
5688                         Yields = true;
5689                 }
5690         }
5691
5692         // Ooouh Martin, templates are missing here.
5693         // When it will be possible move here a lot of child code and template method type.
5694         public abstract class AbstractPropertyEventMethod: MemberCore, IMethodData {
5695                 protected MethodData method_data;
5696                 protected ToplevelBlock block;
5697                 protected ListDictionary declarative_security;
5698
5699                 // The accessor are created event if they are not wanted.
5700                 // But we need them because their names are reserved.
5701                 // Field says whether accessor will be emited or not
5702                 public readonly bool IsDummy;
5703
5704                 protected readonly string prefix;
5705
5706                 ReturnParameter return_attributes;
5707
5708                 public AbstractPropertyEventMethod (MemberBase member, string prefix)
5709                         : base (null, SetupName (prefix, member), null, member.Location)
5710                 {
5711                         this.prefix = prefix;
5712                         IsDummy = true;
5713                 }
5714
5715                 public AbstractPropertyEventMethod (MemberBase member, Accessor accessor,
5716                                                     string prefix)
5717                         : base (null, SetupName (prefix, member),
5718                                 accessor.Attributes, accessor.Location)
5719                 {
5720                         this.prefix = prefix;
5721                         this.block = accessor.Block;
5722                 }
5723
5724                 static MemberName SetupName (string prefix, MemberBase member)
5725                 {
5726                         return new MemberName (member.MemberName.Left, prefix + member.ShortName);
5727                 }
5728
5729                 public void UpdateName (MemberBase member)
5730                 {
5731                         SetMemberName (SetupName (prefix, member));
5732                 }
5733
5734                 #region IMethodData Members
5735
5736                 public ToplevelBlock Block {
5737                         get {
5738                                 return block;
5739                         }
5740
5741                         set {
5742                                 block = value;
5743                         }
5744                 }
5745
5746                 public CallingConventions CallingConventions {
5747                         get {
5748                                 return CallingConventions.Standard;
5749                         }
5750                 }
5751
5752                 public bool IsExcluded (EmitContext ec)
5753                 {
5754                         return false;
5755                 }
5756
5757                 public MemberName MethodName {
5758                         get {
5759                                 return MemberName;
5760                         }
5761                 }
5762
5763                 public abstract ObsoleteAttribute GetObsoleteAttribute ();
5764                 public abstract Type[] ParameterTypes { get; }
5765                 public abstract Type ReturnType { get; }
5766                 public abstract EmitContext CreateEmitContext(TypeContainer tc, ILGenerator ig);
5767
5768                 #endregion
5769
5770                 public override void ApplyAttributeBuilder(Attribute a, CustomAttributeBuilder cb)
5771                 {
5772                         if (a.Type == TypeManager.cls_compliant_attribute_type || a.Type == TypeManager.obsolete_attribute_type ||
5773                                         a.Type == TypeManager.conditional_attribute_type) {
5774                                 Report.Error (1667, a.Location,
5775                                         "Attribute `{0}' is not valid on property or event accessors. It is valid on `{1}' declarations only",
5776                                         TypeManager.CSharpName (a.Type), a.GetValidTargets ());
5777                                 return;
5778                         }
5779
5780                         if (a.Type.IsSubclassOf (TypeManager.security_attr_type) && a.CheckSecurityActionValidity (false)) {
5781                                 if (declarative_security == null)
5782                                         declarative_security = new ListDictionary ();
5783                                 a.ExtractSecurityPermissionSet (declarative_security);
5784                                 return;
5785                         }
5786
5787                         if (a.Target == AttributeTargets.Method) {
5788                                 method_data.MethodBuilder.SetCustomAttribute (cb);
5789                                 return;
5790                         }
5791
5792                         if (a.Target == AttributeTargets.ReturnValue) {
5793                                 if (return_attributes == null)
5794                                         return_attributes = new ReturnParameter (method_data.MethodBuilder, Location);
5795
5796                                 return_attributes.ApplyAttributeBuilder (a, cb);
5797                                 return;
5798                         }
5799
5800                         ApplyToExtraTarget (a, cb);
5801                 }
5802
5803                 virtual protected void ApplyToExtraTarget (Attribute a, CustomAttributeBuilder cb)
5804                 {
5805                         System.Diagnostics.Debug.Fail ("You forgot to define special attribute target handling");
5806                 }
5807
5808                 public override bool Define()
5809                 {
5810                         throw new NotSupportedException ();
5811                 }
5812
5813                 public virtual void Emit (TypeContainer container)
5814                 {
5815                         EmitMethod (container);
5816
5817                         if (declarative_security != null) {
5818                                 foreach (DictionaryEntry de in declarative_security) {
5819                                         method_data.MethodBuilder.AddDeclarativeSecurity ((SecurityAction)de.Key, (PermissionSet)de.Value);
5820                                 }
5821                         }
5822
5823                         block = null;
5824                 }
5825
5826                 protected virtual void EmitMethod (TypeContainer container)
5827                 {
5828                         method_data.Emit (container, this);
5829                 }
5830
5831                 public override bool IsClsCompliaceRequired(DeclSpace ds)
5832                 {
5833                         return false;
5834                 }
5835
5836                 public bool IsDuplicateImplementation (MethodCore method)
5837                 {
5838                         if (!MemberName.Equals (method.MemberName))
5839                                 return false;
5840
5841                         Type[] param_types = method.ParameterTypes;
5842
5843                         if (param_types.Length != ParameterTypes.Length)
5844                                 return false;
5845
5846                         for (int i = 0; i < param_types.Length; i++)
5847                                 if (param_types [i] != ParameterTypes [i])
5848                                         return false;
5849
5850                         Report.SymbolRelatedToPreviousError (method);
5851                         Report.Error (111, Location, TypeContainer.Error111, method.GetSignatureForError ());
5852                         return true;
5853                 }
5854
5855                 public override bool IsUsed
5856                 {
5857                         get {
5858                                 if (IsDummy)
5859                                         return false;
5860
5861                                 return base.IsUsed;
5862                         }
5863                 }
5864
5865                 public new Location Location {
5866                         get {
5867                                 return base.Location;
5868                         }
5869                 }
5870
5871                 //
5872                 //   Represents header string for documentation comment.
5873                 //
5874                 public override string DocCommentHeader {
5875                         get { throw new InvalidOperationException ("Unexpected attempt to get doc comment from " + this.GetType () + "."); }
5876                 }
5877
5878                 protected override void VerifyObsoleteAttribute()
5879                 {
5880                 }
5881
5882         }
5883
5884         //
5885         // Properties and Indexers both generate PropertyBuilders, we use this to share
5886         // their common bits.
5887         //
5888         abstract public class PropertyBase : MethodCore {
5889
5890                 public class GetMethod: PropertyMethod
5891                 {
5892                         static string[] attribute_targets = new string [] { "method", "return" };
5893
5894                         public GetMethod (MethodCore method):
5895                                 base (method, "get_")
5896                         {
5897                         }
5898
5899                         public GetMethod (MethodCore method, Accessor accessor):
5900                                 base (method, accessor, "get_")
5901                         {
5902                         }
5903
5904                         public override MethodBuilder Define(TypeContainer container)
5905                         {
5906                                 base.Define (container);
5907
5908                                 method_data = new MethodData (method, method.ParameterInfo, ModFlags, flags, this);
5909
5910                                 if (!method_data.Define (container))
5911                                         return null;
5912
5913                                 return method_data.MethodBuilder;
5914                         }
5915
5916                         public override Type ReturnType {
5917                                 get {
5918                                         return method.MemberType;
5919                                 }
5920                         }
5921
5922                         public override string[] ValidAttributeTargets {
5923                                 get {
5924                                         return attribute_targets;
5925                                 }
5926                         }
5927                 }
5928
5929                 public class SetMethod: PropertyMethod {
5930
5931                         static string[] attribute_targets = new string [] { "method", "param", "return" };
5932                         ImplicitParameter param_attr;
5933
5934                         public SetMethod (MethodCore method):
5935                                 base (method, "set_")
5936                         {
5937                         }
5938
5939                         public SetMethod (MethodCore method, Accessor accessor):
5940                                 base (method, accessor, "set_")
5941                         {
5942                         }
5943
5944                         protected override void ApplyToExtraTarget(Attribute a, CustomAttributeBuilder cb)
5945                         {
5946                                 if (a.Target == AttributeTargets.Parameter) {
5947                                         if (param_attr == null)
5948                                                 param_attr = new ImplicitParameter (method_data.MethodBuilder, method.Location);
5949
5950                                         param_attr.ApplyAttributeBuilder (a, cb);
5951                                         return;
5952                                 }
5953
5954                                 base.ApplyAttributeBuilder (a, cb);
5955                         }
5956
5957                         protected virtual InternalParameters GetParameterInfo (EmitContext ec)
5958                         {
5959                                 Parameter [] parms = new Parameter [1];
5960                                 parms [0] = new Parameter (method.Type, "value", Parameter.Modifier.NONE, null, method.Location);
5961                                 Parameters parameters = new Parameters (parms, null);
5962
5963                                 bool old_unsafe = ec.InUnsafe;
5964                                 ec.InUnsafe = InUnsafe;
5965                                 Type [] types = parameters.GetParameterInfo (ec);
5966                                 ec.InUnsafe = old_unsafe;
5967
5968                                 return new InternalParameters (types, parameters);
5969                         }
5970
5971                         public override MethodBuilder Define (TypeContainer container)
5972                         {
5973                                 if (container.EmitContext == null)
5974                                         throw new InternalErrorException ("SetMethod.Define called too early");
5975
5976                                 base.Define (container);
5977
5978                                 method_data = new MethodData (method, GetParameterInfo (container.EmitContext), ModFlags, flags, this);
5979
5980                                 if (!method_data.Define (container))
5981                                         return null;
5982
5983                                 return method_data.MethodBuilder;
5984                         }
5985
5986                         public override Type[] ParameterTypes {
5987                                 get {
5988                                         return new Type[] { method.MemberType };
5989                                 }
5990                         }
5991
5992                         public override Type ReturnType {
5993                                 get {
5994                                         return TypeManager.void_type;
5995                                 }
5996                         }
5997
5998                         public override string[] ValidAttributeTargets {
5999                                 get {
6000                                         return attribute_targets;
6001                                 }
6002                         }
6003                 }
6004
6005                 static string[] attribute_targets = new string [] { "property" };
6006
6007                 public abstract class PropertyMethod: AbstractPropertyEventMethod
6008                 {
6009                         protected readonly MethodCore method;
6010                         protected MethodAttributes flags;
6011                         bool yields;
6012
6013                         public PropertyMethod (MethodCore method, string prefix)
6014                                 : base (method, prefix)
6015                         {
6016                                 this.method = method;
6017                                 Parent = method.Parent;
6018                         }
6019
6020                         public PropertyMethod (MethodCore method, Accessor accessor,
6021                                                string prefix)
6022                                 : base (method, accessor, prefix)
6023                         {
6024                                 this.method = method;
6025                                 Parent = method.Parent;
6026                                 this.ModFlags = accessor.ModFlags;
6027                                 yields = accessor.Yields;
6028
6029                                 if (accessor.ModFlags != 0 && RootContext.Version == LanguageVersion.ISO_1) {
6030                                         Report.FeatureIsNotStandardized (Location, "access modifiers on properties");
6031                                 }
6032                         }
6033
6034                         public override AttributeTargets AttributeTargets {
6035                                 get {
6036                                         return AttributeTargets.Method;
6037                                 }
6038                         }
6039
6040                         public override bool IsClsCompliaceRequired(DeclSpace ds)
6041                         {
6042                                 return method.IsClsCompliaceRequired (ds);
6043                         }
6044
6045                         public InternalParameters ParameterInfo
6046                         {
6047                                 get {
6048                                         return method_data.ParameterInfo;
6049                                 }
6050                         }
6051
6052                         public virtual MethodBuilder Define (TypeContainer container)
6053                         {
6054                                 if (!method.CheckAbstractAndExtern (block != null))
6055                                         return null;
6056
6057                                 //
6058                                 // Check for custom access modifier
6059                                 //
6060                                 if (ModFlags == 0) {
6061                                         ModFlags = method.ModFlags;
6062                                         flags = method.flags;
6063                                 } else {
6064                                         if (container.Kind == Kind.Interface)
6065                                                 Report.Error (275, Location, "`{0}': accessibility modifiers may not be used on accessors in an interface",
6066                                                         GetSignatureForError ());
6067
6068                                         if ((method.ModFlags & Modifiers.ABSTRACT) != 0 && (ModFlags & Modifiers.PRIVATE) != 0) {
6069                                                 Report.Error (442, Location, "`{0}': abstract properties cannot have private accessors", GetSignatureForError ());
6070                                         }
6071
6072                                         CheckModifiers (container, ModFlags);
6073                                         ModFlags |= (method.ModFlags & (~Modifiers.Accessibility));
6074                                         ModFlags |= Modifiers.PROPERTY_CUSTOM;
6075                                         flags = Modifiers.MethodAttr (ModFlags);
6076                                         flags |= (method.flags & (~MethodAttributes.MemberAccessMask));
6077                                 }
6078
6079                                 //
6080                                 // Setup iterator if we are one
6081                                 //
6082                                 if (yields) {
6083                                         Iterator iterator = new Iterator (this,
6084                                                 Parent, method.ParameterInfo, ModFlags);
6085
6086                                         if (!iterator.DefineIterator ())
6087                                                 return null;
6088                                 }
6089
6090                                 return null;
6091                         }
6092
6093                         public bool HasCustomAccessModifier
6094                         {
6095                                 get {
6096                                         return (ModFlags & Modifiers.PROPERTY_CUSTOM) != 0;
6097                                 }
6098                         }
6099
6100                         public override Type[] ParameterTypes {
6101                                 get {
6102                                         return TypeManager.NoTypes;
6103                                 }
6104                         }
6105
6106                         public override EmitContext CreateEmitContext (TypeContainer tc,
6107                                                                        ILGenerator ig)
6108                         {
6109                                 return new EmitContext (
6110                                         tc, method.Parent, method.Location, ig, ReturnType,
6111                                         method.ModFlags, false);
6112                         }
6113
6114                         public override ObsoleteAttribute GetObsoleteAttribute ()
6115                         {
6116                                 return method.GetObsoleteAttribute (method.Parent);
6117                         }
6118
6119                         public override string GetSignatureForError()
6120                         {
6121                                 return method.GetSignatureForError () + '.' + prefix.Substring (0, 3);
6122                         }
6123
6124                         void CheckModifiers (TypeContainer container, int modflags)
6125                         {
6126                                 int flags = 0;
6127                                 int mflags = method.ModFlags & Modifiers.Accessibility;
6128
6129                                 if ((mflags & Modifiers.PUBLIC) != 0) {
6130                                         flags |= Modifiers.PROTECTED | Modifiers.INTERNAL | Modifiers.PRIVATE;
6131                                 }
6132                                 else if ((mflags & Modifiers.PROTECTED) != 0) {
6133                                         if ((mflags & Modifiers.INTERNAL) != 0)
6134                                                 flags |= Modifiers.PROTECTED | Modifiers.INTERNAL;
6135
6136                                         flags |= Modifiers.PRIVATE;
6137                                 }
6138                                 else if ((mflags & Modifiers.INTERNAL) != 0)
6139                                         flags |= Modifiers.PRIVATE;
6140
6141                                 if ((mflags == modflags) || (modflags & (~flags)) != 0) {
6142                                         Report.Error (273, Location,
6143                                                 "The accessibility modifier of the `{0}' accessor must be more restrictive than the modifier of the property or indexer `{1}'",
6144                                                 GetSignatureForError (), method.GetSignatureForError ());
6145                                 }
6146                         }
6147
6148                         public override bool MarkForDuplicationCheck ()
6149                         {
6150                                 caching_flags |= Flags.TestMethodDuplication;
6151                                 return true;
6152                         }
6153                 }
6154
6155
6156                 public PropertyMethod Get, Set;
6157                 public PropertyBuilder PropertyBuilder;
6158                 public MethodBuilder GetBuilder, SetBuilder;
6159
6160                 protected EmitContext ec;
6161
6162                 public PropertyBase (TypeContainer ds, Expression type, int mod_flags,
6163                                      int allowed_mod, bool is_iface, MemberName name,
6164                                      Parameters parameters, Attributes attrs,
6165                                      Location loc)
6166                         : base (ds, type, mod_flags, allowed_mod, is_iface, name,
6167                                 attrs, parameters, loc)
6168                 {
6169                 }
6170
6171                 public override void ApplyAttributeBuilder (Attribute a, CustomAttributeBuilder cb)
6172                 {
6173                         if (a.Type.IsSubclassOf (TypeManager.security_attr_type)) {
6174                                 a.Error_InvalidSecurityParent ();
6175                                 return;
6176                         }
6177
6178                         PropertyBuilder.SetCustomAttribute (cb);
6179                 }
6180
6181                 public override AttributeTargets AttributeTargets {
6182                         get {
6183                                 return AttributeTargets.Property;
6184                         }
6185                 }
6186
6187                 public override bool Define ()
6188                 {
6189                         if (!DoDefine ())
6190                                 return false;
6191
6192                         if (!IsTypePermitted ())
6193                                 return false;
6194
6195                         return true;
6196                 }
6197
6198                 protected override bool DoDefine ()
6199                 {
6200                         if (!base.DoDefine ())
6201                                 return false;
6202
6203                         //
6204                         // Accessors modifiers check
6205                         //
6206                         if (Get.ModFlags != 0 && Set.ModFlags != 0) {
6207                                 Report.Error (274, Location, "`{0}': Cannot specify accessibility modifiers for both accessors of the property or indexer",
6208                                                 GetSignatureForError ());
6209                                 return false;
6210                         }
6211
6212                         if ((Get.IsDummy || Set.IsDummy)
6213                                         && (Get.ModFlags != 0 || Set.ModFlags != 0) && (ModFlags & Modifiers.OVERRIDE) == 0) {
6214                                 Report.Error (276, Location,
6215                                         "`{0}': accessibility modifiers on accessors may only be used if the property or indexer has both a get and a set accessor",
6216                                         GetSignatureForError ());
6217                                 return false;
6218                         }
6219
6220                         if (MemberType.IsAbstract && MemberType.IsSealed) {
6221                                 Report.Error (722, Location, Error722, TypeManager.CSharpName (MemberType));
6222                                 return false;
6223                         }
6224
6225                         ec = new EmitContext (Parent, Location, null, MemberType, ModFlags);
6226                         return true;
6227                 }
6228
6229                 protected override bool CheckForDuplications ()
6230                 {
6231                         ArrayList ar = Parent.Indexers;
6232                         if (ar != null) {
6233                                 int arLen = ar.Count;
6234
6235                                 for (int i = 0; i < arLen; i++) {
6236                                         Indexer m = (Indexer) ar [i];
6237                                         if (IsDuplicateImplementation (m))
6238                                                 return false;
6239                                 }
6240                         }
6241
6242                         ar = Parent.Properties;
6243                         if (ar != null) {
6244                                 int arLen = ar.Count;
6245
6246                                 for (int i = 0; i < arLen; i++) {
6247                                         Property m = (Property) ar [i];
6248                                         if (IsDuplicateImplementation (m))
6249                                                 return false;
6250                                 }
6251                         }
6252
6253                         return true;
6254                 }
6255
6256                 // TODO: rename to Resolve......
6257                 protected override MethodInfo FindOutBaseMethod (TypeContainer container, ref Type base_ret_type)
6258                 {
6259                         PropertyInfo base_property = container.BaseCache.FindMemberToOverride (
6260                                 container.TypeBuilder, Name, ParameterTypes, true) as PropertyInfo;
6261
6262                         if (base_property == null)
6263                                 return null;
6264
6265                         base_ret_type = base_property.PropertyType;
6266                         MethodInfo get_accessor = base_property.GetGetMethod (true);
6267                         MethodInfo set_accessor = base_property.GetSetMethod (true);
6268                         MethodAttributes get_accessor_access, set_accessor_access;
6269
6270                         if ((ModFlags & Modifiers.OVERRIDE) != 0) {
6271                                 if (Get != null && !Get.IsDummy && get_accessor == null) {
6272                                         Report.SymbolRelatedToPreviousError (base_property);
6273                                         Report.Error (545, Location, "`{0}.get': cannot override because `{1}' does not have an overridable get accessor", GetSignatureForError (), TypeManager.GetFullNameSignature (base_property));
6274                                 }
6275
6276                                 if (Set != null && !Set.IsDummy && set_accessor == null) {
6277                                         Report.SymbolRelatedToPreviousError (base_property);
6278                                         Report.Error (546, Location, "`{0}.set': cannot override because `{1}' does not have an overridable set accessor", GetSignatureForError (), TypeManager.GetFullNameSignature (base_property));
6279                                 }
6280                         }
6281
6282                         //
6283                         // Check base class accessors access
6284                         //
6285
6286                         // TODO: rewrite to reuse Get|Set.CheckAccessModifiers and share code there
6287                         get_accessor_access = set_accessor_access = 0;
6288                         if ((ModFlags & Modifiers.NEW) == 0) {
6289                                 if (get_accessor != null) {
6290                                         MethodAttributes get_flags = Modifiers.MethodAttr (Get.ModFlags != 0 ? Get.ModFlags : ModFlags);
6291                                         get_accessor_access = (get_accessor.Attributes & MethodAttributes.MemberAccessMask);
6292
6293                                         if (!Get.IsDummy && !CheckAccessModifiers (get_flags & MethodAttributes.MemberAccessMask, get_accessor_access, get_accessor))
6294                                                 Error_CannotChangeAccessModifiers (get_accessor, get_accessor_access,  ".get");
6295                                 }
6296
6297                                 if (set_accessor != null)  {
6298                                         MethodAttributes set_flags = Modifiers.MethodAttr (Set.ModFlags != 0 ? Set.ModFlags : ModFlags);
6299                                         set_accessor_access = (set_accessor.Attributes & MethodAttributes.MemberAccessMask);
6300
6301                                         if (!Set.IsDummy && !CheckAccessModifiers (set_flags & MethodAttributes.MemberAccessMask, set_accessor_access, set_accessor))
6302                                                 Error_CannotChangeAccessModifiers (set_accessor, set_accessor_access, ".set");
6303                                 }
6304                         }
6305
6306                         //
6307                         // Get the less restrictive access
6308                         //
6309                         return get_accessor_access > set_accessor_access ? get_accessor : set_accessor;
6310                 }
6311
6312                 public override void Emit ()
6313                 {
6314                         //
6315                         // The PropertyBuilder can be null for explicit implementations, in that
6316                         // case, we do not actually emit the ".property", so there is nowhere to
6317                         // put the attribute
6318                         //
6319                         if (PropertyBuilder != null && OptAttributes != null)
6320                                 OptAttributes.Emit (ec, this);
6321
6322                         if (!Get.IsDummy)
6323                                 Get.Emit (Parent);
6324
6325                         if (!Set.IsDummy)
6326                                 Set.Emit (Parent);
6327
6328                         base.Emit ();
6329                 }
6330
6331                 /// <summary>
6332                 /// Tests whether accessors are not in collision with some method (CS0111)
6333                 /// </summary>
6334                 public bool AreAccessorsDuplicateImplementation (MethodCore mc)
6335                 {
6336                         return Get.IsDuplicateImplementation (mc) || Set.IsDuplicateImplementation (mc);
6337                 }
6338
6339                 public override bool IsUsed
6340                 {
6341                         get {
6342                                 if (IsExplicitImpl)
6343                                         return true;
6344
6345                                 return Get.IsUsed | Set.IsUsed;
6346                         }
6347                 }
6348
6349                 protected override void SetMemberName (MemberName new_name)
6350                 {
6351                         base.SetMemberName (new_name);
6352
6353                         Get.UpdateName (this);
6354                         Set.UpdateName (this);
6355                 }
6356
6357                 public override string[] ValidAttributeTargets {
6358                         get {
6359                                 return attribute_targets;
6360                         }
6361                 }
6362
6363                 //
6364                 //   Represents header string for documentation comment.
6365                 //
6366                 public override string DocCommentHeader {
6367                         get { return "P:"; }
6368                 }
6369         }
6370
6371         public class Property : PropertyBase {
6372                 const int AllowedModifiers =
6373                         Modifiers.NEW |
6374                         Modifiers.PUBLIC |
6375                         Modifiers.PROTECTED |
6376                         Modifiers.INTERNAL |
6377                         Modifiers.PRIVATE |
6378                         Modifiers.STATIC |
6379                         Modifiers.SEALED |
6380                         Modifiers.OVERRIDE |
6381                         Modifiers.ABSTRACT |
6382                         Modifiers.UNSAFE |
6383                         Modifiers.EXTERN |
6384                         Modifiers.METHOD_YIELDS |
6385                         Modifiers.VIRTUAL;
6386
6387                 const int AllowedInterfaceModifiers =
6388                         Modifiers.NEW;
6389
6390                 public Property (TypeContainer ds, Expression type, int mod, bool is_iface,
6391                                  MemberName name, Attributes attrs, Accessor get_block,
6392                                  Accessor set_block, Location loc)
6393                         : base (ds, type, mod,
6394                                 is_iface ? AllowedInterfaceModifiers : AllowedModifiers,
6395                                 is_iface, name, Parameters.EmptyReadOnlyParameters, attrs,
6396                                 loc)
6397                 {
6398                         if (get_block == null)
6399                                 Get = new GetMethod (this);
6400                         else
6401                                 Get = new GetMethod (this, get_block);
6402
6403                         if (set_block == null)
6404                                 Set = new SetMethod (this);
6405                         else
6406                                 Set = new SetMethod (this, set_block);
6407                 }
6408
6409                 public override bool Define ()
6410                 {
6411                         if (!base.Define ())
6412                                 return false;
6413
6414                         if (!CheckBase ())
6415                                 return false;
6416
6417                         flags |= MethodAttributes.HideBySig | MethodAttributes.SpecialName;
6418
6419                         if (!Get.IsDummy) {
6420                                 GetBuilder = Get.Define (Parent);
6421                                 if (GetBuilder == null)
6422                                         return false;
6423                         }
6424
6425                         if (!Set.IsDummy) {
6426                                 SetBuilder = Set.Define (Parent);
6427                                 if (SetBuilder == null)
6428                                         return false;
6429
6430                                 SetBuilder.DefineParameter (1, ParameterAttributes.None, "value");
6431                         }
6432
6433                         // FIXME - PropertyAttributes.HasDefault ?
6434
6435                         PropertyAttributes prop_attr = PropertyAttributes.None;
6436                         if (!IsInterface)
6437                                 prop_attr |= PropertyAttributes.RTSpecialName |
6438                                         PropertyAttributes.SpecialName;
6439
6440                         PropertyBuilder = Parent.TypeBuilder.DefineProperty (
6441                              Name, prop_attr, MemberType, null);
6442
6443                         if (!Get.IsDummy)
6444                                 PropertyBuilder.SetGetMethod (GetBuilder);
6445
6446                         if (!Set.IsDummy)
6447                                 PropertyBuilder.SetSetMethod (SetBuilder);
6448
6449                         TypeManager.RegisterProperty (PropertyBuilder, GetBuilder, SetBuilder);
6450                         return true;
6451                 }
6452         }
6453
6454         /// </summary>
6455         ///  Gigantic workaround  for lameness in SRE follows :
6456         ///  This class derives from EventInfo and attempts to basically
6457         ///  wrap around the EventBuilder so that FindMembers can quickly
6458         ///  return this in it search for members
6459         /// </summary>
6460         public class MyEventBuilder : EventInfo {
6461
6462                 //
6463                 // We use this to "point" to our Builder which is
6464                 // not really a MemberInfo
6465                 //
6466                 EventBuilder MyBuilder;
6467
6468                 //
6469                 // We "catch" and wrap these methods
6470                 //
6471                 MethodInfo raise, remove, add;
6472
6473                 EventAttributes attributes;
6474                 Type declaring_type, reflected_type, event_type;
6475                 string name;
6476
6477                 Event my_event;
6478
6479                 public MyEventBuilder (Event ev, TypeBuilder type_builder, string name, EventAttributes event_attr, Type event_type)
6480                 {
6481                         MyBuilder = type_builder.DefineEvent (name, event_attr, event_type);
6482
6483                         // And now store the values in our own fields.
6484
6485                         declaring_type = type_builder;
6486
6487                         reflected_type = type_builder;
6488
6489                         attributes = event_attr;
6490                         this.name = name;
6491                         my_event = ev;
6492                         this.event_type = event_type;
6493                 }
6494
6495                 //
6496                 // Methods that you have to override.  Note that you only need
6497                 // to "implement" the variants that take the argument (those are
6498                 // the "abstract" methods, the others (GetAddMethod()) are
6499                 // regular.
6500                 //
6501                 public override MethodInfo GetAddMethod (bool nonPublic)
6502                 {
6503                         return add;
6504                 }
6505
6506                 public override MethodInfo GetRemoveMethod (bool nonPublic)
6507                 {
6508                         return remove;
6509                 }
6510
6511                 public override MethodInfo GetRaiseMethod (bool nonPublic)
6512                 {
6513                         return raise;
6514                 }
6515
6516                 //
6517                 // These methods make "MyEventInfo" look like a Builder
6518                 //
6519                 public void SetRaiseMethod (MethodBuilder raiseMethod)
6520                 {
6521                         raise = raiseMethod;
6522                         MyBuilder.SetRaiseMethod (raiseMethod);
6523                 }
6524
6525                 public void SetRemoveOnMethod (MethodBuilder removeMethod)
6526                 {
6527                         remove = removeMethod;
6528                         MyBuilder.SetRemoveOnMethod (removeMethod);
6529                 }
6530
6531                 public void SetAddOnMethod (MethodBuilder addMethod)
6532                 {
6533                         add = addMethod;
6534                         MyBuilder.SetAddOnMethod (addMethod);
6535                 }
6536
6537                 public void SetCustomAttribute (CustomAttributeBuilder cb)
6538                 {
6539                         MyBuilder.SetCustomAttribute (cb);
6540                 }
6541
6542                 public override object [] GetCustomAttributes (bool inherit)
6543                 {
6544                         // FIXME : There's nothing which can be seemingly done here because
6545                         // we have no way of getting at the custom attribute objects of the
6546                         // EventBuilder !
6547                         return null;
6548                 }
6549
6550                 public override object [] GetCustomAttributes (Type t, bool inherit)
6551                 {
6552                         // FIXME : Same here !
6553                         return null;
6554                 }
6555
6556                 public override bool IsDefined (Type t, bool b)
6557                 {
6558                         return true;
6559                 }
6560
6561                 public override EventAttributes Attributes {
6562                         get {
6563                                 return attributes;
6564                         }
6565                 }
6566
6567                 public override string Name {
6568                         get {
6569                                 return name;
6570                         }
6571                 }
6572
6573                 public override Type DeclaringType {
6574                         get {
6575                                 return declaring_type;
6576                         }
6577                 }
6578
6579                 public override Type ReflectedType {
6580                         get {
6581                                 return reflected_type;
6582                         }
6583                 }
6584
6585                 public Type EventType {
6586                         get {
6587                                 return event_type;
6588                         }
6589                 }
6590
6591                 public void SetUsed ()
6592                 {
6593                         if (my_event != null) {
6594                                 my_event.SetAssigned ();
6595                                 my_event.SetMemberIsUsed ();
6596                         }
6597                 }
6598         }
6599
6600         /// <summary>
6601         /// For case when event is declared like property (with add and remove accessors).
6602         /// </summary>
6603         public class EventProperty: Event {
6604
6605                 static string[] attribute_targets = new string [] { "event" }; // "property" target was disabled for 2.0 version
6606
6607                 public EventProperty (TypeContainer parent, Expression type, int mod_flags,
6608                                       bool is_iface, MemberName name, Object init,
6609                                       Attributes attrs, Accessor add, Accessor remove,
6610                                       Location loc)
6611                         : base (parent, type, mod_flags, is_iface, name, init, attrs, loc)
6612                 {
6613                         Add = new AddDelegateMethod (this, add);
6614                         Remove = new RemoveDelegateMethod (this, remove);
6615
6616                         // For this event syntax we don't report error CS0067
6617                         // because it is hard to do it.
6618                         SetAssigned ();
6619                 }
6620
6621                 public override string[] ValidAttributeTargets {
6622                         get {
6623                                 return attribute_targets;
6624                         }
6625                 }
6626         }
6627
6628         /// <summary>
6629         /// Event is declared like field.
6630         /// </summary>
6631         public class EventField: Event {
6632
6633                 static string[] attribute_targets = new string [] { "event", "field", "method" };
6634                 static string[] attribute_targets_interface = new string[] { "event", "method" };
6635
6636                 public EventField (TypeContainer parent, Expression type, int mod_flags,
6637                                    bool is_iface, MemberName name, Object init,
6638                                    Attributes attrs, Location loc)
6639                         : base (parent, type, mod_flags, is_iface, name, init, attrs, loc)
6640                 {
6641                         Add = new AddDelegateMethod (this);
6642                         Remove = new RemoveDelegateMethod (this);
6643                 }
6644
6645                 public override void ApplyAttributeBuilder (Attribute a, CustomAttributeBuilder cb)
6646                 {
6647                         if (a.Target == AttributeTargets.Field) {
6648                                 FieldBuilder.SetCustomAttribute (cb);
6649                                 return;
6650                         }
6651
6652                         if (a.Target == AttributeTargets.Method) {
6653                                 Add.ApplyAttributeBuilder (a, cb);
6654                                 Remove.ApplyAttributeBuilder (a, cb);
6655                                 return;
6656                         }
6657
6658                         base.ApplyAttributeBuilder (a, cb);
6659                 }
6660
6661                 public override string[] ValidAttributeTargets {
6662                         get {
6663                                 return IsInterface ? attribute_targets_interface : attribute_targets;
6664                         }
6665                 }
6666         }
6667
6668         public abstract class Event : FieldBase {
6669
6670                 protected sealed class AddDelegateMethod: DelegateMethod
6671                 {
6672
6673                         public AddDelegateMethod (Event method):
6674                                 base (method, "add_")
6675                         {
6676                         }
6677
6678                         public AddDelegateMethod (Event method, Accessor accessor):
6679                                 base (method, accessor, "add_")
6680                         {
6681                         }
6682
6683                         protected override MethodInfo DelegateMethodInfo {
6684                                 get {
6685                                         return TypeManager.delegate_combine_delegate_delegate;
6686                                 }
6687                         }
6688
6689                 }
6690
6691                 protected sealed class RemoveDelegateMethod: DelegateMethod
6692                 {
6693                         public RemoveDelegateMethod (Event method):
6694                                 base (method, "remove_")
6695                         {
6696                         }
6697
6698                         public RemoveDelegateMethod (Event method, Accessor accessor):
6699                                 base (method, accessor, "remove_")
6700                         {
6701                         }
6702
6703                         protected override MethodInfo DelegateMethodInfo {
6704                                 get {
6705                                         return TypeManager.delegate_remove_delegate_delegate;
6706                                 }
6707                         }
6708
6709                 }
6710
6711                 public abstract class DelegateMethod: AbstractPropertyEventMethod
6712                 {
6713                         protected readonly Event method;
6714                         ImplicitParameter param_attr;
6715
6716                         static string[] attribute_targets = new string [] { "method", "param", "return" };
6717
6718                         public DelegateMethod (Event method, string prefix)
6719                                 : base (method, prefix)
6720                         {
6721                                 this.method = method;
6722                         }
6723
6724                         public DelegateMethod (Event method, Accessor accessor, string prefix)
6725                                 : base (method, accessor, prefix)
6726                         {
6727                                 this.method = method;
6728                         }
6729
6730                         protected override void ApplyToExtraTarget(Attribute a, CustomAttributeBuilder cb)
6731                         {
6732                                 if (a.Target == AttributeTargets.Parameter) {
6733                                         if (param_attr == null)
6734                                                 param_attr = new ImplicitParameter (method_data.MethodBuilder, method.Location);
6735
6736                                         param_attr.ApplyAttributeBuilder (a, cb);
6737                                         return;
6738                                 }
6739
6740                                 base.ApplyAttributeBuilder (a, cb);
6741                         }
6742
6743                         public override AttributeTargets AttributeTargets {
6744                                 get {
6745                                         return AttributeTargets.Method;
6746                                 }
6747                         }
6748
6749                         public override bool IsClsCompliaceRequired(DeclSpace ds)
6750                         {
6751                                 return method.IsClsCompliaceRequired (ds);
6752                         }
6753
6754                         public MethodBuilder Define (TypeContainer container, InternalParameters ip)
6755                         {
6756                                 method_data = new MethodData (method, ip, method.ModFlags,
6757                                         method.flags | MethodAttributes.HideBySig | MethodAttributes.SpecialName, this);
6758
6759                                 if (!method_data.Define (container))
6760                                         return null;
6761
6762                                 MethodBuilder mb = method_data.MethodBuilder;
6763                                 mb.DefineParameter (1, ParameterAttributes.None, "value");
6764                                 return mb;
6765                         }
6766
6767
6768                         protected override void EmitMethod (TypeContainer tc)
6769                         {
6770                                 if (block != null) {
6771                                         base.EmitMethod (tc);
6772                                         return;
6773                                 }
6774
6775                                 if ((method.ModFlags & (Modifiers.ABSTRACT | Modifiers.EXTERN)) != 0)
6776                                         return;
6777
6778                                 ILGenerator ig = method_data.MethodBuilder.GetILGenerator ();
6779                                 FieldInfo field_info = (FieldInfo)method.FieldBuilder;
6780
6781                                 method_data.MethodBuilder.SetImplementationFlags (MethodImplAttributes.Synchronized);
6782                                 if ((method.ModFlags & Modifiers.STATIC) != 0) {
6783                                         ig.Emit (OpCodes.Ldsfld, field_info);
6784                                         ig.Emit (OpCodes.Ldarg_0);
6785                                         ig.Emit (OpCodes.Call, DelegateMethodInfo);
6786                                         ig.Emit (OpCodes.Castclass, method.MemberType);
6787                                         ig.Emit (OpCodes.Stsfld, field_info);
6788                                 } else {
6789                                         ig.Emit (OpCodes.Ldarg_0);
6790                                         ig.Emit (OpCodes.Ldarg_0);
6791                                         ig.Emit (OpCodes.Ldfld, field_info);
6792                                         ig.Emit (OpCodes.Ldarg_1);
6793                                         ig.Emit (OpCodes.Call, DelegateMethodInfo);
6794                                         ig.Emit (OpCodes.Castclass, method.MemberType);
6795                                         ig.Emit (OpCodes.Stfld, field_info);
6796                                 }
6797                                 ig.Emit (OpCodes.Ret);
6798                         }
6799
6800                         protected abstract MethodInfo DelegateMethodInfo { get; }
6801
6802                         public override Type[] ParameterTypes {
6803                                 get {
6804                                         return new Type[] { method.MemberType };
6805                                 }
6806                         }
6807
6808                         public override Type ReturnType {
6809                                 get {
6810                                         return TypeManager.void_type;
6811                                 }
6812                         }
6813
6814                         public override EmitContext CreateEmitContext (TypeContainer tc,
6815                                                                        ILGenerator ig)
6816                         {
6817                                 return new EmitContext (
6818                                         tc, method.Parent, Location, ig, ReturnType,
6819                                         method.ModFlags, false);
6820                         }
6821
6822                         public override ObsoleteAttribute GetObsoleteAttribute ()
6823                         {
6824                                 return method.GetObsoleteAttribute (method.Parent);
6825                         }
6826
6827                         public override string[] ValidAttributeTargets {
6828                                 get {
6829                                         return attribute_targets;
6830                                 }
6831                         }
6832                 }
6833
6834
6835                 const int AllowedModifiers =
6836                         Modifiers.NEW |
6837                         Modifiers.PUBLIC |
6838                         Modifiers.PROTECTED |
6839                         Modifiers.INTERNAL |
6840                         Modifiers.PRIVATE |
6841                         Modifiers.STATIC |
6842                         Modifiers.VIRTUAL |
6843                         Modifiers.SEALED |
6844                         Modifiers.OVERRIDE |
6845                         Modifiers.UNSAFE |
6846                         Modifiers.ABSTRACT;
6847
6848                 const int AllowedInterfaceModifiers =
6849                         Modifiers.NEW;
6850
6851                 public DelegateMethod Add, Remove;
6852                 public MyEventBuilder     EventBuilder;
6853                 public MethodBuilder AddBuilder, RemoveBuilder;
6854
6855                 public Event (TypeContainer parent, Expression type, int mod_flags,
6856                               bool is_iface, MemberName name, Object init, Attributes attrs,
6857                               Location loc)
6858                         : base (parent, type, mod_flags,
6859                                 is_iface ? AllowedInterfaceModifiers : AllowedModifiers,
6860                                 name, init, attrs, loc)
6861                 {
6862                         IsInterface = is_iface;
6863                 }
6864
6865                 public override void ApplyAttributeBuilder (Attribute a, CustomAttributeBuilder cb)
6866                 {
6867                         if (a.Type.IsSubclassOf (TypeManager.security_attr_type)) {
6868                                 a.Error_InvalidSecurityParent ();
6869                                 return;
6870                         }
6871
6872                         EventBuilder.SetCustomAttribute (cb);
6873                 }
6874
6875                 public bool AreAccessorsDuplicateImplementation (MethodCore mc)
6876                 {
6877                         return Add.IsDuplicateImplementation (mc) || Remove.IsDuplicateImplementation (mc);
6878                 }
6879
6880                 public override AttributeTargets AttributeTargets {
6881                         get {
6882                                 return AttributeTargets.Event;
6883                         }
6884                 }
6885
6886                 public override bool Define ()
6887                 {
6888                         EventAttributes e_attr;
6889                         e_attr = EventAttributes.None;
6890
6891                         if (!DoDefine ())
6892                                 return false;
6893
6894                         if (init != null && ((ModFlags & Modifiers.ABSTRACT) != 0)){
6895                                 Report.Error (74, Location, "`" + GetSignatureForError () +
6896                                               "': abstract event cannot have an initializer");
6897                                 return false;
6898                         }
6899
6900                         if (!MemberType.IsSubclassOf (TypeManager.delegate_type)) {
6901                                 Report.Error (66, Location, "`{0}': event must be of a delegate type", GetSignatureForError ());
6902                                 return false;
6903                         }
6904
6905                         EmitContext ec = Parent.EmitContext;
6906                         if (ec == null)
6907                                 throw new InternalErrorException ("Event.Define called too early?");
6908                         bool old_unsafe = ec.InUnsafe;
6909                         ec.InUnsafe = InUnsafe;
6910
6911                         Parameter [] parms = new Parameter [1];
6912                         parms [0] = new Parameter (Type, "value", Parameter.Modifier.NONE, null, Location);
6913                         Parameters parameters = new Parameters (parms, null);
6914                         Type [] types = parameters.GetParameterInfo (ec);
6915                         InternalParameters ip = new InternalParameters (types, parameters);
6916
6917                         ec.InUnsafe = old_unsafe;
6918
6919                         if (!CheckBase ())
6920                                 return false;
6921
6922                         //
6923                         // Now define the accessors
6924                         //
6925
6926                         AddBuilder = Add.Define (Parent, ip);
6927                         if (AddBuilder == null)
6928                                 return false;
6929
6930                         RemoveBuilder = Remove.Define (Parent, ip);
6931                         if (RemoveBuilder == null)
6932                                 return false;
6933
6934                         EventBuilder = new MyEventBuilder (this, Parent.TypeBuilder, Name, e_attr, MemberType);
6935
6936                         if (Add.Block == null && Remove.Block == null && !IsInterface) {
6937                                 FieldBuilder = Parent.TypeBuilder.DefineField (
6938                                         Name, MemberType,
6939                                         FieldAttributes.Private | ((ModFlags & Modifiers.STATIC) != 0 ? FieldAttributes.Static : 0));
6940                                 TypeManager.RegisterPrivateFieldOfEvent (
6941                                         (EventInfo) EventBuilder, FieldBuilder);
6942                                 TypeManager.RegisterFieldBase (FieldBuilder, this);
6943                         }
6944
6945                         EventBuilder.SetAddOnMethod (AddBuilder);
6946                         EventBuilder.SetRemoveOnMethod (RemoveBuilder);
6947
6948                         TypeManager.RegisterEvent (EventBuilder, AddBuilder, RemoveBuilder);
6949                         return true;
6950                 }
6951
6952                 protected override bool CheckBase ()
6953                 {
6954                         if (!base.CheckBase ())
6955                                 return false;
6956
6957                         if (conflict_symbol != null && (ModFlags & Modifiers.NEW) == 0) {
6958                                 if (!(conflict_symbol is EventInfo)) {
6959                                         Report.SymbolRelatedToPreviousError (conflict_symbol);
6960                                         Report.Error (72, Location, "Event `{0}' can override only event", GetSignatureForError ());
6961                                         return false;
6962                                 }
6963                         }
6964
6965                         return true;
6966                 }
6967
6968                 public override void Emit ()
6969                 {
6970                         if (OptAttributes != null) {
6971                                 EmitContext ec = new EmitContext (
6972                                         Parent, Location, null, MemberType, ModFlags);
6973                                 OptAttributes.Emit (ec, this);
6974                         }
6975
6976                         Add.Emit (Parent);
6977                         Remove.Emit (Parent);
6978
6979                         base.Emit ();
6980                 }
6981
6982                 public override string GetSignatureForError ()
6983                 {
6984                         return base.GetSignatureForError ();
6985                 }
6986
6987                 //
6988                 //   Represents header string for documentation comment.
6989                 //
6990                 public override string DocCommentHeader {
6991                         get { return "E:"; }
6992                 }
6993         }
6994
6995
6996         public class Indexer : PropertyBase {
6997
6998                 class GetIndexerMethod: GetMethod
6999                 {
7000                         public GetIndexerMethod (MethodCore method):
7001                                 base (method)
7002                         {
7003                         }
7004
7005                         public GetIndexerMethod (MethodCore method, Accessor accessor):
7006                                 base (method, accessor)
7007                         {
7008                         }
7009
7010                         public override Type[] ParameterTypes {
7011                                 get {
7012                                         return method.ParameterTypes;
7013                                 }
7014                         }
7015                 }
7016
7017                 class SetIndexerMethod: SetMethod
7018                 {
7019                         readonly Parameters parameters;
7020
7021                         public SetIndexerMethod (MethodCore method):
7022                                 base (method)
7023                         {
7024                         }
7025
7026                         public SetIndexerMethod (MethodCore method, Parameters parameters, Accessor accessor):
7027                                 base (method, accessor)
7028                         {
7029                                 this.parameters = parameters;
7030                         }
7031
7032                         public override Type[] ParameterTypes {
7033                                 get {
7034                                         int top = method.ParameterTypes.Length;
7035                                         Type [] set_pars = new Type [top + 1];
7036                                         method.ParameterTypes.CopyTo (set_pars, 0);
7037                                         set_pars [top] = method.MemberType;
7038                                         return set_pars;
7039                                 }
7040                         }
7041
7042                         protected override InternalParameters GetParameterInfo (EmitContext ec)
7043                         {
7044                                 Parameter [] fixed_parms = parameters.FixedParameters;
7045
7046                                 if (fixed_parms == null){
7047                                         throw new Exception ("We currently do not support only array arguments in an indexer at: " + method.Location);
7048                                         // BUG BUG BUG BUG BUG BUG BUG BUG BUG BUG
7049                                         // BUG BUG BUG BUG BUG BUG BUG BUG BUG BUG
7050                                         //
7051                                         // Here is the problem: the `value' parameter has
7052                                         // to come *after* the array parameter in the declaration
7053                                         // like this:
7054                                         // X (object [] x, Type value)
7055                                         // .param [0]
7056                                         //
7057                                         // BUG BUG BUG BUG BUG BUG BUG BUG BUG BUG
7058                                         // BUG BUG BUG BUG BUG BUG BUG BUG BUG BUG
7059
7060                                 }
7061
7062                                 Parameter [] tmp = new Parameter [fixed_parms.Length + 1];
7063
7064                                 fixed_parms.CopyTo (tmp, 0);
7065                                 tmp [fixed_parms.Length] = new Parameter (
7066                                         method.Type, "value", Parameter.Modifier.NONE, null, method.Location);
7067
7068                                 Parameters set_formal_params = new Parameters (tmp, null);
7069                                 Type [] types = set_formal_params.GetParameterInfo (ec);
7070
7071                                 return new InternalParameters (types, set_formal_params);
7072                         }
7073                 }
7074
7075
7076                 const int AllowedModifiers =
7077                         Modifiers.NEW |
7078                         Modifiers.PUBLIC |
7079                         Modifiers.PROTECTED |
7080                         Modifiers.INTERNAL |
7081                         Modifiers.PRIVATE |
7082                         Modifiers.VIRTUAL |
7083                         Modifiers.SEALED |
7084                         Modifiers.OVERRIDE |
7085                         Modifiers.UNSAFE |
7086                         Modifiers.EXTERN |
7087                         Modifiers.ABSTRACT;
7088
7089                 const int AllowedInterfaceModifiers =
7090                         Modifiers.NEW;
7091
7092
7093                 public Indexer (TypeContainer ds, Expression type, MemberName name, int mod,
7094                                 bool is_iface, Parameters parameters, Attributes attrs,
7095                                 Accessor get_block, Accessor set_block, Location loc)
7096                         : base (ds, type, mod,
7097                                 is_iface ? AllowedInterfaceModifiers : AllowedModifiers,
7098                                 is_iface, name, parameters, attrs, loc)
7099                 {
7100                         if (get_block == null)
7101                                 Get = new GetIndexerMethod (this);
7102                         else
7103                                 Get = new GetIndexerMethod (this, get_block);
7104
7105                         if (set_block == null)
7106                                 Set = new SetIndexerMethod (this);
7107                         else
7108                                 Set = new SetIndexerMethod (this, parameters, set_block);
7109                 }
7110
7111                 public override bool Define ()
7112                 {
7113                         PropertyAttributes prop_attr =
7114                                 PropertyAttributes.RTSpecialName |
7115                                 PropertyAttributes.SpecialName;
7116
7117                         if (!base.Define ())
7118                                 return false;
7119
7120                         if (MemberType == TypeManager.void_type) {
7121                                 Report.Error (620, Location, "Indexers cannot have void type");
7122                                 return false;
7123                         }
7124
7125                         if (OptAttributes != null) {
7126                                 Attribute indexer_attr = OptAttributes.Search (TypeManager.indexer_name_type, ec);
7127                                 if (indexer_attr != null) {
7128                                         // Remove the attribute from the list because it is not emitted
7129                                         OptAttributes.Attrs.Remove (indexer_attr);
7130
7131                                         ShortName = indexer_attr.GetIndexerAttributeValue (ec);
7132
7133                                         if (IsExplicitImpl) {
7134                                                 Report.Error (415, indexer_attr.Location,
7135                                                               "The `IndexerName' attribute is valid only on an " +
7136                                                               "indexer that is not an explicit interface member declaration");
7137                                                 return false;
7138                                         }
7139
7140                                         if ((ModFlags & Modifiers.OVERRIDE) != 0) {
7141                                                 Report.Error (609, indexer_attr.Location,
7142                                                               "Cannot set the `IndexerName' attribute on an indexer marked override");
7143                                                 return false;
7144                                         }
7145
7146                                         if (!Tokenizer.IsValidIdentifier (ShortName)) {
7147                                                 Report.Error (633, indexer_attr.Location,
7148                                                               "The argument to the `IndexerName' attribute must be a valid identifier");
7149                                                 return false;
7150                                         }
7151                                 }
7152                         }
7153
7154                         if (InterfaceType != null) {
7155                                 string base_IndexerName = TypeManager.IndexerPropertyName (InterfaceType);
7156                                 if (base_IndexerName != Name)
7157                                         ShortName = base_IndexerName;
7158                         }
7159
7160                         if (!Parent.AddToMemberContainer (this) ||
7161                                 !Parent.AddToMemberContainer (Get) || !Parent.AddToMemberContainer (Set))
7162                                 return false;
7163
7164                         if (!CheckBase ())
7165                                 return false;
7166
7167                         flags |= MethodAttributes.HideBySig | MethodAttributes.SpecialName;
7168                         if (!Get.IsDummy){
7169                                 GetBuilder = Get.Define (Parent);
7170                                 if (GetBuilder == null)
7171                                         return false;
7172                         }
7173
7174                         if (!Set.IsDummy){
7175                                 SetBuilder = Set.Define (Parent);
7176                                 if (SetBuilder == null)
7177                                         return false;
7178                         }
7179
7180                         //
7181                         // Now name the parameters
7182                         //
7183                         Parameter [] p = Parameters.FixedParameters;
7184                         if (p != null) {
7185                                 if ((p [0].ModFlags & Parameter.Modifier.ISBYREF) != 0) {
7186                                         Report.Error (631, Location, "ref and out are not valid in this context");
7187                                         return false;
7188                                 }
7189
7190                                 int i;
7191
7192                                 for (i = 0; i < p.Length; ++i) {
7193                                         if (!Get.IsDummy)
7194                                                 GetBuilder.DefineParameter (
7195                                                         i + 1, p [i].Attributes, p [i].Name);
7196
7197                                         if (!Set.IsDummy)
7198                                                 SetBuilder.DefineParameter (
7199                                                         i + 1, p [i].Attributes, p [i].Name);
7200                                 }
7201
7202                                 if (!Set.IsDummy)
7203                                         SetBuilder.DefineParameter (
7204                                                 i + 1, ParameterAttributes.None, "value");
7205
7206                                 if (i != ParameterTypes.Length) {
7207                                         Parameter array_param = Parameters.ArrayParameter;
7208
7209                                         SetBuilder.DefineParameter (
7210                                                 i + 1, array_param.Attributes, array_param.Name);
7211                                 }
7212                         }
7213
7214                         PropertyBuilder = Parent.TypeBuilder.DefineProperty (
7215                                 Name, prop_attr, MemberType, ParameterTypes);
7216
7217                         if (!Get.IsDummy)
7218                                 PropertyBuilder.SetGetMethod (GetBuilder);
7219
7220                         if (!Set.IsDummy)
7221                                 PropertyBuilder.SetSetMethod (SetBuilder);
7222
7223                         TypeManager.RegisterIndexer (PropertyBuilder, GetBuilder, SetBuilder, ParameterTypes);
7224
7225                         return true;
7226                 }
7227
7228                 public override string GetSignatureForError ()
7229                 {
7230                         StringBuilder sb = new StringBuilder (Parent.GetSignatureForError ());
7231                         if (MemberName.Left != null) {
7232                                 sb.Append ('.');
7233                                 sb.Append (MemberName.Left);
7234                         }
7235
7236                         sb.Append (".this");
7237                         sb.Append (Parameters.GetSignatureForError ().Replace ('(', '[').Replace (')', ']'));
7238                         return sb.ToString ();
7239                 }
7240
7241                 public override bool MarkForDuplicationCheck ()
7242                 {
7243                         caching_flags |= Flags.TestMethodDuplication;
7244                         return true;
7245                 }
7246
7247         }
7248
7249         public class Operator : MethodCore, IIteratorContainer {
7250
7251                 const int AllowedModifiers =
7252                         Modifiers.PUBLIC |
7253                         Modifiers.UNSAFE |
7254                         Modifiers.EXTERN |
7255                         Modifiers.STATIC;
7256
7257                 public enum OpType : byte {
7258
7259                         // Unary operators
7260                         LogicalNot,
7261                         OnesComplement,
7262                         Increment,
7263                         Decrement,
7264                         True,
7265                         False,
7266
7267                         // Unary and Binary operators
7268                         Addition,
7269                         Subtraction,
7270
7271                         UnaryPlus,
7272                         UnaryNegation,
7273
7274                         // Binary operators
7275                         Multiply,
7276                         Division,
7277                         Modulus,
7278                         BitwiseAnd,
7279                         BitwiseOr,
7280                         ExclusiveOr,
7281                         LeftShift,
7282                         RightShift,
7283                         Equality,
7284                         Inequality,
7285                         GreaterThan,
7286                         LessThan,
7287                         GreaterThanOrEqual,
7288                         LessThanOrEqual,
7289
7290                         // Implicit and Explicit
7291                         Implicit,
7292                         Explicit,
7293
7294                         // Just because of enum
7295                         TOP
7296                 };
7297
7298                 public readonly OpType OperatorType;
7299                 public MethodBuilder   OperatorMethodBuilder;
7300
7301                 public Method OperatorMethod;
7302
7303                 static string[] attribute_targets = new string [] { "method", "return" };
7304
7305                 public Operator (TypeContainer parent, OpType type, Expression ret_type,
7306                                  int mod_flags, Parameters parameters,
7307                                  ToplevelBlock block, Attributes attrs, Location loc)
7308                         : base (parent, ret_type, mod_flags, AllowedModifiers, false,
7309                                 new MemberName ("op_" + type), attrs, parameters, loc)
7310                 {
7311                         OperatorType = type;
7312                         Block = block;
7313                 }
7314
7315                 public override void ApplyAttributeBuilder (Attribute a, CustomAttributeBuilder cb)
7316                 {
7317                         OperatorMethod.ApplyAttributeBuilder (a, cb);
7318                 }
7319
7320                 public override AttributeTargets AttributeTargets {
7321                         get {
7322                                 return AttributeTargets.Method;
7323                         }
7324                 }
7325
7326                 protected override bool CheckForDuplications()
7327                 {
7328                         ArrayList ar = Parent.Operators;
7329                         if (ar != null) {
7330                                 int arLen = ar.Count;
7331
7332                                 for (int i = 0; i < arLen; i++) {
7333                                         Operator o = (Operator) ar [i];
7334                                         if (IsDuplicateImplementation (o))
7335                                                 return false;
7336                                 }
7337                         }
7338
7339                         ar = Parent.Methods;
7340                         if (ar != null) {
7341                                 int arLen = ar.Count;
7342
7343                                 for (int i = 0; i < arLen; i++) {
7344                                         Method m = (Method) ar [i];
7345                                         if (IsDuplicateImplementation (m))
7346                                                 return false;
7347                                 }
7348                         }
7349
7350                         return true;
7351                 }
7352
7353                 public override bool Define ()
7354                 {
7355                         const int RequiredModifiers = Modifiers.PUBLIC | Modifiers.STATIC;
7356                         if ((ModFlags & RequiredModifiers) != RequiredModifiers){
7357                                 Report.Error (558, Location, "User-defined operator `{0}' must be declared static and public", GetSignatureForError ());
7358                                 return false;
7359                         }
7360
7361                         if (!DoDefine ())
7362                                 return false;
7363
7364                         if (MemberType == TypeManager.void_type) {
7365                                 Report.Error (590, Location, "User-defined operators cannot return void");
7366                                 return false;
7367                         }
7368
7369                         OperatorMethod = new Method (
7370                                 Parent, Type, ModFlags, false, MemberName,
7371                                 Parameters, OptAttributes, Location);
7372
7373                         OperatorMethod.Block = Block;
7374                         OperatorMethod.IsOperator = this;
7375                         OperatorMethod.flags |= MethodAttributes.SpecialName | MethodAttributes.HideBySig;
7376                         OperatorMethod.Define ();
7377
7378                         if (OperatorMethod.MethodBuilder == null)
7379                                 return false;
7380
7381                         OperatorMethodBuilder = OperatorMethod.MethodBuilder;
7382
7383                         parameter_types = OperatorMethod.ParameterTypes;
7384                         Type declaring_type = OperatorMethodBuilder.DeclaringType;
7385                         Type return_type = OperatorMethod.ReturnType;
7386                         Type first_arg_type = parameter_types [0];
7387
7388                         if (!CheckBase ())
7389                                 return false;
7390
7391                         // Rules for conversion operators
7392
7393                         if (OperatorType == OpType.Implicit || OperatorType == OpType.Explicit) {
7394                                 if (first_arg_type == return_type && first_arg_type == declaring_type){
7395                                         Report.Error (555, Location,
7396                                                 "User-defined operator cannot take an object of the enclosing type and convert to an object of the enclosing type");
7397                                         return false;
7398                                 }
7399
7400                                 if (first_arg_type != declaring_type && return_type != declaring_type){
7401                                         Report.Error (
7402                                                 556, Location,
7403                                                 "User-defined conversion must convert to or from the " +
7404                                                 "enclosing type");
7405                                         return false;
7406                                 }
7407
7408                                 if (first_arg_type == TypeManager.object_type ||
7409                                         return_type == TypeManager.object_type){
7410                                         Report.Error (
7411                                                 -8, Location,
7412                                                 "User-defined conversion cannot convert to or from " +
7413                                                 "object type");
7414                                         return false;
7415                                 }
7416
7417                                 if (first_arg_type.IsInterface || return_type.IsInterface){
7418                                         Report.Error (552, Location, "User-defined conversion `{0}' cannot convert to or from an interface type",
7419                                                 GetSignatureForError ());
7420                                         return false;
7421                                 }
7422
7423                                 if (first_arg_type.IsSubclassOf (return_type)
7424                                         || return_type.IsSubclassOf (first_arg_type)){
7425                                         if (declaring_type.IsSubclassOf (return_type)) {
7426                                                 Report.Error (553, Location, "User-defined conversion `{0}' cannot convert to or from base class",
7427                                                         GetSignatureForError ());
7428                                                 return false;
7429                                         }
7430                                         Report.Error (554, Location, "User-defined conversion `{0}' cannot convert to or from derived class",
7431                                                 GetSignatureForError ());
7432                                         return false;
7433                                 }
7434                         } else if (OperatorType == OpType.LeftShift || OperatorType == OpType.RightShift) {
7435                                 if (first_arg_type != declaring_type || parameter_types [1] != TypeManager.int32_type) {
7436                                         Report.Error (564, Location, "Overloaded shift operator must have the type of the first operand be the containing type, and the type of the second operand must be int");
7437                                         return false;
7438                                 }
7439                         } else if (Parameters.FixedParameters.Length == 1) {
7440                                 // Checks for Unary operators
7441
7442                                 if (OperatorType == OpType.Increment || OperatorType == OpType.Decrement) {
7443                                         if (return_type != declaring_type && !return_type.IsSubclassOf (declaring_type)) {
7444                                                 Report.Error (448, Location,
7445                                                         "The return type for ++ or -- operator must be the containing type or derived from the containing type");
7446                                                 return false;
7447                                         }
7448                                         if (first_arg_type != declaring_type) {
7449                                                 Report.Error (
7450                                                         559, Location, "The parameter type for ++ or -- operator must be the containing type");
7451                                                 return false;
7452                                         }
7453                                 }
7454
7455                                 if (first_arg_type != declaring_type){
7456                                         Report.Error (
7457                                                 562, Location,
7458                                                 "The parameter of a unary operator must be the " +
7459                                                 "containing type");
7460                                         return false;
7461                                 }
7462
7463                                 if (OperatorType == OpType.True || OperatorType == OpType.False) {
7464                                         if (return_type != TypeManager.bool_type){
7465                                                 Report.Error (
7466                                                         215, Location,
7467                                                         "The return type of operator True or False " +
7468                                                         "must be bool");
7469                                                 return false;
7470                                         }
7471                                 }
7472
7473                         } else {
7474                                 // Checks for Binary operators
7475
7476                                 if (first_arg_type != declaring_type &&
7477                                     parameter_types [1] != declaring_type){
7478                                         Report.Error (
7479                                                 563, Location,
7480                                                 "One of the parameters of a binary operator must " +
7481                                                 "be the containing type");
7482                                         return false;
7483                                 }
7484                         }
7485
7486                         return true;
7487                 }
7488
7489                 public override void Emit ()
7490                 {
7491                         //
7492                         // abstract or extern methods have no bodies
7493                         //
7494                         if ((ModFlags & (Modifiers.ABSTRACT | Modifiers.EXTERN)) != 0)
7495                                 return;
7496
7497                         OperatorMethod.Emit ();
7498                         Block = null;
7499                 }
7500
7501                 // Operator cannot be override
7502                 protected override MethodInfo FindOutBaseMethod (TypeContainer container, ref Type base_ret_type)
7503                 {
7504                         return null;
7505                 }
7506
7507                 public static string GetName (OpType ot)
7508                 {
7509                         switch (ot){
7510                         case OpType.LogicalNot:
7511                                 return "!";
7512                         case OpType.OnesComplement:
7513                                 return "~";
7514                         case OpType.Increment:
7515                                 return "++";
7516                         case OpType.Decrement:
7517                                 return "--";
7518                         case OpType.True:
7519                                 return "true";
7520                         case OpType.False:
7521                                 return "false";
7522                         case OpType.Addition:
7523                                 return "+";
7524                         case OpType.Subtraction:
7525                                 return "-";
7526                         case OpType.UnaryPlus:
7527                                 return "+";
7528                         case OpType.UnaryNegation:
7529                                 return "-";
7530                         case OpType.Multiply:
7531                                 return "*";
7532                         case OpType.Division:
7533                                 return "/";
7534                         case OpType.Modulus:
7535                                 return "%";
7536                         case OpType.BitwiseAnd:
7537                                 return "&";
7538                         case OpType.BitwiseOr:
7539                                 return "|";
7540                         case OpType.ExclusiveOr:
7541                                 return "^";
7542                         case OpType.LeftShift:
7543                                 return "<<";
7544                         case OpType.RightShift:
7545                                 return ">>";
7546                         case OpType.Equality:
7547                                 return "==";
7548                         case OpType.Inequality:
7549                                 return "!=";
7550                         case OpType.GreaterThan:
7551                                 return ">";
7552                         case OpType.LessThan:
7553                                 return "<";
7554                         case OpType.GreaterThanOrEqual:
7555                                 return ">=";
7556                         case OpType.LessThanOrEqual:
7557                                 return "<=";
7558                         case OpType.Implicit:
7559                                 return "implicit";
7560                         case OpType.Explicit:
7561                                 return "explicit";
7562                         default: return "";
7563                         }
7564                 }
7565
7566                 public static OpType GetOperatorType (string name)
7567                 {
7568                         if (name.StartsWith ("op_")){
7569                                 for (int i = 0; i < Unary.oper_names.Length; ++i) {
7570                                         if (Unary.oper_names [i] == name)
7571                                                 return (OpType)i;
7572                                 }
7573
7574                                 for (int i = 0; i < Binary.oper_names.Length; ++i) {
7575                                         if (Binary.oper_names [i] == name)
7576                                                 return (OpType)i;
7577                                 }
7578                         }
7579                         return OpType.TOP;
7580                 }
7581
7582                 public override string GetSignatureForError ()
7583                 {
7584                         StringBuilder sb = new StringBuilder ();
7585                         if (OperatorType == OpType.Implicit || OperatorType == OpType.Explicit) {
7586                                 sb.AppendFormat ("{0}.{1} operator {2}", Parent.GetSignatureForError (), GetName (OperatorType), Type.Type == null ? Type.ToString () : TypeManager.CSharpName (Type.Type));
7587                         }
7588                         else {
7589                                 sb.AppendFormat ("{0}.operator {1}", Parent.GetSignatureForError (), GetName (OperatorType));
7590                         }
7591
7592                         sb.Append (Parameters.GetSignatureForError ());
7593                         return sb.ToString ();
7594                 }
7595
7596                 public override bool MarkForDuplicationCheck ()
7597                 {
7598                         caching_flags |= Flags.TestMethodDuplication;
7599                         return true;
7600                 }
7601
7602                 public override string[] ValidAttributeTargets {
7603                         get {
7604                                 return attribute_targets;
7605                         }
7606                 }
7607         }
7608
7609         //
7610         // This is used to compare method signatures
7611         //
7612         struct MethodSignature {
7613                 public string Name;
7614                 public Type RetType;
7615                 public Type [] Parameters;
7616
7617                 /// <summary>
7618                 ///    This delegate is used to extract methods which have the
7619                 ///    same signature as the argument
7620                 /// </summary>
7621                 public static MemberFilter method_signature_filter = new MemberFilter (MemberSignatureCompare);
7622
7623                 public MethodSignature (string name, Type ret_type, Type [] parameters)
7624                 {
7625                         Name = name;
7626                         RetType = ret_type;
7627
7628                         if (parameters == null)
7629                                 Parameters = TypeManager.NoTypes;
7630                         else
7631                                 Parameters = parameters;
7632                 }
7633
7634                 public override string ToString ()
7635                 {
7636                         string pars = "";
7637                         if (Parameters.Length != 0){
7638                                 System.Text.StringBuilder sb = new System.Text.StringBuilder ();
7639                                 for (int i = 0; i < Parameters.Length; i++){
7640                                         sb.Append (Parameters [i]);
7641                                         if (i+1 < Parameters.Length)
7642                                                 sb.Append (", ");
7643                                 }
7644                                 pars = sb.ToString ();
7645                         }
7646
7647                         return String.Format ("{0} {1} ({2})", RetType, Name, pars);
7648                 }
7649
7650                 public override int GetHashCode ()
7651                 {
7652                         return Name.GetHashCode ();
7653                 }
7654
7655                 public override bool Equals (Object o)
7656                 {
7657                         MethodSignature other = (MethodSignature) o;
7658
7659                         if (other.Name != Name)
7660                                 return false;
7661
7662                         if (other.RetType != RetType)
7663                                 return false;
7664
7665                         if (Parameters == null){
7666                                 if (other.Parameters == null)
7667                                         return true;
7668                                 return false;
7669                         }
7670
7671                         if (other.Parameters == null)
7672                                 return false;
7673
7674                         int c = Parameters.Length;
7675                         if (other.Parameters.Length != c)
7676                                 return false;
7677
7678                         for (int i = 0; i < c; i++)
7679                                 if (other.Parameters [i] != Parameters [i])
7680                                         return false;
7681
7682                         return true;
7683                 }
7684
7685                 static bool MemberSignatureCompare (MemberInfo m, object filter_criteria)
7686                 {
7687                         MethodSignature sig = (MethodSignature) filter_criteria;
7688
7689                         if (m.Name != sig.Name)
7690                                 return false;
7691
7692                         Type ReturnType;
7693                         MethodInfo mi = m as MethodInfo;
7694                         PropertyInfo pi = m as PropertyInfo;
7695
7696                         if (mi != null)
7697                                 ReturnType = mi.ReturnType;
7698                         else if (pi != null)
7699                                 ReturnType = pi.PropertyType;
7700                         else
7701                                 return false;
7702
7703                         //
7704                         // we use sig.RetType == null to mean `do not check the
7705                         // method return value.
7706                         //
7707                         if (sig.RetType != null)
7708                                 if (ReturnType != sig.RetType)
7709                                         return false;
7710
7711                         Type [] args;
7712                         if (mi != null)
7713                                 args = TypeManager.GetArgumentTypes (mi);
7714                         else
7715                                 args = TypeManager.GetArgumentTypes (pi);
7716                         Type [] sigp = sig.Parameters;
7717
7718                         if (args.Length != sigp.Length)
7719                                 return false;
7720
7721                         for (int i = args.Length; i > 0; ){
7722                                 i--;
7723                                 if (args [i] != sigp [i])
7724                                         return false;
7725                         }
7726                         return true;
7727                 }
7728         }
7729 }