mcs/mcs/class.cs

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