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 MOBILE
  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                 //
 512                 // Checks whether the type P is as accessible as this member
 513                 //
 514                 public bool IsAccessibleAs (TypeSpec p)
 515                 {
 516                         //
 517                         // if M is private, its accessibility is the same as this declspace.
 518                         // we already know that P is accessible to T before this method, so we
 519                         // may return true.
 520                         //
 521                         if ((mod_flags & Modifiers.PRIVATE) != 0)
 522                                 return true;
 523
 524                         while (TypeManager.HasElementType (p))
 525                                 p = TypeManager.GetElementType (p);
 526
 527                         if (p.BuiltinType != BuiltinTypeSpec.Type.None)
 528                                 return true;
 529
 530                         if (p.IsGenericParameter)
 531                                 return true;
 532
 533                         for (TypeSpec p_parent; p != null; p = p_parent) {
 534                                 p_parent = p.DeclaringType;
 535
 536                                 if (p.IsGeneric) {
 537                                         foreach (TypeSpec t in p.TypeArguments) {
 538                                                 if (!IsAccessibleAs (t))
 539                                                         return false;
 540                                         }
 541                                 }
 542
 543                                 var pAccess = p.Modifiers & Modifiers.AccessibilityMask;
 544                                 if (pAccess == Modifiers.PUBLIC)
 545                                         continue;
 546
 547                                 bool same_access_restrictions = false;
 548                                 for (MemberCore mc = this; !same_access_restrictions && mc != null && mc.Parent != null; mc = mc.Parent) {
 549                                         var tc = mc as TypeContainer;
 550                                         if (tc != null && tc.PartialContainer != null)
 551                                                 mc = tc.PartialContainer;
 552
 553                                         var al = mc.ModFlags & Modifiers.AccessibilityMask;
 554                                         switch (pAccess) {
 555                                         case Modifiers.INTERNAL:
 556                                                 if (al == Modifiers.PRIVATE || al == Modifiers.INTERNAL)
 557                                                         same_access_restrictions = p.MemberDefinition.IsInternalAsPublic (mc.Module.DeclaringAssembly);
 558
 559                                                 break;
 560
 561                                         case Modifiers.PROTECTED:
 562                                                 if (al == Modifiers.PROTECTED) {
 563                                                         same_access_restrictions = mc.Parent.PartialContainer.IsBaseTypeDefinition (p_parent);
 564                                                         break;
 565                                                 }
 566
 567                                                 if (al == Modifiers.PRIVATE) {
 568                                                         //
 569                                                         // When type is private and any of its parents derives from
 570                                                         // protected type then the type is accessible
 571                                                         //
 572                                                         while (mc.Parent != null && mc.Parent.PartialContainer != null) {
 573                                                                 if (mc.Parent.PartialContainer.IsBaseTypeDefinition (p_parent)) {
 574                                                                         same_access_restrictions = true;
 575                                                                         break;
 576                                                                 }
 577
 578                                                                 mc = mc.Parent;
 579                                                         }
 580                                                 }
 581
 582                                                 break;
 583
 584                                         case Modifiers.PROTECTED | Modifiers.INTERNAL:
 585                                                 if (al == Modifiers.INTERNAL)
 586                                                         same_access_restrictions = p.MemberDefinition.IsInternalAsPublic (mc.Module.DeclaringAssembly);
 587                                                 else if (al == (Modifiers.PROTECTED | Modifiers.INTERNAL))
 588                                                         same_access_restrictions = mc.Parent.PartialContainer.IsBaseTypeDefinition (p_parent) && p.MemberDefinition.IsInternalAsPublic (mc.Module.DeclaringAssembly);
 589                                                 else if (al == Modifiers.PROTECTED)
 590                                                         goto case Modifiers.PROTECTED;
 591                                                 else if (al == Modifiers.PRIVATE) {
 592                                                         if (p.MemberDefinition.IsInternalAsPublic (mc.Module.DeclaringAssembly)) {
 593                                                                 same_access_restrictions = true;
 594                                                         } else {
 595                                                                 goto case Modifiers.PROTECTED;
 596                                                         }
 597                                                 }
 598
 599                                                 break;
 600
 601                                         case Modifiers.PRIVATE:
 602                                                 //
 603                                                 // Both are private and share same parent
 604                                                 //
 605                                                 if (al == Modifiers.PRIVATE) {
 606                                                         var decl = mc.Parent;
 607                                                         do {
 608                                                                 same_access_restrictions = decl.CurrentType.MemberDefinition == p_parent.MemberDefinition;
 609                                                         } while (!same_access_restrictions && !decl.PartialContainer.IsTopLevel && (decl = decl.Parent) != null);
 610                                                 }
 611
 612                                                 break;
 613
 614                                         default:
 615                                                 throw new InternalErrorException (al.ToString ());
 616                                         }
 617                                 }
 618
 619                                 if (!same_access_restrictions)
 620                                         return false;
 621                         }
 622
 623                         return true;
 624                 }
 625
 626                 /// <summary>
 627                 /// Analyze whether CLS-Compliant verification must be execute for this MemberCore.
 628                 /// </summary>
 629                 public override bool IsClsComplianceRequired ()
 630                 {
 631                         if ((caching_flags & Flags.ClsCompliance_Undetected) == 0)
 632                                 return (caching_flags & Flags.ClsCompliant) != 0;
 633
 634                         caching_flags &= ~Flags.ClsCompliance_Undetected;
 635
 636                         if (HasClsCompliantAttribute) {
 637                                 if ((caching_flags & Flags.ClsCompliantAttributeFalse) != 0)
 638                                         return false;
 639
 640                                 caching_flags |= Flags.ClsCompliant;
 641                                 return true;
 642                         }
 643
 644                         if (Parent.IsClsComplianceRequired ()) {
 645                                 caching_flags |= Flags.ClsCompliant;
 646                                 return true;
 647                         }
 648
 649                         return false;
 650                 }
 651
 652                 public virtual string[] ConditionalConditions ()
 653                 {
 654                         return null;
 655                 }
 656
 657                 /// <summary>
 658                 /// Returns true when MemberCore is exposed from assembly.
 659                 /// </summary>
 660                 public bool IsExposedFromAssembly ()
 661                 {
 662                         if ((ModFlags & (Modifiers.PUBLIC | Modifiers.PROTECTED)) == 0)
 663                                 return this is NamespaceContainer;
 664
 665                         var parentContainer = Parent.PartialContainer;
 666                         while (parentContainer != null) {
 667                                 if ((parentContainer.ModFlags & (Modifiers.PUBLIC | Modifiers.PROTECTED)) == 0)
 668                                         return false;
 669
 670                                 parentContainer = parentContainer.Parent.PartialContainer;
 671                         }
 672
 673                         return true;
 674                 }
 675
 676                 //
 677                 // Does extension methods look up to find a method which matches name and extensionType.
 678                 // Search starts from this namespace and continues hierarchically up to top level.
 679                 //
 680                 public ExtensionMethodCandidates LookupExtensionMethod (string name, int arity)
 681                 {
 682                         var m = Parent;
 683                         do {
 684                                 var ns = m as NamespaceContainer;
 685                                 if (ns != null)
 686                                         return ns.LookupExtensionMethod (this, name, arity, 0);
 687
 688                                 m = m.Parent;
 689                         } while (m != null);
 690
 691                         return null;
 692                 }
 693
 694                 public virtual FullNamedExpression LookupNamespaceAlias (string name)
 695                 {
 696                         return Parent.LookupNamespaceAlias (name);
 697                 }
 698
 699                 public virtual FullNamedExpression LookupNamespaceOrType (string name, int arity, LookupMode mode, Location loc)
 700                 {
 701                         return Parent.LookupNamespaceOrType (name, arity, mode, loc);
 702                 }
 703
 704                 /// <summary>
 705                 /// Goes through class hierarchy and gets value of first found CLSCompliantAttribute.
 706                 /// If no is attribute exists then assembly CLSCompliantAttribute is returned.
 707                 /// </summary>
 708                 public bool? CLSAttributeValue {
 709                         get {
 710                                 if ((caching_flags & Flags.HasCompliantAttribute_Undetected) == 0) {
 711                                         if ((caching_flags & Flags.HasClsCompliantAttribute) == 0)
 712                                                 return null;
 713
 714                                         return (caching_flags & Flags.ClsCompliantAttributeFalse) == 0;
 715                                 }
 716
 717                                 caching_flags &= ~Flags.HasCompliantAttribute_Undetected;
 718
 719                                 if (OptAttributes != null) {
 720                                         Attribute cls_attribute = OptAttributes.Search (Module.PredefinedAttributes.CLSCompliant);
 721                                         if (cls_attribute != null) {
 722                                                 caching_flags |= Flags.HasClsCompliantAttribute;
 723                                                 if (cls_attribute.GetClsCompliantAttributeValue ())
 724                                                         return true;
 725
 726                                                 caching_flags |= Flags.ClsCompliantAttributeFalse;
 727                                                 return false;
 728                                         }
 729                                 }
 730
 731                                 return null;
 732                         }
 733                 }
 734
 735                 /// <summary>
 736                 /// Returns true if MemberCore is explicitly marked with CLSCompliantAttribute
 737                 /// </summary>
 738                 protected bool HasClsCompliantAttribute {
 739                         get {
 740                                 return CLSAttributeValue.HasValue;
 741                         }
 742                 }
 743
 744                 /// <summary>
 745                 /// Returns true when a member supports multiple overloads (methods, indexers, etc)
 746                 /// </summary>
 747                 public virtual bool EnableOverloadChecks (MemberCore overload)
 748                 {
 749                         return false;
 750                 }
 751
 752                 /// <summary>
 753                 /// The main virtual method for CLS-Compliant verifications.
 754                 /// The method returns true if member is CLS-Compliant and false if member is not
 755                 /// CLS-Compliant which means that CLS-Compliant tests are not necessary. A descendants override it
 756                 /// and add their extra verifications.
 757                 /// </summary>
 758                 protected virtual bool VerifyClsCompliance ()
 759                 {
 760                         if (HasClsCompliantAttribute) {
 761                                 if (!Module.DeclaringAssembly.HasCLSCompliantAttribute) {
 762                                         Attribute a = OptAttributes.Search (Module.PredefinedAttributes.CLSCompliant);
 763                                         if ((caching_flags & Flags.ClsCompliantAttributeFalse) != 0) {
 764                                                 Report.Warning (3021, 2, a.Location,
 765                                                         "`{0}' does not need a CLSCompliant attribute because the assembly is not marked as CLS-compliant",
 766                                                         GetSignatureForError ());
 767                                         } else {
 768                                                 Report.Warning (3014, 1, a.Location,
 769                                                         "`{0}' cannot be marked as CLS-compliant because the assembly is not marked as CLS-compliant",
 770                                                         GetSignatureForError ());
 771                                         }
 772                                         return false;
 773                                 }
 774
 775                                 if (!IsExposedFromAssembly ()) {
 776                                         Attribute a = OptAttributes.Search (Module.PredefinedAttributes.CLSCompliant);
 777                                         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 ());
 778                                         return false;
 779                                 }
 780
 781                                 if ((caching_flags & Flags.ClsCompliantAttributeFalse) != 0) {
 782                                         if (Parent is Interface && Parent.IsClsComplianceRequired ()) {
 783                                                 Report.Warning (3010, 1, Location, "`{0}': CLS-compliant interfaces must have only CLS-compliant members", GetSignatureForError ());
 784                                         } else if (Parent.Kind == MemberKind.Class && (ModFlags & Modifiers.ABSTRACT) != 0 && Parent.IsClsComplianceRequired ()) {
 785                                                 Report.Warning (3011, 1, Location, "`{0}': only CLS-compliant members can be abstract", GetSignatureForError ());
 786                                         }
 787
 788                                         return false;
 789                                 }
 790
 791                                 if (Parent.Kind != MemberKind.Namespace && Parent.Kind != 0 && !Parent.IsClsComplianceRequired ()) {
 792                                         Attribute a = OptAttributes.Search (Module.PredefinedAttributes.CLSCompliant);
 793                                         Report.Warning (3018, 1, a.Location, "`{0}' cannot be marked as CLS-compliant because it is a member of non CLS-compliant type `{1}'",
 794                                                 GetSignatureForError (), Parent.GetSignatureForError ());
 795                                         return false;
 796                                 }
 797                         } else {
 798                                 if (!IsExposedFromAssembly ())
 799                                         return false;
 800
 801                                 if (!Parent.IsClsComplianceRequired ())
 802                                         return false;
 803                         }
 804
 805                         if (member_name.Name [0] == '_') {
 806                                 Warning_IdentifierNotCompliant ();
 807                         }
 808
 809                         if (member_name.TypeParameters != null)
 810                                 member_name.TypeParameters.VerifyClsCompliance ();
 811
 812                         return true;
 813                 }
 814
 815                 protected void Warning_IdentifierNotCompliant ()
 816                 {
 817                         Report.Warning (3008, 1, MemberName.Location, "Identifier `{0}' is not CLS-compliant", GetSignatureForError ());
 818                 }
 819
 820                 public virtual string GetCallerMemberName ()
 821                 {
 822                         return MemberName.Name;
 823                 }
 824
 825                 //
 826                 // Returns a string that represents the signature for this
 827                 // member which should be used in XML documentation.
 828                 //
 829                 public abstract string GetSignatureForDocumentation ();
 830
 831                 public virtual void GetCompletionStartingWith (string prefix, List<string> results)
 832                 {
 833                         Parent.GetCompletionStartingWith (prefix, results);
 834                 }
 835
 836                 //
 837                 // Generates xml doc comments (if any), and if required,
 838                 // handle warning report.
 839                 //
 840                 internal virtual void GenerateDocComment (DocumentationBuilder builder)
 841                 {
 842                         if (DocComment == null) {
 843                                 if (IsExposedFromAssembly ()) {
 844                                         Constructor c = this as Constructor;
 845                                         if (c == null || !c.IsDefault ())
 846                                                 Report.Warning (1591, 4, Location,
 847                                                         "Missing XML comment for publicly visible type or member `{0}'", GetSignatureForError ());
 848                                 }
 849
 850                                 return;
 851                         }
 852
 853                         try {
 854                                 builder.GenerateDocumentationForMember (this);
 855                         } catch (Exception e) {
 856                                 throw new InternalErrorException (this, e);
 857                         }
 858                 }
 859
 860                 public virtual void WriteDebugSymbol (MonoSymbolFile file)
 861                 {
 862                 }
 863
 864                 #region IMemberContext Members
 865
 866                 public virtual CompilerContext Compiler {
 867                         get {
 868                                 return Module.Compiler;
 869                         }
 870                 }
 871
 872                 public virtual TypeSpec CurrentType {
 873                         get { return Parent.CurrentType; }
 874                 }
 875
 876                 public MemberCore CurrentMemberDefinition {
 877                         get { return this; }
 878                 }
 879
 880                 public virtual TypeParameters CurrentTypeParameters {
 881                         get { return null; }
 882                 }
 883
 884                 public bool IsObsolete {
 885                         get {
 886                                 if (GetAttributeObsolete () != null)
 887                                         return true;
 888
 889                                 return Parent != null && Parent.IsObsolete;
 890                         }
 891                 }
 892
 893                 public bool IsUnsafe {
 894                         get {
 895                                 if ((ModFlags & Modifiers.UNSAFE) != 0)
 896                                         return true;
 897
 898                                 return Parent != null && Parent.IsUnsafe;
 899                         }
 900                 }
 901
 902                 public bool IsStatic {
 903                         get {
 904                                 return (ModFlags & Modifiers.STATIC) != 0;
 905                         }
 906                 }
 907
 908                 #endregion
 909         }
 910
 911         //
 912         // Base member specification. A member specification contains
 913         // member details which can alter in the context (e.g. generic instances)
 914         //
 915         public abstract class MemberSpec
 916         {
 917                 [Flags]
 918                 public enum StateFlags
 919                 {
 920                         Obsolete_Undetected = 1,        // Obsolete attribute has not been detected yet
 921                         Obsolete = 1 << 1,                      // Member has obsolete attribute
 922                         CLSCompliant_Undetected = 1 << 2,       // CLSCompliant attribute has not been detected yet
 923                         CLSCompliant = 1 << 3,          // Member is CLS Compliant
 924                         MissingDependency_Undetected = 1 << 4,
 925                         MissingDependency = 1 << 5,
 926                         HasDynamicElement = 1 << 6,
 927                         ConstraintsChecked = 1 << 7,
 928
 929                         IsAccessor = 1 << 9,            // Method is an accessor
 930                         IsGeneric = 1 << 10,            // Member contains type arguments
 931
 932                         PendingMetaInflate = 1 << 12,
 933                         PendingMakeMethod = 1 << 13,
 934                         PendingMemberCacheMembers = 1 << 14,
 935                         PendingBaseTypeInflate = 1 << 15,
 936                         InterfacesExpanded = 1 << 16,
 937                         IsNotCSharpCompatible = 1 << 17,
 938                         SpecialRuntimeType = 1 << 18,
 939                         InflatedExpressionType = 1 << 19,
 940                         InflatedNullableType = 1 << 20,
 941                         GenericIterateInterface = 1 << 21,
 942                         GenericTask = 1 << 22,
 943                         InterfacesImported = 1 << 23,
 944                 }
 945
 946                 //
 947                 // Some flags can be copied directly from other member
 948                 //
 949                 protected const StateFlags SharedStateFlags =
 950                         StateFlags.CLSCompliant | StateFlags.CLSCompliant_Undetected |
 951                         StateFlags.Obsolete | StateFlags.Obsolete_Undetected |
 952                         StateFlags.MissingDependency | StateFlags.MissingDependency_Undetected |
 953                         StateFlags.HasDynamicElement;
 954
 955                 protected Modifiers modifiers;
 956                 public StateFlags state;
 957                 protected IMemberDefinition definition;
 958                 public readonly MemberKind Kind;
 959                 protected TypeSpec declaringType;
 960
 961 #if DEBUG
 962                 static int counter;
 963                 public int ID = counter++;
 964 #endif
 965
 966                 protected MemberSpec (MemberKind kind, TypeSpec declaringType, IMemberDefinition definition, Modifiers modifiers)
 967                 {
 968                         this.Kind = kind;
 969                         this.declaringType = declaringType;
 970                         this.definition = definition;
 971                         this.modifiers = modifiers;
 972
 973                         if (kind == MemberKind.MissingType)
 974                                 state = StateFlags.MissingDependency;
 975                         else
 976                                 state = StateFlags.Obsolete_Undetected | StateFlags.CLSCompliant_Undetected | StateFlags.MissingDependency_Undetected;
 977                 }
 978
 979                 #region Properties
 980
 981                 public virtual int Arity {
 982                         get {
 983                                 return 0;
 984                         }
 985                 }
 986
 987                 public TypeSpec DeclaringType {
 988                         get {
 989                                 return declaringType;
 990                         }
 991                         set {
 992                                 declaringType = value;
 993                         }
 994                 }
 995
 996                 public IMemberDefinition MemberDefinition {
 997                         get {
 998                                 return definition;
 999                         }
1000                 }
1001
1002                 public Modifiers Modifiers {
1003                         get {
1004                                 return modifiers;
1005                         }
1006                         set {
1007                                 modifiers = value;
1008                         }
1009                 }
1010
1011                 public virtual string Name {
1012                         get {
1013                                 return definition.Name;
1014                         }
1015                 }
1016
1017                 public bool IsAbstract {
1018                         get { return (modifiers & Modifiers.ABSTRACT) != 0; }
1019                 }
1020
1021                 public bool IsAccessor {
1022                         get {
1023                                 return (state & StateFlags.IsAccessor) != 0;
1024                         }
1025                         set {
1026                                 state = value ? state | StateFlags.IsAccessor : state & ~StateFlags.IsAccessor;
1027                         }
1028                 }
1029
1030                 //
1031                 // Return true when this member is a generic in C# terms
1032                 // A nested non-generic type of generic type will return false
1033                 //
1034                 public bool IsGeneric {
1035                         get {
1036                                 return (state & StateFlags.IsGeneric) != 0;
1037                         }
1038                         set {
1039                                 state = value ? state | StateFlags.IsGeneric : state & ~StateFlags.IsGeneric;
1040                         }
1041                 }
1042
1043                 //
1044                 // Returns true for imported members which are not compatible with C# language
1045                 //
1046                 public bool IsNotCSharpCompatible {
1047                         get {
1048                                 return (state & StateFlags.IsNotCSharpCompatible) != 0;
1049                         }
1050                         set {
1051                                 state = value ? state | StateFlags.IsNotCSharpCompatible : state & ~StateFlags.IsNotCSharpCompatible;
1052                         }
1053                 }
1054
1055                 public bool IsPrivate {
1056                         get { return (modifiers & Modifiers.PRIVATE) != 0; }
1057                 }
1058
1059                 public bool IsPublic {
1060                         get { return (modifiers & Modifiers.PUBLIC) != 0; }
1061                 }
1062
1063                 public bool IsStatic {
1064                         get {
1065                                 return (modifiers & Modifiers.STATIC) != 0;
1066                         }
1067                 }
1068
1069                 #endregion
1070
1071                 public virtual void CheckObsoleteness (IMemberContext mc, Location loc)
1072                 {
1073                         var oa = GetAttributeObsolete ();
1074                         if (oa == null)
1075                                 return;
1076
1077                         if (!mc.IsObsolete)
1078                                 AttributeTester.Report_ObsoleteMessage (oa, GetSignatureForError (), loc, mc.Module.Compiler.Report);
1079                 }
1080
1081                 public virtual ObsoleteAttribute GetAttributeObsolete ()
1082                 {
1083                         if ((state & (StateFlags.Obsolete | StateFlags.Obsolete_Undetected)) == 0)
1084                                 return null;
1085
1086                         state &= ~StateFlags.Obsolete_Undetected;
1087
1088                         var oa = definition.GetAttributeObsolete ();
1089                         if (oa != null)
1090                                 state |= StateFlags.Obsolete;
1091
1092                         return oa;
1093                 }
1094
1095                 //
1096                 // Returns a list of missing dependencies of this member. The list
1097                 // will contain types only but it can have numerous values for members
1098                 // like methods where both return type and all parameters are checked
1099                 //
1100                 public List<MissingTypeSpecReference> GetMissingDependencies ()
1101                 {
1102                         return GetMissingDependencies (this);
1103                 }
1104
1105                 public List<MissingTypeSpecReference> GetMissingDependencies (MemberSpec caller)
1106                 {
1107                         if ((state & (StateFlags.MissingDependency | StateFlags.MissingDependency_Undetected)) == 0)
1108                                 return null;
1109
1110                         state &= ~StateFlags.MissingDependency_Undetected;
1111
1112                         var imported = definition as ImportedDefinition;
1113                         List<MissingTypeSpecReference> missing;
1114                         if (imported != null) {
1115                                 missing = ResolveMissingDependencies (caller);
1116                         } else if (this is ElementTypeSpec) {
1117                                 missing = ((ElementTypeSpec) this).Element.GetMissingDependencies (caller);
1118                         } else {
1119                                 missing = null;
1120                         }
1121
1122                         if (missing != null) {
1123                                 state |= StateFlags.MissingDependency;
1124                         }
1125
1126                         return missing;
1127                 }
1128
1129                 public abstract List<MissingTypeSpecReference> ResolveMissingDependencies (MemberSpec caller);
1130
1131                 protected virtual bool IsNotCLSCompliant (out bool attrValue)
1132                 {
1133                         var cls = MemberDefinition.CLSAttributeValue;
1134                         attrValue = cls ?? false;
1135                         return cls == false;
1136                 }
1137
1138                 public virtual string GetSignatureForDocumentation ()
1139                 {
1140                         return DeclaringType.GetSignatureForDocumentation () + "." + Name;
1141                 }
1142
1143                 public virtual string GetSignatureForError ()
1144                 {
1145                         var bf = MemberDefinition as Property.BackingFieldDeclaration;
1146                         string name;
1147                         if (bf == null) {
1148                                 name = Name;
1149                         } else {
1150                                 name = bf.OriginalProperty.MemberName.Name;
1151                         }
1152
1153                         return DeclaringType.GetSignatureForError () + "." + name;
1154                 }
1155
1156                 public virtual MemberSpec InflateMember (TypeParameterInflator inflator)
1157                 {
1158                         var inflated = (MemberSpec) MemberwiseClone ();
1159                         inflated.declaringType = inflator.TypeInstance;
1160                         if (DeclaringType.IsGenericOrParentIsGeneric)
1161                                 inflated.state |= StateFlags.PendingMetaInflate;
1162 #if DEBUG
1163                         inflated.ID += 1000000;
1164 #endif
1165                         return inflated;
1166                 }
1167
1168                 //
1169                 // Is this member accessible from invocation context
1170                 //
1171                 public bool IsAccessible (IMemberContext ctx)
1172                 {
1173                         var ma = Modifiers & Modifiers.AccessibilityMask;
1174                         if (ma == Modifiers.PUBLIC)
1175                                 return true;
1176
1177                         var parentType = /* this as TypeSpec ?? */ DeclaringType;
1178                         var ctype = ctx.CurrentType;
1179
1180                         if (ma == Modifiers.PRIVATE) {
1181                                 if (ctype == null || parentType == null)
1182                                         return false;
1183                                 //
1184                                 // It's only accessible to the current class or children
1185                                 //
1186                                 if (parentType.MemberDefinition == ctype.MemberDefinition)
1187                                         return true;
1188
1189                                 return TypeManager.IsNestedChildOf (ctype, parentType.MemberDefinition);
1190                         }
1191
1192                         if ((ma & Modifiers.INTERNAL) != 0) {
1193                                 bool b;
1194                                 var assembly = ctype == null ? ctx.Module.DeclaringAssembly : ctype.MemberDefinition.DeclaringAssembly;
1195
1196                                 if (parentType == null) {
1197                                         b = ((ITypeDefinition) MemberDefinition).IsInternalAsPublic (assembly);
1198                                 } else {
1199                                         b = DeclaringType.MemberDefinition.IsInternalAsPublic (assembly);
1200                                 }
1201
1202                                 if (b || ma == Modifiers.INTERNAL)
1203                                         return b;
1204                         }
1205
1206                         //
1207                         // Checks whether `ctype' is a subclass or nested child of `parentType'.
1208                         //
1209                         while (ctype != null) {
1210                                 if (TypeManager.IsFamilyAccessible (ctype, parentType))
1211                                         return true;
1212
1213                                 // Handle nested types.
1214                                 ctype = ctype.DeclaringType;    // TODO: Untested ???
1215                         }
1216
1217                         return false;
1218                 }
1219
1220                 //
1221                 // Returns member CLS compliance based on full member hierarchy
1222                 //
1223                 public bool IsCLSCompliant ()
1224                 {
1225                         if ((state & StateFlags.CLSCompliant_Undetected) != 0) {
1226                                 state &= ~StateFlags.CLSCompliant_Undetected;
1227
1228                                 bool compliant;
1229                                 if (IsNotCLSCompliant (out compliant))
1230                                         return false;
1231
1232                                 if (!compliant) {
1233                                         if (DeclaringType != null) {
1234                                                 compliant = DeclaringType.IsCLSCompliant ();
1235                                         } else {
1236                                                 compliant = ((ITypeDefinition) MemberDefinition).DeclaringAssembly.IsCLSCompliant;
1237                                         }
1238                                 }
1239
1240                                 if (compliant)
1241                                         state |= StateFlags.CLSCompliant;
1242                         }
1243
1244                         return (state & StateFlags.CLSCompliant) != 0;
1245                 }
1246
1247                 public bool IsConditionallyExcluded (IMemberContext ctx)
1248                 {
1249                         if ((Kind & (MemberKind.Class | MemberKind.Method)) == 0)
1250                                 return false;
1251
1252                         var conditions = MemberDefinition.ConditionalConditions ();
1253                         if (conditions == null)
1254                                 return false;
1255
1256                         var m = ctx.CurrentMemberDefinition;
1257                         CompilationSourceFile unit = null;
1258                         while (m != null && unit == null) {
1259                                 unit = m as CompilationSourceFile;
1260                                 m = m.Parent;
1261                         }
1262
1263                         if (unit != null) {
1264                                 foreach (var condition in conditions) {
1265                                         if (unit.IsConditionalDefined (condition))
1266                                                 return false;
1267                                 }
1268                         }
1269
1270                         return true;
1271                 }
1272
1273                 public override string ToString ()
1274                 {
1275                         return GetSignatureForError ();
1276                 }
1277         }
1278
1279         //
1280         // Member details which are same between all member
1281         // specifications
1282         //
1283         public interface IMemberDefinition
1284         {
1285                 bool? CLSAttributeValue { get; }
1286                 string Name { get; }
1287                 bool IsImported { get; }
1288
1289                 string[] ConditionalConditions ();
1290                 ObsoleteAttribute GetAttributeObsolete ();
1291                 void SetIsAssigned ();
1292                 void SetIsUsed ();
1293         }
1294
1295         public interface IMethodDefinition : IMemberDefinition
1296         {
1297                 MethodBase Metadata { get; }
1298         }
1299
1300         public interface IParametersMember : IInterfaceMemberSpec
1301         {
1302                 AParametersCollection Parameters { get; }
1303         }
1304
1305         public interface IInterfaceMemberSpec
1306         {
1307                 TypeSpec MemberType { get; }
1308         }
1309 }