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