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@gmail.com)
   7 //
   8 // Dual licensed under the terms of the MIT X11 or GNU GPL
   9 //
  10 // Copyright 2001, 2002, 2003 Ximian, Inc (http://www.ximian.com)
  11 // Copyright 2004-2011 Novell, Inc
  12 // Copyright 2011 Xamarin, Inc (http://www.xamarin.com)
  13 //
  14
  15 using System;
  16 using System.Linq;
  17 using System.Collections.Generic;
  18 using System.Runtime.InteropServices;
  19 using System.Security;
  20 using System.Security.Permissions;
  21 using System.Text;
  22 using System.Diagnostics;
  23 using Mono.CompilerServices.SymbolWriter;
  24
  25 #if MOBILE
  26 using XmlElement = System.Object;
  27 #endif
  28
  29 #if STATIC
  30 using SecurityType = System.Collections.Generic.List<IKVM.Reflection.Emit.CustomAttributeBuilder>;
  31 using IKVM.Reflection;
  32 using IKVM.Reflection.Emit;
  33 #else
  34 using SecurityType = System.Collections.Generic.Dictionary<System.Security.Permissions.SecurityAction, System.Security.PermissionSet>;
  35 using System.Reflection;
  36 using System.Reflection.Emit;
  37 #endif
  38
  39 namespace Mono.CSharp
  40 {
  41         //
  42         // General types container, used as a base class for all constructs which can hold types
  43         //
  44         public abstract class TypeContainer : MemberCore
  45         {
  46                 public readonly MemberKind Kind;
  47
  48                 protected List<TypeContainer> containers;
  49
  50                 TypeDefinition main_container;
  51
  52                 protected Dictionary<string, MemberCore> defined_names;
  53
  54                 protected bool is_defined;
  55
  56                 public int CounterAnonymousMethods { get; set; }
  57                 public int CounterAnonymousContainers { get; set; }
  58                 public int CounterSwitchTypes { get; set; }
  59
  60                 protected TypeContainer (TypeContainer parent, MemberName name, Attributes attrs, MemberKind kind)
  61                         : base (parent, name, attrs)
  62                 {
  63                         this.Kind = kind;
  64                         defined_names = new Dictionary<string, MemberCore> ();
  65                 }
  66
  67                 public override TypeSpec CurrentType {
  68                         get {
  69                                 return null;
  70                         }
  71                 }
  72
  73                 public Dictionary<string, MemberCore> DefinedNames {
  74                         get {
  75                                 return defined_names;
  76                         }
  77                 }
  78
  79                 public TypeDefinition PartialContainer {
  80                         get {
  81                                 return main_container;
  82                         }
  83                         protected set {
  84                                 main_container = value;
  85                         }
  86                 }
  87
  88                 public IList<TypeContainer> Containers {
  89                         get {
  90                                 return containers;
  91                         }
  92                 }
  93
  94                 //
  95                 // Any unattached attributes during parsing get added here. Used
  96                 // by FULL_AST mode
  97                 //
  98                 public Attributes UnattachedAttributes {
  99                         get; set;
 100                 }
 101
 102                 public void AddCompilerGeneratedClass (CompilerGeneratedContainer c)
 103                 {
 104                         AddTypeContainerMember (c);
 105                 }
 106
 107                 public virtual void AddPartial (TypeDefinition next_part)
 108                 {
 109                         MemberCore mc;
 110                         (PartialContainer ?? this).defined_names.TryGetValue (next_part.MemberName.Basename, out mc);
 111
 112                         AddPartial (next_part, mc as TypeDefinition);
 113                 }
 114
 115                 protected void AddPartial (TypeDefinition next_part, TypeDefinition existing)
 116                 {
 117                         next_part.ModFlags |= Modifiers.PARTIAL;
 118
 119                         if (existing == null) {
 120                                 AddTypeContainer (next_part);
 121                                 return;
 122                         }
 123
 124                         if ((existing.ModFlags & Modifiers.PARTIAL) == 0) {
 125                                 if (existing.Kind != next_part.Kind) {
 126                                         AddTypeContainer (next_part);
 127                                 } else {
 128                                         Report.SymbolRelatedToPreviousError (next_part);
 129                                         Error_MissingPartialModifier (existing);
 130                                 }
 131
 132                                 return;
 133                         }
 134
 135                         if (existing.Kind != next_part.Kind) {
 136                                 Report.SymbolRelatedToPreviousError (existing);
 137                                 Report.Error (261, next_part.Location,
 138                                         "Partial declarations of `{0}' must be all classes, all structs or all interfaces",
 139                                         next_part.GetSignatureForError ());
 140                         }
 141
 142                         if ((existing.ModFlags & Modifiers.AccessibilityMask) != (next_part.ModFlags & Modifiers.AccessibilityMask) &&
 143                                 ((existing.ModFlags & Modifiers.DEFAULT_ACCESS_MODIFIER) == 0 &&
 144                                  (next_part.ModFlags & Modifiers.DEFAULT_ACCESS_MODIFIER) == 0)) {
 145                                          Report.SymbolRelatedToPreviousError (existing);
 146                                 Report.Error (262, next_part.Location,
 147                                         "Partial declarations of `{0}' have conflicting accessibility modifiers",
 148                                         next_part.GetSignatureForError ());
 149                         }
 150
 151                         var tc_names = existing.CurrentTypeParameters;
 152                         if (tc_names != null) {
 153                                 for (int i = 0; i < tc_names.Count; ++i) {
 154                                         var tp = next_part.MemberName.TypeParameters[i];
 155                                         if (tc_names[i].MemberName.Name != tp.MemberName.Name) {
 156                                                 Report.SymbolRelatedToPreviousError (existing.Location, "");
 157                                                 Report.Error (264, next_part.Location, "Partial declarations of `{0}' must have the same type parameter names in the same order",
 158                                                         next_part.GetSignatureForError ());
 159                                                 break;
 160                                         }
 161
 162                                         if (tc_names[i].Variance != tp.Variance) {
 163                                                 Report.SymbolRelatedToPreviousError (existing.Location, "");
 164                                                 Report.Error (1067, next_part.Location, "Partial declarations of `{0}' must have the same type parameter variance modifiers",
 165                                                         next_part.GetSignatureForError ());
 166                                                 break;
 167                                         }
 168                                 }
 169                         }
 170
 171                         if ((next_part.ModFlags & Modifiers.DEFAULT_ACCESS_MODIFIER) != 0) {
 172                                 existing.ModFlags |= next_part.ModFlags & ~(Modifiers.DEFAULT_ACCESS_MODIFIER | Modifiers.AccessibilityMask);
 173                         } else if ((existing.ModFlags & Modifiers.DEFAULT_ACCESS_MODIFIER) != 0) {
 174                                 existing.ModFlags &= ~(Modifiers.DEFAULT_ACCESS_MODIFIER | Modifiers.AccessibilityMask);
 175                                 existing.ModFlags |= next_part.ModFlags;
 176                         } else {
 177                                 existing.ModFlags |= next_part.ModFlags;
 178                         }
 179
 180                         existing.Definition.Modifiers = existing.ModFlags;
 181
 182                         if (next_part.attributes != null) {
 183                                 if (existing.attributes == null)
 184                                         existing.attributes = next_part.attributes;
 185                                 else
 186                                         existing.attributes.AddAttributes (next_part.attributes.Attrs);
 187                         }
 188
 189                         next_part.PartialContainer = existing;
 190
 191                         existing.AddPartialPart (next_part);
 192
 193                         AddTypeContainerMember (next_part);
 194                 }
 195
 196                 public virtual void AddTypeContainer (TypeContainer tc)
 197                 {
 198                         AddTypeContainerMember (tc);
 199
 200                         var tparams = tc.MemberName.TypeParameters;
 201                         if (tparams != null && tc.PartialContainer != null) {
 202                                 var td = (TypeDefinition) tc;
 203                                 for (int i = 0; i < tparams.Count; ++i) {
 204                                         var tp = tparams[i];
 205                                         if (tp.MemberName == null)
 206                                                 continue;
 207
 208                                         td.AddNameToContainer (tp, tp.Name);
 209                                 }
 210                         }
 211                 }
 212
 213                 protected virtual void AddTypeContainerMember (TypeContainer tc)
 214                 {
 215                         containers.Add (tc);
 216                 }
 217
 218                 public virtual void CloseContainer ()
 219                 {
 220                         if (containers != null) {
 221                                 foreach (TypeContainer tc in containers) {
 222                                         tc.CloseContainer ();
 223                                 }
 224                         }
 225                 }
 226
 227                 public virtual void CreateMetadataName (StringBuilder sb)
 228                 {
 229                         if (Parent != null && Parent.MemberName != null)
 230                                 Parent.CreateMetadataName (sb);
 231
 232                         MemberName.CreateMetadataName (sb);
 233                 }
 234
 235                 public virtual bool CreateContainer ()
 236                 {
 237                         if (containers != null) {
 238                                 foreach (TypeContainer tc in containers) {
 239                                         tc.CreateContainer ();
 240                                 }
 241                         }
 242
 243                         return true;
 244                 }
 245
 246                 public override bool Define ()
 247                 {
 248                         if (containers != null) {
 249                                 foreach (TypeContainer tc in containers) {
 250                                         tc.Define ();
 251                                 }
 252                         }
 253
 254                         // Release cache used by parser only
 255                         if (Module.Evaluator == null) {
 256                                 defined_names = null;
 257                         } else {
 258                                 defined_names.Clear ();
 259                         }
 260
 261                         return true;
 262                 }
 263
 264                 public virtual void PrepareEmit ()
 265                 {
 266                         if (containers != null) {
 267                                 foreach (var t in containers) {
 268                                         try {
 269                                                 t.PrepareEmit ();
 270                                         } catch (Exception e) {
 271                                                 if (MemberName == MemberName.Null)
 272                                                         throw;
 273
 274                                                 throw new InternalErrorException (t, e);
 275                                         }
 276                                 }
 277                         }
 278                 }
 279
 280                 public virtual bool DefineContainer ()
 281                 {
 282                         if (is_defined)
 283                                 return true;
 284
 285                         is_defined = true;
 286
 287                         DoDefineContainer ();
 288
 289                         if (containers != null) {
 290                                 foreach (TypeContainer tc in containers) {
 291                                         try {
 292                                                 tc.DefineContainer ();
 293                                         } catch (Exception e) {
 294                                                 if (MemberName == MemberName.Null)
 295                                                         throw;
 296
 297                                                 throw new InternalErrorException (tc, e);
 298                                         }
 299                                 }
 300
 301                                 if (PartialContainer != null && PartialContainer != this) {
 302                                         containers = null;
 303                                 }
 304                         }
 305
 306                         return true;
 307                 }
 308
 309                 public virtual void ExpandBaseInterfaces ()
 310                 {
 311                         if (containers != null) {
 312                                 foreach (TypeContainer tc in containers) {
 313                                         tc.ExpandBaseInterfaces ();
 314                                 }
 315                         }
 316                 }
 317
 318                 protected virtual void DefineNamespace ()
 319                 {
 320                         if (containers != null) {
 321                                 foreach (var tc in containers) {
 322                                         try {
 323                                                 tc.DefineNamespace ();
 324                                         } catch (Exception e) {
 325                                                 throw new InternalErrorException (tc, e);
 326                                         }
 327                                 }
 328                         }
 329                 }
 330
 331                 protected virtual void DoDefineContainer ()
 332                 {
 333                 }
 334
 335                 public virtual void EmitContainer ()
 336                 {
 337                         if (containers != null) {
 338                                 for (int i = 0; i < containers.Count; ++i)
 339                                         containers[i].EmitContainer ();
 340                         }
 341                 }
 342
 343                 protected void Error_MissingPartialModifier (MemberCore type)
 344                 {
 345                         Report.Error (260, type.Location,
 346                                 "Missing partial modifier on declaration of type `{0}'. Another partial declaration of this type exists",
 347                                 type.GetSignatureForError ());
 348                 }
 349
 350                 public override string GetSignatureForDocumentation ()
 351                 {
 352                         if (Parent != null && Parent.MemberName != null)
 353                                 return Parent.GetSignatureForDocumentation () + "." + MemberName.GetSignatureForDocumentation ();
 354
 355                         return MemberName.GetSignatureForDocumentation ();
 356                 }
 357
 358                 public override string GetSignatureForError ()
 359                 {
 360                         if (Parent != null && Parent.MemberName != null)
 361                                 return Parent.GetSignatureForError () + "." + MemberName.GetSignatureForError ();
 362
 363                         return MemberName.GetSignatureForError ();
 364                 }
 365
 366                 public virtual string GetSignatureForMetadata ()
 367                 {
 368                         var sb = new StringBuilder ();
 369                         CreateMetadataName (sb);
 370                         return sb.ToString ();
 371                 }
 372
 373                 public virtual void RemoveContainer (TypeContainer cont)
 374                 {
 375                         if (containers != null)
 376                                 containers.Remove (cont);
 377
 378                         var tc = Parent == Module ? Module : this;
 379                         tc.defined_names.Remove (cont.MemberName.Basename);
 380                 }
 381
 382                 public virtual void VerifyMembers ()
 383                 {
 384                         if (containers != null) {
 385                                 foreach (TypeContainer tc in containers)
 386                                         tc.VerifyMembers ();
 387                         }
 388                 }
 389
 390                 public override void WriteDebugSymbol (MonoSymbolFile file)
 391                 {
 392                         if (containers != null) {
 393                                 foreach (TypeContainer tc in containers) {
 394                                         tc.WriteDebugSymbol (file);
 395                                 }
 396                         }
 397                 }
 398         }
 399
 400         public abstract class TypeDefinition : TypeContainer, ITypeDefinition
 401         {
 402                 //
 403                 // Different context is needed when resolving type container base
 404                 // types. Type names come from the parent scope but type parameter
 405                 // names from the container scope.
 406                 //
 407                 public struct BaseContext : IMemberContext
 408                 {
 409                         TypeContainer tc;
 410
 411                         public BaseContext (TypeContainer tc)
 412                         {
 413                                 this.tc = tc;
 414                         }
 415
 416                         #region IMemberContext Members
 417
 418                         public CompilerContext Compiler {
 419                                 get { return tc.Compiler; }
 420                         }
 421
 422                         public TypeSpec CurrentType {
 423                                 get { return tc.PartialContainer.CurrentType; }
 424                         }
 425
 426                         public TypeParameters CurrentTypeParameters {
 427                                 get { return tc.PartialContainer.CurrentTypeParameters; }
 428                         }
 429
 430                         public MemberCore CurrentMemberDefinition {
 431                                 get { return tc; }
 432                         }
 433
 434                         public bool IsObsolete {
 435                                 get { return tc.IsObsolete; }
 436                         }
 437
 438                         public bool IsUnsafe {
 439                                 get { return tc.IsUnsafe; }
 440                         }
 441
 442                         public bool IsStatic {
 443                                 get { return tc.IsStatic; }
 444                         }
 445
 446                         public ModuleContainer Module {
 447                                 get { return tc.Module; }
 448                         }
 449
 450                         public string GetSignatureForError ()
 451                         {
 452                                 return tc.GetSignatureForError ();
 453                         }
 454
 455                         public ExtensionMethodCandidates LookupExtensionMethod (string name, int arity)
 456                         {
 457                                 return null;
 458                         }
 459
 460                         public FullNamedExpression LookupNamespaceAlias (string name)
 461                         {
 462                                 return tc.Parent.LookupNamespaceAlias (name);
 463                         }
 464
 465                         public FullNamedExpression LookupNamespaceOrType (string name, int arity, LookupMode mode, Location loc)
 466                         {
 467                                 if (arity == 0) {
 468                                         var tp = CurrentTypeParameters;
 469                                         if (tp != null) {
 470                                                 TypeParameter t = tp.Find (name);
 471                                                 if (t != null)
 472                                                         return new TypeParameterExpr (t, loc);
 473                                         }
 474                                 }
 475
 476                                 return tc.Parent.LookupNamespaceOrType (name, arity, mode, loc);
 477                         }
 478
 479                         #endregion
 480                 }
 481
 482                 [Flags]
 483                 enum CachedMethods
 484                 {
 485                         Equals                          = 1,
 486                         GetHashCode                     = 1 << 1,
 487                         HasStaticFieldInitializer       = 1 << 2
 488                 }
 489
 490                 readonly List<MemberCore> members;
 491
 492                 // Holds a list of fields that have initializers
 493                 protected List<FieldInitializer> initialized_fields;
 494
 495                 // Holds a list of static fields that have initializers
 496                 protected List<FieldInitializer> initialized_static_fields;
 497
 498                 Dictionary<MethodSpec, Method> hoisted_base_call_proxies;
 499
 500                 Dictionary<string, FullNamedExpression> Cache = new Dictionary<string, FullNamedExpression> ();
 501
 502                 //
 503                 // Points to the first non-static field added to the container.
 504                 //
 505                 // This is an arbitrary choice.  We are interested in looking at _some_ non-static field,
 506                 // and the first one's as good as any.
 507                 //
 508                 protected FieldBase first_nonstatic_field;
 509
 510                 //
 511                 // This one is computed after we can distinguish interfaces
 512                 // from classes from the arraylist `type_bases'
 513                 //
 514                 protected TypeSpec base_type;
 515                 FullNamedExpression base_type_expr;     // TODO: It's temporary variable
 516                 protected TypeSpec[] iface_exprs;
 517
 518                 protected List<FullNamedExpression> type_bases;
 519
 520                 // Partial parts for classes only
 521                 List<TypeDefinition> class_partial_parts;
 522
 523                 TypeDefinition InTransit;
 524
 525                 public TypeBuilder TypeBuilder;
 526                 GenericTypeParameterBuilder[] all_tp_builders;
 527                 //
 528                 // All recursive type parameters put together sharing same
 529                 // TypeParameter instances
 530                 //
 531                 TypeParameters all_type_parameters;
 532
 533                 public const string DefaultIndexerName = "Item";
 534
 535                 bool has_normal_indexers;
 536                 string indexer_name;
 537                 bool error;
 538                 bool members_defined;
 539                 bool members_defined_ok;
 540                 protected bool has_static_constructor;
 541
 542                 private CachedMethods cached_method;
 543
 544                 protected TypeSpec spec;
 545                 TypeSpec current_type;
 546
 547                 public int DynamicSitesCounter;
 548                 public int AnonymousMethodsCounter;
 549                 public int MethodGroupsCounter;
 550
 551                 static readonly string[] attribute_targets = new [] { "type" };
 552                 static readonly string[] attribute_targets_primary = new [] { "type", "method" };
 553
 554                 /// <remarks>
 555                 ///  The pending methods that need to be implemented
 556                 //   (interfaces or abstract methods)
 557                 /// </remarks>
 558                 PendingImplementation pending;
 559
 560                 protected TypeDefinition (TypeContainer parent, MemberName name, Attributes attrs, MemberKind kind)
 561                         : base (parent, name, attrs, kind)
 562                 {
 563                         PartialContainer = this;
 564                         members = new List<MemberCore> ();
 565                 }
 566
 567                 #region Properties
 568
 569                 public List<FullNamedExpression> BaseTypeExpressions {
 570                         get {
 571                                 return type_bases;
 572                         }
 573                 }
 574
 575                 public override TypeSpec CurrentType {
 576                         get {
 577                                 if (current_type == null) {
 578                                         if (IsGenericOrParentIsGeneric) {
 579                                                 //
 580                                                 // Switch to inflated version as it's used by all expressions
 581                                                 //
 582                                                 var targs = CurrentTypeParameters == null ? TypeSpec.EmptyTypes : CurrentTypeParameters.Types;
 583                                                 current_type = spec.MakeGenericType (this, targs);
 584                                         } else {
 585                                                 current_type = spec;
 586                                         }
 587                                 }
 588
 589                                 return current_type;
 590                         }
 591                 }
 592
 593                 public override TypeParameters CurrentTypeParameters {
 594                         get {
 595                                 return PartialContainer.MemberName.TypeParameters;
 596                         }
 597                 }
 598
 599                 int CurrentTypeParametersStartIndex {
 600                         get {
 601                                 int total = all_tp_builders.Length;
 602                                 if (CurrentTypeParameters != null) {
 603                                         return total - CurrentTypeParameters.Count;
 604                                 }
 605                                 return total;
 606                         }
 607                 }
 608
 609                 public virtual AssemblyDefinition DeclaringAssembly {
 610                         get {
 611                                 return Module.DeclaringAssembly;
 612                         }
 613                 }
 614
 615                 IAssemblyDefinition ITypeDefinition.DeclaringAssembly {
 616                         get {
 617                                 return Module.DeclaringAssembly;
 618                         }
 619                 }
 620
 621                 public TypeSpec Definition {
 622                         get {
 623                                 return spec;
 624                         }
 625                 }
 626
 627                 public bool HasMembersDefined {
 628                         get {
 629                                 return members_defined;
 630                         }
 631                 }
 632
 633                 public bool HasInstanceConstructor {
 634                         get {
 635                                 return (caching_flags & Flags.HasInstanceConstructor) != 0;
 636                         }
 637                         set {
 638                                 caching_flags |= Flags.HasInstanceConstructor;
 639                         }
 640                 }
 641
 642                 // Indicated whether container has StructLayout attribute set Explicit
 643                 public bool HasExplicitLayout {
 644                         get { return (caching_flags & Flags.HasExplicitLayout) != 0; }
 645                         set { caching_flags |= Flags.HasExplicitLayout; }
 646                 }
 647
 648                 public bool HasOperators {
 649                         get {
 650                                 return (caching_flags & Flags.HasUserOperators) != 0;
 651                         }
 652                         set {
 653                                 caching_flags |= Flags.HasUserOperators;
 654                         }
 655                 }
 656
 657                 public bool HasStructLayout {
 658                         get { return (caching_flags & Flags.HasStructLayout) != 0; }
 659                         set { caching_flags |= Flags.HasStructLayout; }
 660                 }
 661
 662                 public TypeSpec[] Interfaces {
 663                         get {
 664                                 return iface_exprs;
 665                         }
 666                 }
 667
 668                 public bool IsGenericOrParentIsGeneric {
 669                         get {
 670                                 return all_type_parameters != null;
 671                         }
 672                 }
 673
 674                 public bool IsTopLevel {
 675                         get {
 676                                 return !(Parent is TypeDefinition);
 677                         }
 678                 }
 679
 680                 public bool IsPartial {
 681                         get {
 682                                 return (ModFlags & Modifiers.PARTIAL) != 0;
 683                         }
 684                 }
 685
 686                 bool ITypeDefinition.IsTypeForwarder {
 687                         get {
 688                                 return false;
 689                         }
 690                 }
 691
 692                 bool ITypeDefinition.IsCyclicTypeForwarder {
 693                         get {
 694                                 return false;
 695                         }
 696                 }
 697
 698                 //
 699                 // Returns true for secondary partial containers
 700                 //
 701                 bool IsPartialPart {
 702                         get {
 703                                 return PartialContainer != this;
 704                         }
 705                 }
 706
 707                 public MemberCache MemberCache {
 708                         get {
 709                                 return spec.MemberCache;
 710                         }
 711                 }
 712
 713                 public List<MemberCore> Members {
 714                         get {
 715                                 return members;
 716                         }
 717                 }
 718
 719                 string ITypeDefinition.Namespace {
 720                         get {
 721                                 var p = Parent;
 722                                 while (p.Kind != MemberKind.Namespace)
 723                                         p = p.Parent;
 724
 725                                 return p.MemberName == null ? null : p.GetSignatureForError ();
 726                         }
 727                 }
 728
 729                 public ParametersCompiled PrimaryConstructorParameters { get; set; }
 730
 731                 public Arguments PrimaryConstructorBaseArguments { get; set; }
 732
 733                 public Location PrimaryConstructorBaseArgumentsStart { get; set; }
 734
 735                 public TypeParameters TypeParametersAll {
 736                         get {
 737                                 return all_type_parameters;
 738                         }
 739                 }
 740
 741                 public override string[] ValidAttributeTargets {
 742                         get {
 743                                 return PrimaryConstructorParameters != null ? attribute_targets_primary : attribute_targets;
 744                         }
 745                 }
 746
 747                 #endregion
 748
 749                 public override void Accept (StructuralVisitor visitor)
 750                 {
 751                         visitor.Visit (this);
 752                 }
 753
 754                 public void AddMember (MemberCore symbol)
 755                 {
 756                         if (symbol.MemberName.ExplicitInterface != null) {
 757                                 if (!(Kind == MemberKind.Class || Kind == MemberKind.Struct)) {
 758                                         Report.Error (541, symbol.Location,
 759                                                 "`{0}': explicit interface declaration can only be declared in a class or struct",
 760                                                 symbol.GetSignatureForError ());
 761                                 }
 762                         }
 763
 764                         AddNameToContainer (symbol, symbol.MemberName.Name);
 765                         members.Add (symbol);
 766                 }
 767
 768                 public override void AddTypeContainer (TypeContainer tc)
 769                 {
 770                         AddNameToContainer (tc, tc.MemberName.Basename);
 771
 772                         base.AddTypeContainer (tc);
 773                 }
 774
 775                 protected override void AddTypeContainerMember (TypeContainer tc)
 776                 {
 777                         members.Add (tc);
 778
 779                         if (containers == null)
 780                                 containers = new List<TypeContainer> ();
 781
 782                         base.AddTypeContainerMember (tc);
 783                 }
 784
 785                 //
 786                 // Adds the member to defined_names table. It tests for duplications and enclosing name conflicts
 787                 //
 788                 public virtual void AddNameToContainer (MemberCore symbol, string name)
 789                 {
 790                         if (((ModFlags | symbol.ModFlags) & Modifiers.COMPILER_GENERATED) != 0)
 791                                 return;
 792
 793                         MemberCore mc;
 794                         if (!PartialContainer.defined_names.TryGetValue (name, out mc)) {
 795                                 PartialContainer.defined_names.Add (name, symbol);
 796                                 return;
 797                         }
 798
 799                         if (symbol.EnableOverloadChecks (mc))
 800                                 return;
 801
 802                         InterfaceMemberBase im = mc as InterfaceMemberBase;
 803                         if (im != null && im.IsExplicitImpl)
 804                                 return;
 805
 806                         Report.SymbolRelatedToPreviousError (mc);
 807                         if ((mc.ModFlags & Modifiers.PARTIAL) != 0 && (symbol is ClassOrStruct || symbol is Interface)) {
 808                                 Error_MissingPartialModifier (symbol);
 809                                 return;
 810                         }
 811
 812                         if (symbol is TypeParameter) {
 813                                 Report.Error (692, symbol.Location,
 814                                         "Duplicate type parameter `{0}'", symbol.GetSignatureForError ());
 815                         } else {
 816                                 Report.Error (102, symbol.Location,
 817                                         "The type `{0}' already contains a definition for `{1}'",
 818                                         GetSignatureForError (), name);
 819                         }
 820
 821                         return;
 822                 }
 823
 824                 public void AddConstructor (Constructor c)
 825                 {
 826                         AddConstructor (c, false);
 827                 }
 828
 829                 public void AddConstructor (Constructor c, bool isDefault)
 830                 {
 831                         bool is_static = (c.ModFlags & Modifiers.STATIC) != 0;
 832                         if (!isDefault)
 833                                 AddNameToContainer (c, is_static ? Constructor.TypeConstructorName : Constructor.ConstructorName);
 834
 835                         if (is_static && c.ParameterInfo.IsEmpty) {
 836                                 PartialContainer.has_static_constructor = true;
 837                         } else {
 838                                 PartialContainer.HasInstanceConstructor = true;
 839                         }
 840
 841                         members.Add (c);
 842                 }
 843
 844                 public bool AddField (FieldBase field)
 845                 {
 846                         AddMember (field);
 847
 848                         if ((field.ModFlags & Modifiers.STATIC) != 0)
 849                                 return true;
 850
 851                         var first_field = PartialContainer.first_nonstatic_field;
 852                         if (first_field == null) {
 853                                 PartialContainer.first_nonstatic_field = field;
 854                                 return true;
 855                         }
 856
 857                         if (Kind == MemberKind.Struct && first_field.Parent != field.Parent) {
 858                                 Report.SymbolRelatedToPreviousError (first_field.Parent);
 859                                 Report.Warning (282, 3, field.Location,
 860                                         "struct instance field `{0}' found in different declaration from instance field `{1}'",
 861                                         field.GetSignatureForError (), first_field.GetSignatureForError ());
 862                         }
 863                         return true;
 864                 }
 865
 866                 /// <summary>
 867                 /// Indexer has special handling in constrast to other AddXXX because the name can be driven by IndexerNameAttribute
 868                 /// </summary>
 869                 public void AddIndexer (Indexer i)
 870                 {
 871                         members.Add (i);
 872                 }
 873
 874                 public void AddOperator (Operator op)
 875                 {
 876                         PartialContainer.HasOperators = true;
 877                         AddMember (op);
 878                 }
 879
 880                 public void AddPartialPart (TypeDefinition part)
 881                 {
 882                         if (Kind != MemberKind.Class)
 883                                 return;
 884
 885                         if (class_partial_parts == null)
 886                                 class_partial_parts = new List<TypeDefinition> ();
 887
 888                         class_partial_parts.Add (part);
 889                 }
 890
 891                 public override void ApplyAttributeBuilder (Attribute a, MethodSpec ctor, byte[] cdata, PredefinedAttributes pa)
 892                 {
 893                         if (a.Target == AttributeTargets.Method) {
 894                                 foreach (var m in members) {
 895                                         var c = m as Constructor;
 896                                         if (c == null)
 897                                                 continue;
 898
 899                                         if (c.IsPrimaryConstructor) {
 900                                                 c.ApplyAttributeBuilder (a, ctor, cdata, pa);
 901                                                 return;
 902                                         }
 903                                 }
 904
 905                                 throw new InternalErrorException ();
 906                         }
 907
 908                         if (has_normal_indexers && a.Type == pa.DefaultMember) {
 909                                 Report.Error (646, a.Location, "Cannot specify the `DefaultMember' attribute on type containing an indexer");
 910                                 return;
 911                         }
 912
 913                         if (a.Type == pa.Required) {
 914                                 Report.Error (1608, a.Location, "The RequiredAttribute attribute is not permitted on C# types");
 915                                 return;
 916                         }
 917
 918                         TypeBuilder.SetCustomAttribute ((ConstructorInfo) ctor.GetMetaInfo (), cdata);
 919                 }
 920
 921                 public override AttributeTargets AttributeTargets {
 922                         get {
 923                                 throw new NotSupportedException ();
 924                         }
 925                 }
 926
 927                 public TypeSpec BaseType {
 928                         get {
 929                                 return spec.BaseType;
 930                         }
 931                 }
 932
 933                 protected virtual TypeAttributes TypeAttr {
 934                         get {
 935                                 return ModifiersExtensions.TypeAttr (ModFlags, IsTopLevel);
 936                         }
 937                 }
 938
 939                 public int TypeParametersCount {
 940                         get {
 941                                 return MemberName.Arity;
 942                         }
 943                 }
 944
 945                 TypeParameterSpec[] ITypeDefinition.TypeParameters {
 946                         get {
 947                                 var ctp = PartialContainer.CurrentTypeParameters;
 948                                 return ctp == null ? TypeParameterSpec.EmptyTypes : ctp.Types;
 949                         }
 950                 }
 951
 952                 public string GetAttributeDefaultMember ()
 953                 {
 954                         return indexer_name ?? DefaultIndexerName;
 955                 }
 956
 957                 public bool IsComImport {
 958                         get {
 959                                 if (OptAttributes == null)
 960                                         return false;
 961
 962                                 return OptAttributes.Contains (Module.PredefinedAttributes.ComImport);
 963                         }
 964                 }
 965
 966                 public void RegisterFieldForInitialization (MemberCore field, FieldInitializer expression)
 967                 {
 968                         if (IsPartialPart)
 969                                 PartialContainer.RegisterFieldForInitialization (field, expression);
 970
 971                         if ((field.ModFlags & Modifiers.STATIC) != 0){
 972                                 if (initialized_static_fields == null) {
 973                                         HasStaticFieldInitializer = true;
 974                                         initialized_static_fields = new List<FieldInitializer> (4);
 975                                 }
 976
 977                                 initialized_static_fields.Add (expression);
 978                         } else {
 979                                 if (Kind == MemberKind.Struct) {
 980                                         if (Compiler.Settings.Version != LanguageVersion.Experimental) {
 981                                                 Report.Error (573, expression.Location, "'{0}': Structs cannot have instance property or field initializers",
 982                                                         GetSignatureForError ());
 983                                         }
 984                                 }
 985
 986                                 if (initialized_fields == null)
 987                                         initialized_fields = new List<FieldInitializer> (4);
 988
 989                                 initialized_fields.Add (expression);
 990                         }
 991                 }
 992
 993                 public void ResolveFieldInitializers (BlockContext ec)
 994                 {
 995                         Debug.Assert (!IsPartialPart);
 996
 997                         if (ec.IsStatic) {
 998                                 if (initialized_static_fields == null)
 999                                         return;
1000
1001                                 bool has_complex_initializer = !ec.Module.Compiler.Settings.Optimize;
1002                                 int i;
1003                                 ExpressionStatement [] init = new ExpressionStatement [initialized_static_fields.Count];
1004                                 for (i = 0; i < initialized_static_fields.Count; ++i) {
1005                                         FieldInitializer fi = initialized_static_fields [i];
1006                                         ExpressionStatement s = fi.ResolveStatement (ec);
1007                                         if (s == null) {
1008                                                 s = EmptyExpressionStatement.Instance;
1009                                         } else if (!fi.IsSideEffectFree) {
1010                                                 has_complex_initializer = true;
1011                                         }
1012
1013                                         init [i] = s;
1014                                 }
1015
1016                                 for (i = 0; i < initialized_static_fields.Count; ++i) {
1017                                         FieldInitializer fi = initialized_static_fields [i];
1018                                         //
1019                                         // Need special check to not optimize code like this
1020                                         // static int a = b = 5;
1021                                         // static int b = 0;
1022                                         //
1023                                         if (!has_complex_initializer && fi.IsDefaultInitializer)
1024                                                 continue;
1025
1026                                         ec.AssignmentInfoOffset += fi.AssignmentOffset;
1027                                         ec.CurrentBlock.AddScopeStatement (new StatementExpression (init [i]));
1028                                 }
1029
1030                                 return;
1031                         }
1032
1033                         if (initialized_fields == null)
1034                                 return;
1035
1036                         for (int i = 0; i < initialized_fields.Count; ++i) {
1037                                 FieldInitializer fi = initialized_fields [i];
1038
1039                                 //
1040                                 // Clone before resolving otherwise when field initializer is needed
1041                                 // in more than 1 constructor any resolve after the initial one would
1042                                 // only took the resolved expression which is problem for expressions
1043                                 // that generate extra expressions or code during Resolve phase
1044                                 //
1045                                 var cloned = fi.Clone (new CloneContext ());
1046
1047                                 ExpressionStatement s = fi.ResolveStatement (ec);
1048                                 if (s == null) {
1049                                         initialized_fields [i] = new FieldInitializer (fi.Field, ErrorExpression.Instance, Location.Null);
1050                                         continue;
1051                                 }
1052
1053                                 //
1054                                 // Field is re-initialized to its default value => removed
1055                                 //
1056                                 if (fi.IsDefaultInitializer && Kind != MemberKind.Struct && ec.Module.Compiler.Settings.Optimize)
1057                                         continue;
1058
1059                                 ec.AssignmentInfoOffset += fi.AssignmentOffset;
1060                                 ec.CurrentBlock.AddScopeStatement (new StatementExpression (s));
1061                                 initialized_fields [i] = (FieldInitializer) cloned;
1062                         }
1063                 }
1064
1065                 public override string DocComment {
1066                         get {
1067                                 return comment;
1068                         }
1069                         set {
1070                                 if (value == null)
1071                                         return;
1072
1073                                 comment += value;
1074                         }
1075                 }
1076
1077                 public PendingImplementation PendingImplementations {
1078                         get { return pending; }
1079                 }
1080
1081                 internal override void GenerateDocComment (DocumentationBuilder builder)
1082                 {
1083                         if (IsPartialPart)
1084                                 return;
1085
1086                         base.GenerateDocComment (builder);
1087
1088                         foreach (var member in members)
1089                                 member.GenerateDocComment (builder);
1090                 }
1091
1092                 public TypeSpec GetAttributeCoClass ()
1093                 {
1094                         if (OptAttributes == null)
1095                                 return null;
1096
1097                         Attribute a = OptAttributes.Search (Module.PredefinedAttributes.CoClass);
1098                         if (a == null)
1099                                 return null;
1100
1101                         return a.GetCoClassAttributeValue ();
1102                 }
1103
1104                 public AttributeUsageAttribute GetAttributeUsage (PredefinedAttribute pa)
1105                 {
1106                         Attribute a = null;
1107                         if (OptAttributes != null) {
1108                                 a = OptAttributes.Search (pa);
1109                         }
1110
1111                         if (a == null)
1112                                 return null;
1113
1114                         return a.GetAttributeUsageAttribute ();
1115                 }
1116
1117                 public virtual CompilationSourceFile GetCompilationSourceFile ()
1118                 {
1119                         TypeContainer ns = Parent;
1120                         while (true) {
1121                                 var sf = ns as CompilationSourceFile;
1122                                 if (sf != null)
1123                                         return sf;
1124
1125                                 ns = ns.Parent;
1126                         }
1127                 }
1128
1129                 public override string GetSignatureForMetadata ()
1130                 {
1131                         if (Parent is TypeDefinition) {
1132                                 return Parent.GetSignatureForMetadata () + "+" + TypeNameParser.Escape (FilterNestedName (MemberName.Basename));
1133                         }
1134
1135                         return base.GetSignatureForMetadata ();
1136                 }
1137
1138                 public virtual void SetBaseTypes (List<FullNamedExpression> baseTypes)
1139                 {
1140                         type_bases = baseTypes;
1141                 }
1142
1143                 /// <summary>
1144                 ///   This function computes the Base class and also the
1145                 ///   list of interfaces that the class or struct @c implements.
1146                 ///
1147                 ///   The return value is an array (might be null) of
1148                 ///   interfaces implemented (as Types).
1149                 ///
1150                 ///   The @base_class argument is set to the base object or null
1151                 ///   if this is `System.Object'.
1152                 /// </summary>
1153                 protected virtual TypeSpec[] ResolveBaseTypes (out FullNamedExpression base_class)
1154                 {
1155                         base_class = null;
1156                         if (type_bases == null)
1157                                 return null;
1158
1159                         int count = type_bases.Count;
1160                         TypeSpec[] ifaces = null;
1161                         var base_context = new BaseContext (this);
1162                         for (int i = 0, j = 0; i < count; i++){
1163                                 FullNamedExpression fne = type_bases [i];
1164
1165                                 var fne_resolved = fne.ResolveAsType (base_context);
1166                                 if (fne_resolved == null)
1167                                         continue;
1168
1169                                 if (i == 0 && Kind == MemberKind.Class && !fne_resolved.IsInterface) {
1170                                         if (fne_resolved.BuiltinType == BuiltinTypeSpec.Type.Dynamic) {
1171                                                 Report.Error (1965, Location, "Class `{0}' cannot derive from the dynamic type",
1172                                                         GetSignatureForError ());
1173
1174                                                 continue;
1175                                         }
1176
1177                                         base_type = fne_resolved;
1178                                         base_class = fne;
1179                                         continue;
1180                                 }
1181
1182                                 if (ifaces == null)
1183                                         ifaces = new TypeSpec [count - i];
1184
1185                                 if (fne_resolved.IsInterface) {
1186                                         for (int ii = 0; ii < j; ++ii) {
1187                                                 if (fne_resolved == ifaces [ii]) {
1188                                                         Report.Error (528, Location, "`{0}' is already listed in interface list",
1189                                                                 fne_resolved.GetSignatureForError ());
1190                                                         break;
1191                                                 }
1192                                         }
1193
1194                                         if (Kind == MemberKind.Interface && !IsAccessibleAs (fne_resolved)) {
1195                                                 Report.Error (61, fne.Location,
1196                                                         "Inconsistent accessibility: base interface `{0}' is less accessible than interface `{1}'",
1197                                                         fne_resolved.GetSignatureForError (), GetSignatureForError ());
1198                                         }
1199                                 } else {
1200                                         Report.SymbolRelatedToPreviousError (fne_resolved);
1201                                         if (Kind != MemberKind.Class) {
1202                                                 Report.Error (527, fne.Location, "Type `{0}' in interface list is not an interface", fne_resolved.GetSignatureForError ());
1203                                         } else if (base_class != null)
1204                                                 Report.Error (1721, fne.Location, "`{0}': Classes cannot have multiple base classes (`{1}' and `{2}')",
1205                                                         GetSignatureForError (), base_class.GetSignatureForError (), fne_resolved.GetSignatureForError ());
1206                                         else {
1207                                                 Report.Error (1722, fne.Location, "`{0}': Base class `{1}' must be specified as first",
1208                                                         GetSignatureForError (), fne_resolved.GetSignatureForError ());
1209                                         }
1210                                 }
1211
1212                                 ifaces [j++] = fne_resolved;
1213                         }
1214
1215                         return ifaces;
1216                 }
1217
1218                 //
1219                 // Checks that some operators come in pairs:
1220                 //  == and !=
1221                 // > and <
1222                 // >= and <=
1223                 // true and false
1224                 //
1225                 // They are matched based on the return type and the argument types
1226                 //
1227                 void CheckPairedOperators ()
1228                 {
1229                         bool has_equality_or_inequality = false;
1230                         List<Operator.OpType> found_matched = new List<Operator.OpType> ();
1231
1232                         for (int i = 0; i < members.Count; ++i) {
1233                                 var o_a = members[i] as Operator;
1234                                 if (o_a == null)
1235                                         continue;
1236
1237                                 var o_type = o_a.OperatorType;
1238                                 if (o_type == Operator.OpType.Equality || o_type == Operator.OpType.Inequality)
1239                                         has_equality_or_inequality = true;
1240
1241                                 if (found_matched.Contains (o_type))
1242                                         continue;
1243
1244                                 var matching_type = o_a.GetMatchingOperator ();
1245                                 if (matching_type == Operator.OpType.TOP) {
1246                                         continue;
1247                                 }
1248
1249                                 bool pair_found = false;
1250                                 for (int ii = 0; ii < members.Count; ++ii) {
1251                                         var o_b = members[ii] as Operator;
1252                                         if (o_b == null || o_b.OperatorType != matching_type)
1253                                                 continue;
1254
1255                                         if (!TypeSpecComparer.IsEqual (o_a.ReturnType, o_b.ReturnType))
1256                                                 continue;
1257
1258                                         if (!TypeSpecComparer.Equals (o_a.ParameterTypes, o_b.ParameterTypes))
1259                                                 continue;
1260
1261                                         found_matched.Add (matching_type);
1262                                         pair_found = true;
1263                                         break;
1264                                 }
1265
1266                                 if (!pair_found) {
1267                                         Report.Error (216, o_a.Location,
1268                                                 "The operator `{0}' requires a matching operator `{1}' to also be defined",
1269                                                 o_a.GetSignatureForError (), Operator.GetName (matching_type));
1270                                 }
1271                         }
1272
1273                         if (has_equality_or_inequality) {
1274                                 if (!HasEquals)
1275                                         Report.Warning (660, 2, Location, "`{0}' defines operator == or operator != but does not override Object.Equals(object o)",
1276                                                 GetSignatureForError ());
1277
1278                                 if (!HasGetHashCode)
1279                                         Report.Warning (661, 2, Location, "`{0}' defines operator == or operator != but does not override Object.GetHashCode()",
1280                                                 GetSignatureForError ());
1281                         }
1282                 }
1283
1284                 public override void CreateMetadataName (StringBuilder sb)
1285                 {
1286                         if (Parent.MemberName != null) {
1287                                 Parent.CreateMetadataName (sb);
1288
1289                                 if (sb.Length != 0) {
1290                                         sb.Append (".");
1291                                 }
1292                         }
1293
1294                         sb.Append (MemberName.Basename);
1295                 }
1296
1297                 bool CreateTypeBuilder ()
1298                 {
1299                         //
1300                         // Sets .size to 1 for structs with no instance fields
1301                         //
1302                         int type_size = Kind == MemberKind.Struct && first_nonstatic_field == null && !(this is StateMachine) ? 1 : 0;
1303
1304                         var parent_def = Parent as TypeDefinition;
1305                         if (parent_def == null) {
1306                                 var sb = new StringBuilder ();
1307                                 CreateMetadataName (sb);
1308                                 TypeBuilder = Module.CreateBuilder (sb.ToString (), TypeAttr, type_size);
1309                         } else {
1310                                 TypeBuilder = parent_def.TypeBuilder.DefineNestedType (FilterNestedName (MemberName.Basename), TypeAttr, null, type_size);
1311                         }
1312
1313                         if (DeclaringAssembly.Importer != null)
1314                                 DeclaringAssembly.Importer.AddCompiledType (TypeBuilder, spec);
1315
1316                         spec.SetMetaInfo (TypeBuilder);
1317                         spec.MemberCache = new MemberCache (this);
1318
1319                         TypeParameters parentAllTypeParameters = null;
1320                         if (parent_def != null) {
1321                                 spec.DeclaringType = Parent.CurrentType;
1322                                 parent_def.MemberCache.AddMember (spec);
1323                                 parentAllTypeParameters = parent_def.all_type_parameters;
1324                         }
1325
1326                         if (MemberName.TypeParameters != null || parentAllTypeParameters != null) {
1327                                 var tparam_names = CreateTypeParameters (parentAllTypeParameters);
1328
1329                                 all_tp_builders = TypeBuilder.DefineGenericParameters (tparam_names);
1330
1331                                 if (CurrentTypeParameters != null) {
1332                                         CurrentTypeParameters.Create (spec, CurrentTypeParametersStartIndex, this);
1333                                         CurrentTypeParameters.Define (all_tp_builders);
1334                                 }
1335                         }
1336
1337                         return true;
1338                 }
1339
1340                 public static string FilterNestedName (string name)
1341                 {
1342                         //
1343                         // SRE API does not handle namespaces and types separately but
1344                         // determine that from '.' in name. That's problematic because
1345                         // dot is valid character for type name. By replacing any '.'
1346                         // in name we avoid any ambiguities and never emit metadata
1347                         // namespace for nested types
1348                         //
1349                         return name.Replace ('.', '_');
1350                 }
1351
1352                 string[] CreateTypeParameters (TypeParameters parentAllTypeParameters)
1353                 {
1354                         string[] names;
1355                         int parent_offset = 0;
1356                         if (parentAllTypeParameters != null) {
1357                                 if (CurrentTypeParameters == null) {
1358                                         all_type_parameters = parentAllTypeParameters;
1359                                         return parentAllTypeParameters.GetAllNames ();
1360                                 }
1361
1362                                 names = new string[parentAllTypeParameters.Count + CurrentTypeParameters.Count];
1363                                 all_type_parameters = new TypeParameters (names.Length);
1364                                 all_type_parameters.Add (parentAllTypeParameters);
1365
1366                                 parent_offset = all_type_parameters.Count;
1367                                 for (int i = 0; i < parent_offset; ++i)
1368                                         names[i] = all_type_parameters[i].MemberName.Name;
1369
1370                         } else {
1371                                 names = new string[CurrentTypeParameters.Count];
1372                         }
1373
1374                         for (int i = 0; i < CurrentTypeParameters.Count; ++i) {
1375                                 if (all_type_parameters != null)
1376                                         all_type_parameters.Add (MemberName.TypeParameters[i]);
1377
1378                                 var name = CurrentTypeParameters[i].MemberName.Name;
1379                                 names[parent_offset + i] = name;
1380                                 for (int ii = 0; ii < parent_offset + i; ++ii) {
1381                                         if (names[ii] != name)
1382                                                 continue;
1383
1384                                         var tp = CurrentTypeParameters[i];
1385                                         var conflict = all_type_parameters[ii];
1386
1387                                         tp.WarningParentNameConflict (conflict);
1388                                 }
1389                         }
1390
1391                         if (all_type_parameters == null)
1392                                 all_type_parameters = CurrentTypeParameters;
1393
1394                         return names;
1395                 }
1396
1397
1398                 public SourceMethodBuilder CreateMethodSymbolEntry ()
1399                 {
1400                         if (Module.DeclaringAssembly.SymbolWriter == null || (ModFlags & Modifiers.DEBUGGER_HIDDEN) != 0)
1401                                 return null;
1402
1403                         var source_file = GetCompilationSourceFile ();
1404                         if (source_file == null)
1405                                 return null;
1406
1407                         return new SourceMethodBuilder (source_file.SymbolUnitEntry);
1408                 }
1409
1410                 //
1411                 // Creates a proxy base method call inside this container for hoisted base member calls
1412                 //
1413                 public MethodSpec CreateHoistedBaseCallProxy (ResolveContext rc, MethodSpec method)
1414                 {
1415                         Method proxy_method;
1416
1417                         //
1418                         // One proxy per base method is enough
1419                         //
1420                         if (hoisted_base_call_proxies == null) {
1421                                 hoisted_base_call_proxies = new Dictionary<MethodSpec, Method> ();
1422                                 proxy_method = null;
1423                         } else {
1424                                 hoisted_base_call_proxies.TryGetValue (method, out proxy_method);
1425                         }
1426
1427                         if (proxy_method == null) {
1428                                 string name = CompilerGeneratedContainer.MakeName (method.Name, null, "BaseCallProxy", hoisted_base_call_proxies.Count);
1429
1430                                 MemberName member_name;
1431                                 TypeArguments targs = null;
1432                                 TypeSpec return_type = method.ReturnType;
1433                                 var local_param_types = method.Parameters.Types;
1434
1435                                 if (method.IsGeneric) {
1436                                         //
1437                                         // Copy all base generic method type parameters info
1438                                         //
1439                                         var hoisted_tparams = method.GenericDefinition.TypeParameters;
1440                                         var tparams = new TypeParameters ();
1441
1442                                         targs = new TypeArguments ();
1443                                         targs.Arguments = new TypeSpec[hoisted_tparams.Length];
1444                                         for (int i = 0; i < hoisted_tparams.Length; ++i) {
1445                                                 var tp = hoisted_tparams[i];
1446                                                 var tp_name = tp.Name;
1447 #if DEBUG
1448                                                 tp_name += "_Proxy";
1449 #endif
1450                                                 var local_tp = new TypeParameter (tp, null, new MemberName (tp_name, Location), null);
1451                                                 tparams.Add (local_tp);
1452
1453                                                 targs.Add (new SimpleName (tp.Name, Location));
1454                                                 targs.Arguments[i] = local_tp.Type;
1455                                         }
1456
1457                                         member_name = new MemberName (name, tparams, Location);
1458
1459                                         //
1460                                         // Mutate any method type parameters from original
1461                                         // to newly created hoisted version
1462                                         //
1463                                         var mutator = new TypeParameterMutator (hoisted_tparams, tparams);
1464                                         return_type = mutator.Mutate (return_type);
1465                                         local_param_types = mutator.Mutate (local_param_types);
1466
1467                                         var inflator = new TypeParameterInflator (this, null, hoisted_tparams, targs.Arguments);
1468                                         for (int i = 0; i < hoisted_tparams.Length; ++i) {
1469                                                 var tp_spec = (TypeParameterSpec) targs.Arguments [i];
1470                                                 tp_spec.InflateConstraints (inflator, tp_spec);
1471                                         }
1472                                 } else {
1473                                         member_name = new MemberName (name);
1474                                 }
1475
1476                                 var base_parameters = new Parameter[method.Parameters.Count];
1477                                 for (int i = 0; i < base_parameters.Length; ++i) {
1478                                         var base_param = method.Parameters.FixedParameters[i];
1479                                         base_parameters[i] = new Parameter (new TypeExpression (local_param_types [i], Location),
1480                                                 base_param.Name, base_param.ModFlags, null, Location);
1481                                         base_parameters[i].Resolve (this, i);
1482                                 }
1483
1484                                 var cloned_params = ParametersCompiled.CreateFullyResolved (base_parameters, local_param_types);
1485                                 if (method.Parameters.HasArglist) {
1486                                         cloned_params.FixedParameters[0] = new Parameter (null, "__arglist", Parameter.Modifier.NONE, null, Location);
1487                                         cloned_params.Types[0] = Module.PredefinedTypes.RuntimeArgumentHandle.Resolve ();
1488                                 }
1489
1490                                 // Compiler generated proxy
1491                                 proxy_method = new Method (this, new TypeExpression (return_type, Location),
1492                                         Modifiers.PRIVATE | Modifiers.COMPILER_GENERATED | Modifiers.DEBUGGER_HIDDEN,
1493                                         member_name, cloned_params, null);
1494
1495                                 var block = new ToplevelBlock (Compiler, proxy_method.ParameterInfo, Location) {
1496                                         IsCompilerGenerated = true
1497                                 };
1498
1499                                 var mg = MethodGroupExpr.CreatePredefined (method, method.DeclaringType, Location);
1500                                 mg.InstanceExpression = new BaseThis (method.DeclaringType, Location);
1501                                 if (targs != null)
1502                                         mg.SetTypeArguments (rc, targs);
1503
1504                                 // Get all the method parameters and pass them as arguments
1505                                 var real_base_call = new Invocation (mg, block.GetAllParametersArguments ());
1506                                 Statement statement;
1507                                 if (method.ReturnType.Kind == MemberKind.Void)
1508                                         statement = new StatementExpression (real_base_call);
1509                                 else
1510                                         statement = new Return (real_base_call, Location);
1511
1512                                 block.AddStatement (statement);
1513                                 proxy_method.Block = block;
1514
1515                                 members.Add (proxy_method);
1516                                 proxy_method.Define ();
1517                                 proxy_method.PrepareEmit ();
1518
1519                                 hoisted_base_call_proxies.Add (method, proxy_method);
1520                         }
1521
1522                         return proxy_method.Spec;
1523                 }
1524
1525                 protected bool DefineBaseTypes ()
1526                 {
1527                         if (IsPartialPart && Kind == MemberKind.Class)
1528                                 return true;
1529
1530                         return DoDefineBaseType ();
1531                 }
1532
1533                 bool DoDefineBaseType ()
1534                 {
1535                         iface_exprs = ResolveBaseTypes (out base_type_expr);
1536                         bool set_base_type;
1537
1538                         if (IsPartialPart) {
1539                                 set_base_type = false;
1540
1541                                 if (base_type_expr != null) {
1542                                         if (PartialContainer.base_type_expr != null && PartialContainer.base_type != base_type) {
1543                                                 Report.SymbolRelatedToPreviousError (base_type_expr.Location, "");
1544                                                 Report.Error (263, Location,
1545                                                         "Partial declarations of `{0}' must not specify different base classes",
1546                                                         GetSignatureForError ());
1547                                         } else {
1548                                                 PartialContainer.base_type_expr = base_type_expr;
1549                                                 PartialContainer.base_type = base_type;
1550                                                 set_base_type = true;
1551                                         }
1552                                 }
1553
1554                                 if (iface_exprs != null) {
1555                                         if (PartialContainer.iface_exprs == null)
1556                                                 PartialContainer.iface_exprs = iface_exprs;
1557                                         else {
1558                                                 var ifaces = new List<TypeSpec> (PartialContainer.iface_exprs);
1559                                                 foreach (var iface_partial in iface_exprs) {
1560                                                         if (ifaces.Contains (iface_partial))
1561                                                                 continue;
1562
1563                                                         ifaces.Add (iface_partial);
1564                                                 }
1565
1566                                                 PartialContainer.iface_exprs = ifaces.ToArray ();
1567                                         }
1568                                 }
1569
1570                                 PartialContainer.members.AddRange (members);
1571                                 if (containers != null) {
1572                                         if (PartialContainer.containers == null)
1573                                                 PartialContainer.containers = new List<TypeContainer> ();
1574
1575                                         PartialContainer.containers.AddRange (containers);
1576                                 }
1577
1578                                 if (PrimaryConstructorParameters != null) {
1579                                         if (PartialContainer.PrimaryConstructorParameters != null) {
1580                                                 Report.Error (8036, Location, "Only one part of a partial type can declare primary constructor parameters");
1581                                         } else {
1582                                                 PartialContainer.PrimaryConstructorParameters = PrimaryConstructorParameters;
1583                                         }
1584                                 }
1585
1586                                 members_defined = members_defined_ok = true;
1587                                 caching_flags |= Flags.CloseTypeCreated;
1588                         } else {
1589                                 set_base_type = true;
1590                         }
1591
1592                         var cycle = CheckRecursiveDefinition (this);
1593                         if (cycle != null) {
1594                                 Report.SymbolRelatedToPreviousError (cycle);
1595                                 if (this is Interface) {
1596                                         Report.Error (529, Location,
1597                                                 "Inherited interface `{0}' causes a cycle in the interface hierarchy of `{1}'",
1598                                             GetSignatureForError (), cycle.GetSignatureForError ());
1599
1600                                         iface_exprs = null;
1601                                         PartialContainer.iface_exprs = null;
1602                                 } else {
1603                                         Report.Error (146, Location,
1604                                                 "Circular base class dependency involving `{0}' and `{1}'",
1605                                                 GetSignatureForError (), cycle.GetSignatureForError ());
1606
1607                                         base_type = null;
1608                                         PartialContainer.base_type = null;
1609                                 }
1610                         }
1611
1612                         if (iface_exprs != null) {
1613                                 if (!PrimaryConstructorBaseArgumentsStart.IsNull) {
1614                                         Report.Error (8049, PrimaryConstructorBaseArgumentsStart, "Implemented interfaces cannot have arguments");
1615                                 }
1616
1617                                 foreach (var iface_type in iface_exprs) {
1618                                         // Prevents a crash, the interface might not have been resolved: 442144
1619                                         if (iface_type == null)
1620                                                 continue;
1621
1622                                         if (!spec.AddInterfaceDefined (iface_type))
1623                                                 continue;
1624
1625                                         TypeBuilder.AddInterfaceImplementation (iface_type.GetMetaInfo ());
1626                                 }
1627                         }
1628
1629                         if (Kind == MemberKind.Interface) {
1630                                 spec.BaseType = Compiler.BuiltinTypes.Object;
1631                                 return true;
1632                         }
1633
1634                         if (set_base_type) {
1635                                 SetBaseType ();
1636                         }
1637
1638                         //
1639                         // Base type of partial container has to be resolved before we
1640                         // resolve any nested types of the container. We need to know
1641                         // partial parts because the base type can be specified in file
1642                         // defined after current container
1643                         //
1644                         if (class_partial_parts != null) {
1645                                 foreach (var pp in class_partial_parts) {
1646                                         if (pp.PrimaryConstructorBaseArguments != null)
1647                                                 PrimaryConstructorBaseArguments = pp.PrimaryConstructorBaseArguments;
1648
1649                                         pp.DoDefineBaseType ();
1650                                 }
1651
1652                         }
1653
1654                         return true;
1655                 }
1656
1657                 void SetBaseType ()
1658                 {
1659                         if (base_type == null) {
1660                                 TypeBuilder.SetParent (null);
1661                                 return;
1662                         }
1663
1664                         if (spec.BaseType == base_type)
1665                                 return;
1666
1667                         spec.BaseType = base_type;
1668
1669                         if (IsPartialPart)
1670                                 spec.UpdateInflatedInstancesBaseType ();
1671
1672                         // Set base type after type creation
1673                         TypeBuilder.SetParent (base_type.GetMetaInfo ());
1674                 }
1675
1676                 public override void ExpandBaseInterfaces ()
1677                 {
1678                         DoResolveTypeParameters ();
1679
1680                         if (!IsPartialPart)
1681                                 DoExpandBaseInterfaces ();
1682
1683                         base.ExpandBaseInterfaces ();
1684                 }
1685
1686                 public void DoExpandBaseInterfaces ()
1687                 {
1688                         if ((caching_flags & Flags.InterfacesExpanded) != 0)
1689                                 return;
1690
1691                         caching_flags |= Flags.InterfacesExpanded;
1692
1693                         //
1694                         // Expand base interfaces. It cannot be done earlier because all partial
1695                         // interface parts need to be defined before the type they are used from
1696                         //
1697                         if (iface_exprs != null) {
1698                                 foreach (var iface in iface_exprs) {
1699                                         if (iface == null)
1700                                                 continue;
1701
1702                                         var td = iface.MemberDefinition as TypeDefinition;
1703                                         if (td != null)
1704                                                 td.DoExpandBaseInterfaces ();
1705
1706                                         if (iface.Interfaces == null)
1707                                                 continue;
1708
1709                                         foreach (var biface in iface.Interfaces) {
1710                                                 if (spec.AddInterfaceDefined (biface)) {
1711                                                         TypeBuilder.AddInterfaceImplementation (biface.GetMetaInfo ());
1712                                                 }
1713                                         }
1714                                 }
1715                         }
1716
1717                         //
1718                         // Include all base type interfaces too, see ImportTypeBase for details
1719                         //
1720                         if (base_type != null) {
1721                                 var td = base_type.MemberDefinition as TypeDefinition;
1722                                 if (td != null)
1723                                         td.DoExpandBaseInterfaces ();
1724
1725                                 //
1726                                 // Simply use base interfaces only, they are all expanded which makes
1727                                 // it easy to handle generic type argument propagation with single
1728                                 // inflator only.
1729                                 //
1730                                 // interface IA<T> : IB<T>
1731                                 // interface IB<U> : IC<U>
1732                                 // interface IC<V>
1733                                 //
1734                                 if (base_type.Interfaces != null) {
1735                                         foreach (var iface in base_type.Interfaces) {
1736                                                 spec.AddInterfaceDefined (iface);
1737                                         }
1738                                 }
1739                         }
1740                 }
1741
1742                 public override void PrepareEmit ()
1743                 {
1744                         if ((caching_flags & Flags.CloseTypeCreated) != 0)
1745                                 return;
1746
1747                         foreach (var member in members) {
1748                                 var pbm = member as MemberBase;
1749                                 if (pbm != null)
1750                                         pbm.PrepareEmit ();
1751                         }
1752
1753                         base.PrepareEmit ();
1754                 }
1755
1756                 //
1757                 // Defines the type in the appropriate ModuleBuilder or TypeBuilder.
1758                 //
1759                 public override bool CreateContainer ()
1760                 {
1761                         if (TypeBuilder != null)
1762                                 return !error;
1763
1764                         if (error)
1765                                 return false;
1766
1767                         if (IsPartialPart) {
1768                                 spec = PartialContainer.spec;
1769                                 TypeBuilder = PartialContainer.TypeBuilder;
1770                                 all_tp_builders = PartialContainer.all_tp_builders;
1771                                 all_type_parameters = PartialContainer.all_type_parameters;
1772                         } else {
1773                                 if (!CreateTypeBuilder ()) {
1774                                         error = true;
1775                                         return false;
1776                                 }
1777                         }
1778
1779                         return base.CreateContainer ();
1780                 }
1781
1782                 protected override void DoDefineContainer ()
1783                 {
1784                         DefineBaseTypes ();
1785                 }
1786
1787                 //
1788                 // Replaces normal spec with predefined one when compiling corlib
1789                 // and this type container defines predefined type
1790                 //
1791                 public void SetPredefinedSpec (BuiltinTypeSpec spec)
1792                 {
1793                         // When compiling build-in types we start with two
1794                         // version of same type. One is of BuiltinTypeSpec and
1795                         // second one is ordinary TypeSpec. The unification
1796                         // happens at later stage when we know which type
1797                         // really matches the builtin type signature. However
1798                         // that means TypeSpec create during CreateType of this
1799                         // type has to be replaced with builtin one
1800                         //
1801                         spec.SetMetaInfo (TypeBuilder);
1802                         spec.MemberCache = this.spec.MemberCache;
1803                         spec.DeclaringType = this.spec.DeclaringType;
1804
1805                         this.spec = spec;
1806                         current_type = null;
1807                         if (class_partial_parts != null) {
1808                                 foreach (var part in class_partial_parts)
1809                                         part.spec = spec;
1810                         }
1811                 }
1812
1813                 public override void RemoveContainer (TypeContainer cont)
1814                 {
1815                         base.RemoveContainer (cont);
1816                         Members.Remove (cont);
1817                         Cache.Remove (cont.MemberName.Basename);
1818                 }
1819
1820                 protected virtual bool DoResolveTypeParameters ()
1821                 {
1822                         var tparams = MemberName.TypeParameters;
1823                         if (tparams == null)
1824                                 return true;
1825
1826                         var base_context = new BaseContext (this);
1827                         for (int i = 0; i < tparams.Count; ++i) {
1828                                 var tp = tparams[i];
1829
1830                                 if (!tp.ResolveConstraints (base_context)) {
1831                                         error = true;
1832                                         return false;
1833                                 }
1834
1835                                 if (IsPartialPart) {
1836                                         var pc_tp = PartialContainer.CurrentTypeParameters [i];
1837
1838                                         tp.Create (spec, this);
1839                                         tp.Define (pc_tp);
1840
1841                                         if (tp.OptAttributes != null) {
1842                                                 if (pc_tp.OptAttributes == null)
1843                                                         pc_tp.OptAttributes = tp.OptAttributes;
1844                                                 else
1845                                                         pc_tp.OptAttributes.Attrs.AddRange (tp.OptAttributes.Attrs);
1846                                         }
1847                                 }
1848                         }
1849
1850                         if (IsPartialPart) {
1851                                 PartialContainer.CurrentTypeParameters.UpdateConstraints (this);
1852                         }
1853
1854                         return true;
1855                 }
1856
1857                 TypeSpec CheckRecursiveDefinition (TypeDefinition tc)
1858                 {
1859                         if (InTransit != null)
1860                                 return spec;
1861
1862                         InTransit = tc;
1863
1864                         if (base_type != null) {
1865                                 var ptc = base_type.MemberDefinition as TypeDefinition;
1866                                 if (ptc != null && ptc.CheckRecursiveDefinition (this) != null)
1867                                         return base_type;
1868                         }
1869
1870                         if (iface_exprs != null && this is Interface) {
1871                                 foreach (var iface in iface_exprs) {
1872                                         // the interface might not have been resolved, prevents a crash, see #442144
1873                                         if (iface == null)
1874                                                 continue;
1875                                         var ptc = iface.MemberDefinition as Interface;
1876                                         if (ptc != null && ptc.CheckRecursiveDefinition (this) != null)
1877                                                 return iface;
1878                                 }
1879                         }
1880
1881                         if (!IsTopLevel && Parent.PartialContainer.CheckRecursiveDefinition (this) != null)
1882                                 return spec;
1883
1884                         InTransit = null;
1885                         return null;
1886                 }
1887
1888                 /// <summary>
1889                 ///   Populates our TypeBuilder with fields and methods
1890                 /// </summary>
1891                 public sealed override bool Define ()
1892                 {
1893                         if (members_defined)
1894                                 return members_defined_ok;
1895
1896                         members_defined_ok = DoDefineMembers ();
1897                         members_defined = true;
1898
1899                         base.Define ();
1900
1901                         return members_defined_ok;
1902                 }
1903
1904                 protected virtual bool DoDefineMembers ()
1905                 {
1906                         Debug.Assert (!IsPartialPart);
1907
1908                         if (iface_exprs != null) {
1909                                 foreach (var iface_type in iface_exprs) {
1910                                         if (iface_type == null)
1911                                                 continue;
1912
1913                                         // Ensure the base is always setup
1914                                         var compiled_iface = iface_type.MemberDefinition as Interface;
1915                                         if (compiled_iface != null)
1916                                                 compiled_iface.Define ();
1917
1918                                         iface_type.CheckObsoleteness (this, Location);
1919
1920                                         if (iface_type.Arity > 0) {
1921                                                 // TODO: passing `this' is wrong, should be base type iface instead
1922                                                 VarianceDecl.CheckTypeVariance (iface_type, Variance.Covariant, this);
1923
1924                                                 if (((InflatedTypeSpec) iface_type).HasDynamicArgument () && !IsCompilerGenerated) {
1925                                                         Report.Error (1966, Location,
1926                                                                 "`{0}': cannot implement a dynamic interface `{1}'",
1927                                                                 GetSignatureForError (), iface_type.GetSignatureForError ());
1928                                                         return false;
1929                                                 }
1930                                         }
1931
1932                                         if (iface_type.IsGenericOrParentIsGeneric) {
1933                                                 foreach (var prev_iface in iface_exprs) {
1934                                                         if (prev_iface == iface_type || prev_iface == null)
1935                                                                 break;
1936
1937                                                         if (!TypeSpecComparer.Unify.IsEqual (iface_type, prev_iface))
1938                                                                 continue;
1939
1940                                                         Report.Error (695, Location,
1941                                                                 "`{0}' cannot implement both `{1}' and `{2}' because they may unify for some type parameter substitutions",
1942                                                                 GetSignatureForError (), prev_iface.GetSignatureForError (), iface_type.GetSignatureForError ());
1943                                                 }
1944                                         }
1945                                 }
1946
1947                                 if (Kind == MemberKind.Interface) {
1948                                         foreach (var iface in spec.Interfaces) {
1949                                                 MemberCache.AddInterface (iface);
1950                                         }
1951                                 }
1952                         }
1953
1954                         if (base_type != null) {
1955                                 //
1956                                 // Run checks skipped during DefineType (e.g FullNamedExpression::ResolveAsType)
1957                                 //
1958                                 if (base_type_expr != null) {
1959                                         base_type.CheckObsoleteness (this, base_type_expr.Location);
1960
1961                                         if (IsGenericOrParentIsGeneric && base_type.IsAttribute) {
1962                                                 Report.Error (698, base_type_expr.Location,
1963                                                         "A generic type cannot derive from `{0}' because it is an attribute class",
1964                                                         base_type.GetSignatureForError ());
1965                                         }
1966                                 }
1967
1968                                 var baseContainer = base_type.MemberDefinition as ClassOrStruct;
1969                                 if (baseContainer != null) {
1970                                         baseContainer.Define ();
1971
1972                                         //
1973                                         // It can trigger define of this type (for generic types only)
1974                                         //
1975                                         if (HasMembersDefined)
1976                                                 return true;
1977                                 }
1978                         }
1979
1980                         if (Kind == MemberKind.Struct || Kind == MemberKind.Class) {
1981                                 pending = PendingImplementation.GetPendingImplementations (this);
1982                         }
1983
1984                         var count = members.Count;
1985                         for (int i = 0; i < count; ++i) {
1986                                 var mc = members[i] as InterfaceMemberBase;
1987                                 if (mc == null || !mc.IsExplicitImpl)
1988                                         continue;
1989
1990                                 try {
1991                                         mc.Define ();
1992                                 } catch (Exception e) {
1993                                         throw new InternalErrorException (mc, e);
1994                                 }
1995                         }
1996
1997                         for (int i = 0; i < count; ++i) {
1998                                 var mc = members[i] as InterfaceMemberBase;
1999                                 if (mc != null && mc.IsExplicitImpl)
2000                                         continue;
2001
2002                                 if (members[i] is TypeContainer)
2003                                         continue;
2004
2005                                 try {
2006                                         members[i].Define ();
2007                                 } catch (Exception e) {
2008                                         throw new InternalErrorException (members[i], e);
2009                                 }
2010                         }
2011
2012                         if (HasOperators) {
2013                                 CheckPairedOperators ();
2014                         }
2015
2016                         ComputeIndexerName();
2017
2018                         if (HasEquals && !HasGetHashCode) {
2019                                 Report.Warning (659, 3, Location,
2020                                         "`{0}' overrides Object.Equals(object) but does not override Object.GetHashCode()", GetSignatureForError ());
2021                         }
2022
2023                         if (Kind == MemberKind.Interface && iface_exprs != null) {
2024                                 MemberCache.RemoveHiddenMembers (spec);
2025                         }
2026
2027                         return true;
2028                 }
2029
2030                 void ComputeIndexerName ()
2031                 {
2032                         var indexers = MemberCache.FindMembers (spec, MemberCache.IndexerNameAlias, true);
2033                         if (indexers == null)
2034                                 return;
2035
2036                         string class_indexer_name = null;
2037
2038                         //
2039                         // Check normal indexers for consistent name, explicit interface implementation
2040                         // indexers are ignored
2041                         //
2042                         foreach (var indexer in indexers) {
2043                                 //
2044                                 // FindMembers can return unfiltered full hierarchy names
2045                                 //
2046                                 if (indexer.DeclaringType != spec)
2047                                         continue;
2048
2049                                 has_normal_indexers = true;
2050
2051                                 if (class_indexer_name == null) {
2052                                         indexer_name = class_indexer_name = indexer.Name;
2053                                         continue;
2054                                 }
2055
2056                                 if (indexer.Name != class_indexer_name)
2057                                         Report.Error (668, ((Indexer)indexer.MemberDefinition).Location,
2058                                                 "Two indexers have different names; the IndexerName attribute must be used with the same name on every indexer within a type");
2059                         }
2060                 }
2061
2062                 void EmitIndexerName ()
2063                 {
2064                         if (!has_normal_indexers)
2065                                 return;
2066
2067                         var ctor = Module.PredefinedMembers.DefaultMemberAttributeCtor.Get ();
2068                         if (ctor == null)
2069                                 return;
2070
2071                         var encoder = new AttributeEncoder ();
2072                         encoder.Encode (GetAttributeDefaultMember ());
2073                         encoder.EncodeEmptyNamedArguments ();
2074
2075                         TypeBuilder.SetCustomAttribute ((ConstructorInfo) ctor.GetMetaInfo (), encoder.ToArray ());
2076                 }
2077
2078                 public override void VerifyMembers ()
2079                 {
2080                         //
2081                         // Check for internal or private fields that were never assigned
2082                         //
2083                         if (!IsCompilerGenerated && Compiler.Settings.WarningLevel >= 3 && this == PartialContainer) {
2084                                 bool is_type_exposed = Kind == MemberKind.Struct || IsExposedFromAssembly ();
2085                                 foreach (var member in members) {
2086                                         if (member is Event) {
2087                                                 //
2088                                                 // An event can be assigned from same class only, report
2089                                                 // this warning for all accessibility modes
2090                                                 //
2091                                                 if (!member.IsUsed && !PartialContainer.HasStructLayout)
2092                                                         Report.Warning (67, 3, member.Location, "The event `{0}' is never used", member.GetSignatureForError ());
2093
2094                                                 continue;
2095                                         }
2096
2097                                         if ((member.ModFlags & Modifiers.AccessibilityMask) != Modifiers.PRIVATE) {
2098                                                 if (is_type_exposed)
2099                                                         continue;
2100
2101                                                 member.SetIsUsed ();
2102                                         }
2103
2104                                         var f = member as Field;
2105                                         if (f == null)
2106                                                 continue;
2107
2108                                         if (!member.IsUsed) {
2109                                                 if (!PartialContainer.HasStructLayout) {
2110                                                         if ((member.caching_flags & Flags.IsAssigned) == 0) {
2111                                                                 Report.Warning (169, 3, member.Location, "The private field `{0}' is never used", member.GetSignatureForError ());
2112                                                         } else {
2113                                                                 Report.Warning (414, 3, member.Location, "The private field `{0}' is assigned but its value is never used",
2114                                                                         member.GetSignatureForError ());
2115                                                         }
2116                                                 }
2117
2118                                                 continue;
2119                                         }
2120
2121                                         if ((f.caching_flags & Flags.IsAssigned) != 0)
2122                                                 continue;
2123
2124                                         //
2125                                         // Only report 649 on level 4
2126                                         //
2127                                         if (Compiler.Settings.WarningLevel < 4)
2128                                                 continue;
2129
2130                                         //
2131                                         // Don't be pedantic when type requires specific layout
2132                                         //
2133                                         if (f.OptAttributes != null || PartialContainer.HasStructLayout)
2134                                                 continue;
2135
2136                                         Constant c = New.Constantify (f.MemberType, f.Location);
2137                                         string value;
2138                                         if (c != null) {
2139                                                 value = c.GetValueAsLiteral ();
2140                                         } else if (TypeSpec.IsReferenceType (f.MemberType)) {
2141                                                 value = "null";
2142                                         } else {
2143                                                 value = null;
2144                                         }
2145
2146                                         if (value != null)
2147                                                 value = " `" + value + "'";
2148
2149                                         Report.Warning (649, 4, f.Location, "Field `{0}' is never assigned to, and will always have its default value{1}",
2150                                                 f.GetSignatureForError (), value);
2151                                 }
2152                         }
2153
2154                         base.VerifyMembers ();
2155                 }
2156
2157                 public override void Emit ()
2158                 {
2159                         if (OptAttributes != null)
2160                                 OptAttributes.Emit ();
2161
2162                         if (!IsCompilerGenerated) {
2163                                 if (!IsTopLevel) {
2164                                         MemberSpec candidate;
2165                                         bool overrides = false;
2166                                         var conflict_symbol = MemberCache.FindBaseMember (this, out candidate, ref overrides);
2167                                         if (conflict_symbol == null && candidate == null) {
2168                                                 if ((ModFlags & Modifiers.NEW) != 0)
2169                                                         Report.Warning (109, 4, Location, "The member `{0}' does not hide an inherited member. The new keyword is not required",
2170                                                                 GetSignatureForError ());
2171                                         } else {
2172                                                 if ((ModFlags & Modifiers.NEW) == 0) {
2173                                                         if (candidate == null)
2174                                                                 candidate = conflict_symbol;
2175
2176                                                         Report.SymbolRelatedToPreviousError (candidate);
2177                                                         Report.Warning (108, 2, Location, "`{0}' hides inherited member `{1}'. Use the new keyword if hiding was intended",
2178                                                                 GetSignatureForError (), candidate.GetSignatureForError ());
2179                                                 }
2180                                         }
2181                                 }
2182
2183                                 // Run constraints check on all possible generic types
2184                                 if (base_type != null && base_type_expr != null) {
2185                                         ConstraintChecker.Check (this, base_type, base_type_expr.Location);
2186                                 }
2187
2188                                 if (iface_exprs != null) {
2189                                         foreach (var iface_type in iface_exprs) {
2190                                                 if (iface_type == null)
2191                                                         continue;
2192
2193                                                 ConstraintChecker.Check (this, iface_type, Location);   // TODO: Location is wrong
2194                                         }
2195                                 }
2196                         }
2197
2198                         if (all_tp_builders != null) {
2199                                 int current_starts_index = CurrentTypeParametersStartIndex;
2200                                 for (int i = 0; i < all_tp_builders.Length; i++) {
2201                                         if (i < current_starts_index) {
2202                                                 all_type_parameters[i].EmitConstraints (all_tp_builders [i]);
2203                                         } else {
2204                                                 var tp = CurrentTypeParameters [i - current_starts_index];
2205                                                 tp.CheckGenericConstraints (!IsObsolete);
2206                                                 tp.Emit ();
2207                                         }
2208                                 }
2209                         }
2210
2211                         if ((ModFlags & Modifiers.COMPILER_GENERATED) != 0 && !Parent.IsCompilerGenerated)
2212                                 Module.PredefinedAttributes.CompilerGenerated.EmitAttribute (TypeBuilder);
2213
2214 #if STATIC
2215                         if ((TypeBuilder.Attributes & TypeAttributes.StringFormatMask) == 0 && Module.HasDefaultCharSet)
2216                                 TypeBuilder.__SetAttributes (TypeBuilder.Attributes | Module.DefaultCharSetType);
2217 #endif
2218
2219                         base.Emit ();
2220
2221                         for (int i = 0; i < members.Count; i++) {
2222                                 var m = members[i];
2223                                 if ((m.caching_flags & Flags.CloseTypeCreated) != 0)
2224                                         continue;
2225
2226                                 m.Emit ();
2227                         }
2228
2229                         EmitIndexerName ();
2230                         CheckAttributeClsCompliance ();
2231
2232                         if (pending != null)
2233                                 pending.VerifyPendingMethods ();
2234                 }
2235
2236
2237                 void CheckAttributeClsCompliance ()
2238                 {
2239                         if (!spec.IsAttribute || !IsExposedFromAssembly () || !Compiler.Settings.VerifyClsCompliance || !IsClsComplianceRequired ())
2240                                 return;
2241
2242                         foreach (var m in members) {
2243                                 var c = m as Constructor;
2244                                 if (c == null)
2245                                         continue;
2246
2247                                 if (c.HasCompliantArgs)
2248                                         return;
2249                         }
2250
2251                         Report.Warning (3015, 1, Location, "`{0}' has no accessible constructors which use only CLS-compliant types", GetSignatureForError ());
2252                 }
2253
2254                 public sealed override void EmitContainer ()
2255                 {
2256                         if ((caching_flags & Flags.CloseTypeCreated) != 0)
2257                                 return;
2258
2259                         Emit ();
2260                 }
2261
2262                 public override void CloseContainer ()
2263                 {
2264                         if ((caching_flags & Flags.CloseTypeCreated) != 0)
2265                                 return;
2266
2267                         // Close base type container first to avoid TypeLoadException
2268                         if (spec.BaseType != null) {
2269                                 var btype = spec.BaseType.MemberDefinition as TypeContainer;
2270                                 if (btype != null) {
2271                                         btype.CloseContainer ();
2272
2273                                         if ((caching_flags & Flags.CloseTypeCreated) != 0)
2274                                                 return;
2275                                 }
2276                         }
2277
2278                         try {
2279                                 caching_flags |= Flags.CloseTypeCreated;
2280                                 TypeBuilder.CreateType ();
2281                         } catch (TypeLoadException) {
2282                                 //
2283                                 // This is fine, the code still created the type
2284                                 //
2285                         } catch (Exception e) {
2286                                 throw new InternalErrorException (this, e);
2287                         }
2288
2289                         base.CloseContainer ();
2290
2291                         containers = null;
2292                         initialized_fields = null;
2293                         initialized_static_fields = null;
2294                         type_bases = null;
2295                         OptAttributes = null;
2296                 }
2297
2298                 //
2299                 // Performs the validation on a Method's modifiers (properties have
2300                 // the same properties).
2301                 //
2302                 // TODO: Why is it not done at parse stage, move to Modifiers::Check
2303                 //
2304                 public bool MethodModifiersValid (MemberCore mc)
2305                 {
2306                         const Modifiers vao = (Modifiers.VIRTUAL | Modifiers.ABSTRACT | Modifiers.OVERRIDE);
2307                         const Modifiers nv = (Modifiers.NEW | Modifiers.VIRTUAL);
2308                         bool ok = true;
2309                         var flags = mc.ModFlags;
2310
2311                         //
2312                         // At most one of static, virtual or override
2313                         //
2314                         if ((flags & Modifiers.STATIC) != 0){
2315                                 if ((flags & vao) != 0){
2316                                         Report.Error (112, mc.Location, "A static member `{0}' cannot be marked as override, virtual or abstract",
2317                                                 mc.GetSignatureForError ());
2318                                         ok = false;
2319                                 }
2320                         }
2321
2322                         if ((flags & Modifiers.OVERRIDE) != 0 && (flags & nv) != 0){
2323                                 Report.Error (113, mc.Location, "A member `{0}' marked as override cannot be marked as new or virtual",
2324                                         mc.GetSignatureForError ());
2325                                 ok = false;
2326                         }
2327
2328                         //
2329                         // If the declaration includes the abstract modifier, then the
2330                         // declaration does not include static, virtual or extern
2331                         //
2332                         if ((flags & Modifiers.ABSTRACT) != 0){
2333                                 if ((flags & Modifiers.EXTERN) != 0){
2334                                         Report.Error (
2335                                                 180, mc.Location, "`{0}' cannot be both extern and abstract", mc.GetSignatureForError ());
2336                                         ok = false;
2337                                 }
2338
2339                                 if ((flags & Modifiers.SEALED) != 0) {
2340                                         Report.Error (502, mc.Location, "`{0}' cannot be both abstract and sealed", mc.GetSignatureForError ());
2341                                         ok = false;
2342                                 }
2343
2344                                 if ((flags & Modifiers.VIRTUAL) != 0){
2345                                         Report.Error (503, mc.Location, "The abstract method `{0}' cannot be marked virtual", mc.GetSignatureForError ());
2346                                         ok = false;
2347                                 }
2348
2349                                 if ((ModFlags & Modifiers.ABSTRACT) == 0){
2350                                         Report.SymbolRelatedToPreviousError (this);
2351                                         Report.Error (513, mc.Location, "`{0}' is abstract but it is declared in the non-abstract class `{1}'",
2352                                                 mc.GetSignatureForError (), GetSignatureForError ());
2353                                         ok = false;
2354                                 }
2355                         }
2356
2357                         if ((flags & Modifiers.PRIVATE) != 0){
2358                                 if ((flags & vao) != 0){
2359                                         Report.Error (621, mc.Location, "`{0}': virtual or abstract members cannot be private", mc.GetSignatureForError ());
2360                                         ok = false;
2361                                 }
2362                         }
2363
2364                         if ((flags & Modifiers.SEALED) != 0){
2365                                 if ((flags & Modifiers.OVERRIDE) == 0){
2366                                         Report.Error (238, mc.Location, "`{0}' cannot be sealed because it is not an override", mc.GetSignatureForError ());
2367                                         ok = false;
2368                                 }
2369                         }
2370
2371                         return ok;
2372                 }
2373
2374                 protected override bool VerifyClsCompliance ()
2375                 {
2376                         if (!base.VerifyClsCompliance ())
2377                                 return false;
2378
2379                         // Check all container names for user classes
2380                         if (Kind != MemberKind.Delegate)
2381                                 MemberCache.VerifyClsCompliance (Definition, Report);
2382
2383                         if (BaseType != null && !BaseType.IsCLSCompliant ()) {
2384                                 Report.Warning (3009, 1, Location, "`{0}': base type `{1}' is not CLS-compliant",
2385                                         GetSignatureForError (), BaseType.GetSignatureForError ());
2386                         }
2387                         return true;
2388                 }
2389
2390                 /// <summary>
2391                 ///   Performs checks for an explicit interface implementation.  First it
2392                 ///   checks whether the `interface_type' is a base inteface implementation.
2393                 ///   Then it checks whether `name' exists in the interface type.
2394                 /// </summary>
2395                 public bool VerifyImplements (InterfaceMemberBase mb)
2396                 {
2397                         var ifaces = PartialContainer.Interfaces;
2398                         if (ifaces != null) {
2399                                 foreach (TypeSpec t in ifaces){
2400                                         if (t == mb.InterfaceType || t == null)
2401                                                 return true;
2402
2403                                         var expanded_base = t.Interfaces;
2404                                         if (expanded_base == null)
2405                                                 continue;
2406
2407                                         foreach (var bt in expanded_base) {
2408                                                 if (bt == mb.InterfaceType)
2409                                                         return true;
2410                                         }
2411                                 }
2412                         }
2413
2414                         Report.SymbolRelatedToPreviousError (mb.InterfaceType);
2415                         Report.Error (540, mb.Location, "`{0}': containing type does not implement interface `{1}'",
2416                                 mb.GetSignatureForError (), mb.InterfaceType.GetSignatureForError ());
2417                         return false;
2418                 }
2419
2420                 //
2421                 // Used for visiblity checks to tests whether this definition shares
2422                 // base type baseType, it does member-definition search
2423                 //
2424                 public bool IsBaseTypeDefinition (TypeSpec baseType)
2425                 {
2426                         // RootContext check
2427                         if (TypeBuilder == null)
2428                                 return false;
2429
2430                         var type = spec;
2431                         do {
2432                                 if (type.MemberDefinition == baseType.MemberDefinition)
2433                                         return true;
2434
2435                                 type = type.BaseType;
2436                         } while (type != null);
2437
2438                         return false;
2439                 }
2440
2441                 public override bool IsClsComplianceRequired ()
2442                 {
2443                         if (IsPartialPart)
2444                                 return PartialContainer.IsClsComplianceRequired ();
2445
2446                         return base.IsClsComplianceRequired ();
2447                 }
2448
2449                 bool ITypeDefinition.IsInternalAsPublic (IAssemblyDefinition assembly)
2450                 {
2451                         return Module.DeclaringAssembly == assembly;
2452                 }
2453
2454                 public virtual bool IsUnmanagedType ()
2455                 {
2456                         return false;
2457                 }
2458
2459                 public void LoadMembers (TypeSpec declaringType, bool onlyTypes, ref MemberCache cache)
2460                 {
2461                         throw new NotSupportedException ("Not supported for compiled definition " + GetSignatureForError ());
2462                 }
2463
2464                 //
2465                 // Public function used to locate types.
2466                 //
2467                 // Returns: Type or null if they type can not be found.
2468                 //
2469                 public override FullNamedExpression LookupNamespaceOrType (string name, int arity, LookupMode mode, Location loc)
2470                 {
2471                         FullNamedExpression e;
2472                         if (arity == 0 && Cache.TryGetValue (name, out e) && mode != LookupMode.IgnoreAccessibility)
2473                                 return e;
2474
2475                         e = null;
2476
2477                         if (arity == 0) {
2478                                 var tp = CurrentTypeParameters;
2479                                 if (tp != null) {
2480                                         TypeParameter tparam = tp.Find (name);
2481                                         if (tparam != null)
2482                                                 e = new TypeParameterExpr (tparam, Location.Null);
2483                                 }
2484                         }
2485
2486                         if (e == null) {
2487                                 TypeSpec t = LookupNestedTypeInHierarchy (name, arity);
2488
2489                                 if (t != null && (t.IsAccessible (this) || mode == LookupMode.IgnoreAccessibility))
2490                                         e = new TypeExpression (t, Location.Null);
2491                                 else {
2492                                         var errors = Compiler.Report.Errors;
2493                                         e = Parent.LookupNamespaceOrType (name, arity, mode, loc);
2494
2495                                         // TODO: LookupNamespaceOrType does more than just lookup. The result
2496                                         // cannot be cached or the error reporting won't happen
2497                                         if (errors != Compiler.Report.Errors)
2498                                                 return e;
2499                                 }
2500                         }
2501
2502                         // TODO MemberCache: How to cache arity stuff ?
2503                         if (arity == 0 && mode == LookupMode.Normal)
2504                                 Cache[name] = e;
2505
2506                         return e;
2507                 }
2508
2509                 TypeSpec LookupNestedTypeInHierarchy (string name, int arity)
2510                 {
2511                         // Has any nested type
2512                         // Does not work, because base type can have
2513                         //if (PartialContainer.Types == null)
2514                         //      return null;
2515
2516                         var container = PartialContainer.CurrentType;
2517                         return MemberCache.FindNestedType (container, name, arity, false);
2518                 }
2519
2520                 public void Mark_HasEquals ()
2521                 {
2522                         cached_method |= CachedMethods.Equals;
2523                 }
2524
2525                 public void Mark_HasGetHashCode ()
2526                 {
2527                         cached_method |= CachedMethods.GetHashCode;
2528                 }
2529
2530                 public override void WriteDebugSymbol (MonoSymbolFile file)
2531                 {
2532                         if (IsPartialPart)
2533                                 return;
2534
2535                         foreach (var m in members) {
2536                                 m.WriteDebugSymbol (file);
2537                         }
2538                 }
2539
2540                 /// <summary>
2541                 /// Method container contains Equals method
2542                 /// </summary>
2543                 public bool HasEquals {
2544                         get {
2545                                 return (cached_method & CachedMethods.Equals) != 0;
2546                         }
2547                 }
2548
2549                 /// <summary>
2550                 /// Method container contains GetHashCode method
2551                 /// </summary>
2552                 public bool HasGetHashCode {
2553                         get {
2554                                 return (cached_method & CachedMethods.GetHashCode) != 0;
2555                         }
2556                 }
2557
2558                 public bool HasStaticFieldInitializer {
2559                         get {
2560                                 return (cached_method & CachedMethods.HasStaticFieldInitializer) != 0;
2561                         }
2562                         set {
2563                                 if (value)
2564                                         cached_method |= CachedMethods.HasStaticFieldInitializer;
2565                                 else
2566                                         cached_method &= ~CachedMethods.HasStaticFieldInitializer;
2567                         }
2568                 }
2569
2570                 public override string DocCommentHeader {
2571                         get { return "T:"; }
2572                 }
2573         }
2574
2575         public abstract class ClassOrStruct : TypeDefinition
2576         {
2577                 public const TypeAttributes StaticClassAttribute = TypeAttributes.Abstract | TypeAttributes.Sealed;
2578
2579                 SecurityType declarative_security;
2580                 protected Constructor generated_primary_constructor;
2581
2582                 protected ClassOrStruct (TypeContainer parent, MemberName name, Attributes attrs, MemberKind kind)
2583                         : base (parent, name, attrs, kind)
2584                 {
2585                 }
2586
2587                 public ToplevelBlock PrimaryConstructorBlock { get; set; }
2588
2589                 protected override TypeAttributes TypeAttr {
2590                         get {
2591                                 TypeAttributes ta = base.TypeAttr;
2592                                 if (!has_static_constructor)
2593                                         ta |= TypeAttributes.BeforeFieldInit;
2594
2595                                 if (Kind == MemberKind.Class) {
2596                                         ta |= TypeAttributes.AutoLayout | TypeAttributes.Class;
2597                                         if (IsStatic)
2598                                                 ta |= StaticClassAttribute;
2599                                 } else {
2600                                         ta |= TypeAttributes.SequentialLayout;
2601                                 }
2602
2603                                 return ta;
2604                         }
2605                 }
2606
2607                 public override void AddNameToContainer (MemberCore symbol, string name)
2608                 {
2609                         if (!(symbol is Constructor) && symbol.MemberName.Name == MemberName.Name) {
2610                                 if (symbol is TypeParameter) {
2611                                         Report.Error (694, symbol.Location,
2612                                                 "Type parameter `{0}' has same name as containing type, or method",
2613                                                 symbol.GetSignatureForError ());
2614                                         return;
2615                                 }
2616
2617                                 InterfaceMemberBase imb = symbol as InterfaceMemberBase;
2618                                 if (imb == null || !imb.IsExplicitImpl) {
2619                                         Report.SymbolRelatedToPreviousError (this);
2620                                         Report.Error (542, symbol.Location, "`{0}': member names cannot be the same as their enclosing type",
2621                                                 symbol.GetSignatureForError ());
2622                                         return;
2623                                 }
2624                         }
2625
2626                         base.AddNameToContainer (symbol, name);
2627                 }
2628
2629                 public override void ApplyAttributeBuilder (Attribute a, MethodSpec ctor, byte[] cdata, PredefinedAttributes pa)
2630                 {
2631                         if (a.IsValidSecurityAttribute ()) {
2632                                 a.ExtractSecurityPermissionSet (ctor, ref declarative_security);
2633                                 return;
2634                         }
2635
2636                         if (a.Type == pa.StructLayout) {
2637                                 PartialContainer.HasStructLayout = true;
2638                                 if (a.IsExplicitLayoutKind ())
2639                                         PartialContainer.HasExplicitLayout = true;
2640                         }
2641
2642                         if (a.Type == pa.Dynamic) {
2643                                 a.Error_MisusedDynamicAttribute ();
2644                                 return;
2645                         }
2646
2647                         base.ApplyAttributeBuilder (a, ctor, cdata, pa);
2648                 }
2649
2650                 /// <summary>
2651                 /// Defines the default constructors
2652                 /// </summary>
2653                 protected virtual Constructor DefineDefaultConstructor (bool is_static)
2654                 {
2655                         // The default instance constructor is public
2656                         // If the class is abstract, the default constructor is protected
2657                         // The default static constructor is private
2658
2659                         Modifiers mods;
2660                         ParametersCompiled parameters = null;
2661                         if (is_static) {
2662                                 mods = Modifiers.STATIC | Modifiers.PRIVATE;
2663                                 parameters = ParametersCompiled.EmptyReadOnlyParameters;
2664                         } else {
2665                                 mods = ((ModFlags & Modifiers.ABSTRACT) != 0) ? Modifiers.PROTECTED : Modifiers.PUBLIC;
2666                                 parameters = PrimaryConstructorParameters ?? ParametersCompiled.EmptyReadOnlyParameters;
2667                         }
2668
2669                         var c = new Constructor (this, MemberName.Name, mods, null, parameters, Location);
2670                         if (Kind == MemberKind.Class)
2671                                 c.Initializer = new GeneratedBaseInitializer (Location, PrimaryConstructorBaseArguments);
2672
2673                         if (PrimaryConstructorParameters != null && !is_static) {
2674                                 c.IsPrimaryConstructor = true;
2675                                 c.caching_flags |= Flags.MethodOverloadsExist;
2676                         }
2677
2678                         AddConstructor (c, true);
2679                         if (PrimaryConstructorBlock == null) {
2680                                 c.Block = new ToplevelBlock (Compiler, parameters, Location) {
2681                                         IsCompilerGenerated = true
2682                                 };
2683                         } else {
2684                                 c.Block = PrimaryConstructorBlock;
2685                         }
2686
2687                         return c;
2688                 }
2689
2690                 protected override bool DoDefineMembers ()
2691                 {
2692                         CheckProtectedModifier ();
2693
2694                         if (PrimaryConstructorParameters != null) {
2695
2696                                 foreach (Parameter p in PrimaryConstructorParameters.FixedParameters) {
2697                                         if (p.Name == MemberName.Name) {
2698                                                 Report.Error (8039, p.Location, "Primary constructor of type `{0}' has parameter of same name as containing type",
2699                                                         GetSignatureForError ());
2700                                         }
2701
2702                                         if (CurrentTypeParameters != null) {
2703                                                 for (int i = 0; i < CurrentTypeParameters.Count; ++i) {
2704                                                         var tp = CurrentTypeParameters [i];
2705                                                         if (p.Name == tp.Name) {
2706                                                                 Report.Error (8038, p.Location, "Primary constructor of type `{0}' has parameter of same name as type parameter `{1}'",
2707                                                                         GetSignatureForError (), p.GetSignatureForError ());
2708                                                         }
2709                                                 }
2710                                         }
2711                                 }
2712                         }
2713
2714                         base.DoDefineMembers ();
2715
2716                         return true;
2717                 }
2718
2719                 public override void PrepareEmit ()
2720                 {
2721                         var s = this as Struct;
2722                         if (s == null || !s.HasUnmanagedCheckDone) {
2723                                 for (int i = 0; i < Members.Count; ++i) {
2724                                         var f = Members [i] as Field;
2725                                         if (f == null || f.MemberType == null || !f.MemberType.IsPointer)
2726                                                 continue;
2727
2728                                         TypeManager.VerifyUnmanaged (Module, f.MemberType, f.Location);
2729                                 }
2730                         }
2731
2732                         base.PrepareEmit ();
2733                 }
2734
2735                 public override void Emit ()
2736                 {
2737                         if (!has_static_constructor && HasStaticFieldInitializer) {
2738                                 var c = DefineDefaultConstructor (true);
2739                                 c.Define ();
2740                         }
2741
2742                         base.Emit ();
2743
2744                         if (declarative_security != null) {
2745                                 foreach (var de in declarative_security) {
2746 #if STATIC
2747                                         TypeBuilder.__AddDeclarativeSecurity (de);
2748 #else
2749                                         TypeBuilder.AddDeclarativeSecurity (de.Key, de.Value);
2750 #endif
2751                                 }
2752                         }
2753                 }
2754         }
2755
2756
2757         public sealed class Class : ClassOrStruct
2758         {
2759                 const Modifiers AllowedModifiers =
2760                         Modifiers.NEW |
2761                         Modifiers.PUBLIC |
2762                         Modifiers.PROTECTED |
2763                         Modifiers.INTERNAL |
2764                         Modifiers.PRIVATE |
2765                         Modifiers.ABSTRACT |
2766                         Modifiers.SEALED |
2767                         Modifiers.STATIC |
2768                         Modifiers.UNSAFE;
2769
2770                 public Class (TypeContainer parent, MemberName name, Modifiers mod, Attributes attrs)
2771                         : base (parent, name, attrs, MemberKind.Class)
2772                 {
2773                         var accmods = IsTopLevel ? Modifiers.INTERNAL : Modifiers.PRIVATE;
2774                         this.ModFlags = ModifiersExtensions.Check (AllowedModifiers, mod, accmods, Location, Report);
2775                         spec = new TypeSpec (Kind, null, this, null, ModFlags);
2776                 }
2777
2778                 public override void Accept (StructuralVisitor visitor)
2779                 {
2780                         visitor.Visit (this);
2781                 }
2782
2783                 public override void SetBaseTypes (List<FullNamedExpression> baseTypes)
2784                 {
2785                         var pmn = MemberName;
2786                         if (pmn.Name == "Object" && !pmn.IsGeneric && Parent.MemberName.Name == "System" && Parent.MemberName.Left == null)
2787                                 Report.Error (537, Location,
2788                                         "The class System.Object cannot have a base class or implement an interface.");
2789
2790                         base.SetBaseTypes (baseTypes);
2791                 }
2792
2793                 public override void ApplyAttributeBuilder (Attribute a, MethodSpec ctor, byte[] cdata, PredefinedAttributes pa)
2794                 {
2795                         if (a.Type == pa.AttributeUsage) {
2796                                 if (!BaseType.IsAttribute && spec.BuiltinType != BuiltinTypeSpec.Type.Attribute) {
2797                                         Report.Error (641, a.Location, "Attribute `{0}' is only valid on classes derived from System.Attribute", a.GetSignatureForError ());
2798                                 }
2799                         }
2800
2801                         if (a.Type == pa.Conditional && !BaseType.IsAttribute) {
2802                                 Report.Error (1689, a.Location, "Attribute `System.Diagnostics.ConditionalAttribute' is only valid on methods or attribute classes");
2803                                 return;
2804                         }
2805
2806                         if (a.Type == pa.ComImport && !attributes.Contains (pa.Guid)) {
2807                                 a.Error_MissingGuidAttribute ();
2808                                 return;
2809                         }
2810
2811                         if (a.Type == pa.Extension) {
2812                                 a.Error_MisusedExtensionAttribute ();
2813                                 return;
2814                         }
2815
2816                         if (a.Type.IsConditionallyExcluded (this))
2817                                 return;
2818
2819                         base.ApplyAttributeBuilder (a, ctor, cdata, pa);
2820                 }
2821
2822                 public override AttributeTargets AttributeTargets {
2823                         get {
2824                                 return AttributeTargets.Class;
2825                         }
2826                 }
2827
2828                 protected override bool DoDefineMembers ()
2829                 {
2830                         if ((ModFlags & Modifiers.ABSTRACT) == Modifiers.ABSTRACT && (ModFlags & (Modifiers.SEALED | Modifiers.STATIC)) != 0) {
2831                                 Report.Error (418, Location, "`{0}': an abstract class cannot be sealed or static", GetSignatureForError ());
2832                         }
2833
2834                         if ((ModFlags & (Modifiers.SEALED | Modifiers.STATIC)) == (Modifiers.SEALED | Modifiers.STATIC)) {
2835                                 Report.Error (441, Location, "`{0}': a class cannot be both static and sealed", GetSignatureForError ());
2836                         }
2837
2838                         if (IsStatic) {
2839                                 if (PrimaryConstructorParameters != null) {
2840                                         Report.Error (-800, Location, "`{0}': Static classes cannot have primary constructor", GetSignatureForError ());
2841                                         PrimaryConstructorParameters = null;
2842                                 }
2843
2844                                 foreach (var m in Members) {
2845                                         if (m is Operator) {
2846                                                 Report.Error (715, m.Location, "`{0}': Static classes cannot contain user-defined operators", m.GetSignatureForError ());
2847                                                 continue;
2848                                         }
2849
2850                                         if (m is Destructor) {
2851                                                 Report.Error (711, m.Location, "`{0}': Static classes cannot contain destructor", GetSignatureForError ());
2852                                                 continue;
2853                                         }
2854
2855                                         if (m is Indexer) {
2856                                                 Report.Error (720, m.Location, "`{0}': cannot declare indexers in a static class", m.GetSignatureForError ());
2857                                                 continue;
2858                                         }
2859
2860                                         if ((m.ModFlags & Modifiers.STATIC) != 0 || m is TypeContainer)
2861                                                 continue;
2862
2863                                         if (m is Constructor) {
2864                                                 Report.Error (710, m.Location, "`{0}': Static classes cannot have instance constructors", GetSignatureForError ());
2865                                                 continue;
2866                                         }
2867
2868                                         Report.Error (708, m.Location, "`{0}': cannot declare instance members in a static class", m.GetSignatureForError ());
2869                                 }
2870                         } else {
2871                                 if (!PartialContainer.HasInstanceConstructor || PrimaryConstructorParameters != null)
2872                                         generated_primary_constructor = DefineDefaultConstructor (false);
2873                         }
2874
2875                         return base.DoDefineMembers ();
2876                 }
2877
2878                 public override void Emit ()
2879                 {
2880                         base.Emit ();
2881
2882                         if ((ModFlags & Modifiers.METHOD_EXTENSION) != 0)
2883                                 Module.PredefinedAttributes.Extension.EmitAttribute (TypeBuilder);
2884
2885                         if (base_type != null && base_type.HasDynamicElement) {
2886                                 Module.PredefinedAttributes.Dynamic.EmitAttribute (TypeBuilder, base_type, Location);
2887                         }
2888                 }
2889
2890                 public override void GetCompletionStartingWith (string prefix, List<string> results)
2891                 {
2892                         base.GetCompletionStartingWith (prefix, results);
2893
2894                         var bt = base_type;
2895                         while (bt != null) {
2896                                 results.AddRange (MemberCache.GetCompletitionMembers (this, bt, prefix).Where (l => l.IsStatic).Select (l => l.Name));
2897                                 bt = bt.BaseType;
2898                         }
2899                 }
2900
2901                 protected override TypeSpec[] ResolveBaseTypes (out FullNamedExpression base_class)
2902                 {
2903                         var ifaces = base.ResolveBaseTypes (out base_class);
2904
2905                         if (base_class == null) {
2906                                 if (spec.BuiltinType != BuiltinTypeSpec.Type.Object)
2907                                         base_type = Compiler.BuiltinTypes.Object;
2908                         } else {
2909                                 if (base_type.IsGenericParameter){
2910                                         Report.Error (689, base_class.Location, "`{0}': Cannot derive from type parameter `{1}'",
2911                                                 GetSignatureForError (), base_type.GetSignatureForError ());
2912                                 } else if (base_type.IsStatic) {
2913                                         Report.SymbolRelatedToPreviousError (base_type);
2914                                         Report.Error (709, Location, "`{0}': Cannot derive from static class `{1}'",
2915                                                 GetSignatureForError (), base_type.GetSignatureForError ());
2916                                 } else if (base_type.IsSealed) {
2917                                         Report.SymbolRelatedToPreviousError (base_type);
2918                                         Report.Error (509, Location, "`{0}': cannot derive from sealed type `{1}'",
2919                                                 GetSignatureForError (), base_type.GetSignatureForError ());
2920                                 } else if (PartialContainer.IsStatic && base_type.BuiltinType != BuiltinTypeSpec.Type.Object) {
2921                                         Report.Error (713, Location, "Static class `{0}' cannot derive from type `{1}'. Static classes must derive from object",
2922                                                 GetSignatureForError (), base_type.GetSignatureForError ());
2923                                 }
2924
2925                                 switch (base_type.BuiltinType) {
2926                                 case BuiltinTypeSpec.Type.Enum:
2927                                 case BuiltinTypeSpec.Type.ValueType:
2928                                 case BuiltinTypeSpec.Type.MulticastDelegate:
2929                                 case BuiltinTypeSpec.Type.Delegate:
2930                                 case BuiltinTypeSpec.Type.Array:
2931                                         if (!(spec is BuiltinTypeSpec)) {
2932                                                 Report.Error (644, Location, "`{0}' cannot derive from special class `{1}'",
2933                                                         GetSignatureForError (), base_type.GetSignatureForError ());
2934
2935                                                 base_type = Compiler.BuiltinTypes.Object;
2936                                         }
2937                                         break;
2938                                 }
2939
2940                                 if (!IsAccessibleAs (base_type)) {
2941                                         Report.SymbolRelatedToPreviousError (base_type);
2942                                         Report.Error (60, Location, "Inconsistent accessibility: base class `{0}' is less accessible than class `{1}'",
2943                                                 base_type.GetSignatureForError (), GetSignatureForError ());
2944                                 }
2945                         }
2946
2947                         if (PartialContainer.IsStatic && ifaces != null) {
2948                                 foreach (var t in ifaces)
2949                                         Report.SymbolRelatedToPreviousError (t);
2950                                 Report.Error (714, Location, "Static class `{0}' cannot implement interfaces", GetSignatureForError ());
2951                         }
2952
2953                         return ifaces;
2954                 }
2955
2956                 /// Search for at least one defined condition in ConditionalAttribute of attribute class
2957                 /// Valid only for attribute classes.
2958                 public override string[] ConditionalConditions ()
2959                 {
2960                         if ((caching_flags & (Flags.Excluded_Undetected | Flags.Excluded)) == 0)
2961                                 return null;
2962
2963                         caching_flags &= ~Flags.Excluded_Undetected;
2964
2965                         if (OptAttributes == null)
2966                                 return null;
2967
2968                         Attribute[] attrs = OptAttributes.SearchMulti (Module.PredefinedAttributes.Conditional);
2969                         if (attrs == null)
2970                                 return null;
2971
2972                         string[] conditions = new string[attrs.Length];
2973                         for (int i = 0; i < conditions.Length; ++i)
2974                                 conditions[i] = attrs[i].GetConditionalAttributeValue ();
2975
2976                         caching_flags |= Flags.Excluded;
2977                         return conditions;
2978                 }
2979         }
2980
2981         public sealed class Struct : ClassOrStruct
2982         {
2983                 bool is_unmanaged, has_unmanaged_check_done, requires_delayed_unmanagedtype_check;
2984                 bool InTransit;
2985
2986                 // <summary>
2987                 //   Modifiers allowed in a struct declaration
2988                 // </summary>
2989                 const Modifiers AllowedModifiers =
2990                         Modifiers.NEW       |
2991                         Modifiers.PUBLIC    |
2992                         Modifiers.PROTECTED |
2993                         Modifiers.INTERNAL  |
2994                         Modifiers.UNSAFE    |
2995                         Modifiers.PRIVATE;
2996
2997                 public Struct (TypeContainer parent, MemberName name, Modifiers mod, Attributes attrs)
2998                         : base (parent, name, attrs, MemberKind.Struct)
2999                 {
3000                         var accmods = IsTopLevel ? Modifiers.INTERNAL : Modifiers.PRIVATE;
3001                         this.ModFlags = ModifiersExtensions.Check (AllowedModifiers, mod, accmods, Location, Report) | Modifiers.SEALED ;
3002                         spec = new TypeSpec (Kind, null, this, null, ModFlags);
3003                 }
3004
3005                 public override AttributeTargets AttributeTargets {
3006                         get {
3007                                 return AttributeTargets.Struct;
3008                         }
3009                 }
3010
3011                 public override void Accept (StructuralVisitor visitor)
3012                 {
3013                         visitor.Visit (this);
3014                 }
3015
3016                 public override void ApplyAttributeBuilder (Attribute a, MethodSpec ctor, byte[] cdata, PredefinedAttributes pa)
3017                 {
3018                         base.ApplyAttributeBuilder (a, ctor, cdata, pa);
3019
3020                         //
3021                         // When struct constains fixed fixed and struct layout has explicitly
3022                         // set CharSet, its value has to be propagated to compiler generated
3023                         // fixed types
3024                         //
3025                         if (a.Type == pa.StructLayout) {
3026                                 var value = a.GetNamedValue ("CharSet");
3027                                 if (value == null)
3028                                         return;
3029
3030                                 for (int i = 0; i < Members.Count; ++i) {
3031                                         FixedField ff = Members [i] as FixedField;
3032                                         if (ff == null)
3033                                                 continue;
3034
3035                                         ff.CharSetValue = (CharSet) System.Enum.Parse (typeof (CharSet), value.GetValue ().ToString ());
3036                                 }
3037                         }
3038                 }
3039
3040                 bool CheckStructCycles ()
3041                 {
3042                         if (InTransit)
3043                                 return false;
3044
3045                         InTransit = true;
3046                         foreach (var member in Members) {
3047                                 var field = member as Field;
3048                                 if (field == null)
3049                                         continue;
3050
3051                                 TypeSpec ftype = field.Spec.MemberType;
3052                                 if (!ftype.IsStruct)
3053                                         continue;
3054
3055                                 if (ftype is BuiltinTypeSpec)
3056                                         continue;
3057
3058                                 foreach (var targ in ftype.TypeArguments) {
3059                                         if (!CheckFieldTypeCycle (targ)) {
3060                                                 Report.Error (523, field.Location,
3061                                                         "Struct member `{0}' of type `{1}' causes a cycle in the struct layout",
3062                                                         field.GetSignatureForError (), ftype.GetSignatureForError ());
3063                                                 break;
3064                                         }
3065                                 }
3066
3067                                 //
3068                                 // Static fields of exactly same type are allowed
3069                                 //
3070                                 if (field.IsStatic && ftype == CurrentType)
3071                                         continue;
3072
3073                                 if (!CheckFieldTypeCycle (ftype)) {
3074                                         Report.Error (523, field.Location,
3075                                                 "Struct member `{0}' of type `{1}' causes a cycle in the struct layout",
3076                                                 field.GetSignatureForError (), ftype.GetSignatureForError ());
3077                                         break;
3078                                 }
3079                         }
3080
3081                         InTransit = false;
3082                         return true;
3083                 }
3084
3085                 static bool CheckFieldTypeCycle (TypeSpec ts)
3086                 {
3087                         var fts = ts.MemberDefinition as Struct;
3088                         if (fts == null)
3089                                 return true;
3090
3091                         return fts.CheckStructCycles ();
3092                 }
3093
3094                 protected override bool DoDefineMembers ()
3095                 {
3096                         var res = base.DoDefineMembers ();
3097
3098                         if (PrimaryConstructorParameters != null || (initialized_fields != null && !HasUserDefaultConstructor ())) {
3099                                 generated_primary_constructor = DefineDefaultConstructor (false);
3100                                 generated_primary_constructor.Define ();
3101                         }
3102
3103                         return res;
3104                 }
3105
3106                 public override void Emit ()
3107                 {
3108                         CheckStructCycles ();
3109
3110                         base.Emit ();
3111                 }
3112
3113                 public bool HasUnmanagedCheckDone {
3114                         get {
3115                                 return has_unmanaged_check_done;
3116                         }
3117                 }
3118
3119                 bool HasUserDefaultConstructor ()
3120                 {
3121                         foreach (var m in PartialContainer.Members) {
3122                                 var c = m as Constructor;
3123                                 if (c == null)
3124                                         continue;
3125
3126                                 if (!c.IsStatic && c.ParameterInfo.IsEmpty)
3127                                         return true;
3128                         }
3129
3130                         return false;
3131                 }
3132
3133                 public override bool IsUnmanagedType ()
3134                 {
3135                         if (has_unmanaged_check_done)
3136                                 return is_unmanaged;
3137
3138                         if (requires_delayed_unmanagedtype_check)
3139                                 return true;
3140
3141                         var parent_def = Parent.PartialContainer;
3142                         if (parent_def != null && parent_def.IsGenericOrParentIsGeneric) {
3143                                 has_unmanaged_check_done = true;
3144                                 return false;
3145                         }
3146
3147                         if (first_nonstatic_field != null) {
3148                                 requires_delayed_unmanagedtype_check = true;
3149
3150                                 foreach (var member in Members) {
3151                                         var f = member as Field;
3152                                         if (f == null)
3153                                                 continue;
3154
3155                                         if (f.IsStatic)
3156                                                 continue;
3157
3158                                         // It can happen when recursive unmanaged types are defined
3159                                         // struct S { S* s; }
3160                                         TypeSpec mt = f.MemberType;
3161                                         if (mt == null) {
3162                                                 return true;
3163                                         }
3164
3165                                         if (mt.IsUnmanaged)
3166                                                 continue;
3167
3168                                         has_unmanaged_check_done = true;
3169                                         return false;
3170                                 }
3171
3172                                 has_unmanaged_check_done = true;
3173                         }
3174
3175                         is_unmanaged = true;
3176                         return true;
3177                 }
3178
3179                 protected override TypeSpec[] ResolveBaseTypes (out FullNamedExpression base_class)
3180                 {
3181                         var ifaces = base.ResolveBaseTypes (out base_class);
3182                         base_type = Compiler.BuiltinTypes.ValueType;
3183                         return ifaces;
3184                 }
3185         }
3186
3187         /// <summary>
3188         ///   Interfaces
3189         /// </summary>
3190         public sealed class Interface : TypeDefinition {
3191
3192                 /// <summary>
3193                 ///   Modifiers allowed in a class declaration
3194                 /// </summary>
3195                 const Modifiers AllowedModifiers =
3196                         Modifiers.NEW       |
3197                         Modifiers.PUBLIC    |
3198                         Modifiers.PROTECTED |
3199                         Modifiers.INTERNAL  |
3200                         Modifiers.UNSAFE    |
3201                         Modifiers.PRIVATE;
3202
3203                 public Interface (TypeContainer parent, MemberName name, Modifiers mod, Attributes attrs)
3204                         : base (parent, name, attrs, MemberKind.Interface)
3205                 {
3206                         var accmods = IsTopLevel ? Modifiers.INTERNAL : Modifiers.PRIVATE;
3207
3208                         this.ModFlags = ModifiersExtensions.Check (AllowedModifiers, mod, accmods, name.Location, Report);
3209                         spec = new TypeSpec (Kind, null, this, null, ModFlags);
3210                 }
3211
3212                 #region Properties
3213
3214                 public override AttributeTargets AttributeTargets {
3215                         get {
3216                                 return AttributeTargets.Interface;
3217                         }
3218                 }
3219
3220                 protected override TypeAttributes TypeAttr {
3221                         get {
3222                                 const TypeAttributes DefaultTypeAttributes =
3223                                         TypeAttributes.AutoLayout |
3224                                         TypeAttributes.Abstract |
3225                                         TypeAttributes.Interface;
3226
3227                                 return base.TypeAttr | DefaultTypeAttributes;
3228                         }
3229                 }
3230
3231                 #endregion
3232
3233                 public override void Accept (StructuralVisitor visitor)
3234                 {
3235                         visitor.Visit (this);
3236                 }
3237
3238                 public override void ApplyAttributeBuilder (Attribute a, MethodSpec ctor, byte[] cdata, PredefinedAttributes pa)
3239                 {
3240                         if (a.Type == pa.ComImport && !attributes.Contains (pa.Guid)) {
3241                                 a.Error_MissingGuidAttribute ();
3242                                 return;
3243                         }
3244
3245                         base.ApplyAttributeBuilder (a, ctor, cdata, pa);
3246                 }
3247
3248                 protected override bool VerifyClsCompliance ()
3249                 {
3250                         if (!base.VerifyClsCompliance ())
3251                                 return false;
3252
3253                         if (iface_exprs != null) {
3254                                 foreach (var iface in iface_exprs) {
3255                                         if (iface.IsCLSCompliant ())
3256                                                 continue;
3257
3258                                         Report.SymbolRelatedToPreviousError (iface);
3259                                         Report.Warning (3027, 1, Location, "`{0}' is not CLS-compliant because base interface `{1}' is not CLS-compliant",
3260                                                 GetSignatureForError (), iface.GetSignatureForError ());
3261                                 }
3262                         }
3263
3264                         return true;
3265                 }
3266         }
3267
3268         public abstract class InterfaceMemberBase : MemberBase
3269         {
3270                 //
3271                 // Common modifiers allowed in a class declaration
3272                 //
3273                 protected const Modifiers AllowedModifiersClass =
3274                         Modifiers.NEW |
3275                         Modifiers.PUBLIC |
3276                         Modifiers.PROTECTED |
3277                         Modifiers.INTERNAL |
3278                         Modifiers.PRIVATE |
3279                         Modifiers.STATIC |
3280                         Modifiers.VIRTUAL |
3281                         Modifiers.SEALED |
3282                         Modifiers.OVERRIDE |
3283                         Modifiers.ABSTRACT |
3284                         Modifiers.UNSAFE |
3285                         Modifiers.EXTERN;
3286
3287                 //
3288                 // Common modifiers allowed in a struct declaration
3289                 //
3290                 protected const Modifiers AllowedModifiersStruct =
3291                         Modifiers.NEW |
3292                         Modifiers.PUBLIC |
3293                         Modifiers.PROTECTED |
3294                         Modifiers.INTERNAL |
3295                         Modifiers.PRIVATE |
3296                         Modifiers.STATIC |
3297                         Modifiers.OVERRIDE |
3298                         Modifiers.UNSAFE |
3299                         Modifiers.EXTERN;
3300
3301                 //
3302                 // Common modifiers allowed in a interface declaration
3303                 //
3304                 protected const Modifiers AllowedModifiersInterface =
3305                         Modifiers.NEW |
3306                         Modifiers.UNSAFE;
3307
3308                 //
3309                 // Whether this is an interface member.
3310                 //
3311                 public bool IsInterface;
3312
3313                 //
3314                 // If true, this is an explicit interface implementation
3315                 //
3316                 public readonly bool IsExplicitImpl;
3317
3318                 protected bool is_external_implementation;
3319
3320                 //
3321                 // The interface type we are explicitly implementing
3322                 //
3323                 public TypeSpec InterfaceType;
3324
3325                 //
3326                 // The method we're overriding if this is an override method.
3327                 //
3328                 protected MethodSpec base_method;
3329
3330                 readonly Modifiers explicit_mod_flags;
3331                 public MethodAttributes flags;
3332
3333                 protected InterfaceMemberBase (TypeDefinition parent, FullNamedExpression type, Modifiers mod, Modifiers allowed_mod, MemberName name, Attributes attrs)
3334                         : base (parent, type, mod, allowed_mod, Modifiers.PRIVATE, name, attrs)
3335                 {
3336                         IsInterface = parent.Kind == MemberKind.Interface;
3337                         IsExplicitImpl = (MemberName.ExplicitInterface != null);
3338                         explicit_mod_flags = mod;
3339                 }
3340
3341                 public abstract Variance ExpectedMemberTypeVariance { get; }
3342
3343                 protected override bool CheckBase ()
3344                 {
3345                         if (!base.CheckBase ())
3346                                 return false;
3347
3348                         if ((caching_flags & Flags.MethodOverloadsExist) != 0)
3349                                 CheckForDuplications ();
3350
3351                         if (IsExplicitImpl)
3352                                 return true;
3353
3354                         // For System.Object only
3355                         if (Parent.BaseType == null)
3356                                 return true;
3357
3358                         MemberSpec candidate;
3359                         bool overrides = false;
3360                         var base_member = FindBaseMember (out candidate, ref overrides);
3361
3362                         if ((ModFlags & Modifiers.OVERRIDE) != 0) {
3363                                 if (base_member == null) {
3364                                         if (candidate == null) {
3365                                                 if (this is Method && ((Method)this).ParameterInfo.IsEmpty && MemberName.Name == Destructor.MetadataName && MemberName.Arity == 0) {
3366                                                         Report.Error (249, Location, "Do not override `{0}'. Use destructor syntax instead",
3367                                                                 "object.Finalize()");
3368                                                 } else {
3369                                                         Report.Error (115, Location, "`{0}' is marked as an override but no suitable {1} found to override",
3370                                                                 GetSignatureForError (), SimpleName.GetMemberType (this));
3371                                                 }
3372                                         } else {
3373                                                 Report.SymbolRelatedToPreviousError (candidate);
3374                                                 if (this is Event)
3375                                                         Report.Error (72, Location, "`{0}': cannot override because `{1}' is not an event",
3376                                                                 GetSignatureForError (), TypeManager.GetFullNameSignature (candidate));
3377                                                 else if (this is PropertyBase)
3378                                                         Report.Error (544, Location, "`{0}': cannot override because `{1}' is not a property",
3379                                                                 GetSignatureForError (), TypeManager.GetFullNameSignature (candidate));
3380                                                 else
3381                                                         Report.Error (505, Location, "`{0}': cannot override because `{1}' is not a method",
3382                                                                 GetSignatureForError (), TypeManager.GetFullNameSignature (candidate));
3383                                         }
3384
3385                                         return false;
3386                                 }
3387
3388                                 //
3389                                 // Handles ambiguous overrides
3390                                 //
3391                                 if (candidate != null) {
3392                                         Report.SymbolRelatedToPreviousError (candidate);
3393                                         Report.SymbolRelatedToPreviousError (base_member);
3394
3395                                         // Get member definition for error reporting
3396                                         var m1 = MemberCache.GetMember (base_member.DeclaringType.GetDefinition (), base_member);
3397                                         var m2 = MemberCache.GetMember (candidate.DeclaringType.GetDefinition (), candidate);
3398
3399                                         Report.Error (462, Location,
3400                                                 "`{0}' cannot override inherited members `{1}' and `{2}' because they have the same signature when used in type `{3}'",
3401                                                 GetSignatureForError (), m1.GetSignatureForError (), m2.GetSignatureForError (), Parent.GetSignatureForError ());
3402                                 }
3403
3404                                 if (!CheckOverrideAgainstBase (base_member))
3405                                         return false;
3406
3407                                 ObsoleteAttribute oa = base_member.GetAttributeObsolete ();
3408                                 if (oa != null) {
3409                                         if (OptAttributes == null || !OptAttributes.Contains (Module.PredefinedAttributes.Obsolete)) {
3410                                                 Report.SymbolRelatedToPreviousError (base_member);
3411                                                 Report.Warning (672, 1, Location, "Member `{0}' overrides obsolete member `{1}'. Add the Obsolete attribute to `{0}'",
3412                                                         GetSignatureForError (), base_member.GetSignatureForError ());
3413                                         }
3414                                 } else {
3415                                         if (OptAttributes != null && OptAttributes.Contains (Module.PredefinedAttributes.Obsolete)) {
3416                                                 Report.SymbolRelatedToPreviousError (base_member);
3417                                                 Report.Warning (809, 1, Location, "Obsolete member `{0}' overrides non-obsolete member `{1}'",
3418                                                         GetSignatureForError (), base_member.GetSignatureForError ());
3419                                         }
3420                                 }
3421
3422                                 base_method = base_member as MethodSpec;
3423                                 return true;
3424                         }
3425
3426                         if (base_member == null && candidate != null && (!(candidate is IParametersMember) || !(this is IParametersMember)))
3427                                 base_member = candidate;
3428
3429                         if (base_member == null) {
3430                                 if ((ModFlags & Modifiers.NEW) != 0) {
3431                                         if (base_member == null) {
3432                                                 Report.Warning (109, 4, Location, "The member `{0}' does not hide an inherited member. The new keyword is not required",
3433                                                         GetSignatureForError ());
3434                                         }
3435                                 }
3436                         } else {
3437                                 if ((ModFlags & Modifiers.NEW) == 0) {
3438                                         ModFlags |= Modifiers.NEW;
3439                                         if (!IsCompilerGenerated) {
3440                                                 Report.SymbolRelatedToPreviousError (base_member);
3441                                                 if ((base_member.Kind & MemberKind.NestedMask) == 0 && !IsInterface && (base_member.Modifiers & (Modifiers.ABSTRACT | Modifiers.VIRTUAL | Modifiers.OVERRIDE)) != 0) {
3442                                                         Report.Warning (114, 2, Location, "`{0}' hides inherited member `{1}'. To make the current member override that implementation, add the override keyword. Otherwise add the new keyword",
3443                                                                 GetSignatureForError (), base_member.GetSignatureForError ());
3444                                                 } else {
3445                                                         Report.Warning (108, 2, Location, "`{0}' hides inherited member `{1}'. Use the new keyword if hiding was intended",
3446                                                                 GetSignatureForError (), base_member.GetSignatureForError ());
3447                                                 }
3448                                         }
3449                                 }
3450
3451                                 if (!IsInterface && base_member.IsAbstract && !overrides && !IsStatic) {
3452                                         switch (base_member.Kind) {
3453                                         case MemberKind.Event:
3454                                         case MemberKind.Indexer:
3455                                         case MemberKind.Method:
3456                                         case MemberKind.Property:
3457                                                 Report.SymbolRelatedToPreviousError (base_member);
3458                                                 Report.Error (533, Location, "`{0}' hides inherited abstract member `{1}'",
3459                                                         GetSignatureForError (), base_member.GetSignatureForError ());
3460                                                 break;
3461                                         }
3462                                 }
3463                         }
3464
3465                         return true;
3466                 }
3467
3468                 protected virtual bool CheckForDuplications ()
3469                 {
3470                         return Parent.MemberCache.CheckExistingMembersOverloads (this, ParametersCompiled.EmptyReadOnlyParameters);
3471                 }
3472
3473                 //
3474                 // Performs various checks on the MethodInfo `mb' regarding the modifier flags
3475                 // that have been defined.
3476                 //
3477                 protected virtual bool CheckOverrideAgainstBase (MemberSpec base_member)
3478                 {
3479                         bool ok = true;
3480
3481                         if ((base_member.Modifiers & (Modifiers.ABSTRACT | Modifiers.VIRTUAL | Modifiers.OVERRIDE)) == 0) {
3482                                 Report.SymbolRelatedToPreviousError (base_member);
3483                                 Report.Error (506, Location,
3484                                         "`{0}': cannot override inherited member `{1}' because it is not marked virtual, abstract or override",
3485                                          GetSignatureForError (), TypeManager.CSharpSignature (base_member));
3486                                 ok = false;
3487                         }
3488
3489                         // Now we check that the overriden method is not final
3490                         if ((base_member.Modifiers & Modifiers.SEALED) != 0) {
3491                                 Report.SymbolRelatedToPreviousError (base_member);
3492                                 Report.Error (239, Location, "`{0}': cannot override inherited member `{1}' because it is sealed",
3493                                                           GetSignatureForError (), TypeManager.CSharpSignature (base_member));
3494                                 ok = false;
3495                         }
3496
3497                         var base_member_type = ((IInterfaceMemberSpec) base_member).MemberType;
3498                         if (!TypeSpecComparer.Override.IsEqual (MemberType, base_member_type)) {
3499                                 Report.SymbolRelatedToPreviousError (base_member);
3500                                 if (this is PropertyBasedMember) {
3501                                         Report.Error (1715, Location, "`{0}': type must be `{1}' to match overridden member `{2}'",
3502                                                 GetSignatureForError (), base_member_type.GetSignatureForError (), base_member.GetSignatureForError ());
3503                                 } else {
3504                                         Report.Error (508, Location, "`{0}': return type must be `{1}' to match overridden member `{2}'",
3505                                                 GetSignatureForError (), base_member_type.GetSignatureForError (), base_member.GetSignatureForError ());
3506                                 }
3507                                 ok = false;
3508                         }
3509
3510                         return ok;
3511                 }
3512
3513                 protected static bool CheckAccessModifiers (MemberCore this_member, MemberSpec base_member)
3514                 {
3515                         var thisp = this_member.ModFlags & Modifiers.AccessibilityMask;
3516                         var base_classp = base_member.Modifiers & Modifiers.AccessibilityMask;
3517
3518                         if ((base_classp & (Modifiers.PROTECTED | Modifiers.INTERNAL)) == (Modifiers.PROTECTED | Modifiers.INTERNAL)) {
3519                                 //
3520                                 // It must be at least "protected"
3521                                 //
3522                                 if ((thisp & Modifiers.PROTECTED) == 0) {
3523                                         return false;
3524                                 }
3525
3526                                 //
3527                                 // when overriding protected internal, the method can be declared
3528                                 // protected internal only within the same assembly or assembly
3529                                 // which has InternalsVisibleTo
3530                                 //
3531                                 if ((thisp & Modifiers.INTERNAL) != 0) {
3532                                         return base_member.DeclaringType.MemberDefinition.IsInternalAsPublic (this_member.Module.DeclaringAssembly);
3533                                 }
3534
3535                                 //
3536                                 // protected overriding protected internal inside same assembly
3537                                 // requires internal modifier as well
3538                                 //
3539                                 if (base_member.DeclaringType.MemberDefinition.IsInternalAsPublic (this_member.Module.DeclaringAssembly)) {
3540                                         return false;
3541                                 }
3542
3543                                 return true;
3544                         }
3545
3546                         return thisp == base_classp;
3547                 }
3548
3549                 public override bool Define ()
3550                 {
3551                         if (IsInterface) {
3552                                 ModFlags = Modifiers.PUBLIC | Modifiers.ABSTRACT |
3553                                         Modifiers.VIRTUAL | (ModFlags & (Modifiers.UNSAFE | Modifiers.NEW));
3554
3555                                 flags = MethodAttributes.Public |
3556                                         MethodAttributes.Abstract |
3557                                         MethodAttributes.HideBySig |
3558                                         MethodAttributes.NewSlot |
3559                                         MethodAttributes.Virtual;
3560                         } else {
3561                                 Parent.PartialContainer.MethodModifiersValid (this);
3562
3563                                 flags = ModifiersExtensions.MethodAttr (ModFlags);
3564                         }
3565
3566                         if (IsExplicitImpl) {
3567                                 InterfaceType = MemberName.ExplicitInterface.ResolveAsType (Parent);
3568                                 if (InterfaceType == null)
3569                                         return false;
3570
3571                                 if ((ModFlags & Modifiers.PARTIAL) != 0) {
3572                                         Report.Error (754, Location, "A partial method `{0}' cannot explicitly implement an interface",
3573                                                 GetSignatureForError ());
3574                                 }
3575
3576                                 if (!InterfaceType.IsInterface) {
3577                                         Report.SymbolRelatedToPreviousError (InterfaceType);
3578                                         Report.Error (538, Location, "The type `{0}' in explicit interface declaration is not an interface",
3579                                                 InterfaceType.GetSignatureForError ());
3580                                 } else {
3581                                         Parent.PartialContainer.VerifyImplements (this);
3582                                 }
3583
3584                                 Modifiers allowed_explicit = Modifiers.AllowedExplicitImplFlags;
3585                                 if (this is Method)
3586                                         allowed_explicit |= Modifiers.ASYNC;
3587
3588                                 ModifiersExtensions.Check (allowed_explicit, explicit_mod_flags, 0, Location, Report);
3589                         }
3590
3591                         return base.Define ();
3592                 }
3593
3594                 protected bool DefineParameters (ParametersCompiled parameters)
3595                 {
3596                         if (!parameters.Resolve (this))
3597                                 return false;
3598
3599                         bool error = false;
3600                         for (int i = 0; i < parameters.Count; ++i) {
3601                                 Parameter p = parameters [i];
3602
3603                                 if (p.HasDefaultValue && (IsExplicitImpl || this is Operator || (this is Indexer && parameters.Count == 1)))
3604                                         p.Warning_UselessOptionalParameter (Report);
3605
3606                                 if (p.CheckAccessibility (this))
3607                                         continue;
3608
3609                                 TypeSpec t = parameters.Types [i];
3610                                 Report.SymbolRelatedToPreviousError (t);
3611                                 if (this is Indexer)
3612                                         Report.Error (55, Location,
3613                                                       "Inconsistent accessibility: parameter type `{0}' is less accessible than indexer `{1}'",
3614                                                       t.GetSignatureForError (), GetSignatureForError ());
3615                                 else if (this is Operator)
3616                                         Report.Error (57, Location,
3617                                                       "Inconsistent accessibility: parameter type `{0}' is less accessible than operator `{1}'",
3618                                                       t.GetSignatureForError (), GetSignatureForError ());
3619                                 else
3620                                         Report.Error (51, Location,
3621                                                 "Inconsistent accessibility: parameter type `{0}' is less accessible than method `{1}'",
3622                                                 t.GetSignatureForError (), GetSignatureForError ());
3623                                 error = true;
3624                         }
3625                         return !error;
3626                 }
3627
3628                 protected override void DoMemberTypeDependentChecks ()
3629                 {
3630                         base.DoMemberTypeDependentChecks ();
3631
3632                         VarianceDecl.CheckTypeVariance (MemberType, ExpectedMemberTypeVariance, this);
3633                 }
3634
3635                 public override void Emit()
3636                 {
3637                         // for extern static method must be specified either DllImport attribute or MethodImplAttribute.
3638                         // We are more strict than csc and report this as an error because SRE does not allow emit that
3639                         if ((ModFlags & Modifiers.EXTERN) != 0 && !is_external_implementation && (OptAttributes == null || !OptAttributes.HasResolveError ())) {
3640                                 if (this is Constructor) {
3641                                         Report.Warning (824, 1, Location,
3642                                                 "Constructor `{0}' is marked `external' but has no external implementation specified", GetSignatureForError ());
3643                                 } else {
3644                                         Report.Warning (626, 1, Location,
3645                                                 "`{0}' is marked as an external but has no DllImport attribute. Consider adding a DllImport attribute to specify the external implementation",
3646                                                 GetSignatureForError ());
3647                                 }
3648                         }
3649
3650                         base.Emit ();
3651                 }
3652
3653                 public override bool EnableOverloadChecks (MemberCore overload)
3654                 {
3655                         //
3656                         // Two members can differ in their explicit interface
3657                         // type parameter only
3658                         //
3659                         InterfaceMemberBase imb = overload as InterfaceMemberBase;
3660                         if (imb != null && imb.IsExplicitImpl) {
3661                                 if (IsExplicitImpl) {
3662                                         caching_flags |= Flags.MethodOverloadsExist;
3663                                 }
3664                                 return true;
3665                         }
3666
3667                         return IsExplicitImpl;
3668                 }
3669
3670                 protected void Error_CannotChangeAccessModifiers (MemberCore member, MemberSpec base_member)
3671                 {
3672                         var base_modifiers = base_member.Modifiers;
3673
3674                         // Remove internal modifier from types which are not internally accessible
3675                         if ((base_modifiers & Modifiers.AccessibilityMask) == (Modifiers.PROTECTED | Modifiers.INTERNAL) &&
3676                                 !base_member.DeclaringType.MemberDefinition.IsInternalAsPublic (member.Module.DeclaringAssembly))
3677                                 base_modifiers = Modifiers.PROTECTED;
3678
3679                         Report.SymbolRelatedToPreviousError (base_member);
3680                         Report.Error (507, member.Location,
3681                                 "`{0}': cannot change access modifiers when overriding `{1}' inherited member `{2}'",
3682                                 member.GetSignatureForError (),
3683                                 ModifiersExtensions.AccessibilityName (base_modifiers),
3684                                 base_member.GetSignatureForError ());
3685                 }
3686
3687                 protected void Error_StaticReturnType ()
3688                 {
3689                         Report.Error (722, Location,
3690                                 "`{0}': static types cannot be used as return types",
3691                                 MemberType.GetSignatureForError ());
3692                 }
3693
3694                 /// <summary>
3695                 /// Gets base method and its return type
3696                 /// </summary>
3697                 protected virtual MemberSpec FindBaseMember (out MemberSpec bestCandidate, ref bool overrides)
3698                 {
3699                         return MemberCache.FindBaseMember (this, out bestCandidate, ref overrides);
3700                 }
3701
3702                 //
3703                 // The "short" name of this property / indexer / event.  This is the
3704                 // name without the explicit interface.
3705                 //
3706                 public string ShortName {
3707                         get { return MemberName.Name; }
3708                 }
3709
3710                 //
3711                 // Returns full metadata method name
3712                 //
3713                 public string GetFullName (MemberName name)
3714                 {
3715                         return GetFullName (name.Name);
3716                 }
3717
3718                 public string GetFullName (string name)
3719                 {
3720                         if (!IsExplicitImpl)
3721                                 return name;
3722
3723                         //
3724                         // When dealing with explicit members a full interface type
3725                         // name is added to member name to avoid possible name conflicts
3726                         //
3727                         // We use CSharpName which gets us full name with benefit of
3728                         // replacing predefined names which saves some space and name
3729                         // is still unique
3730                         //
3731                         return InterfaceType.GetSignatureForError () + "." + name;
3732                 }
3733
3734                 public override string GetSignatureForDocumentation ()
3735                 {
3736                         if (IsExplicitImpl)
3737                                 return Parent.GetSignatureForDocumentation () + "." + InterfaceType.GetSignatureForDocumentation (true) + "#" + ShortName;
3738
3739                         return Parent.GetSignatureForDocumentation () + "." + ShortName;
3740                 }
3741
3742                 public override bool IsUsed
3743                 {
3744                         get { return IsExplicitImpl || base.IsUsed; }
3745                 }
3746
3747                 public override void SetConstraints (List<Constraints> constraints_list)
3748                 {
3749                         if (((ModFlags & Modifiers.OVERRIDE) != 0 || IsExplicitImpl)) {
3750                                 Report.Error (460, Location,
3751                                         "`{0}': Cannot specify constraints for overrides and explicit interface implementation methods",
3752                                         GetSignatureForError ());
3753                         }
3754
3755                         base.SetConstraints (constraints_list);
3756                 }
3757         }
3758
3759         public abstract class MemberBase : MemberCore
3760         {
3761                 protected FullNamedExpression type_expr;
3762                 protected TypeSpec member_type;
3763                 public new TypeDefinition Parent;
3764
3765                 protected MemberBase (TypeDefinition parent, FullNamedExpression type, Modifiers mod, Modifiers allowed_mod, Modifiers def_mod, MemberName name, Attributes attrs)
3766                         : base (parent, name, attrs)
3767                 {
3768                         this.Parent = parent;
3769                         this.type_expr = type;
3770
3771                         if (name != MemberName.Null)
3772                                 ModFlags = ModifiersExtensions.Check (allowed_mod, mod, def_mod, Location, Report);
3773                 }
3774
3775                 #region Properties
3776
3777                 public TypeSpec MemberType {
3778                         get {
3779                                 return member_type;
3780                         }
3781                 }
3782
3783                 public FullNamedExpression TypeExpression {
3784                         get {
3785                                 return type_expr;
3786                         }
3787                         set {
3788                                 type_expr = value;
3789                         }
3790                 }
3791
3792                 #endregion
3793
3794                 //
3795                 // Main member define entry
3796                 //
3797                 public override bool Define ()
3798                 {
3799                         DoMemberTypeIndependentChecks ();
3800
3801                         //
3802                         // Returns false only when type resolution failed
3803                         //
3804                         if (!ResolveMemberType ())
3805                                 return false;
3806
3807                         DoMemberTypeDependentChecks ();
3808                         return true;
3809                 }
3810
3811                 //
3812                 // Any type_name independent checks
3813                 //
3814                 protected virtual void DoMemberTypeIndependentChecks ()
3815                 {
3816                         if ((Parent.ModFlags & Modifiers.SEALED) != 0 &&
3817                                 (ModFlags & (Modifiers.VIRTUAL | Modifiers.ABSTRACT)) != 0) {
3818                                 Report.Error (549, Location, "New virtual member `{0}' is declared in a sealed class `{1}'",
3819                                         GetSignatureForError (), Parent.GetSignatureForError ());
3820                         }
3821                 }
3822
3823                 //
3824                 // Any type_name dependent checks
3825                 //
3826                 protected virtual void DoMemberTypeDependentChecks ()
3827                 {
3828                         // verify accessibility
3829                         if (!IsAccessibleAs (MemberType)) {
3830                                 Report.SymbolRelatedToPreviousError (MemberType);
3831                                 if (this is Property)
3832                                         Report.Error (53, Location,
3833                                                 "Inconsistent accessibility: property type `" +
3834                                                 MemberType.GetSignatureForError () + "' is less " +
3835                                                 "accessible than property `" + GetSignatureForError () + "'");
3836                                 else if (this is Indexer)
3837                                         Report.Error (54, Location,
3838                                                 "Inconsistent accessibility: indexer return type `" +
3839                                                 MemberType.GetSignatureForError () + "' is less " +
3840                                                 "accessible than indexer `" + GetSignatureForError () + "'");
3841                                 else if (this is MethodCore) {
3842                                         if (this is Operator)
3843                                                 Report.Error (56, Location,
3844                                                         "Inconsistent accessibility: return type `" +
3845                                                         MemberType.GetSignatureForError () + "' is less " +
3846                                                         "accessible than operator `" + GetSignatureForError () + "'");
3847                                         else
3848                                                 Report.Error (50, Location,
3849                                                         "Inconsistent accessibility: return type `" +
3850                                                         MemberType.GetSignatureForError () + "' is less " +
3851                                                         "accessible than method `" + GetSignatureForError () + "'");
3852                                 } else if (this is Event) {
3853                                         Report.Error (7025, Location,
3854                                                 "Inconsistent accessibility: event type `{0}' is less accessible than event `{1}'",
3855                                                 MemberType.GetSignatureForError (), GetSignatureForError ());
3856                                 } else {
3857                                         Report.Error (52, Location,
3858                                                       "Inconsistent accessibility: field type `" +
3859                                                       MemberType.GetSignatureForError () + "' is less " +
3860                                                       "accessible than field `" + GetSignatureForError () + "'");
3861                                 }
3862                         }
3863                 }
3864
3865                 protected void IsTypePermitted ()
3866                 {
3867                         if (MemberType.IsSpecialRuntimeType) {
3868                                 if (Parent is StateMachine) {
3869                                         Report.Error (4012, Location,
3870                                                 "Parameters or local variables of type `{0}' cannot be declared in async methods or iterators",
3871                                                 MemberType.GetSignatureForError ());
3872                                 } else if (Parent is HoistedStoreyClass) {
3873                                         Report.Error (4013, Location,
3874                                                 "Local variables of type `{0}' cannot be used inside anonymous methods, lambda expressions or query expressions",
3875                                                 MemberType.GetSignatureForError ());
3876                                 } else {
3877                                         Report.Error (610, Location,
3878                                                 "Field or property cannot be of type `{0}'", MemberType.GetSignatureForError ());
3879                                 }
3880                         }
3881                 }
3882
3883                 protected virtual bool CheckBase ()
3884                 {
3885                         CheckProtectedModifier ();
3886
3887                         return true;
3888                 }
3889
3890                 public override string GetSignatureForDocumentation ()
3891                 {
3892                         return Parent.GetSignatureForDocumentation () + "." + MemberName.Basename;
3893                 }
3894
3895                 public virtual void PrepareEmit ()
3896                 {
3897                         if (member_type != null && type_expr != null)
3898                                 member_type.CheckObsoleteness (this, type_expr.Location);
3899                 }
3900
3901                 protected virtual bool ResolveMemberType ()
3902                 {
3903                         if (member_type != null)
3904                                 throw new InternalErrorException ("Multi-resolve");
3905
3906                         member_type = type_expr.ResolveAsType (this);
3907                         return member_type != null;
3908                 }
3909         }
3910 }
3911