mcs/mcs/decl.cs

   1 //
   2 // decl.cs: Declaration base class for structs, classes, enums and interfaces.
   3 //
   4 // Author: Miguel de Icaza (miguel@gnu.org)
   5 //         Marek Safar (marek.safar@seznam.cz)
   6 //
   7 // Dual licensed under the terms of the MIT X11 or GNU GPL
   8 //
   9 // Copyright 2001 Ximian, Inc (http://www.ximian.com)
  10 // Copyright 2004-2008 Novell, Inc
  11 // Copyright 2011 Xamarin Inc
  12 //
  13 //
  14
  15 using System;
  16 using System.Collections.Generic;
  17 using System.Diagnostics;
  18 using System.Text;
  19 using Mono.CompilerServices.SymbolWriter;
  20
  21 #if NET_2_1
  22 using XmlElement = System.Object;
  23 #else
  24 using System.Xml;
  25 #endif
  26
  27 #if STATIC
  28 using IKVM.Reflection;
  29 using IKVM.Reflection.Emit;
  30 #else
  31 using System.Reflection;
  32 using System.Reflection.Emit;
  33 #endif
  34
  35 namespace Mono.CSharp {
  36
  37         //
  38         // Better name would be DottenName
  39         //
  40         [DebuggerDisplay ("{GetSignatureForError()}")]
  41         public class MemberName
  42         {
  43                 public static readonly MemberName Null = new MemberName ("");
  44
  45                 public readonly string Name;
  46                 public TypeParameters TypeParameters;
  47                 public readonly FullNamedExpression ExplicitInterface;
  48                 public readonly Location Location;
  49
  50                 public readonly MemberName Left;
  51
  52                 public MemberName (string name)
  53                         : this (name, Location.Null)
  54                 { }
  55
  56                 public MemberName (string name, Location loc)
  57                         : this (null, name, loc)
  58                 { }
  59
  60                 public MemberName (string name, TypeParameters tparams, Location loc)
  61                 {
  62                         this.Name = name;
  63                         this.Location = loc;
  64
  65                         this.TypeParameters = tparams;
  66                 }
  67
  68                 public MemberName (string name, TypeParameters tparams, FullNamedExpression explicitInterface, Location loc)
  69                         : this (name, tparams, loc)
  70                 {
  71                         this.ExplicitInterface = explicitInterface;
  72                 }
  73
  74                 public MemberName (MemberName left, string name, Location loc)
  75                 {
  76                         this.Name = name;
  77                         this.Location = loc;
  78                         this.Left = left;
  79                 }
  80
  81                 public MemberName (MemberName left, string name, FullNamedExpression explicitInterface, Location loc)
  82                         : this (left, name, loc)
  83                 {
  84                         this.ExplicitInterface = explicitInterface;
  85                 }
  86
  87                 public MemberName (MemberName left, MemberName right)
  88                 {
  89                         this.Name = right.Name;
  90                         this.Location = right.Location;
  91                         this.TypeParameters = right.TypeParameters;
  92                         this.Left = left;
  93                 }
  94
  95                 public int Arity {
  96                         get {
  97                                 return TypeParameters == null ? 0 : TypeParameters.Count;
  98                         }
  99                 }
 100
 101                 public bool IsGeneric {
 102                         get {
 103                                 return TypeParameters != null;
 104                         }
 105                 }
 106
 107                 public string Basename {
 108                         get {
 109                                 if (TypeParameters != null)
 110                                         return MakeName (Name, TypeParameters);
 111                                 return Name;
 112                         }
 113                 }
 114
 115                 public void CreateMetadataName (StringBuilder sb)
 116                 {
 117                         if (Left != null)
 118                                 Left.CreateMetadataName (sb);
 119
 120                         if (sb.Length != 0) {
 121                                 sb.Append (".");
 122                         }
 123
 124                         sb.Append (Basename);
 125                 }
 126
 127                 public string GetSignatureForDocumentation ()
 128                 {
 129                         var s = Basename;
 130
 131                         if (ExplicitInterface != null)
 132                                 s = ExplicitInterface.GetSignatureForError () + "." + s;
 133
 134                         if (Left == null)
 135                                 return s;
 136
 137                         return Left.GetSignatureForDocumentation () + "." + s;
 138                 }
 139
 140                 public string GetSignatureForError ()
 141                 {
 142                         string s = TypeParameters == null ? null : "<" + TypeParameters.GetSignatureForError () + ">";
 143                         s = Name + s;
 144
 145                         if (ExplicitInterface != null)
 146                                 s = ExplicitInterface.GetSignatureForError () + "." + s;
 147
 148                         if (Left == null)
 149                                 return s;
 150
 151                         return Left.GetSignatureForError () + "." + s;
 152                 }
 153
 154                 public override bool Equals (object other)
 155                 {
 156                         return Equals (other as MemberName);
 157                 }
 158
 159                 public bool Equals (MemberName other)
 160                 {
 161                         if (this == other)
 162                                 return true;
 163                         if (other == null || Name != other.Name)
 164                                 return false;
 165
 166                         if ((TypeParameters != null) &&
 167                             (other.TypeParameters == null || TypeParameters.Count != other.TypeParameters.Count))
 168                                 return false;
 169
 170                         if ((TypeParameters == null) && (other.TypeParameters != null))
 171                                 return false;
 172
 173                         if (Left == null)
 174                                 return other.Left == null;
 175
 176                         return Left.Equals (other.Left);
 177                 }
 178
 179                 public override int GetHashCode ()
 180                 {
 181                         int hash = Name.GetHashCode ();
 182                         for (MemberName n = Left; n != null; n = n.Left)
 183                                 hash ^= n.Name.GetHashCode ();
 184
 185                         if (TypeParameters != null)
 186                                 hash ^= TypeParameters.Count << 5;
 187
 188                         return hash & 0x7FFFFFFF;
 189                 }
 190
 191                 public static string MakeName (string name, TypeParameters args)
 192                 {
 193                         if (args == null)
 194                                 return name;
 195
 196                         return name + "`" + args.Count;
 197                 }
 198         }
 199
 200         public class SimpleMemberName
 201         {
 202                 public string Value;
 203                 public Location Location;
 204
 205                 public SimpleMemberName (string name, Location loc)
 206                 {
 207                         this.Value = name;
 208                         this.Location = loc;
 209                 }
 210         }
 211
 212         /// <summary>
 213         ///   Base representation for members.  This is used to keep track
 214         ///   of Name, Location and Modifier flags, and handling Attributes.
 215         /// </summary>
 216         [System.Diagnostics.DebuggerDisplay ("{GetSignatureForError()}")]
 217         public abstract class MemberCore : Attributable, IMemberContext, IMemberDefinition
 218         {
 219                 string IMemberDefinition.Name {
 220                         get {
 221                                 return member_name.Name;
 222                         }
 223                 }
 224
 225                 // Is not readonly because of IndexerName attribute
 226                 private MemberName member_name;
 227                 public MemberName MemberName {
 228                         get { return member_name; }
 229                 }
 230
 231                 /// <summary>
 232                 ///   Modifier flags that the user specified in the source code
 233                 /// </summary>
 234                 private Modifiers mod_flags;
 235                 public Modifiers ModFlags {
 236                         set {
 237                                 mod_flags = value;
 238                                 if ((value & Modifiers.COMPILER_GENERATED) != 0)
 239                                         caching_flags = Flags.IsUsed | Flags.IsAssigned;
 240                         }
 241                         get {
 242                                 return mod_flags;
 243                         }
 244                 }
 245
 246                 public virtual ModuleContainer Module {
 247                         get {
 248                                 return Parent.Module;
 249                         }
 250                 }
 251
 252                 public /*readonly*/ TypeContainer Parent;
 253
 254                 /// <summary>
 255                 ///   Location where this declaration happens
 256                 /// </summary>
 257                 public Location Location {
 258                         get { return member_name.Location; }
 259                 }
 260
 261                 /// <summary>
 262                 ///   XML documentation comment
 263                 /// </summary>
 264                 protected string comment;
 265
 266                 /// <summary>
 267                 ///   Represents header string for documentation comment
 268                 ///   for each member types.
 269                 /// </summary>
 270                 public abstract string DocCommentHeader { get; }
 271
 272                 [Flags]
 273                 public enum Flags {
 274                         Obsolete_Undetected = 1,                // Obsolete attribute has not been detected yet
 275                         Obsolete = 1 << 1,                      // Type has obsolete attribute
 276                         ClsCompliance_Undetected = 1 << 2,      // CLS Compliance has not been detected yet
 277                         ClsCompliant = 1 << 3,                  // Type is CLS Compliant
 278                         CloseTypeCreated = 1 << 4,              // Tracks whether we have Closed the type
 279                         HasCompliantAttribute_Undetected = 1 << 5,      // Presence of CLSCompliantAttribute has not been detected
 280                         HasClsCompliantAttribute = 1 << 6,                      // Type has CLSCompliantAttribute
 281                         ClsCompliantAttributeFalse = 1 << 7,                    // Member has CLSCompliant(false)
 282                         Excluded_Undetected = 1 << 8,           // Conditional attribute has not been detected yet
 283                         Excluded = 1 << 9,                                      // Method is conditional
 284                         MethodOverloadsExist = 1 << 10,         // Test for duplication must be performed
 285                         IsUsed = 1 << 11,
 286                         IsAssigned = 1 << 12,                           // Field is assigned
 287                         HasExplicitLayout       = 1 << 13,
 288                         PartialDefinitionExists = 1 << 14,      // Set when corresponding partial method definition exists
 289                         HasStructLayout = 1 << 15,                      // Has StructLayoutAttribute
 290                         HasInstanceConstructor = 1 << 16,
 291                         HasUserOperators = 1 << 17,
 292                         CanBeReused = 1 << 18,
 293                         InterfacesExpanded = 1 << 19
 294                 }
 295
 296                 /// <summary>
 297                 ///   MemberCore flags at first detected then cached
 298                 /// </summary>
 299                 internal Flags caching_flags;
 300
 301                 protected MemberCore (TypeContainer parent, MemberName name, Attributes attrs)
 302                 {
 303                         this.Parent = parent;
 304                         member_name = name;
 305                         caching_flags = Flags.Obsolete_Undetected | Flags.ClsCompliance_Undetected | Flags.HasCompliantAttribute_Undetected | Flags.Excluded_Undetected;
 306                         AddAttributes (attrs, this);
 307                 }
 308
 309                 protected virtual void SetMemberName (MemberName new_name)
 310                 {
 311                         member_name = new_name;
 312                 }
 313
 314                 public virtual void Accept (StructuralVisitor visitor)
 315                 {
 316                         visitor.Visit (this);
 317                 }
 318
 319                 protected bool CheckAbstractAndExtern (bool has_block)
 320                 {
 321                         if (Parent.PartialContainer.Kind == MemberKind.Interface)
 322                                 return true;
 323
 324                         if (has_block) {
 325                                 if ((ModFlags & Modifiers.EXTERN) != 0) {
 326                                         Report.Error (179, Location, "`{0}' cannot declare a body because it is marked extern",
 327                                                 GetSignatureForError ());
 328                                         return false;
 329                                 }
 330
 331                                 if ((ModFlags & Modifiers.ABSTRACT) != 0) {
 332                                         Report.Error (500, Location, "`{0}' cannot declare a body because it is marked abstract",
 333                                                 GetSignatureForError ());
 334                                         return false;
 335                                 }
 336                         } else {
 337                                 if ((ModFlags & (Modifiers.ABSTRACT | Modifiers.EXTERN | Modifiers.PARTIAL)) == 0 && !(Parent is Delegate)) {
 338                                         if (Compiler.Settings.Version >= LanguageVersion.V_3) {
 339                                                 Property.PropertyMethod pm = this as Property.PropertyMethod;
 340                                                 if (pm is Indexer.GetIndexerMethod || pm is Indexer.SetIndexerMethod)
 341                                                         pm = null;
 342
 343                                                 if (pm != null && pm.Property.AccessorSecond == null) {
 344                                                         Report.Error (840, Location,
 345                                                                 "`{0}' must have a body because it is not marked abstract or extern. The property can be automatically implemented when you define both accessors",
 346                                                                 GetSignatureForError ());
 347                                                         return false;
 348                                                 }
 349                                         }
 350
 351                                         Report.Error (501, Location, "`{0}' must have a body because it is not marked abstract, extern, or partial",
 352                                                       GetSignatureForError ());
 353                                         return false;
 354                                 }
 355                         }
 356
 357                         return true;
 358                 }
 359
 360                 protected void CheckProtectedModifier ()
 361                 {
 362                         if ((ModFlags & Modifiers.PROTECTED) == 0)
 363                                 return;
 364
 365                         if (Parent.PartialContainer.Kind == MemberKind.Struct) {
 366                                 Report.Error (666, Location, "`{0}': Structs cannot contain protected members",
 367                                         GetSignatureForError ());
 368                                 return;
 369                         }
 370
 371                         if ((Parent.ModFlags & Modifiers.STATIC) != 0) {
 372                                 Report.Error (1057, Location, "`{0}': Static classes cannot contain protected members",
 373                                         GetSignatureForError ());
 374                                 return;
 375                         }
 376
 377                         if ((Parent.ModFlags & Modifiers.SEALED) != 0 && (ModFlags & Modifiers.OVERRIDE) == 0 &&
 378                                 !(this is Destructor)) {
 379                                 Report.Warning (628, 4, Location, "`{0}': new protected member declared in sealed class",
 380                                         GetSignatureForError ());
 381                                 return;
 382                         }
 383                 }
 384
 385                 public abstract bool Define ();
 386
 387                 public virtual string DocComment {
 388                         get {
 389                                 return comment;
 390                         }
 391                         set {
 392                                 comment = value;
 393                         }
 394                 }
 395
 396                 //
 397                 // Returns full member name for error message
 398                 //
 399                 public virtual string GetSignatureForError ()
 400                 {
 401                         var parent = Parent.GetSignatureForError ();
 402                         if (parent == null)
 403                                 return member_name.GetSignatureForError ();
 404
 405                         return parent + "." + member_name.GetSignatureForError ();
 406                 }
 407
 408                 /// <summary>
 409                 /// Base Emit method. This is also entry point for CLS-Compliant verification.
 410                 /// </summary>
 411                 public virtual void Emit ()
 412                 {
 413                         if (!Compiler.Settings.VerifyClsCompliance)
 414                                 return;
 415
 416                         VerifyClsCompliance ();
 417                 }
 418
 419                 public bool IsAvailableForReuse {
 420                         get {
 421                                 return (caching_flags & Flags.CanBeReused) != 0;
 422                         }
 423                         set {
 424                                 caching_flags = value ? (caching_flags | Flags.CanBeReused) : (caching_flags & ~Flags.CanBeReused);
 425                         }
 426                 }
 427
 428                 public bool IsCompilerGenerated {
 429                         get     {
 430                                 if ((mod_flags & Modifiers.COMPILER_GENERATED) != 0)
 431                                         return true;
 432
 433                                 return Parent != null && Parent.IsCompilerGenerated;
 434                         }
 435                 }
 436
 437                 public bool IsImported {
 438                         get {
 439                                 return false;
 440                         }
 441                 }
 442
 443                 public virtual bool IsUsed {
 444                         get {
 445                                 return (caching_flags & Flags.IsUsed) != 0;
 446                         }
 447                 }
 448
 449                 protected Report Report {
 450                         get {
 451                                 return Compiler.Report;
 452                         }
 453                 }
 454
 455                 public void SetIsUsed ()
 456                 {
 457                         caching_flags |= Flags.IsUsed;
 458                 }
 459
 460                 public void SetIsAssigned ()
 461                 {
 462                         caching_flags |= Flags.IsAssigned;
 463                 }
 464
 465                 public virtual void SetConstraints (List<Constraints> constraints_list)
 466                 {
 467                         var tparams = member_name.TypeParameters;
 468                         if (tparams == null) {
 469                                 Report.Error (80, Location, "Constraints are not allowed on non-generic declarations");
 470                                 return;
 471                         }
 472
 473                         foreach (var c in constraints_list) {
 474                                 var tp = tparams.Find (c.TypeParameter.Value);
 475                                 if (tp == null) {
 476                                         Report.Error (699, c.Location, "`{0}': A constraint references nonexistent type parameter `{1}'",
 477                                                 GetSignatureForError (), c.TypeParameter.Value);
 478                                         continue;
 479                                 }
 480
 481                                 tp.Constraints = c;
 482                         }
 483                 }
 484
 485                 /// <summary>
 486                 /// Returns instance of ObsoleteAttribute for this MemberCore
 487                 /// </summary>
 488                 public virtual ObsoleteAttribute GetAttributeObsolete ()
 489                 {
 490                         if ((caching_flags & (Flags.Obsolete_Undetected | Flags.Obsolete)) == 0)
 491                                 return null;
 492
 493                         caching_flags &= ~Flags.Obsolete_Undetected;
 494
 495                         if (OptAttributes == null)
 496                                 return null;
 497
 498                         Attribute obsolete_attr = OptAttributes.Search (Module.PredefinedAttributes.Obsolete);
 499                         if (obsolete_attr == null)
 500                                 return null;
 501
 502                         caching_flags |= Flags.Obsolete;
 503
 504                         ObsoleteAttribute obsolete = obsolete_attr.GetObsoleteAttribute ();
 505                         if (obsolete == null)
 506                                 return null;
 507
 508                         return obsolete;
 509                 }
 510
 511                 /// <summary>
 512                 /// Checks for ObsoleteAttribute presence. It's used for testing of all non-types elements
 513                 /// </summary>
 514                 public virtual void CheckObsoleteness (Location loc)
 515                 {
 516                         ObsoleteAttribute oa = GetAttributeObsolete ();
 517                         if (oa != null)
 518                                 AttributeTester.Report_ObsoleteMessage (oa, GetSignatureForError (), loc, Report);
 519                 }
 520
 521                 //
 522                 // Checks whether the type P is as accessible as this member
 523                 //
 524                 public bool IsAccessibleAs (TypeSpec p)
 525                 {
 526                         //
 527                         // if M is private, its accessibility is the same as this declspace.
 528                         // we already know that P is accessible to T before this method, so we
 529                         // may return true.
 530                         //
 531                         if ((mod_flags & Modifiers.PRIVATE) != 0)
 532                                 return true;
 533
 534                         while (TypeManager.HasElementType (p))
 535                                 p = TypeManager.GetElementType (p);
 536
 537                         if (p.IsGenericParameter)
 538                                 return true;
 539
 540                         for (TypeSpec p_parent; p != null; p = p_parent) {
 541                                 p_parent = p.DeclaringType;
 542
 543                                 if (p.IsGeneric) {
 544                                         foreach (TypeSpec t in p.TypeArguments) {
 545                                                 if (!IsAccessibleAs (t))
 546                                                         return false;
 547                                         }
 548                                 }
 549
 550                                 var pAccess = p.Modifiers & Modifiers.AccessibilityMask;
 551                                 if (pAccess == Modifiers.PUBLIC)
 552                                         continue;
 553
 554                                 bool same_access_restrictions = false;
 555                                 for (MemberCore mc = this; !same_access_restrictions && mc != null && mc.Parent != null; mc = mc.Parent) {
 556                                         var al = mc.ModFlags & Modifiers.AccessibilityMask;
 557                                         switch (pAccess) {
 558                                         case Modifiers.INTERNAL:
 559                                                 if (al == Modifiers.PRIVATE || al == Modifiers.INTERNAL)
 560                                                         same_access_restrictions = p.MemberDefinition.IsInternalAsPublic (mc.Module.DeclaringAssembly);
 561
 562                                                 break;
 563
 564                                         case Modifiers.PROTECTED:
 565                                                 if (al == Modifiers.PROTECTED) {
 566                                                         same_access_restrictions = mc.Parent.PartialContainer.IsBaseTypeDefinition (p_parent);
 567                                                         break;
 568                                                 }
 569
 570                                                 if (al == Modifiers.PRIVATE) {
 571                                                         //
 572                                                         // When type is private and any of its parents derives from
 573                                                         // protected type then the type is accessible
 574                                                         //
 575                                                         while (mc.Parent != null && mc.Parent.PartialContainer != null) {
 576                                                                 if (mc.Parent.PartialContainer.IsBaseTypeDefinition (p_parent)) {
 577                                                                         same_access_restrictions = true;
 578                                                                         break;
 579                                                                 }
 580
 581                                                                 mc = mc.Parent;
 582                                                         }
 583                                                 }
 584
 585                                                 break;
 586
 587                                         case Modifiers.PROTECTED | Modifiers.INTERNAL:
 588                                                 if (al == Modifiers.INTERNAL)
 589                                                         same_access_restrictions = p.MemberDefinition.IsInternalAsPublic (mc.Module.DeclaringAssembly);
 590                                                 else if (al == (Modifiers.PROTECTED | Modifiers.INTERNAL))
 591                                                         same_access_restrictions = mc.Parent.PartialContainer.IsBaseTypeDefinition (p_parent) && p.MemberDefinition.IsInternalAsPublic (mc.Module.DeclaringAssembly);
 592                                                 else if (al == Modifiers.PROTECTED)
 593                                                         goto case Modifiers.PROTECTED;
 594                                                 else if (al == Modifiers.PRIVATE) {
 595                                                         if (p.MemberDefinition.IsInternalAsPublic (mc.Module.DeclaringAssembly)) {
 596                                                                 same_access_restrictions = true;
 597                                                         } else {
 598                                                                 goto case Modifiers.PROTECTED;
 599                                                         }
 600                                                 }
 601
 602                                                 break;
 603
 604                                         case Modifiers.PRIVATE:
 605                                                 //
 606                                                 // Both are private and share same parent
 607                                                 //
 608                                                 if (al == Modifiers.PRIVATE) {
 609                                                         var decl = mc.Parent;
 610                                                         do {
 611                                                                 same_access_restrictions = decl.CurrentType.MemberDefinition == p_parent.MemberDefinition;
 612                                                         } while (!same_access_restrictions && !decl.PartialContainer.IsTopLevel && (decl = decl.Parent) != null);
 613                                                 }
 614
 615                                                 break;
 616
 617                                         default:
 618                                                 throw new InternalErrorException (al.ToString ());
 619                                         }
 620                                 }
 621
 622                                 if (!same_access_restrictions)
 623                                         return false;
 624                         }
 625
 626                         return true;
 627                 }
 628
 629                 /// <summary>
 630                 /// Analyze whether CLS-Compliant verification must be execute for this MemberCore.
 631                 /// </summary>
 632                 public override bool IsClsComplianceRequired ()
 633                 {
 634                         if ((caching_flags & Flags.ClsCompliance_Undetected) == 0)
 635                                 return (caching_flags & Flags.ClsCompliant) != 0;
 636
 637                         caching_flags &= ~Flags.ClsCompliance_Undetected;
 638
 639                         if (HasClsCompliantAttribute) {
 640                                 if ((caching_flags & Flags.ClsCompliantAttributeFalse) != 0)
 641                                         return false;
 642
 643                                 caching_flags |= Flags.ClsCompliant;
 644                                 return true;
 645                         }
 646
 647                         if (Parent.IsClsComplianceRequired ()) {
 648                                 caching_flags |= Flags.ClsCompliant;
 649                                 return true;
 650                         }
 651
 652                         return false;
 653                 }
 654
 655                 public virtual string[] ConditionalConditions ()
 656                 {
 657                         return null;
 658                 }
 659
 660                 /// <summary>
 661                 /// Returns true when MemberCore is exposed from assembly.
 662                 /// </summary>
 663                 public bool IsExposedFromAssembly ()
 664                 {
 665                         if ((ModFlags & (Modifiers.PUBLIC | Modifiers.PROTECTED)) == 0)
 666                                 return this is NamespaceContainer;
 667
 668                         var parentContainer = Parent.PartialContainer;
 669                         while (parentContainer != null) {
 670                                 if ((parentContainer.ModFlags & (Modifiers.PUBLIC | Modifiers.PROTECTED)) == 0)
 671                                         return false;
 672
 673                                 parentContainer = parentContainer.Parent.PartialContainer;
 674                         }
 675
 676                         return true;
 677                 }
 678
 679                 //
 680                 // Does extension methods look up to find a method which matches name and extensionType.
 681                 // Search starts from this namespace and continues hierarchically up to top level.
 682                 //
 683                 public ExtensionMethodCandidates LookupExtensionMethod (string name, int arity)
 684                 {
 685                         var m = Parent;
 686                         do {
 687                                 var ns = m as NamespaceContainer;
 688                                 if (ns != null)
 689                                         return ns.LookupExtensionMethod (this, name, arity, 0);
 690
 691                                 m = m.Parent;
 692                         } while (m != null);
 693
 694                         return null;
 695                 }
 696
 697                 public virtual FullNamedExpression LookupNamespaceAlias (string name)
 698                 {
 699                         return Parent.LookupNamespaceAlias (name);
 700                 }
 701
 702                 public virtual FullNamedExpression LookupNamespaceOrType (string name, int arity, LookupMode mode, Location loc)
 703                 {
 704                         return Parent.LookupNamespaceOrType (name, arity, mode, loc);
 705                 }
 706
 707                 /// <summary>
 708                 /// Goes through class hierarchy and gets value of first found CLSCompliantAttribute.
 709                 /// If no is attribute exists then assembly CLSCompliantAttribute is returned.
 710                 /// </summary>
 711                 public bool? CLSAttributeValue {
 712                         get {
 713                                 if ((caching_flags & Flags.HasCompliantAttribute_Undetected) == 0) {
 714                                         if ((caching_flags & Flags.HasClsCompliantAttribute) == 0)
 715                                                 return null;
 716
 717                                         return (caching_flags & Flags.ClsCompliantAttributeFalse) == 0;
 718                                 }
 719
 720                                 caching_flags &= ~Flags.HasCompliantAttribute_Undetected;
 721
 722                                 if (OptAttributes != null) {
 723                                         Attribute cls_attribute = OptAttributes.Search (Module.PredefinedAttributes.CLSCompliant);
 724                                         if (cls_attribute != null) {
 725                                                 caching_flags |= Flags.HasClsCompliantAttribute;
 726                                                 if (cls_attribute.GetClsCompliantAttributeValue ())
 727                                                         return true;
 728
 729                                                 caching_flags |= Flags.ClsCompliantAttributeFalse;
 730                                                 return false;
 731                                         }
 732                                 }
 733
 734                                 return null;
 735                         }
 736                 }
 737
 738                 /// <summary>
 739                 /// Returns true if MemberCore is explicitly marked with CLSCompliantAttribute
 740                 /// </summary>
 741                 protected bool HasClsCompliantAttribute {
 742                         get {
 743                                 return CLSAttributeValue.HasValue;
 744                         }
 745                 }
 746
 747                 /// <summary>
 748                 /// Returns true when a member supports multiple overloads (methods, indexers, etc)
 749                 /// </summary>
 750                 public virtual bool EnableOverloadChecks (MemberCore overload)
 751                 {
 752                         return false;
 753                 }
 754
 755                 /// <summary>
 756                 /// The main virtual method for CLS-Compliant verifications.
 757                 /// The method returns true if member is CLS-Compliant and false if member is not
 758                 /// CLS-Compliant which means that CLS-Compliant tests are not necessary. A descendants override it
 759                 /// and add their extra verifications.
 760                 /// </summary>
 761                 protected virtual bool VerifyClsCompliance ()
 762                 {
 763                         if (HasClsCompliantAttribute) {
 764                                 if (!Module.DeclaringAssembly.HasCLSCompliantAttribute) {
 765                                         Attribute a = OptAttributes.Search (Module.PredefinedAttributes.CLSCompliant);
 766                                         if ((caching_flags & Flags.ClsCompliantAttributeFalse) != 0) {
 767                                                 Report.Warning (3021, 2, a.Location,
 768                                                         "`{0}' does not need a CLSCompliant attribute because the assembly is not marked as CLS-compliant",
 769                                                         GetSignatureForError ());
 770                                         } else {
 771                                                 Report.Warning (3014, 1, a.Location,
 772                                                         "`{0}' cannot be marked as CLS-compliant because the assembly is not marked as CLS-compliant",
 773                                                         GetSignatureForError ());
 774                                         }
 775                                         return false;
 776                                 }
 777
 778                                 if (!IsExposedFromAssembly ()) {
 779                                         Attribute a = OptAttributes.Search (Module.PredefinedAttributes.CLSCompliant);
 780                                         Report.Warning (3019, 2, a.Location, "CLS compliance checking will not be performed on `{0}' because it is not visible from outside this assembly", GetSignatureForError ());
 781                                         return false;
 782                                 }
 783
 784                                 if ((caching_flags & Flags.ClsCompliantAttributeFalse) != 0) {
 785                                         if (Parent is Interface && Parent.IsClsComplianceRequired ()) {
 786                                                 Report.Warning (3010, 1, Location, "`{0}': CLS-compliant interfaces must have only CLS-compliant members", GetSignatureForError ());
 787                                         } else if (Parent.Kind == MemberKind.Class && (ModFlags & Modifiers.ABSTRACT) != 0 && Parent.IsClsComplianceRequired ()) {
 788                                                 Report.Warning (3011, 1, Location, "`{0}': only CLS-compliant members can be abstract", GetSignatureForError ());
 789                                         }
 790
 791                                         return false;
 792                                 }
 793
 794                                 if (Parent.Kind != MemberKind.Namespace && Parent.Kind != 0 && !Parent.IsClsComplianceRequired ()) {
 795                                         Attribute a = OptAttributes.Search (Module.PredefinedAttributes.CLSCompliant);
 796                                         Report.Warning (3018, 1, a.Location, "`{0}' cannot be marked as CLS-compliant because it is a member of non CLS-compliant type `{1}'",
 797                                                 GetSignatureForError (), Parent.GetSignatureForError ());
 798                                         return false;
 799                                 }
 800                         } else {
 801                                 if (!IsExposedFromAssembly ())
 802                                         return false;
 803
 804                                 if (!Parent.IsClsComplianceRequired ())
 805                                         return false;
 806                         }
 807
 808                         if (member_name.Name [0] == '_') {
 809                                 Warning_IdentifierNotCompliant ();
 810                         }
 811
 812                         if (member_name.TypeParameters != null)
 813                                 member_name.TypeParameters.VerifyClsCompliance ();
 814
 815                         return true;
 816                 }
 817
 818                 protected void Warning_IdentifierNotCompliant ()
 819                 {
 820                         Report.Warning (3008, 1, MemberName.Location, "Identifier `{0}' is not CLS-compliant", GetSignatureForError ());
 821                 }
 822
 823                 public virtual string GetCallerMemberName ()
 824                 {
 825                         return MemberName.Name;
 826                 }
 827
 828                 //
 829                 // Returns a string that represents the signature for this
 830                 // member which should be used in XML documentation.
 831                 //
 832                 public abstract string GetSignatureForDocumentation ();
 833
 834                 public virtual void GetCompletionStartingWith (string prefix, List<string> results)
 835                 {
 836                         Parent.GetCompletionStartingWith (prefix, results);
 837                 }
 838
 839                 //
 840                 // Generates xml doc comments (if any), and if required,
 841                 // handle warning report.
 842                 //
 843                 internal virtual void GenerateDocComment (DocumentationBuilder builder)
 844                 {
 845                         if (DocComment == null) {
 846                                 if (IsExposedFromAssembly ()) {
 847                                         Constructor c = this as Constructor;
 848                                         if (c == null || !c.IsDefault ())
 849                                                 Report.Warning (1591, 4, Location,
 850                                                         "Missing XML comment for publicly visible type or member `{0}'", GetSignatureForError ());
 851                                 }
 852
 853                                 return;
 854                         }
 855
 856                         try {
 857                                 builder.GenerateDocumentationForMember (this);
 858                         } catch (Exception e) {
 859                                 throw new InternalErrorException (this, e);
 860                         }
 861                 }
 862
 863                 public virtual void WriteDebugSymbol (MonoSymbolFile file)
 864                 {
 865                 }
 866
 867                 #region IMemberContext Members
 868
 869                 public virtual CompilerContext Compiler {
 870                         get {
 871                                 return Module.Compiler;
 872                         }
 873                 }
 874
 875                 public virtual TypeSpec CurrentType {
 876                         get { return Parent.CurrentType; }
 877                 }
 878
 879                 public MemberCore CurrentMemberDefinition {
 880                         get { return this; }
 881                 }
 882
 883                 public virtual TypeParameters CurrentTypeParameters {
 884                         get { return null; }
 885                 }
 886
 887                 public bool IsObsolete {
 888                         get {
 889                                 if (GetAttributeObsolete () != null)
 890                                         return true;
 891
 892                                 return Parent != null && Parent.IsObsolete;
 893                         }
 894                 }
 895
 896                 public bool IsUnsafe {
 897                         get {
 898                                 if ((ModFlags & Modifiers.UNSAFE) != 0)
 899                                         return true;
 900
 901                                 return Parent != null && Parent.IsUnsafe;
 902                         }
 903                 }
 904
 905                 public bool IsStatic {
 906                         get {
 907                                 return (ModFlags & Modifiers.STATIC) != 0;
 908                         }
 909                 }
 910
 911                 #endregion
 912         }
 913
 914         //
 915         // Base member specification. A member specification contains
 916         // member details which can alter in the context (e.g. generic instances)
 917         //
 918         public abstract class MemberSpec
 919         {
 920                 [Flags]
 921                 public enum StateFlags
 922                 {
 923                         Obsolete_Undetected = 1,        // Obsolete attribute has not been detected yet
 924                         Obsolete = 1 << 1,                      // Member has obsolete attribute
 925                         CLSCompliant_Undetected = 1 << 2,       // CLSCompliant attribute has not been detected yet
 926                         CLSCompliant = 1 << 3,          // Member is CLS Compliant
 927                         MissingDependency_Undetected = 1 << 4,
 928                         MissingDependency = 1 << 5,
 929                         HasDynamicElement = 1 << 6,
 930                         ConstraintsChecked = 1 << 7,
 931
 932                         IsAccessor = 1 << 9,            // Method is an accessor
 933                         IsGeneric = 1 << 10,            // Member contains type arguments
 934
 935                         PendingMetaInflate = 1 << 12,
 936                         PendingMakeMethod = 1 << 13,
 937                         PendingMemberCacheMembers = 1 << 14,
 938                         PendingBaseTypeInflate = 1 << 15,
 939                         InterfacesExpanded = 1 << 16,
 940                         IsNotCSharpCompatible = 1 << 17,
 941                         SpecialRuntimeType = 1 << 18,
 942                         InflatedExpressionType = 1 << 19,
 943                         InflatedNullableType = 1 << 20,
 944                         GenericIterateInterface = 1 << 21,
 945                         GenericTask = 1 << 22,
 946                         InterfacesImported = 1 << 23,
 947                 }
 948
 949                 //
 950                 // Some flags can be copied directly from other member
 951                 //
 952                 protected const StateFlags SharedStateFlags =
 953                         StateFlags.CLSCompliant | StateFlags.CLSCompliant_Undetected |
 954                         StateFlags.Obsolete | StateFlags.Obsolete_Undetected |
 955                         StateFlags.MissingDependency | StateFlags.MissingDependency_Undetected |
 956                         StateFlags.HasDynamicElement;
 957
 958                 protected Modifiers modifiers;
 959                 public StateFlags state;
 960                 protected IMemberDefinition definition;
 961                 public readonly MemberKind Kind;
 962                 protected TypeSpec declaringType;
 963
 964 #if DEBUG
 965                 static int counter;
 966                 public int ID = counter++;
 967 #endif
 968
 969                 protected MemberSpec (MemberKind kind, TypeSpec declaringType, IMemberDefinition definition, Modifiers modifiers)
 970                 {
 971                         this.Kind = kind;
 972                         this.declaringType = declaringType;
 973                         this.definition = definition;
 974                         this.modifiers = modifiers;
 975
 976                         if (kind == MemberKind.MissingType)
 977                                 state = StateFlags.MissingDependency;
 978                         else
 979                                 state = StateFlags.Obsolete_Undetected | StateFlags.CLSCompliant_Undetected | StateFlags.MissingDependency_Undetected;
 980                 }
 981
 982                 #region Properties
 983
 984                 public virtual int Arity {
 985                         get {
 986                                 return 0;
 987                         }
 988                 }
 989
 990                 public TypeSpec DeclaringType {
 991                         get {
 992                                 return declaringType;
 993                         }
 994                         set {
 995                                 declaringType = value;
 996                         }
 997                 }
 998
 999                 public IMemberDefinition MemberDefinition {
1000                         get {
1001                                 return definition;
1002                         }
1003                 }
1004
1005                 public Modifiers Modifiers {
1006                         get {
1007                                 return modifiers;
1008                         }
1009                         set {
1010                                 modifiers = value;
1011                         }
1012                 }
1013
1014                 public virtual string Name {
1015                         get {
1016                                 return definition.Name;
1017                         }
1018                 }
1019
1020                 public bool IsAbstract {
1021                         get { return (modifiers & Modifiers.ABSTRACT) != 0; }
1022                 }
1023
1024                 public bool IsAccessor {
1025                         get {
1026                                 return (state & StateFlags.IsAccessor) != 0;
1027                         }
1028                         set {
1029                                 state = value ? state | StateFlags.IsAccessor : state & ~StateFlags.IsAccessor;
1030                         }
1031                 }
1032
1033                 //
1034                 // Return true when this member is a generic in C# terms
1035                 // A nested non-generic type of generic type will return false
1036                 //
1037                 public bool IsGeneric {
1038                         get {
1039                                 return (state & StateFlags.IsGeneric) != 0;
1040                         }
1041                         set {
1042                                 state = value ? state | StateFlags.IsGeneric : state & ~StateFlags.IsGeneric;
1043                         }
1044                 }
1045
1046                 //
1047                 // Returns true for imported members which are not compatible with C# language
1048                 //
1049                 public bool IsNotCSharpCompatible {
1050                         get {
1051                                 return (state & StateFlags.IsNotCSharpCompatible) != 0;
1052                         }
1053                         set {
1054                                 state = value ? state | StateFlags.IsNotCSharpCompatible : state & ~StateFlags.IsNotCSharpCompatible;
1055                         }
1056                 }
1057
1058                 public bool IsPrivate {
1059                         get { return (modifiers & Modifiers.PRIVATE) != 0; }
1060                 }
1061
1062                 public bool IsPublic {
1063                         get { return (modifiers & Modifiers.PUBLIC) != 0; }
1064                 }
1065
1066                 public bool IsStatic {
1067                         get {
1068                                 return (modifiers & Modifiers.STATIC) != 0;
1069                         }
1070                 }
1071
1072                 #endregion
1073
1074                 public virtual ObsoleteAttribute GetAttributeObsolete ()
1075                 {
1076                         if ((state & (StateFlags.Obsolete | StateFlags.Obsolete_Undetected)) == 0)
1077                                 return null;
1078
1079                         state &= ~StateFlags.Obsolete_Undetected;
1080
1081                         var oa = definition.GetAttributeObsolete ();
1082                         if (oa != null)
1083                                 state |= StateFlags.Obsolete;
1084
1085                         return oa;
1086                 }
1087
1088                 //
1089                 // Returns a list of missing dependencies of this member. The list
1090                 // will contain types only but it can have numerous values for members
1091                 // like methods where both return type and all parameters are checked
1092                 //
1093                 public List<MissingTypeSpecReference> GetMissingDependencies ()
1094                 {
1095                         return GetMissingDependencies (this);
1096                 }
1097
1098                 public List<MissingTypeSpecReference> GetMissingDependencies (MemberSpec caller)
1099                 {
1100                         if ((state & (StateFlags.MissingDependency | StateFlags.MissingDependency_Undetected)) == 0)
1101                                 return null;
1102
1103                         state &= ~StateFlags.MissingDependency_Undetected;
1104
1105                         var imported = definition as ImportedDefinition;
1106                         List<MissingTypeSpecReference> missing;
1107                         if (imported != null) {
1108                                 missing = ResolveMissingDependencies (caller);
1109                         } else if (this is ElementTypeSpec) {
1110                                 missing = ((ElementTypeSpec) this).Element.GetMissingDependencies (caller);
1111                         } else {
1112                                 missing = null;
1113                         }
1114
1115                         if (missing != null) {
1116                                 state |= StateFlags.MissingDependency;
1117                         }
1118
1119                         return missing;
1120                 }
1121
1122                 public abstract List<MissingTypeSpecReference> ResolveMissingDependencies (MemberSpec caller);
1123
1124                 protected virtual bool IsNotCLSCompliant (out bool attrValue)
1125                 {
1126                         var cls = MemberDefinition.CLSAttributeValue;
1127                         attrValue = cls ?? false;
1128                         return cls == false;
1129                 }
1130
1131                 public virtual string GetSignatureForDocumentation ()
1132                 {
1133                         return DeclaringType.GetSignatureForDocumentation () + "." + Name;
1134                 }
1135
1136                 public virtual string GetSignatureForError ()
1137                 {
1138                         var bf = MemberDefinition as Property.BackingFieldDeclaration;
1139                         string name;
1140                         if (bf == null) {
1141                                 name = Name;
1142                         } else {
1143                                 name = bf.OriginalProperty.MemberName.Name;
1144                         }
1145
1146                         return DeclaringType.GetSignatureForError () + "." + name;
1147                 }
1148
1149                 public virtual MemberSpec InflateMember (TypeParameterInflator inflator)
1150                 {
1151                         var inflated = (MemberSpec) MemberwiseClone ();
1152                         inflated.declaringType = inflator.TypeInstance;
1153                         if (DeclaringType.IsGenericOrParentIsGeneric)
1154                                 inflated.state |= StateFlags.PendingMetaInflate;
1155 #if DEBUG
1156                         inflated.ID += 1000000;
1157 #endif
1158                         return inflated;
1159                 }
1160
1161                 //
1162                 // Is this member accessible from invocation context
1163                 //
1164                 public bool IsAccessible (IMemberContext ctx)
1165                 {
1166                         var ma = Modifiers & Modifiers.AccessibilityMask;
1167                         if (ma == Modifiers.PUBLIC)
1168                                 return true;
1169
1170                         var parentType = /* this as TypeSpec ?? */ DeclaringType;
1171                         var ctype = ctx.CurrentType;
1172
1173                         if (ma == Modifiers.PRIVATE) {
1174                                 if (ctype == null || parentType == null)
1175                                         return false;
1176                                 //
1177                                 // It's only accessible to the current class or children
1178                                 //
1179                                 if (parentType.MemberDefinition == ctype.MemberDefinition)
1180                                         return true;
1181
1182                                 return TypeManager.IsNestedChildOf (ctype, parentType.MemberDefinition);
1183                         }
1184
1185                         if ((ma & Modifiers.INTERNAL) != 0) {
1186                                 bool b;
1187                                 var assembly = ctype == null ? ctx.Module.DeclaringAssembly : ctype.MemberDefinition.DeclaringAssembly;
1188
1189                                 if (parentType == null) {
1190                                         b = ((ITypeDefinition) MemberDefinition).IsInternalAsPublic (assembly);
1191                                 } else {
1192                                         b = DeclaringType.MemberDefinition.IsInternalAsPublic (assembly);
1193                                 }
1194
1195                                 if (b || ma == Modifiers.INTERNAL)
1196                                         return b;
1197                         }
1198
1199                         //
1200                         // Checks whether `ctype' is a subclass or nested child of `parentType'.
1201                         //
1202                         while (ctype != null) {
1203                                 if (TypeManager.IsFamilyAccessible (ctype, parentType))
1204                                         return true;
1205
1206                                 // Handle nested types.
1207                                 ctype = ctype.DeclaringType;    // TODO: Untested ???
1208                         }
1209
1210                         return false;
1211                 }
1212
1213                 //
1214                 // Returns member CLS compliance based on full member hierarchy
1215                 //
1216                 public bool IsCLSCompliant ()
1217                 {
1218                         if ((state & StateFlags.CLSCompliant_Undetected) != 0) {
1219                                 state &= ~StateFlags.CLSCompliant_Undetected;
1220
1221                                 bool compliant;
1222                                 if (IsNotCLSCompliant (out compliant))
1223                                         return false;
1224
1225                                 if (!compliant) {
1226                                         if (DeclaringType != null) {
1227                                                 compliant = DeclaringType.IsCLSCompliant ();
1228                                         } else {
1229                                                 compliant = ((ITypeDefinition) MemberDefinition).DeclaringAssembly.IsCLSCompliant;
1230                                         }
1231                                 }
1232
1233                                 if (compliant)
1234                                         state |= StateFlags.CLSCompliant;
1235                         }
1236
1237                         return (state & StateFlags.CLSCompliant) != 0;
1238                 }
1239
1240                 public bool IsConditionallyExcluded (IMemberContext ctx)
1241                 {
1242                         if ((Kind & (MemberKind.Class | MemberKind.Method)) == 0)
1243                                 return false;
1244
1245                         var conditions = MemberDefinition.ConditionalConditions ();
1246                         if (conditions == null)
1247                                 return false;
1248
1249                         var m = ctx.CurrentMemberDefinition;
1250                         CompilationSourceFile unit = null;
1251                         while (m != null && unit == null) {
1252                                 unit = m as CompilationSourceFile;
1253                                 m = m.Parent;
1254                         }
1255
1256                         if (unit != null) {
1257                                 foreach (var condition in conditions) {
1258                                         if (unit.IsConditionalDefined (condition))
1259                                                 return false;
1260                                 }
1261                         }
1262
1263                         return true;
1264                 }
1265
1266                 public override string ToString ()
1267                 {
1268                         return GetSignatureForError ();
1269                 }
1270         }
1271
1272         //
1273         // Member details which are same between all member
1274         // specifications
1275         //
1276         public interface IMemberDefinition
1277         {
1278                 bool? CLSAttributeValue { get; }
1279                 string Name { get; }
1280                 bool IsImported { get; }
1281
1282                 string[] ConditionalConditions ();
1283                 ObsoleteAttribute GetAttributeObsolete ();
1284                 void SetIsAssigned ();
1285                 void SetIsUsed ();
1286         }
1287
1288         public interface IMethodDefinition : IMemberDefinition
1289         {
1290                 MethodBase Metadata { get; }
1291         }
1292
1293         public interface IParametersMember : IInterfaceMemberSpec
1294         {
1295                 AParametersCollection Parameters { get; }
1296         }
1297
1298         public interface IInterfaceMemberSpec
1299         {
1300                 TypeSpec MemberType { get; }
1301         }
1302 }