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. Used
  96                 // by FULL_AST mode
  97                 //
  98                 public Attributes UnattachedAttributes {
  99                         get; set;
 100                 }
 101
 102                 public void AddCompilerGeneratedClass (CompilerGeneratedContainer c)
 103                 {
 104                         AddTypeContainerMember (c);
 105                 }
 106
 107                 public virtual void AddPartial (TypeDefinition next_part)
 108                 {
 109                         MemberCore mc;
 110                         (PartialContainer ?? this).defined_names.TryGetValue (next_part.MemberName.Basename, out mc);
 111
 112                         AddPartial (next_part, mc as TypeDefinition);
 113                 }
 114
 115                 protected void AddPartial (TypeDefinition next_part, TypeDefinition existing)
 116                 {
 117                         next_part.ModFlags |= Modifiers.PARTIAL;
 118
 119                         if (existing == null) {
 120                                 AddTypeContainer (next_part);
 121                                 return;
 122                         }
 123
 124                         if ((existing.ModFlags & Modifiers.PARTIAL) == 0) {
 125                                 if (existing.Kind != next_part.Kind) {
 126                                         AddTypeContainer (next_part);
 127                                 } else {
 128                                         Report.SymbolRelatedToPreviousError (next_part);
 129                                         Error_MissingPartialModifier (existing);
 130                                 }
 131
 132                                 return;
 133                         }
 134
 135                         if (existing.Kind != next_part.Kind) {
 136                                 Report.SymbolRelatedToPreviousError (existing);
 137                                 Report.Error (261, next_part.Location,
 138                                         "Partial declarations of `{0}' must be all classes, all structs or all interfaces",
 139                                         next_part.GetSignatureForError ());
 140                         }
 141
 142                         if ((existing.ModFlags & Modifiers.AccessibilityMask) != (next_part.ModFlags & Modifiers.AccessibilityMask) &&
 143                                 ((existing.ModFlags & Modifiers.DEFAULT_ACCESS_MODIFIER) == 0 &&
 144                                  (next_part.ModFlags & Modifiers.DEFAULT_ACCESS_MODIFIER) == 0)) {
 145                                          Report.SymbolRelatedToPreviousError (existing);
 146                                 Report.Error (262, next_part.Location,
 147                                         "Partial declarations of `{0}' have conflicting accessibility modifiers",
 148                                         next_part.GetSignatureForError ());
 149                         }
 150
 151                         var tc_names = existing.CurrentTypeParameters;
 152                         if (tc_names != null) {
 153                                 for (int i = 0; i < tc_names.Count; ++i) {
 154                                         var tp = next_part.MemberName.TypeParameters[i];
 155                                         if (tc_names[i].MemberName.Name != tp.MemberName.Name) {
 156                                                 Report.SymbolRelatedToPreviousError (existing.Location, "");
 157                                                 Report.Error (264, next_part.Location, "Partial declarations of `{0}' must have the same type parameter names in the same order",
 158                                                         next_part.GetSignatureForError ());
 159                                                 break;
 160                                         }
 161
 162                                         if (tc_names[i].Variance != tp.Variance) {
 163                                                 Report.SymbolRelatedToPreviousError (existing.Location, "");
 164                                                 Report.Error (1067, next_part.Location, "Partial declarations of `{0}' must have the same type parameter variance modifiers",
 165                                                         next_part.GetSignatureForError ());
 166                                                 break;
 167                                         }
 168                                 }
 169                         }
 170
 171                         if ((next_part.ModFlags & Modifiers.DEFAULT_ACCESS_MODIFIER) != 0) {
 172                                 existing.ModFlags |= next_part.ModFlags & ~(Modifiers.DEFAULT_ACCESS_MODIFIER | Modifiers.AccessibilityMask);
 173                         } else if ((existing.ModFlags & Modifiers.DEFAULT_ACCESS_MODIFIER) != 0) {
 174                                 existing.ModFlags &= ~(Modifiers.DEFAULT_ACCESS_MODIFIER | Modifiers.AccessibilityMask);
 175                                 existing.ModFlags |= next_part.ModFlags;
 176                         } else {
 177                                 existing.ModFlags |= next_part.ModFlags;
 178                         }
 179
 180                         existing.Definition.Modifiers = existing.ModFlags;
 181
 182                         if (next_part.attributes != null) {
 183                                 if (existing.attributes == null)
 184                                         existing.attributes = next_part.attributes;
 185                                 else
 186                                         existing.attributes.AddAttributes (next_part.attributes.Attrs);
 187                         }
 188
 189                         next_part.PartialContainer = existing;
 190
 191                         existing.AddPartialPart (next_part);
 192
 193                         AddTypeContainerMember (next_part);
 194                 }
 195
 196                 public virtual void AddTypeContainer (TypeContainer tc)
 197                 {
 198                         AddTypeContainerMember (tc);
 199
 200                         var tparams = tc.MemberName.TypeParameters;
 201                         if (tparams != null && tc.PartialContainer != null) {
 202                                 var td = (TypeDefinition) tc;
 203                                 for (int i = 0; i < tparams.Count; ++i) {
 204                                         var tp = tparams[i];
 205                                         if (tp.MemberName == null)
 206                                                 continue;
 207
 208                                         td.AddNameToContainer (tp, tp.Name);
 209                                 }
 210                         }
 211                 }
 212
 213                 protected virtual void AddTypeContainerMember (TypeContainer tc)
 214                 {
 215                         containers.Add (tc);
 216                 }
 217
 218                 public virtual void CloseContainer ()
 219                 {
 220                         if (containers != null) {
 221                                 foreach (TypeContainer tc in containers) {
 222                                         tc.CloseContainer ();
 223                                 }
 224                         }
 225                 }
 226
 227                 public virtual void CreateMetadataName (StringBuilder sb)
 228                 {
 229                         if (Parent != null && Parent.MemberName != null)
 230                                 Parent.CreateMetadataName (sb);
 231
 232                         MemberName.CreateMetadataName (sb);
 233                 }
 234
 235                 public virtual bool CreateContainer ()
 236                 {
 237                         if (containers != null) {
 238                                 foreach (TypeContainer tc in containers) {
 239                                         tc.CreateContainer ();
 240                                 }
 241                         }
 242
 243                         return true;
 244                 }
 245
 246                 public override bool Define ()
 247                 {
 248                         if (containers != null) {
 249                                 foreach (TypeContainer tc in containers) {
 250                                         tc.Define ();
 251                                 }
 252                         }
 253
 254                         // Release cache used by parser only
 255                         if (Module.Evaluator == null) {
 256                                 defined_names = null;
 257                         } else {
 258                                 defined_names.Clear ();
 259                         }
 260
 261                         return true;
 262                 }
 263
 264                 public virtual void PrepareEmit ()
 265                 {
 266                         if (containers != null) {
 267                                 foreach (var t in containers) {
 268                                         try {
 269                                                 t.PrepareEmit ();
 270                                         } catch (Exception e) {
 271                                                 if (MemberName == MemberName.Null)
 272                                                         throw;
 273
 274                                                 throw new InternalErrorException (t, e);
 275                                         }
 276                                 }
 277                         }
 278                 }
 279
 280                 public virtual bool DefineContainer ()
 281                 {
 282                         if (is_defined)
 283                                 return true;
 284
 285                         is_defined = true;
 286
 287                         DoDefineContainer ();
 288
 289                         if (containers != null) {
 290                                 foreach (TypeContainer tc in containers) {
 291                                         try {
 292                                                 tc.DefineContainer ();
 293                                         } catch (Exception e) {
 294                                                 if (MemberName == MemberName.Null)
 295                                                         throw;
 296
 297                                                 throw new InternalErrorException (tc, e);
 298                                         }
 299                                 }
 300                         }
 301
 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                 bool error;
 534                 bool members_defined;
 535                 bool members_defined_ok;
 536                 protected bool has_static_constructor;
 537
 538                 private CachedMethods cached_method;
 539
 540                 protected TypeSpec spec;
 541                 TypeSpec current_type;
 542
 543                 public int DynamicSitesCounter;
 544                 public int AnonymousMethodsCounter;
 545                 public int MethodGroupsCounter;
 546
 547                 static readonly string[] attribute_targets = new [] { "type" };
 548                 static readonly string[] attribute_targets_primary = new [] { "type", "method" };
 549
 550                 /// <remarks>
 551                 ///  The pending methods that need to be implemented
 552                 //   (interfaces or abstract methods)
 553                 /// </remarks>
 554                 PendingImplementation pending;
 555
 556                 protected TypeDefinition (TypeContainer parent, MemberName name, Attributes attrs, MemberKind kind)
 557                         : base (parent, name, attrs, kind)
 558                 {
 559                         PartialContainer = this;
 560                         members = new List<MemberCore> ();
 561                 }
 562
 563                 #region Properties
 564
 565                 public List<FullNamedExpression> BaseTypeExpressions {
 566                         get {
 567                                 return type_bases;
 568                         }
 569                 }
 570
 571                 public override TypeSpec CurrentType {
 572                         get {
 573                                 if (current_type == null) {
 574                                         if (IsGenericOrParentIsGeneric) {
 575                                                 //
 576                                                 // Switch to inflated version as it's used by all expressions
 577                                                 //
 578                                                 var targs = CurrentTypeParameters == null ? TypeSpec.EmptyTypes : CurrentTypeParameters.Types;
 579                                                 current_type = spec.MakeGenericType (this, targs);
 580                                         } else {
 581                                                 current_type = spec;
 582                                         }
 583                                 }
 584
 585                                 return current_type;
 586                         }
 587                 }
 588
 589                 public override TypeParameters CurrentTypeParameters {
 590                         get {
 591                                 return PartialContainer.MemberName.TypeParameters;
 592                         }
 593                 }
 594
 595                 int CurrentTypeParametersStartIndex {
 596                         get {
 597                                 int total = all_tp_builders.Length;
 598                                 if (CurrentTypeParameters != null) {
 599                                         return total - CurrentTypeParameters.Count;
 600                                 }
 601                                 return total;
 602                         }
 603                 }
 604
 605                 public virtual AssemblyDefinition DeclaringAssembly {
 606                         get {
 607                                 return Module.DeclaringAssembly;
 608                         }
 609                 }
 610
 611                 IAssemblyDefinition ITypeDefinition.DeclaringAssembly {
 612                         get {
 613                                 return Module.DeclaringAssembly;
 614                         }
 615                 }
 616
 617                 public TypeSpec Definition {
 618                         get {
 619                                 return spec;
 620                         }
 621                 }
 622
 623                 public bool HasMembersDefined {
 624                         get {
 625                                 return members_defined;
 626                         }
 627                 }
 628
 629                 public bool HasInstanceConstructor {
 630                         get {
 631                                 return (caching_flags & Flags.HasInstanceConstructor) != 0;
 632                         }
 633                         set {
 634                                 caching_flags |= Flags.HasInstanceConstructor;
 635                         }
 636                 }
 637
 638                 // Indicated whether container has StructLayout attribute set Explicit
 639                 public bool HasExplicitLayout {
 640                         get { return (caching_flags & Flags.HasExplicitLayout) != 0; }
 641                         set { caching_flags |= Flags.HasExplicitLayout; }
 642                 }
 643
 644                 public bool HasOperators {
 645                         get {
 646                                 return (caching_flags & Flags.HasUserOperators) != 0;
 647                         }
 648                         set {
 649                                 caching_flags |= Flags.HasUserOperators;
 650                         }
 651                 }
 652
 653                 public bool HasStructLayout {
 654                         get { return (caching_flags & Flags.HasStructLayout) != 0; }
 655                         set { caching_flags |= Flags.HasStructLayout; }
 656                 }
 657
 658                 public TypeSpec[] Interfaces {
 659                         get {
 660                                 return iface_exprs;
 661                         }
 662                 }
 663
 664                 public bool IsGenericOrParentIsGeneric {
 665                         get {
 666                                 return all_type_parameters != null;
 667                         }
 668                 }
 669
 670                 public bool IsTopLevel {
 671                         get {
 672                                 return !(Parent is TypeDefinition);
 673                         }
 674                 }
 675
 676                 public bool IsPartial {
 677                         get {
 678                                 return (ModFlags & Modifiers.PARTIAL) != 0;
 679                         }
 680                 }
 681
 682                 bool ITypeDefinition.IsTypeForwarder {
 683                         get {
 684                                 return false;
 685                         }
 686                 }
 687
 688                 bool ITypeDefinition.IsCyclicTypeForwarder {
 689                         get {
 690                                 return false;
 691                         }
 692                 }
 693
 694                 //
 695                 // Returns true for secondary partial containers
 696                 //
 697                 bool IsPartialPart {
 698                         get {
 699                                 return PartialContainer != this;
 700                         }
 701                 }
 702
 703                 public MemberCache MemberCache {
 704                         get {
 705                                 return spec.MemberCache;
 706                         }
 707                 }
 708
 709                 public List<MemberCore> Members {
 710                         get {
 711                                 return members;
 712                         }
 713                 }
 714
 715                 string ITypeDefinition.Namespace {
 716                         get {
 717                                 var p = Parent;
 718                                 while (p.Kind != MemberKind.Namespace)
 719                                         p = p.Parent;
 720
 721                                 return p.MemberName == null ? null : p.GetSignatureForError ();
 722                         }
 723                 }
 724
 725                 public ParametersCompiled PrimaryConstructorParameters { get; set; }
 726
 727                 public Arguments PrimaryConstructorBaseArguments { get; set; }
 728
 729                 public Location PrimaryConstructorBaseArgumentsStart { get; set; }
 730
 731                 public TypeParameters TypeParametersAll {
 732                         get {
 733                                 return all_type_parameters;
 734                         }
 735                 }
 736
 737                 public override string[] ValidAttributeTargets {
 738                         get {
 739                                 return PrimaryConstructorParameters != null ? attribute_targets_primary : attribute_targets;
 740                         }
 741                 }
 742
 743                 #endregion
 744
 745                 public override void Accept (StructuralVisitor visitor)
 746                 {
 747                         visitor.Visit (this);
 748                 }
 749
 750                 public void AddMember (MemberCore symbol)
 751                 {
 752                         if (symbol.MemberName.ExplicitInterface != null) {
 753                                 if (!(Kind == MemberKind.Class || Kind == MemberKind.Struct)) {
 754                                         Report.Error (541, symbol.Location,
 755                                                 "`{0}': explicit interface declaration can only be declared in a class or struct",
 756                                                 symbol.GetSignatureForError ());
 757                                 }
 758                         }
 759
 760                         AddNameToContainer (symbol, symbol.MemberName.Name);
 761                         members.Add (symbol);
 762                 }
 763
 764                 public override void AddTypeContainer (TypeContainer tc)
 765                 {
 766                         AddNameToContainer (tc, tc.MemberName.Basename);
 767
 768                         base.AddTypeContainer (tc);
 769                 }
 770
 771                 protected override void AddTypeContainerMember (TypeContainer tc)
 772                 {
 773                         members.Add (tc);
 774
 775                         if (containers == null)
 776                                 containers = new List<TypeContainer> ();
 777
 778                         base.AddTypeContainerMember (tc);
 779                 }
 780
 781                 //
 782                 // Adds the member to defined_names table. It tests for duplications and enclosing name conflicts
 783                 //
 784                 public virtual void AddNameToContainer (MemberCore symbol, string name)
 785                 {
 786                         if (((ModFlags | symbol.ModFlags) & Modifiers.COMPILER_GENERATED) != 0)
 787                                 return;
 788
 789                         MemberCore mc;
 790                         if (!PartialContainer.defined_names.TryGetValue (name, out mc)) {
 791                                 PartialContainer.defined_names.Add (name, symbol);
 792                                 return;
 793                         }
 794
 795                         if (symbol.EnableOverloadChecks (mc))
 796                                 return;
 797
 798                         InterfaceMemberBase im = mc as InterfaceMemberBase;
 799                         if (im != null && im.IsExplicitImpl)
 800                                 return;
 801
 802                         Report.SymbolRelatedToPreviousError (mc);
 803                         if ((mc.ModFlags & Modifiers.PARTIAL) != 0 && (symbol is ClassOrStruct || symbol is Interface)) {
 804                                 Error_MissingPartialModifier (symbol);
 805                                 return;
 806                         }
 807
 808                         if (symbol is TypeParameter) {
 809                                 Report.Error (692, symbol.Location,
 810                                         "Duplicate type parameter `{0}'", symbol.GetSignatureForError ());
 811                         } else {
 812                                 Report.Error (102, symbol.Location,
 813                                         "The type `{0}' already contains a definition for `{1}'",
 814                                         GetSignatureForError (), name);
 815                         }
 816
 817                         return;
 818                 }
 819
 820                 public void AddConstructor (Constructor c)
 821                 {
 822                         AddConstructor (c, false);
 823                 }
 824
 825                 public void AddConstructor (Constructor c, bool isDefault)
 826                 {
 827                         bool is_static = (c.ModFlags & Modifiers.STATIC) != 0;
 828                         if (!isDefault)
 829                                 AddNameToContainer (c, is_static ? Constructor.TypeConstructorName : Constructor.ConstructorName);
 830
 831                         if (is_static && c.ParameterInfo.IsEmpty) {
 832                                 PartialContainer.has_static_constructor = true;
 833                         } else {
 834                                 PartialContainer.HasInstanceConstructor = true;
 835                         }
 836
 837                         members.Add (c);
 838                 }
 839
 840                 public bool AddField (FieldBase field)
 841                 {
 842                         AddMember (field);
 843
 844                         if ((field.ModFlags & Modifiers.STATIC) != 0)
 845                                 return true;
 846
 847                         var first_field = PartialContainer.first_nonstatic_field;
 848                         if (first_field == null) {
 849                                 PartialContainer.first_nonstatic_field = field;
 850                                 return true;
 851                         }
 852
 853                         if (Kind == MemberKind.Struct && first_field.Parent != field.Parent) {
 854                                 Report.SymbolRelatedToPreviousError (first_field.Parent);
 855                                 Report.Warning (282, 3, field.Location,
 856                                         "struct instance field `{0}' found in different declaration from instance field `{1}'",
 857                                         field.GetSignatureForError (), first_field.GetSignatureForError ());
 858                         }
 859                         return true;
 860                 }
 861
 862                 /// <summary>
 863                 /// Indexer has special handling in constrast to other AddXXX because the name can be driven by IndexerNameAttribute
 864                 /// </summary>
 865                 public void AddIndexer (Indexer i)
 866                 {
 867                         members.Add (i);
 868                 }
 869
 870                 public void AddOperator (Operator op)
 871                 {
 872                         PartialContainer.HasOperators = true;
 873                         AddMember (op);
 874                 }
 875
 876                 public void AddPartialPart (TypeDefinition part)
 877                 {
 878                         if (Kind != MemberKind.Class)
 879                                 return;
 880
 881                         if (class_partial_parts == null)
 882                                 class_partial_parts = new List<TypeDefinition> ();
 883
 884                         class_partial_parts.Add (part);
 885                 }
 886
 887                 public override void ApplyAttributeBuilder (Attribute a, MethodSpec ctor, byte[] cdata, PredefinedAttributes pa)
 888                 {
 889                         if (a.Target == AttributeTargets.Method) {
 890                                 foreach (var m in members) {
 891                                         var c = m as Constructor;
 892                                         if (c == null)
 893                                                 continue;
 894
 895                                         if (c.IsPrimaryConstructor) {
 896                                                 c.ApplyAttributeBuilder (a, ctor, cdata, pa);
 897                                                 return;
 898                                         }
 899                                 }
 900
 901                                 throw new InternalErrorException ();
 902                         }
 903
 904                         if (has_normal_indexers && a.Type == pa.DefaultMember) {
 905                                 Report.Error (646, a.Location, "Cannot specify the `DefaultMember' attribute on type containing an indexer");
 906                                 return;
 907                         }
 908
 909                         if (a.Type == pa.Required) {
 910                                 Report.Error (1608, a.Location, "The RequiredAttribute attribute is not permitted on C# types");
 911                                 return;
 912                         }
 913
 914                         TypeBuilder.SetCustomAttribute ((ConstructorInfo) ctor.GetMetaInfo (), cdata);
 915                 }
 916
 917                 public override AttributeTargets AttributeTargets {
 918                         get {
 919                                 throw new NotSupportedException ();
 920                         }
 921                 }
 922
 923                 public TypeSpec BaseType {
 924                         get {
 925                                 return spec.BaseType;
 926                         }
 927                 }
 928
 929                 protected virtual TypeAttributes TypeAttr {
 930                         get {
 931                                 return ModifiersExtensions.TypeAttr (ModFlags, IsTopLevel);
 932                         }
 933                 }
 934
 935                 public int TypeParametersCount {
 936                         get {
 937                                 return MemberName.Arity;
 938                         }
 939                 }
 940
 941                 TypeParameterSpec[] ITypeDefinition.TypeParameters {
 942                         get {
 943                                 var ctp = PartialContainer.CurrentTypeParameters;
 944                                 return ctp == null ? TypeParameterSpec.EmptyTypes : ctp.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 && this is Interface) {
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                         ComputeIndexerName();
2003
2004                         if (HasEquals && !HasGetHashCode) {
2005                                 Report.Warning (659, 3, Location,
2006                                         "`{0}' overrides Object.Equals(object) but does not override Object.GetHashCode()", GetSignatureForError ());
2007                         }
2008
2009                         if (Kind == MemberKind.Interface && iface_exprs != null) {
2010                                 MemberCache.RemoveHiddenMembers (spec);
2011                         }
2012
2013                         return true;
2014                 }
2015
2016                 void ComputeIndexerName ()
2017                 {
2018                         var indexers = MemberCache.FindMembers (spec, MemberCache.IndexerNameAlias, true);
2019                         if (indexers == null)
2020                                 return;
2021
2022                         string class_indexer_name = null;
2023
2024                         //
2025                         // Check normal indexers for consistent name, explicit interface implementation
2026                         // indexers are ignored
2027                         //
2028                         foreach (var indexer in indexers) {
2029                                 //
2030                                 // FindMembers can return unfiltered full hierarchy names
2031                                 //
2032                                 if (indexer.DeclaringType != spec)
2033                                         continue;
2034
2035                                 has_normal_indexers = true;
2036
2037                                 if (class_indexer_name == null) {
2038                                         indexer_name = class_indexer_name = indexer.Name;
2039                                         continue;
2040                                 }
2041
2042                                 if (indexer.Name != class_indexer_name)
2043                                         Report.Error (668, ((Indexer)indexer.MemberDefinition).Location,
2044                                                 "Two indexers have different names; the IndexerName attribute must be used with the same name on every indexer within a type");
2045                         }
2046                 }
2047
2048                 void EmitIndexerName ()
2049                 {
2050                         if (!has_normal_indexers)
2051                                 return;
2052
2053                         var ctor = Module.PredefinedMembers.DefaultMemberAttributeCtor.Get ();
2054                         if (ctor == null)
2055                                 return;
2056
2057                         var encoder = new AttributeEncoder ();
2058                         encoder.Encode (GetAttributeDefaultMember ());
2059                         encoder.EncodeEmptyNamedArguments ();
2060
2061                         TypeBuilder.SetCustomAttribute ((ConstructorInfo) ctor.GetMetaInfo (), encoder.ToArray ());
2062                 }
2063
2064                 public override void VerifyMembers ()
2065                 {
2066                         //
2067                         // Check for internal or private fields that were never assigned
2068                         //
2069                         if (!IsCompilerGenerated && Compiler.Settings.WarningLevel >= 3 && this == PartialContainer) {
2070                                 bool is_type_exposed = Kind == MemberKind.Struct || IsExposedFromAssembly ();
2071                                 foreach (var member in members) {
2072                                         if (member is Event) {
2073                                                 //
2074                                                 // An event can be assigned from same class only, report
2075                                                 // this warning for all accessibility modes
2076                                                 //
2077                                                 if (!member.IsUsed && !PartialContainer.HasStructLayout)
2078                                                         Report.Warning (67, 3, member.Location, "The event `{0}' is never used", member.GetSignatureForError ());
2079
2080                                                 continue;
2081                                         }
2082
2083                                         if ((member.ModFlags & Modifiers.AccessibilityMask) != Modifiers.PRIVATE) {
2084                                                 if (is_type_exposed)
2085                                                         continue;
2086
2087                                                 member.SetIsUsed ();
2088                                         }
2089
2090                                         var f = member as Field;
2091                                         if (f == null)
2092                                                 continue;
2093
2094                                         if (!member.IsUsed) {
2095                                                 if (!PartialContainer.HasStructLayout) {
2096                                                         if ((member.caching_flags & Flags.IsAssigned) == 0) {
2097                                                                 Report.Warning (169, 3, member.Location, "The private field `{0}' is never used", member.GetSignatureForError ());
2098                                                         } else {
2099                                                                 Report.Warning (414, 3, member.Location, "The private field `{0}' is assigned but its value is never used",
2100                                                                         member.GetSignatureForError ());
2101                                                         }
2102                                                 }
2103
2104                                                 continue;
2105                                         }
2106
2107                                         if ((f.caching_flags & Flags.IsAssigned) != 0)
2108                                                 continue;
2109
2110                                         //
2111                                         // Only report 649 on level 4
2112                                         //
2113                                         if (Compiler.Settings.WarningLevel < 4)
2114                                                 continue;
2115
2116                                         //
2117                                         // Don't be pedantic when type requires specific layout
2118                                         //
2119                                         if (f.OptAttributes != null || PartialContainer.HasStructLayout)
2120                                                 continue;
2121
2122                                         Constant c = New.Constantify (f.MemberType, f.Location);
2123                                         string value;
2124                                         if (c != null) {
2125                                                 value = c.GetValueAsLiteral ();
2126                                         } else if (TypeSpec.IsReferenceType (f.MemberType)) {
2127                                                 value = "null";
2128                                         } else {
2129                                                 value = null;
2130                                         }
2131
2132                                         if (value != null)
2133                                                 value = " `" + value + "'";
2134
2135                                         Report.Warning (649, 4, f.Location, "Field `{0}' is never assigned to, and will always have its default value{1}",
2136                                                 f.GetSignatureForError (), value);
2137                                 }
2138                         }
2139
2140                         base.VerifyMembers ();
2141                 }
2142
2143                 public override void Emit ()
2144                 {
2145                         if (OptAttributes != null)
2146                                 OptAttributes.Emit ();
2147
2148                         if (!IsCompilerGenerated) {
2149                                 if (!IsTopLevel) {
2150                                         MemberSpec candidate;
2151                                         bool overrides = false;
2152                                         var conflict_symbol = MemberCache.FindBaseMember (this, out candidate, ref overrides);
2153                                         if (conflict_symbol == null && candidate == null) {
2154                                                 if ((ModFlags & Modifiers.NEW) != 0)
2155                                                         Report.Warning (109, 4, Location, "The member `{0}' does not hide an inherited member. The new keyword is not required",
2156                                                                 GetSignatureForError ());
2157                                         } else {
2158                                                 if ((ModFlags & Modifiers.NEW) == 0) {
2159                                                         if (candidate == null)
2160                                                                 candidate = conflict_symbol;
2161
2162                                                         Report.SymbolRelatedToPreviousError (candidate);
2163                                                         Report.Warning (108, 2, Location, "`{0}' hides inherited member `{1}'. Use the new keyword if hiding was intended",
2164                                                                 GetSignatureForError (), candidate.GetSignatureForError ());
2165                                                 }
2166                                         }
2167                                 }
2168
2169                                 // Run constraints check on all possible generic types
2170                                 if (base_type != null && base_type_expr != null) {
2171                                         ConstraintChecker.Check (this, base_type, base_type_expr.Location);
2172                                 }
2173
2174                                 if (iface_exprs != null) {
2175                                         foreach (var iface_type in iface_exprs) {
2176                                                 if (iface_type == null)
2177                                                         continue;
2178
2179                                                 ConstraintChecker.Check (this, iface_type, Location);   // TODO: Location is wrong
2180                                         }
2181                                 }
2182                         }
2183
2184                         if (all_tp_builders != null) {
2185                                 int current_starts_index = CurrentTypeParametersStartIndex;
2186                                 for (int i = 0; i < all_tp_builders.Length; i++) {
2187                                         if (i < current_starts_index) {
2188                                                 all_type_parameters[i].EmitConstraints (all_tp_builders [i]);
2189                                         } else {
2190                                                 var tp = CurrentTypeParameters [i - current_starts_index];
2191                                                 tp.CheckGenericConstraints (!IsObsolete);
2192                                                 tp.Emit ();
2193                                         }
2194                                 }
2195                         }
2196
2197                         if ((ModFlags & Modifiers.COMPILER_GENERATED) != 0 && !Parent.IsCompilerGenerated)
2198                                 Module.PredefinedAttributes.CompilerGenerated.EmitAttribute (TypeBuilder);
2199
2200 #if STATIC
2201                         if ((TypeBuilder.Attributes & TypeAttributes.StringFormatMask) == 0 && Module.HasDefaultCharSet)
2202                                 TypeBuilder.__SetAttributes (TypeBuilder.Attributes | Module.DefaultCharSetType);
2203 #endif
2204
2205                         base.Emit ();
2206
2207                         for (int i = 0; i < members.Count; i++) {
2208                                 var m = members[i];
2209                                 if ((m.caching_flags & Flags.CloseTypeCreated) != 0)
2210                                         continue;
2211
2212                                 m.Emit ();
2213                         }
2214
2215                         EmitIndexerName ();
2216                         CheckAttributeClsCompliance ();
2217
2218                         if (pending != null)
2219                                 pending.VerifyPendingMethods ();
2220                 }
2221
2222
2223                 void CheckAttributeClsCompliance ()
2224                 {
2225                         if (!spec.IsAttribute || !IsExposedFromAssembly () || !Compiler.Settings.VerifyClsCompliance || !IsClsComplianceRequired ())
2226                                 return;
2227
2228                         foreach (var m in members) {
2229                                 var c = m as Constructor;
2230                                 if (c == null)
2231                                         continue;
2232
2233                                 if (c.HasCompliantArgs)
2234                                         return;
2235                         }
2236
2237                         Report.Warning (3015, 1, Location, "`{0}' has no accessible constructors which use only CLS-compliant types", GetSignatureForError ());
2238                 }
2239
2240                 public sealed override void EmitContainer ()
2241                 {
2242                         if ((caching_flags & Flags.CloseTypeCreated) != 0)
2243                                 return;
2244
2245                         Emit ();
2246                 }
2247
2248                 public override void CloseContainer ()
2249                 {
2250                         if ((caching_flags & Flags.CloseTypeCreated) != 0)
2251                                 return;
2252
2253                         // Close base type container first to avoid TypeLoadException
2254                         if (spec.BaseType != null) {
2255                                 var btype = spec.BaseType.MemberDefinition as TypeContainer;
2256                                 if (btype != null) {
2257                                         btype.CloseContainer ();
2258
2259                                         if ((caching_flags & Flags.CloseTypeCreated) != 0)
2260                                                 return;
2261                                 }
2262                         }
2263
2264                         try {
2265                                 caching_flags |= Flags.CloseTypeCreated;
2266                                 TypeBuilder.CreateType ();
2267                         } catch (TypeLoadException) {
2268                                 //
2269                                 // This is fine, the code still created the type
2270                                 //
2271                         } catch (Exception e) {
2272                                 throw new InternalErrorException (this, e);
2273                         }
2274
2275                         base.CloseContainer ();
2276
2277                         containers = null;
2278                         initialized_fields = null;
2279                         initialized_static_fields = null;
2280                         type_bases = null;
2281                         OptAttributes = null;
2282                 }
2283
2284                 //
2285                 // Performs the validation on a Method's modifiers (properties have
2286                 // the same properties).
2287                 //
2288                 // TODO: Why is it not done at parse stage, move to Modifiers::Check
2289                 //
2290                 public bool MethodModifiersValid (MemberCore mc)
2291                 {
2292                         const Modifiers vao = (Modifiers.VIRTUAL | Modifiers.ABSTRACT | Modifiers.OVERRIDE);
2293                         const Modifiers nv = (Modifiers.NEW | Modifiers.VIRTUAL);
2294                         bool ok = true;
2295                         var flags = mc.ModFlags;
2296
2297                         //
2298                         // At most one of static, virtual or override
2299                         //
2300                         if ((flags & Modifiers.STATIC) != 0){
2301                                 if ((flags & vao) != 0){
2302                                         Report.Error (112, mc.Location, "A static member `{0}' cannot be marked as override, virtual or abstract",
2303                                                 mc.GetSignatureForError ());
2304                                         ok = false;
2305                                 }
2306                         }
2307
2308                         if ((flags & Modifiers.OVERRIDE) != 0 && (flags & nv) != 0){
2309                                 Report.Error (113, mc.Location, "A member `{0}' marked as override cannot be marked as new or virtual",
2310                                         mc.GetSignatureForError ());
2311                                 ok = false;
2312                         }
2313
2314                         //
2315                         // If the declaration includes the abstract modifier, then the
2316                         // declaration does not include static, virtual or extern
2317                         //
2318                         if ((flags & Modifiers.ABSTRACT) != 0){
2319                                 if ((flags & Modifiers.EXTERN) != 0){
2320                                         Report.Error (
2321                                                 180, mc.Location, "`{0}' cannot be both extern and abstract", mc.GetSignatureForError ());
2322                                         ok = false;
2323                                 }
2324
2325                                 if ((flags & Modifiers.SEALED) != 0) {
2326                                         Report.Error (502, mc.Location, "`{0}' cannot be both abstract and sealed", mc.GetSignatureForError ());
2327                                         ok = false;
2328                                 }
2329
2330                                 if ((flags & Modifiers.VIRTUAL) != 0){
2331                                         Report.Error (503, mc.Location, "The abstract method `{0}' cannot be marked virtual", mc.GetSignatureForError ());
2332                                         ok = false;
2333                                 }
2334
2335                                 if ((ModFlags & Modifiers.ABSTRACT) == 0){
2336                                         Report.SymbolRelatedToPreviousError (this);
2337                                         Report.Error (513, mc.Location, "`{0}' is abstract but it is declared in the non-abstract class `{1}'",
2338                                                 mc.GetSignatureForError (), GetSignatureForError ());
2339                                         ok = false;
2340                                 }
2341                         }
2342
2343                         if ((flags & Modifiers.PRIVATE) != 0){
2344                                 if ((flags & vao) != 0){
2345                                         Report.Error (621, mc.Location, "`{0}': virtual or abstract members cannot be private", mc.GetSignatureForError ());
2346                                         ok = false;
2347                                 }
2348                         }
2349
2350                         if ((flags & Modifiers.SEALED) != 0){
2351                                 if ((flags & Modifiers.OVERRIDE) == 0){
2352                                         Report.Error (238, mc.Location, "`{0}' cannot be sealed because it is not an override", mc.GetSignatureForError ());
2353                                         ok = false;
2354                                 }
2355                         }
2356
2357                         return ok;
2358                 }
2359
2360                 protected override bool VerifyClsCompliance ()
2361                 {
2362                         if (!base.VerifyClsCompliance ())
2363                                 return false;
2364
2365                         // Check all container names for user classes
2366                         if (Kind != MemberKind.Delegate)
2367                                 MemberCache.VerifyClsCompliance (Definition, Report);
2368
2369                         if (BaseType != null && !BaseType.IsCLSCompliant ()) {
2370                                 Report.Warning (3009, 1, Location, "`{0}': base type `{1}' is not CLS-compliant",
2371                                         GetSignatureForError (), BaseType.GetSignatureForError ());
2372                         }
2373                         return true;
2374                 }
2375
2376                 /// <summary>
2377                 ///   Performs checks for an explicit interface implementation.  First it
2378                 ///   checks whether the `interface_type' is a base inteface implementation.
2379                 ///   Then it checks whether `name' exists in the interface type.
2380                 /// </summary>
2381                 public bool VerifyImplements (InterfaceMemberBase mb)
2382                 {
2383                         var ifaces = PartialContainer.Interfaces;
2384                         if (ifaces != null) {
2385                                 foreach (TypeSpec t in ifaces){
2386                                         if (t == mb.InterfaceType || t == null)
2387                                                 return true;
2388
2389                                         var expanded_base = t.Interfaces;
2390                                         if (expanded_base == null)
2391                                                 continue;
2392
2393                                         foreach (var bt in expanded_base) {
2394                                                 if (bt == mb.InterfaceType)
2395                                                         return true;
2396                                         }
2397                                 }
2398                         }
2399
2400                         Report.SymbolRelatedToPreviousError (mb.InterfaceType);
2401                         Report.Error (540, mb.Location, "`{0}': containing type does not implement interface `{1}'",
2402                                 mb.GetSignatureForError (), mb.InterfaceType.GetSignatureForError ());
2403                         return false;
2404                 }
2405
2406                 //
2407                 // Used for visiblity checks to tests whether this definition shares
2408                 // base type baseType, it does member-definition search
2409                 //
2410                 public bool IsBaseTypeDefinition (TypeSpec baseType)
2411                 {
2412                         // RootContext check
2413                         if (TypeBuilder == null)
2414                                 return false;
2415
2416                         var type = spec;
2417                         do {
2418                                 if (type.MemberDefinition == baseType.MemberDefinition)
2419                                         return true;
2420
2421                                 type = type.BaseType;
2422                         } while (type != null);
2423
2424                         return false;
2425                 }
2426
2427                 public override bool IsClsComplianceRequired ()
2428                 {
2429                         if (IsPartialPart)
2430                                 return PartialContainer.IsClsComplianceRequired ();
2431
2432                         return base.IsClsComplianceRequired ();
2433                 }
2434
2435                 bool ITypeDefinition.IsInternalAsPublic (IAssemblyDefinition assembly)
2436                 {
2437                         return Module.DeclaringAssembly == assembly;
2438                 }
2439
2440                 public virtual bool IsUnmanagedType ()
2441                 {
2442                         return false;
2443                 }
2444
2445                 public void LoadMembers (TypeSpec declaringType, bool onlyTypes, ref MemberCache cache)
2446                 {
2447                         throw new NotSupportedException ("Not supported for compiled definition " + GetSignatureForError ());
2448                 }
2449
2450                 //
2451                 // Public function used to locate types.
2452                 //
2453                 // Returns: Type or null if they type can not be found.
2454                 //
2455                 public override FullNamedExpression LookupNamespaceOrType (string name, int arity, LookupMode mode, Location loc)
2456                 {
2457                         FullNamedExpression e;
2458                         if (arity == 0 && Cache.TryGetValue (name, out e) && mode != LookupMode.IgnoreAccessibility)
2459                                 return e;
2460
2461                         e = null;
2462
2463                         if (arity == 0) {
2464                                 var tp = CurrentTypeParameters;
2465                                 if (tp != null) {
2466                                         TypeParameter tparam = tp.Find (name);
2467                                         if (tparam != null)
2468                                                 e = new TypeParameterExpr (tparam, Location.Null);
2469                                 }
2470                         }
2471
2472                         if (e == null) {
2473                                 TypeSpec t = LookupNestedTypeInHierarchy (name, arity);
2474
2475                                 if (t != null && (t.IsAccessible (this) || mode == LookupMode.IgnoreAccessibility))
2476                                         e = new TypeExpression (t, Location.Null);
2477                                 else {
2478                                         var errors = Compiler.Report.Errors;
2479                                         e = Parent.LookupNamespaceOrType (name, arity, mode, loc);
2480
2481                                         // TODO: LookupNamespaceOrType does more than just lookup. The result
2482                                         // cannot be cached or the error reporting won't happen
2483                                         if (errors != Compiler.Report.Errors)
2484                                                 return e;
2485                                 }
2486                         }
2487
2488                         // TODO MemberCache: How to cache arity stuff ?
2489                         if (arity == 0 && mode == LookupMode.Normal)
2490                                 Cache[name] = e;
2491
2492                         return e;
2493                 }
2494
2495                 TypeSpec LookupNestedTypeInHierarchy (string name, int arity)
2496                 {
2497                         // Has any nested type
2498                         // Does not work, because base type can have
2499                         //if (PartialContainer.Types == null)
2500                         //      return null;
2501
2502                         var container = PartialContainer.CurrentType;
2503                         return MemberCache.FindNestedType (container, name, arity);
2504                 }
2505
2506                 public void Mark_HasEquals ()
2507                 {
2508                         cached_method |= CachedMethods.Equals;
2509                 }
2510
2511                 public void Mark_HasGetHashCode ()
2512                 {
2513                         cached_method |= CachedMethods.GetHashCode;
2514                 }
2515
2516                 public override void WriteDebugSymbol (MonoSymbolFile file)
2517                 {
2518                         if (IsPartialPart)
2519                                 return;
2520
2521                         foreach (var m in members) {
2522                                 m.WriteDebugSymbol (file);
2523                         }
2524                 }
2525
2526                 /// <summary>
2527                 /// Method container contains Equals method
2528                 /// </summary>
2529                 public bool HasEquals {
2530                         get {
2531                                 return (cached_method & CachedMethods.Equals) != 0;
2532                         }
2533                 }
2534
2535                 /// <summary>
2536                 /// Method container contains GetHashCode method
2537                 /// </summary>
2538                 public bool HasGetHashCode {
2539                         get {
2540                                 return (cached_method & CachedMethods.GetHashCode) != 0;
2541                         }
2542                 }
2543
2544                 public bool HasStaticFieldInitializer {
2545                         get {
2546                                 return (cached_method & CachedMethods.HasStaticFieldInitializer) != 0;
2547                         }
2548                         set {
2549                                 if (value)
2550                                         cached_method |= CachedMethods.HasStaticFieldInitializer;
2551                                 else
2552                                         cached_method &= ~CachedMethods.HasStaticFieldInitializer;
2553                         }
2554                 }
2555
2556                 public override string DocCommentHeader {
2557                         get { return "T:"; }
2558                 }
2559         }
2560
2561         public abstract class ClassOrStruct : TypeDefinition
2562         {
2563                 public const TypeAttributes StaticClassAttribute = TypeAttributes.Abstract | TypeAttributes.Sealed;
2564
2565                 SecurityType declarative_security;
2566                 protected Constructor generated_primary_constructor;
2567
2568                 protected ClassOrStruct (TypeContainer parent, MemberName name, Attributes attrs, MemberKind kind)
2569                         : base (parent, name, attrs, kind)
2570                 {
2571                 }
2572
2573                 public ToplevelBlock PrimaryConstructorBlock { get; set; }
2574
2575                 protected override TypeAttributes TypeAttr {
2576                         get {
2577                                 TypeAttributes ta = base.TypeAttr;
2578                                 if (!has_static_constructor)
2579                                         ta |= TypeAttributes.BeforeFieldInit;
2580
2581                                 if (Kind == MemberKind.Class) {
2582                                         ta |= TypeAttributes.AutoLayout | TypeAttributes.Class;
2583                                         if (IsStatic)
2584                                                 ta |= StaticClassAttribute;
2585                                 } else {
2586                                         ta |= TypeAttributes.SequentialLayout;
2587                                 }
2588
2589                                 return ta;
2590                         }
2591                 }
2592
2593                 public override void AddNameToContainer (MemberCore symbol, string name)
2594                 {
2595                         if (!(symbol is Constructor) && symbol.MemberName.Name == MemberName.Name) {
2596                                 if (symbol is TypeParameter) {
2597                                         Report.Error (694, symbol.Location,
2598                                                 "Type parameter `{0}' has same name as containing type, or method",
2599                                                 symbol.GetSignatureForError ());
2600                                         return;
2601                                 }
2602
2603                                 InterfaceMemberBase imb = symbol as InterfaceMemberBase;
2604                                 if (imb == null || !imb.IsExplicitImpl) {
2605                                         Report.SymbolRelatedToPreviousError (this);
2606                                         Report.Error (542, symbol.Location, "`{0}': member names cannot be the same as their enclosing type",
2607                                                 symbol.GetSignatureForError ());
2608                                         return;
2609                                 }
2610                         }
2611
2612                         base.AddNameToContainer (symbol, name);
2613                 }
2614
2615                 public override void ApplyAttributeBuilder (Attribute a, MethodSpec ctor, byte[] cdata, PredefinedAttributes pa)
2616                 {
2617                         if (a.IsValidSecurityAttribute ()) {
2618                                 a.ExtractSecurityPermissionSet (ctor, ref declarative_security);
2619                                 return;
2620                         }
2621
2622                         if (a.Type == pa.StructLayout) {
2623                                 PartialContainer.HasStructLayout = true;
2624                                 if (a.IsExplicitLayoutKind ())
2625                                         PartialContainer.HasExplicitLayout = true;
2626                         }
2627
2628                         if (a.Type == pa.Dynamic) {
2629                                 a.Error_MisusedDynamicAttribute ();
2630                                 return;
2631                         }
2632
2633                         base.ApplyAttributeBuilder (a, ctor, cdata, pa);
2634                 }
2635
2636                 /// <summary>
2637                 /// Defines the default constructors
2638                 /// </summary>
2639                 protected virtual Constructor DefineDefaultConstructor (bool is_static)
2640                 {
2641                         // The default instance constructor is public
2642                         // If the class is abstract, the default constructor is protected
2643                         // The default static constructor is private
2644
2645                         Modifiers mods;
2646                         ParametersCompiled parameters = null;
2647                         if (is_static) {
2648                                 mods = Modifiers.STATIC | Modifiers.PRIVATE;
2649                                 parameters = ParametersCompiled.EmptyReadOnlyParameters;
2650                         } else {
2651                                 mods = ((ModFlags & Modifiers.ABSTRACT) != 0) ? Modifiers.PROTECTED : Modifiers.PUBLIC;
2652                                 parameters = PrimaryConstructorParameters ?? ParametersCompiled.EmptyReadOnlyParameters;
2653                         }
2654
2655                         var c = new Constructor (this, MemberName.Name, mods, null, parameters, Location);
2656                         if (Kind == MemberKind.Class)
2657                                 c.Initializer = new GeneratedBaseInitializer (Location, PrimaryConstructorBaseArguments);
2658
2659                         if (PrimaryConstructorParameters != null && !is_static) {
2660                                 c.IsPrimaryConstructor = true;
2661                                 c.caching_flags |= Flags.MethodOverloadsExist;
2662                         }
2663
2664                         AddConstructor (c, true);
2665                         if (PrimaryConstructorBlock == null) {
2666                                 c.Block = new ToplevelBlock (Compiler, parameters, Location) {
2667                                         IsCompilerGenerated = true
2668                                 };
2669                         } else {
2670                                 c.Block = PrimaryConstructorBlock;
2671                         }
2672
2673                         return c;
2674                 }
2675
2676                 protected override bool DoDefineMembers ()
2677                 {
2678                         CheckProtectedModifier ();
2679
2680                         if (PrimaryConstructorParameters != null) {
2681
2682                                 foreach (Parameter p in PrimaryConstructorParameters.FixedParameters) {
2683                                         if (p.Name == MemberName.Name) {
2684                                                 Report.Error (8039, p.Location, "Primary constructor of type `{0}' has parameter of same name as containing type",
2685                                                         GetSignatureForError ());
2686                                         }
2687
2688                                         if (CurrentTypeParameters != null) {
2689                                                 for (int i = 0; i < CurrentTypeParameters.Count; ++i) {
2690                                                         var tp = CurrentTypeParameters [i];
2691                                                         if (p.Name == tp.Name) {
2692                                                                 Report.Error (8038, p.Location, "Primary constructor of type `{0}' has parameter of same name as type parameter `{1}'",
2693                                                                         GetSignatureForError (), p.GetSignatureForError ());
2694                                                         }
2695                                                 }
2696                                         }
2697                                 }
2698                         }
2699
2700                         base.DoDefineMembers ();
2701
2702                         return true;
2703                 }
2704
2705                 public override void PrepareEmit ()
2706                 {
2707                         var s = this as Struct;
2708                         if (s == null || !s.HasUnmanagedCheckDone) {
2709                                 for (int i = 0; i < Members.Count; ++i) {
2710                                         var f = Members [i] as Field;
2711                                         if (f == null || f.MemberType == null || !f.MemberType.IsPointer)
2712                                                 continue;
2713
2714                                         TypeManager.VerifyUnmanaged (Module, f.MemberType, f.Location);
2715                                 }
2716                         }
2717
2718                         base.PrepareEmit ();
2719                 }
2720
2721                 public override void Emit ()
2722                 {
2723                         if (!has_static_constructor && HasStaticFieldInitializer) {
2724                                 var c = DefineDefaultConstructor (true);
2725                                 c.Define ();
2726                         }
2727
2728                         base.Emit ();
2729
2730                         if (declarative_security != null) {
2731                                 foreach (var de in declarative_security) {
2732 #if STATIC
2733                                         TypeBuilder.__AddDeclarativeSecurity (de);
2734 #else
2735                                         TypeBuilder.AddDeclarativeSecurity (de.Key, de.Value);
2736 #endif
2737                                 }
2738                         }
2739                 }
2740         }
2741
2742
2743         public sealed class Class : ClassOrStruct
2744         {
2745                 const Modifiers AllowedModifiers =
2746                         Modifiers.NEW |
2747                         Modifiers.PUBLIC |
2748                         Modifiers.PROTECTED |
2749                         Modifiers.INTERNAL |
2750                         Modifiers.PRIVATE |
2751                         Modifiers.ABSTRACT |
2752                         Modifiers.SEALED |
2753                         Modifiers.STATIC |
2754                         Modifiers.UNSAFE;
2755
2756                 public Class (TypeContainer parent, MemberName name, Modifiers mod, Attributes attrs)
2757                         : base (parent, name, attrs, MemberKind.Class)
2758                 {
2759                         var accmods = IsTopLevel ? Modifiers.INTERNAL : Modifiers.PRIVATE;
2760                         this.ModFlags = ModifiersExtensions.Check (AllowedModifiers, mod, accmods, Location, Report);
2761                         spec = new TypeSpec (Kind, null, this, null, ModFlags);
2762                 }
2763
2764                 public override void Accept (StructuralVisitor visitor)
2765                 {
2766                         visitor.Visit (this);
2767                 }
2768
2769                 public override void SetBaseTypes (List<FullNamedExpression> baseTypes)
2770                 {
2771                         var pmn = MemberName;
2772                         if (pmn.Name == "Object" && !pmn.IsGeneric && Parent.MemberName.Name == "System" && Parent.MemberName.Left == null)
2773                                 Report.Error (537, Location,
2774                                         "The class System.Object cannot have a base class or implement an interface.");
2775
2776                         base.SetBaseTypes (baseTypes);
2777                 }
2778
2779                 public override void ApplyAttributeBuilder (Attribute a, MethodSpec ctor, byte[] cdata, PredefinedAttributes pa)
2780                 {
2781                         if (a.Type == pa.AttributeUsage) {
2782                                 if (!BaseType.IsAttribute && spec.BuiltinType != BuiltinTypeSpec.Type.Attribute) {
2783                                         Report.Error (641, a.Location, "Attribute `{0}' is only valid on classes derived from System.Attribute", a.GetSignatureForError ());
2784                                 }
2785                         }
2786
2787                         if (a.Type == pa.Conditional && !BaseType.IsAttribute) {
2788                                 Report.Error (1689, a.Location, "Attribute `System.Diagnostics.ConditionalAttribute' is only valid on methods or attribute classes");
2789                                 return;
2790                         }
2791
2792                         if (a.Type == pa.ComImport && !attributes.Contains (pa.Guid)) {
2793                                 a.Error_MissingGuidAttribute ();
2794                                 return;
2795                         }
2796
2797                         if (a.Type == pa.Extension) {
2798                                 a.Error_MisusedExtensionAttribute ();
2799                                 return;
2800                         }
2801
2802                         if (a.Type.IsConditionallyExcluded (this))
2803                                 return;
2804
2805                         base.ApplyAttributeBuilder (a, ctor, cdata, pa);
2806                 }
2807
2808                 public override AttributeTargets AttributeTargets {
2809                         get {
2810                                 return AttributeTargets.Class;
2811                         }
2812                 }
2813
2814                 protected override bool DoDefineMembers ()
2815                 {
2816                         if ((ModFlags & Modifiers.ABSTRACT) == Modifiers.ABSTRACT && (ModFlags & (Modifiers.SEALED | Modifiers.STATIC)) != 0) {
2817                                 Report.Error (418, Location, "`{0}': an abstract class cannot be sealed or static", GetSignatureForError ());
2818                         }
2819
2820                         if ((ModFlags & (Modifiers.SEALED | Modifiers.STATIC)) == (Modifiers.SEALED | Modifiers.STATIC)) {
2821                                 Report.Error (441, Location, "`{0}': a class cannot be both static and sealed", GetSignatureForError ());
2822                         }
2823
2824                         if (IsStatic) {
2825                                 if (PrimaryConstructorParameters != null) {
2826                                         Report.Error (-800, Location, "`{0}': Static classes cannot have primary constructor", GetSignatureForError ());
2827                                         PrimaryConstructorParameters = null;
2828                                 }
2829
2830                                 foreach (var m in Members) {
2831                                         if (m is Operator) {
2832                                                 Report.Error (715, m.Location, "`{0}': Static classes cannot contain user-defined operators", m.GetSignatureForError ());
2833                                                 continue;
2834                                         }
2835
2836                                         if (m is Destructor) {
2837                                                 Report.Error (711, m.Location, "`{0}': Static classes cannot contain destructor", GetSignatureForError ());
2838                                                 continue;
2839                                         }
2840
2841                                         if (m is Indexer) {
2842                                                 Report.Error (720, m.Location, "`{0}': cannot declare indexers in a static class", m.GetSignatureForError ());
2843                                                 continue;
2844                                         }
2845
2846                                         if ((m.ModFlags & Modifiers.STATIC) != 0 || m is TypeContainer)
2847                                                 continue;
2848
2849                                         if (m is Constructor) {
2850                                                 Report.Error (710, m.Location, "`{0}': Static classes cannot have instance constructors", GetSignatureForError ());
2851                                                 continue;
2852                                         }
2853
2854                                         Report.Error (708, m.Location, "`{0}': cannot declare instance members in a static class", m.GetSignatureForError ());
2855                                 }
2856                         } else {
2857                                 if (!PartialContainer.HasInstanceConstructor || PrimaryConstructorParameters != null)
2858                                         generated_primary_constructor = DefineDefaultConstructor (false);
2859                         }
2860
2861                         return base.DoDefineMembers ();
2862                 }
2863
2864                 public override void Emit ()
2865                 {
2866                         base.Emit ();
2867
2868                         if ((ModFlags & Modifiers.METHOD_EXTENSION) != 0)
2869                                 Module.PredefinedAttributes.Extension.EmitAttribute (TypeBuilder);
2870
2871                         if (base_type != null && base_type.HasDynamicElement) {
2872                                 Module.PredefinedAttributes.Dynamic.EmitAttribute (TypeBuilder, base_type, Location);
2873                         }
2874                 }
2875
2876                 public override void GetCompletionStartingWith (string prefix, List<string> results)
2877                 {
2878                         base.GetCompletionStartingWith (prefix, results);
2879
2880                         var bt = base_type;
2881                         while (bt != null) {
2882                                 results.AddRange (MemberCache.GetCompletitionMembers (this, bt, prefix).Where (l => l.IsStatic).Select (l => l.Name));
2883                                 bt = bt.BaseType;
2884                         }
2885                 }
2886
2887                 protected override TypeSpec[] ResolveBaseTypes (out FullNamedExpression base_class)
2888                 {
2889                         var ifaces = base.ResolveBaseTypes (out base_class);
2890
2891                         if (base_class == null) {
2892                                 if (spec.BuiltinType != BuiltinTypeSpec.Type.Object)
2893                                         base_type = Compiler.BuiltinTypes.Object;
2894                         } else {
2895                                 if (base_type.IsGenericParameter){
2896                                         Report.Error (689, base_class.Location, "`{0}': Cannot derive from type parameter `{1}'",
2897                                                 GetSignatureForError (), base_type.GetSignatureForError ());
2898                                 } else if (base_type.IsStatic) {
2899                                         Report.SymbolRelatedToPreviousError (base_type);
2900                                         Report.Error (709, Location, "`{0}': Cannot derive from static class `{1}'",
2901                                                 GetSignatureForError (), base_type.GetSignatureForError ());
2902                                 } else if (base_type.IsSealed) {
2903                                         Report.SymbolRelatedToPreviousError (base_type);
2904                                         Report.Error (509, Location, "`{0}': cannot derive from sealed type `{1}'",
2905                                                 GetSignatureForError (), base_type.GetSignatureForError ());
2906                                 } else if (PartialContainer.IsStatic && base_type.BuiltinType != BuiltinTypeSpec.Type.Object) {
2907                                         Report.Error (713, Location, "Static class `{0}' cannot derive from type `{1}'. Static classes must derive from object",
2908                                                 GetSignatureForError (), base_type.GetSignatureForError ());
2909                                 }
2910
2911                                 switch (base_type.BuiltinType) {
2912                                 case BuiltinTypeSpec.Type.Enum:
2913                                 case BuiltinTypeSpec.Type.ValueType:
2914                                 case BuiltinTypeSpec.Type.MulticastDelegate:
2915                                 case BuiltinTypeSpec.Type.Delegate:
2916                                 case BuiltinTypeSpec.Type.Array:
2917                                         if (!(spec is BuiltinTypeSpec)) {
2918                                                 Report.Error (644, Location, "`{0}' cannot derive from special class `{1}'",
2919                                                         GetSignatureForError (), base_type.GetSignatureForError ());
2920
2921                                                 base_type = Compiler.BuiltinTypes.Object;
2922                                         }
2923                                         break;
2924                                 }
2925
2926                                 if (!IsAccessibleAs (base_type)) {
2927                                         Report.SymbolRelatedToPreviousError (base_type);
2928                                         Report.Error (60, Location, "Inconsistent accessibility: base class `{0}' is less accessible than class `{1}'",
2929                                                 base_type.GetSignatureForError (), GetSignatureForError ());
2930                                 }
2931                         }
2932
2933                         if (PartialContainer.IsStatic && ifaces != null) {
2934                                 foreach (var t in ifaces)
2935                                         Report.SymbolRelatedToPreviousError (t);
2936                                 Report.Error (714, Location, "Static class `{0}' cannot implement interfaces", GetSignatureForError ());
2937                         }
2938
2939                         return ifaces;
2940                 }
2941
2942                 /// Search for at least one defined condition in ConditionalAttribute of attribute class
2943                 /// Valid only for attribute classes.
2944                 public override string[] ConditionalConditions ()
2945                 {
2946                         if ((caching_flags & (Flags.Excluded_Undetected | Flags.Excluded)) == 0)
2947                                 return null;
2948
2949                         caching_flags &= ~Flags.Excluded_Undetected;
2950
2951                         if (OptAttributes == null)
2952                                 return null;
2953
2954                         Attribute[] attrs = OptAttributes.SearchMulti (Module.PredefinedAttributes.Conditional);
2955                         if (attrs == null)
2956                                 return null;
2957
2958                         string[] conditions = new string[attrs.Length];
2959                         for (int i = 0; i < conditions.Length; ++i)
2960                                 conditions[i] = attrs[i].GetConditionalAttributeValue ();
2961
2962                         caching_flags |= Flags.Excluded;
2963                         return conditions;
2964                 }
2965         }
2966
2967         public sealed class Struct : ClassOrStruct
2968         {
2969                 bool is_unmanaged, has_unmanaged_check_done, requires_delayed_unmanagedtype_check;
2970                 bool InTransit;
2971
2972                 // <summary>
2973                 //   Modifiers allowed in a struct declaration
2974                 // </summary>
2975                 const Modifiers AllowedModifiers =
2976                         Modifiers.NEW       |
2977                         Modifiers.PUBLIC    |
2978                         Modifiers.PROTECTED |
2979                         Modifiers.INTERNAL  |
2980                         Modifiers.UNSAFE    |
2981                         Modifiers.PRIVATE;
2982
2983                 public Struct (TypeContainer parent, MemberName name, Modifiers mod, Attributes attrs)
2984                         : base (parent, name, attrs, MemberKind.Struct)
2985                 {
2986                         var accmods = IsTopLevel ? Modifiers.INTERNAL : Modifiers.PRIVATE;
2987                         this.ModFlags = ModifiersExtensions.Check (AllowedModifiers, mod, accmods, Location, Report) | Modifiers.SEALED ;
2988                         spec = new TypeSpec (Kind, null, this, null, ModFlags);
2989                 }
2990
2991                 public override AttributeTargets AttributeTargets {
2992                         get {
2993                                 return AttributeTargets.Struct;
2994                         }
2995                 }
2996
2997                 public override void Accept (StructuralVisitor visitor)
2998                 {
2999                         visitor.Visit (this);
3000                 }
3001
3002                 public override void ApplyAttributeBuilder (Attribute a, MethodSpec ctor, byte[] cdata, PredefinedAttributes pa)
3003                 {
3004                         base.ApplyAttributeBuilder (a, ctor, cdata, pa);
3005
3006                         //
3007                         // When struct constains fixed fixed and struct layout has explicitly
3008                         // set CharSet, its value has to be propagated to compiler generated
3009                         // fixed types
3010                         //
3011                         if (a.Type == pa.StructLayout) {
3012                                 var value = a.GetNamedValue ("CharSet");
3013                                 if (value == null)
3014                                         return;
3015
3016                                 for (int i = 0; i < Members.Count; ++i) {
3017                                         FixedField ff = Members [i] as FixedField;
3018                                         if (ff == null)
3019                                                 continue;
3020
3021                                         ff.CharSetValue = (CharSet) System.Enum.Parse (typeof (CharSet), value.GetValue ().ToString ());
3022                                 }
3023                         }
3024                 }
3025
3026                 bool CheckStructCycles ()
3027                 {
3028                         if (InTransit)
3029                                 return false;
3030
3031                         InTransit = true;
3032                         foreach (var member in Members) {
3033                                 var field = member as Field;
3034                                 if (field == null)
3035                                         continue;
3036
3037                                 TypeSpec ftype = field.Spec.MemberType;
3038                                 if (!ftype.IsStruct)
3039                                         continue;
3040
3041                                 if (ftype is BuiltinTypeSpec)
3042                                         continue;
3043
3044                                 foreach (var targ in ftype.TypeArguments) {
3045                                         if (!CheckFieldTypeCycle (targ)) {
3046                                                 Report.Error (523, field.Location,
3047                                                         "Struct member `{0}' of type `{1}' causes a cycle in the struct layout",
3048                                                         field.GetSignatureForError (), ftype.GetSignatureForError ());
3049                                                 break;
3050                                         }
3051                                 }
3052
3053                                 //
3054                                 // Static fields of exactly same type are allowed
3055                                 //
3056                                 if (field.IsStatic && ftype == CurrentType)
3057                                         continue;
3058
3059                                 if (!CheckFieldTypeCycle (ftype)) {
3060                                         Report.Error (523, field.Location,
3061                                                 "Struct member `{0}' of type `{1}' causes a cycle in the struct layout",
3062                                                 field.GetSignatureForError (), ftype.GetSignatureForError ());
3063                                         break;
3064                                 }
3065                         }
3066
3067                         InTransit = false;
3068                         return true;
3069                 }
3070
3071                 static bool CheckFieldTypeCycle (TypeSpec ts)
3072                 {
3073                         var fts = ts.MemberDefinition as Struct;
3074                         if (fts == null)
3075                                 return true;
3076
3077                         return fts.CheckStructCycles ();
3078                 }
3079
3080                 protected override bool DoDefineMembers ()
3081                 {
3082                         var res = base.DoDefineMembers ();
3083
3084                         if (PrimaryConstructorParameters != null || (initialized_fields != null && !HasUserDefaultConstructor ())) {
3085                                 generated_primary_constructor = DefineDefaultConstructor (false);
3086                                 generated_primary_constructor.Define ();
3087                         }
3088
3089                         return res;
3090                 }
3091
3092                 public override void Emit ()
3093                 {
3094                         CheckStructCycles ();
3095
3096                         base.Emit ();
3097                 }
3098
3099                 public bool HasUnmanagedCheckDone {
3100                         get {
3101                                 return has_unmanaged_check_done;
3102                         }
3103                 }
3104
3105                 bool HasUserDefaultConstructor ()
3106                 {
3107                         foreach (var m in PartialContainer.Members) {
3108                                 var c = m as Constructor;
3109                                 if (c == null)
3110                                         continue;
3111
3112                                 if (!c.IsStatic && c.ParameterInfo.IsEmpty)
3113                                         return true;
3114                         }
3115
3116                         return false;
3117                 }
3118
3119                 public override bool IsUnmanagedType ()
3120                 {
3121                         if (has_unmanaged_check_done)
3122                                 return is_unmanaged;
3123
3124                         if (requires_delayed_unmanagedtype_check)
3125                                 return true;
3126
3127                         var parent_def = Parent.PartialContainer;
3128                         if (parent_def != null && parent_def.IsGenericOrParentIsGeneric) {
3129                                 has_unmanaged_check_done = true;
3130                                 return false;
3131                         }
3132
3133                         if (first_nonstatic_field != null) {
3134                                 requires_delayed_unmanagedtype_check = true;
3135
3136                                 foreach (var member in Members) {
3137                                         var f = member as Field;
3138                                         if (f == null)
3139                                                 continue;
3140
3141                                         if (f.IsStatic)
3142                                                 continue;
3143
3144                                         // It can happen when recursive unmanaged types are defined
3145                                         // struct S { S* s; }
3146                                         TypeSpec mt = f.MemberType;
3147                                         if (mt == null) {
3148                                                 return true;
3149                                         }
3150
3151                                         if (mt.IsUnmanaged)
3152                                                 continue;
3153
3154                                         has_unmanaged_check_done = true;
3155                                         return false;
3156                                 }
3157
3158                                 has_unmanaged_check_done = true;
3159                         }
3160
3161                         is_unmanaged = true;
3162                         return true;
3163                 }
3164
3165                 protected override TypeSpec[] ResolveBaseTypes (out FullNamedExpression base_class)
3166                 {
3167                         var ifaces = base.ResolveBaseTypes (out base_class);
3168                         base_type = Compiler.BuiltinTypes.ValueType;
3169                         return ifaces;
3170                 }
3171         }
3172
3173         /// <summary>
3174         ///   Interfaces
3175         /// </summary>
3176         public sealed class Interface : TypeDefinition {
3177
3178                 /// <summary>
3179                 ///   Modifiers allowed in a class declaration
3180                 /// </summary>
3181                 const Modifiers AllowedModifiers =
3182                         Modifiers.NEW       |
3183                         Modifiers.PUBLIC    |
3184                         Modifiers.PROTECTED |
3185                         Modifiers.INTERNAL  |
3186                         Modifiers.UNSAFE    |
3187                         Modifiers.PRIVATE;
3188
3189                 public Interface (TypeContainer parent, MemberName name, Modifiers mod, Attributes attrs)
3190                         : base (parent, name, attrs, MemberKind.Interface)
3191                 {
3192                         var accmods = IsTopLevel ? Modifiers.INTERNAL : Modifiers.PRIVATE;
3193
3194                         this.ModFlags = ModifiersExtensions.Check (AllowedModifiers, mod, accmods, name.Location, Report);
3195                         spec = new TypeSpec (Kind, null, this, null, ModFlags);
3196                 }
3197
3198                 #region Properties
3199
3200                 public override AttributeTargets AttributeTargets {
3201                         get {
3202                                 return AttributeTargets.Interface;
3203                         }
3204                 }
3205
3206                 protected override TypeAttributes TypeAttr {
3207                         get {
3208                                 const TypeAttributes DefaultTypeAttributes =
3209                                         TypeAttributes.AutoLayout |
3210                                         TypeAttributes.Abstract |
3211                                         TypeAttributes.Interface;
3212
3213                                 return base.TypeAttr | DefaultTypeAttributes;
3214                         }
3215                 }
3216
3217                 #endregion
3218
3219                 public override void Accept (StructuralVisitor visitor)
3220                 {
3221                         visitor.Visit (this);
3222                 }
3223
3224                 public override void ApplyAttributeBuilder (Attribute a, MethodSpec ctor, byte[] cdata, PredefinedAttributes pa)
3225                 {
3226                         if (a.Type == pa.ComImport && !attributes.Contains (pa.Guid)) {
3227                                 a.Error_MissingGuidAttribute ();
3228                                 return;
3229                         }
3230
3231                         base.ApplyAttributeBuilder (a, ctor, cdata, pa);
3232                 }
3233
3234                 protected override bool VerifyClsCompliance ()
3235                 {
3236                         if (!base.VerifyClsCompliance ())
3237                                 return false;
3238
3239                         if (iface_exprs != null) {
3240                                 foreach (var iface in iface_exprs) {
3241                                         if (iface.IsCLSCompliant ())
3242                                                 continue;
3243
3244                                         Report.SymbolRelatedToPreviousError (iface);
3245                                         Report.Warning (3027, 1, Location, "`{0}' is not CLS-compliant because base interface `{1}' is not CLS-compliant",
3246                                                 GetSignatureForError (), iface.GetSignatureForError ());
3247                                 }
3248                         }
3249
3250                         return true;
3251                 }
3252         }
3253
3254         public abstract class InterfaceMemberBase : MemberBase
3255         {
3256                 //
3257                 // Common modifiers allowed in a class declaration
3258                 //
3259                 protected const Modifiers AllowedModifiersClass =
3260                         Modifiers.NEW |
3261                         Modifiers.PUBLIC |
3262                         Modifiers.PROTECTED |
3263                         Modifiers.INTERNAL |
3264                         Modifiers.PRIVATE |
3265                         Modifiers.STATIC |
3266                         Modifiers.VIRTUAL |
3267                         Modifiers.SEALED |
3268                         Modifiers.OVERRIDE |
3269                         Modifiers.ABSTRACT |
3270                         Modifiers.UNSAFE |
3271                         Modifiers.EXTERN;
3272
3273                 //
3274                 // Common modifiers allowed in a struct declaration
3275                 //
3276                 protected const Modifiers AllowedModifiersStruct =
3277                         Modifiers.NEW |
3278                         Modifiers.PUBLIC |
3279                         Modifiers.PROTECTED |
3280                         Modifiers.INTERNAL |
3281                         Modifiers.PRIVATE |
3282                         Modifiers.STATIC |
3283                         Modifiers.OVERRIDE |
3284                         Modifiers.UNSAFE |
3285                         Modifiers.EXTERN;
3286
3287                 //
3288                 // Common modifiers allowed in a interface declaration
3289                 //
3290                 protected const Modifiers AllowedModifiersInterface =
3291                         Modifiers.NEW |
3292                         Modifiers.UNSAFE;
3293
3294                 //
3295                 // Whether this is an interface member.
3296                 //
3297                 public bool IsInterface;
3298
3299                 //
3300                 // If true, this is an explicit interface implementation
3301                 //
3302                 public readonly bool IsExplicitImpl;
3303
3304                 protected bool is_external_implementation;
3305
3306                 //
3307                 // The interface type we are explicitly implementing
3308                 //
3309                 public TypeSpec InterfaceType;
3310
3311                 //
3312                 // The method we're overriding if this is an override method.
3313                 //
3314                 protected MethodSpec base_method;
3315
3316                 readonly Modifiers explicit_mod_flags;
3317                 public MethodAttributes flags;
3318
3319                 protected InterfaceMemberBase (TypeDefinition parent, FullNamedExpression type, Modifiers mod, Modifiers allowed_mod, MemberName name, Attributes attrs)
3320                         : base (parent, type, mod, allowed_mod, Modifiers.PRIVATE, name, attrs)
3321                 {
3322                         IsInterface = parent.Kind == MemberKind.Interface;
3323                         IsExplicitImpl = (MemberName.ExplicitInterface != null);
3324                         explicit_mod_flags = mod;
3325                 }
3326
3327                 public abstract Variance ExpectedMemberTypeVariance { get; }
3328
3329                 protected override bool CheckBase ()
3330                 {
3331                         if (!base.CheckBase ())
3332                                 return false;
3333
3334                         if ((caching_flags & Flags.MethodOverloadsExist) != 0)
3335                                 CheckForDuplications ();
3336
3337                         if (IsExplicitImpl)
3338                                 return true;
3339
3340                         // For System.Object only
3341                         if (Parent.BaseType == null)
3342                                 return true;
3343
3344                         MemberSpec candidate;
3345                         bool overrides = false;
3346                         var base_member = FindBaseMember (out candidate, ref overrides);
3347
3348                         if ((ModFlags & Modifiers.OVERRIDE) != 0) {
3349                                 if (base_member == null) {
3350                                         if (candidate == null) {
3351                                                 if (this is Method && ((Method)this).ParameterInfo.IsEmpty && MemberName.Name == Destructor.MetadataName && MemberName.Arity == 0) {
3352                                                         Report.Error (249, Location, "Do not override `{0}'. Use destructor syntax instead",
3353                                                                 "object.Finalize()");
3354                                                 } else {
3355                                                         Report.Error (115, Location, "`{0}' is marked as an override but no suitable {1} found to override",
3356                                                                 GetSignatureForError (), SimpleName.GetMemberType (this));
3357                                                 }
3358                                         } else {
3359                                                 Report.SymbolRelatedToPreviousError (candidate);
3360                                                 if (this is Event)
3361                                                         Report.Error (72, Location, "`{0}': cannot override because `{1}' is not an event",
3362                                                                 GetSignatureForError (), TypeManager.GetFullNameSignature (candidate));
3363                                                 else if (this is PropertyBase)
3364                                                         Report.Error (544, Location, "`{0}': cannot override because `{1}' is not a property",
3365                                                                 GetSignatureForError (), TypeManager.GetFullNameSignature (candidate));
3366                                                 else
3367                                                         Report.Error (505, Location, "`{0}': cannot override because `{1}' is not a method",
3368                                                                 GetSignatureForError (), TypeManager.GetFullNameSignature (candidate));
3369                                         }
3370
3371                                         return false;
3372                                 }
3373
3374                                 //
3375                                 // Handles ambiguous overrides
3376                                 //
3377                                 if (candidate != null) {
3378                                         Report.SymbolRelatedToPreviousError (candidate);
3379                                         Report.SymbolRelatedToPreviousError (base_member);
3380
3381                                         // Get member definition for error reporting
3382                                         var m1 = MemberCache.GetMember (base_member.DeclaringType.GetDefinition (), base_member);
3383                                         var m2 = MemberCache.GetMember (candidate.DeclaringType.GetDefinition (), candidate);
3384
3385                                         Report.Error (462, Location,
3386                                                 "`{0}' cannot override inherited members `{1}' and `{2}' because they have the same signature when used in type `{3}'",
3387                                                 GetSignatureForError (), m1.GetSignatureForError (), m2.GetSignatureForError (), Parent.GetSignatureForError ());
3388                                 }
3389
3390                                 if (!CheckOverrideAgainstBase (base_member))
3391                                         return false;
3392
3393                                 ObsoleteAttribute oa = base_member.GetAttributeObsolete ();
3394                                 if (oa != null) {
3395                                         if (OptAttributes == null || !OptAttributes.Contains (Module.PredefinedAttributes.Obsolete)) {
3396                                                 Report.SymbolRelatedToPreviousError (base_member);
3397                                                 Report.Warning (672, 1, Location, "Member `{0}' overrides obsolete member `{1}'. Add the Obsolete attribute to `{0}'",
3398                                                         GetSignatureForError (), base_member.GetSignatureForError ());
3399                                         }
3400                                 } else {
3401                                         if (OptAttributes != null && OptAttributes.Contains (Module.PredefinedAttributes.Obsolete)) {
3402                                                 Report.SymbolRelatedToPreviousError (base_member);
3403                                                 Report.Warning (809, 1, Location, "Obsolete member `{0}' overrides non-obsolete member `{1}'",
3404                                                         GetSignatureForError (), base_member.GetSignatureForError ());
3405                                         }
3406                                 }
3407
3408                                 base_method = base_member as MethodSpec;
3409                                 return true;
3410                         }
3411
3412                         if (base_member == null && candidate != null && (!(candidate is IParametersMember) || !(this is IParametersMember)))
3413                                 base_member = candidate;
3414
3415                         if (base_member == null) {
3416                                 if ((ModFlags & Modifiers.NEW) != 0) {
3417                                         if (base_member == null) {
3418                                                 Report.Warning (109, 4, Location, "The member `{0}' does not hide an inherited member. The new keyword is not required",
3419                                                         GetSignatureForError ());
3420                                         }
3421                                 }
3422                         } else {
3423                                 if ((ModFlags & Modifiers.NEW) == 0) {
3424                                         ModFlags |= Modifiers.NEW;
3425                                         if (!IsCompilerGenerated) {
3426                                                 Report.SymbolRelatedToPreviousError (base_member);
3427                                                 if ((base_member.Kind & MemberKind.NestedMask) == 0 && !IsInterface && (base_member.Modifiers & (Modifiers.ABSTRACT | Modifiers.VIRTUAL | Modifiers.OVERRIDE)) != 0) {
3428                                                         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",
3429                                                                 GetSignatureForError (), base_member.GetSignatureForError ());
3430                                                 } else {
3431                                                         Report.Warning (108, 2, Location, "`{0}' hides inherited member `{1}'. Use the new keyword if hiding was intended",
3432                                                                 GetSignatureForError (), base_member.GetSignatureForError ());
3433                                                 }
3434                                         }
3435                                 }
3436
3437                                 if (!IsInterface && base_member.IsAbstract && !overrides && !IsStatic) {
3438                                         switch (base_member.Kind) {
3439                                         case MemberKind.Event:
3440                                         case MemberKind.Indexer:
3441                                         case MemberKind.Method:
3442                                         case MemberKind.Property:
3443                                                 Report.SymbolRelatedToPreviousError (base_member);
3444                                                 Report.Error (533, Location, "`{0}' hides inherited abstract member `{1}'",
3445                                                         GetSignatureForError (), base_member.GetSignatureForError ());
3446                                                 break;
3447                                         }
3448                                 }
3449                         }
3450
3451                         return true;
3452                 }
3453
3454                 protected virtual bool CheckForDuplications ()
3455                 {
3456                         return Parent.MemberCache.CheckExistingMembersOverloads (this, ParametersCompiled.EmptyReadOnlyParameters);
3457                 }
3458
3459                 //
3460                 // Performs various checks on the MethodInfo `mb' regarding the modifier flags
3461                 // that have been defined.
3462                 //
3463                 protected virtual bool CheckOverrideAgainstBase (MemberSpec base_member)
3464                 {
3465                         bool ok = true;
3466
3467                         if ((base_member.Modifiers & (Modifiers.ABSTRACT | Modifiers.VIRTUAL | Modifiers.OVERRIDE)) == 0) {
3468                                 Report.SymbolRelatedToPreviousError (base_member);
3469                                 Report.Error (506, Location,
3470                                         "`{0}': cannot override inherited member `{1}' because it is not marked virtual, abstract or override",
3471                                          GetSignatureForError (), TypeManager.CSharpSignature (base_member));
3472                                 ok = false;
3473                         }
3474
3475                         // Now we check that the overriden method is not final
3476                         if ((base_member.Modifiers & Modifiers.SEALED) != 0) {
3477                                 Report.SymbolRelatedToPreviousError (base_member);
3478                                 Report.Error (239, Location, "`{0}': cannot override inherited member `{1}' because it is sealed",
3479                                                           GetSignatureForError (), TypeManager.CSharpSignature (base_member));
3480                                 ok = false;
3481                         }
3482
3483                         var base_member_type = ((IInterfaceMemberSpec) base_member).MemberType;
3484                         if (!TypeSpecComparer.Override.IsEqual (MemberType, base_member_type)) {
3485                                 Report.SymbolRelatedToPreviousError (base_member);
3486                                 if (this is PropertyBasedMember) {
3487                                         Report.Error (1715, Location, "`{0}': type must be `{1}' to match overridden member `{2}'",
3488                                                 GetSignatureForError (), base_member_type.GetSignatureForError (), base_member.GetSignatureForError ());
3489                                 } else {
3490                                         Report.Error (508, Location, "`{0}': return type must be `{1}' to match overridden member `{2}'",
3491                                                 GetSignatureForError (), base_member_type.GetSignatureForError (), base_member.GetSignatureForError ());
3492                                 }
3493                                 ok = false;
3494                         }
3495
3496                         return ok;
3497                 }
3498
3499                 protected static bool CheckAccessModifiers (MemberCore this_member, MemberSpec base_member)
3500                 {
3501                         var thisp = this_member.ModFlags & Modifiers.AccessibilityMask;
3502                         var base_classp = base_member.Modifiers & Modifiers.AccessibilityMask;
3503
3504                         if ((base_classp & (Modifiers.PROTECTED | Modifiers.INTERNAL)) == (Modifiers.PROTECTED | Modifiers.INTERNAL)) {
3505                                 //
3506                                 // It must be at least "protected"
3507                                 //
3508                                 if ((thisp & Modifiers.PROTECTED) == 0) {
3509                                         return false;
3510                                 }
3511
3512                                 //
3513                                 // when overriding protected internal, the method can be declared
3514                                 // protected internal only within the same assembly or assembly
3515                                 // which has InternalsVisibleTo
3516                                 //
3517                                 if ((thisp & Modifiers.INTERNAL) != 0) {
3518                                         return base_member.DeclaringType.MemberDefinition.IsInternalAsPublic (this_member.Module.DeclaringAssembly);
3519                                 }
3520
3521                                 //
3522                                 // protected overriding protected internal inside same assembly
3523                                 // requires internal modifier as well
3524                                 //
3525                                 if (base_member.DeclaringType.MemberDefinition.IsInternalAsPublic (this_member.Module.DeclaringAssembly)) {
3526                                         return false;
3527                                 }
3528
3529                                 return true;
3530                         }
3531
3532                         return thisp == base_classp;
3533                 }
3534
3535                 public override bool Define ()
3536                 {
3537                         if (IsInterface) {
3538                                 ModFlags = Modifiers.PUBLIC | Modifiers.ABSTRACT |
3539                                         Modifiers.VIRTUAL | (ModFlags & (Modifiers.UNSAFE | Modifiers.NEW));
3540
3541                                 flags = MethodAttributes.Public |
3542                                         MethodAttributes.Abstract |
3543                                         MethodAttributes.HideBySig |
3544                                         MethodAttributes.NewSlot |
3545                                         MethodAttributes.Virtual;
3546                         } else {
3547                                 Parent.PartialContainer.MethodModifiersValid (this);
3548
3549                                 flags = ModifiersExtensions.MethodAttr (ModFlags);
3550                         }
3551
3552                         if (IsExplicitImpl) {
3553                                 InterfaceType = MemberName.ExplicitInterface.ResolveAsType (Parent);
3554                                 if (InterfaceType == null)
3555                                         return false;
3556
3557                                 if ((ModFlags & Modifiers.PARTIAL) != 0) {
3558                                         Report.Error (754, Location, "A partial method `{0}' cannot explicitly implement an interface",
3559                                                 GetSignatureForError ());
3560                                 }
3561
3562                                 if (!InterfaceType.IsInterface) {
3563                                         Report.SymbolRelatedToPreviousError (InterfaceType);
3564                                         Report.Error (538, Location, "The type `{0}' in explicit interface declaration is not an interface",
3565                                                 InterfaceType.GetSignatureForError ());
3566                                 } else {
3567                                         Parent.PartialContainer.VerifyImplements (this);
3568                                 }
3569
3570                                 Modifiers allowed_explicit = Modifiers.AllowedExplicitImplFlags;
3571                                 if (this is Method)
3572                                         allowed_explicit |= Modifiers.ASYNC;
3573
3574                                 ModifiersExtensions.Check (allowed_explicit, explicit_mod_flags, 0, Location, Report);
3575                         }
3576
3577                         return base.Define ();
3578                 }
3579
3580                 protected bool DefineParameters (ParametersCompiled parameters)
3581                 {
3582                         if (!parameters.Resolve (this))
3583                                 return false;
3584
3585                         bool error = false;
3586                         for (int i = 0; i < parameters.Count; ++i) {
3587                                 Parameter p = parameters [i];
3588
3589                                 if (p.HasDefaultValue && (IsExplicitImpl || this is Operator || (this is Indexer && parameters.Count == 1)))
3590                                         p.Warning_UselessOptionalParameter (Report);
3591
3592                                 if (p.CheckAccessibility (this))
3593                                         continue;
3594
3595                                 TypeSpec t = parameters.Types [i];
3596                                 Report.SymbolRelatedToPreviousError (t);
3597                                 if (this is Indexer)
3598                                         Report.Error (55, Location,
3599                                                       "Inconsistent accessibility: parameter type `{0}' is less accessible than indexer `{1}'",
3600                                                       t.GetSignatureForError (), GetSignatureForError ());
3601                                 else if (this is Operator)
3602                                         Report.Error (57, Location,
3603                                                       "Inconsistent accessibility: parameter type `{0}' is less accessible than operator `{1}'",
3604                                                       t.GetSignatureForError (), GetSignatureForError ());
3605                                 else
3606                                         Report.Error (51, Location,
3607                                                 "Inconsistent accessibility: parameter type `{0}' is less accessible than method `{1}'",
3608                                                 t.GetSignatureForError (), GetSignatureForError ());
3609                                 error = true;
3610                         }
3611                         return !error;
3612                 }
3613
3614                 protected override void DoMemberTypeDependentChecks ()
3615                 {
3616                         base.DoMemberTypeDependentChecks ();
3617
3618                         VarianceDecl.CheckTypeVariance (MemberType, ExpectedMemberTypeVariance, this);
3619                 }
3620
3621                 public override void Emit()
3622                 {
3623                         // for extern static method must be specified either DllImport attribute or MethodImplAttribute.
3624                         // We are more strict than csc and report this as an error because SRE does not allow emit that
3625                         if ((ModFlags & Modifiers.EXTERN) != 0 && !is_external_implementation && (OptAttributes == null || !OptAttributes.HasResolveError ())) {
3626                                 if (this is Constructor) {
3627                                         Report.Warning (824, 1, Location,
3628                                                 "Constructor `{0}' is marked `external' but has no external implementation specified", GetSignatureForError ());
3629                                 } else {
3630                                         Report.Warning (626, 1, Location,
3631                                                 "`{0}' is marked as an external but has no DllImport attribute. Consider adding a DllImport attribute to specify the external implementation",
3632                                                 GetSignatureForError ());
3633                                 }
3634                         }
3635
3636                         base.Emit ();
3637                 }
3638
3639                 public override bool EnableOverloadChecks (MemberCore overload)
3640                 {
3641                         //
3642                         // Two members can differ in their explicit interface
3643                         // type parameter only
3644                         //
3645                         InterfaceMemberBase imb = overload as InterfaceMemberBase;
3646                         if (imb != null && imb.IsExplicitImpl) {
3647                                 if (IsExplicitImpl) {
3648                                         caching_flags |= Flags.MethodOverloadsExist;
3649                                 }
3650                                 return true;
3651                         }
3652
3653                         return IsExplicitImpl;
3654                 }
3655
3656                 protected void Error_CannotChangeAccessModifiers (MemberCore member, MemberSpec base_member)
3657                 {
3658                         var base_modifiers = base_member.Modifiers;
3659
3660                         // Remove internal modifier from types which are not internally accessible
3661                         if ((base_modifiers & Modifiers.AccessibilityMask) == (Modifiers.PROTECTED | Modifiers.INTERNAL) &&
3662                                 !base_member.DeclaringType.MemberDefinition.IsInternalAsPublic (member.Module.DeclaringAssembly))
3663                                 base_modifiers = Modifiers.PROTECTED;
3664
3665                         Report.SymbolRelatedToPreviousError (base_member);
3666                         Report.Error (507, member.Location,
3667                                 "`{0}': cannot change access modifiers when overriding `{1}' inherited member `{2}'",
3668                                 member.GetSignatureForError (),
3669                                 ModifiersExtensions.AccessibilityName (base_modifiers),
3670                                 base_member.GetSignatureForError ());
3671                 }
3672
3673                 protected void Error_StaticReturnType ()
3674                 {
3675                         Report.Error (722, Location,
3676                                 "`{0}': static types cannot be used as return types",
3677                                 MemberType.GetSignatureForError ());
3678                 }
3679
3680                 /// <summary>
3681                 /// Gets base method and its return type
3682                 /// </summary>
3683                 protected virtual MemberSpec FindBaseMember (out MemberSpec bestCandidate, ref bool overrides)
3684                 {
3685                         return MemberCache.FindBaseMember (this, out bestCandidate, ref overrides);
3686                 }
3687
3688                 //
3689                 // The "short" name of this property / indexer / event.  This is the
3690                 // name without the explicit interface.
3691                 //
3692                 public string ShortName {
3693                         get { return MemberName.Name; }
3694                 }
3695
3696                 //
3697                 // Returns full metadata method name
3698                 //
3699                 public string GetFullName (MemberName name)
3700                 {
3701                         return GetFullName (name.Name);
3702                 }
3703
3704                 public string GetFullName (string name)
3705                 {
3706                         if (!IsExplicitImpl)
3707                                 return name;
3708
3709                         //
3710                         // When dealing with explicit members a full interface type
3711                         // name is added to member name to avoid possible name conflicts
3712                         //
3713                         // We use CSharpName which gets us full name with benefit of
3714                         // replacing predefined names which saves some space and name
3715                         // is still unique
3716                         //
3717                         return InterfaceType.GetSignatureForError () + "." + name;
3718                 }
3719
3720                 public override string GetSignatureForDocumentation ()
3721                 {
3722                         if (IsExplicitImpl)
3723                                 return Parent.GetSignatureForDocumentation () + "." + InterfaceType.GetSignatureForDocumentation (true) + "#" + ShortName;
3724
3725                         return Parent.GetSignatureForDocumentation () + "." + ShortName;
3726                 }
3727
3728                 public override bool IsUsed
3729                 {
3730                         get { return IsExplicitImpl || base.IsUsed; }
3731                 }
3732
3733                 public override void SetConstraints (List<Constraints> constraints_list)
3734                 {
3735                         if (((ModFlags & Modifiers.OVERRIDE) != 0 || IsExplicitImpl)) {
3736                                 Report.Error (460, Location,
3737                                         "`{0}': Cannot specify constraints for overrides and explicit interface implementation methods",
3738                                         GetSignatureForError ());
3739                         }
3740
3741                         base.SetConstraints (constraints_list);
3742                 }
3743         }
3744
3745         public abstract class MemberBase : MemberCore
3746         {
3747                 protected FullNamedExpression type_expr;
3748                 protected TypeSpec member_type;
3749                 public new TypeDefinition Parent;
3750
3751                 protected MemberBase (TypeDefinition parent, FullNamedExpression type, Modifiers mod, Modifiers allowed_mod, Modifiers def_mod, MemberName name, Attributes attrs)
3752                         : base (parent, name, attrs)
3753                 {
3754                         this.Parent = parent;
3755                         this.type_expr = type;
3756
3757                         if (name != MemberName.Null)
3758                                 ModFlags = ModifiersExtensions.Check (allowed_mod, mod, def_mod, Location, Report);
3759                 }
3760
3761                 #region Properties
3762
3763                 public TypeSpec MemberType {
3764                         get {
3765                                 return member_type;
3766                         }
3767                 }
3768
3769                 public FullNamedExpression TypeExpression {
3770                         get {
3771                                 return type_expr;
3772                         }
3773                         set {
3774                                 type_expr = value;
3775                         }
3776                 }
3777
3778                 #endregion
3779
3780                 //
3781                 // Main member define entry
3782                 //
3783                 public override bool Define ()
3784                 {
3785                         DoMemberTypeIndependentChecks ();
3786
3787                         //
3788                         // Returns false only when type resolution failed
3789                         //
3790                         if (!ResolveMemberType ())
3791                                 return false;
3792
3793                         DoMemberTypeDependentChecks ();
3794                         return true;
3795                 }
3796
3797                 //
3798                 // Any type_name independent checks
3799                 //
3800                 protected virtual void DoMemberTypeIndependentChecks ()
3801                 {
3802                         if ((Parent.ModFlags & Modifiers.SEALED) != 0 &&
3803                                 (ModFlags & (Modifiers.VIRTUAL | Modifiers.ABSTRACT)) != 0) {
3804                                 Report.Error (549, Location, "New virtual member `{0}' is declared in a sealed class `{1}'",
3805                                         GetSignatureForError (), Parent.GetSignatureForError ());
3806                         }
3807                 }
3808
3809                 //
3810                 // Any type_name dependent checks
3811                 //
3812                 protected virtual void DoMemberTypeDependentChecks ()
3813                 {
3814                         // verify accessibility
3815                         if (!IsAccessibleAs (MemberType)) {
3816                                 Report.SymbolRelatedToPreviousError (MemberType);
3817                                 if (this is Property)
3818                                         Report.Error (53, Location,
3819                                                 "Inconsistent accessibility: property type `" +
3820                                                 MemberType.GetSignatureForError () + "' is less " +
3821                                                 "accessible than property `" + GetSignatureForError () + "'");
3822                                 else if (this is Indexer)
3823                                         Report.Error (54, Location,
3824                                                 "Inconsistent accessibility: indexer return type `" +
3825                                                 MemberType.GetSignatureForError () + "' is less " +
3826                                                 "accessible than indexer `" + GetSignatureForError () + "'");
3827                                 else if (this is MethodCore) {
3828                                         if (this is Operator)
3829                                                 Report.Error (56, Location,
3830                                                         "Inconsistent accessibility: return type `" +
3831                                                         MemberType.GetSignatureForError () + "' is less " +
3832                                                         "accessible than operator `" + GetSignatureForError () + "'");
3833                                         else
3834                                                 Report.Error (50, Location,
3835                                                         "Inconsistent accessibility: return type `" +
3836                                                         MemberType.GetSignatureForError () + "' is less " +
3837                                                         "accessible than method `" + GetSignatureForError () + "'");
3838                                 } else if (this is Event) {
3839                                         Report.Error (7025, Location,
3840                                                 "Inconsistent accessibility: event type `{0}' is less accessible than event `{1}'",
3841                                                 MemberType.GetSignatureForError (), GetSignatureForError ());
3842                                 } else {
3843                                         Report.Error (52, Location,
3844                                                       "Inconsistent accessibility: field type `" +
3845                                                       MemberType.GetSignatureForError () + "' is less " +
3846                                                       "accessible than field `" + GetSignatureForError () + "'");
3847                                 }
3848                         }
3849                 }
3850
3851                 protected void IsTypePermitted ()
3852                 {
3853                         if (MemberType.IsSpecialRuntimeType) {
3854                                 if (Parent is StateMachine) {
3855                                         Report.Error (4012, Location,
3856                                                 "Parameters or local variables of type `{0}' cannot be declared in async methods or iterators",
3857                                                 MemberType.GetSignatureForError ());
3858                                 } else if (Parent is HoistedStoreyClass) {
3859                                         Report.Error (4013, Location,
3860                                                 "Local variables of type `{0}' cannot be used inside anonymous methods, lambda expressions or query expressions",
3861                                                 MemberType.GetSignatureForError ());
3862                                 } else {
3863                                         Report.Error (610, Location,
3864                                                 "Field or property cannot be of type `{0}'", MemberType.GetSignatureForError ());
3865                                 }
3866                         }
3867                 }
3868
3869                 protected virtual bool CheckBase ()
3870                 {
3871                         CheckProtectedModifier ();
3872
3873                         return true;
3874                 }
3875
3876                 public override string GetSignatureForDocumentation ()
3877                 {
3878                         return Parent.GetSignatureForDocumentation () + "." + MemberName.Basename;
3879                 }
3880
3881                 public virtual void PrepareEmit ()
3882                 {
3883                         if (member_type != null && type_expr != null)
3884                                 member_type.CheckObsoleteness (this, type_expr.Location);
3885                 }
3886
3887                 protected virtual bool ResolveMemberType ()
3888                 {
3889                         if (member_type != null)
3890                                 throw new InternalErrorException ("Multi-resolve");
3891
3892                         member_type = type_expr.ResolveAsType (this);
3893                         return member_type != null;
3894                 }
3895         }
3896 }
3897