X-Git-Url: http://wien.tomnetworks.com/gitweb/?a=blobdiff_plain;f=mcs%2Fmcs%2Fdecl.cs;h=f98c5ae909d34127577625f819d5228ea96b7732;hb=398ddf57679d166c65418736cdbd540ed5b9e534;hp=f037c63639e111ed473758fdd1572325a28765b4;hpb=a87e3e11455a85e56e38fff893b74243b80ebba4;p=mono.git diff --git a/mcs/mcs/decl.cs b/mcs/mcs/decl.cs index f037c63639e..f98c5ae909d 100644 --- a/mcs/mcs/decl.cs +++ b/mcs/mcs/decl.cs @@ -4,10 +4,10 @@ // Author: Miguel de Icaza (miguel@gnu.org) // Marek Safar (marek.safar@seznam.cz) // -// Licensed under the terms of the GNU GPL +// Dual licensed under the terms of the MIT X11 or GNU GPL // -// (C) 2001 Ximian, Inc (http://www.ximian.com) -// (C) 2004 Novell, Inc +// Copyright 2001 Ximian, Inc (http://www.ximian.com) +// Copyright 2004-2008 Novell, Inc // // TODO: Move the method verification stuff from the class.cs and interface.cs here // @@ -19,7 +19,7 @@ using System.Globalization; using System.Reflection.Emit; using System.Reflection; -#if BOOTSTRAP_WITH_OLDLIB +#if BOOTSTRAP_WITH_OLDLIB || NET_2_1 using XmlElement = System.Object; #else using System.Xml; @@ -51,7 +51,8 @@ namespace Mono.CSharp { TypeArguments args, Location loc) : this (left, name, is_double_colon, loc) { - this.TypeArguments = args; + if (args != null && args.Count > 0) + this.TypeArguments = args; } public MemberName (string name) @@ -78,8 +79,8 @@ namespace Mono.CSharp { : this (left, name, false, args, loc) { } - public MemberName (string alias, string name, Location loc) - : this (new MemberName (alias, loc), name, true, loc) + public MemberName (string alias, string name, TypeArguments args, Location loc) + : this (new MemberName (alias, loc), name, true, args, loc) { } public MemberName (MemberName left, MemberName right) @@ -129,28 +130,19 @@ namespace Mono.CSharp { return MakeName (Name, TypeArguments); } - public Expression GetTypeExpression () + public ATypeNameExpression GetTypeExpression () { -#if GMCS_SOURCE - if (IsUnbound) { - if (!CheckUnbound (Location)) - return null; - - return new UnboundTypeExpression (this, Location); - } -#endif - if (Left == null) { if (TypeArguments != null) return new SimpleName (Basename, TypeArguments, Location); - else - return new SimpleName (Name, Location); + + return new SimpleName (Name, Location); } if (is_double_colon) { if (Left.Left != null) throw new InternalErrorException ("The left side of a :: should be an identifier"); - return new QualifiedAliasMember (Left.Name, Name, Location); + return new QualifiedAliasMember (Left.Name, Name, TypeArguments, Location); } Expression lexpr = Left.GetTypeExpression (); @@ -172,32 +164,29 @@ namespace Mono.CSharp { } } - public string FullName { - get { - if (TypeArguments != null) - return Name + "<" + TypeArguments + ">"; - else - return Name; - } - } - public string MethodName { get { string connect = is_double_colon ? "::" : "."; if (Left != null) - return Left.FullName + connect + Name; + return Left.FullyQualifiedName + connect + Name; else return Name; } } - public override string ToString () + // Please use this only for error reporting. For normal uses, just use the Equals and GetHashCode methods that make + // MemberName a proper hash key, and avoid tons of memory allocations + string FullyQualifiedName { + get { return TypeArguments == null ? MethodName : MethodName + "<" + TypeArguments.GetSignatureForError () + ">"; } + } + + public string GetSignatureForError () { + string append = TypeArguments == null ? "" : "<" + TypeArguments.GetSignatureForError () + ">"; + if (Left == null) + return Name + append; string connect = is_double_colon ? "::" : "."; - if (Left != null) - return Left.FullName + connect + FullName; - else - return FullName; + return Left.GetSignatureForError () + connect + Name + append; } public override bool Equals (object other) @@ -243,10 +232,12 @@ namespace Mono.CSharp { public int CountTypeArguments { get { - if (TypeArguments == null) - return 0; - else + if (TypeArguments != null) return TypeArguments.Count; + else if (Left != null) + return Left.CountTypeArguments; + else + return 0; } } @@ -262,29 +253,6 @@ namespace Mono.CSharp { { return name + "`" + count; } - - protected bool IsUnbound { - get { - if ((Left != null) && Left.IsUnbound) - return true; - else if (TypeArguments == null) - return false; - else - return TypeArguments.IsUnbound; - } - } - - protected bool CheckUnbound (Location loc) - { - if ((Left != null) && !Left.CheckUnbound (loc)) - return false; - if ((TypeArguments != null) && !TypeArguments.IsUnbound) { - Report.Error (1031, loc, "Type expected"); - return false; - } - - return true; - } } /// @@ -326,7 +294,7 @@ namespace Mono.CSharp { } } - public readonly DeclSpace Parent; + public /*readonly*/ DeclSpace Parent; /// /// Location where this declaration happens @@ -358,10 +326,11 @@ namespace Mono.CSharp { ClsCompliantAttributeTrue = 1 << 7, // Type has CLSCompliant (true) Excluded_Undetected = 1 << 8, // Conditional attribute has not been detected yet Excluded = 1 << 9, // Method is conditional - TestMethodDuplication = 1 << 10, // Test for duplication must be performed + MethodOverloadsExist = 1 << 10, // Test for duplication must be performed IsUsed = 1 << 11, IsAssigned = 1 << 12, // Field is assigned - HasExplicitLayout = 1 << 13 + HasExplicitLayout = 1 << 13, + PartialDefinitionExists = 1 << 14 // Set when corresponding partial method definition exists } /// @@ -382,7 +351,7 @@ namespace Mono.CSharp { member_name = new_name; cached_name = null; } - + protected bool CheckAbstractAndExtern (bool has_block) { if (Parent.PartialContainer.Kind == Kind.Interface) @@ -401,12 +370,12 @@ namespace Mono.CSharp { return false; } } else { - if ((ModFlags & (Modifiers.ABSTRACT | Modifiers.EXTERN)) == 0) { + if ((ModFlags & (Modifiers.ABSTRACT | Modifiers.EXTERN | Modifiers.PARTIAL)) == 0) { if (RootContext.Version >= LanguageVersion.LINQ && this is Property.PropertyMethod) { Report.Error (840, Location, "`{0}' must have a body because it is not marked abstract or extern. The property can be automatically implemented when you define both accessors", GetSignatureForError ()); } else { - Report.Error (501, Location, "`{0}' must have a body because it is not marked abstract or extern", + Report.Error (501, Location, "`{0}' must have a body because it is not marked abstract, extern, or partial", GetSignatureForError ()); } return false; @@ -414,7 +383,32 @@ namespace Mono.CSharp { } return true; - } + } + + public void CheckProtectedModifier () + { + if ((ModFlags & Modifiers.PROTECTED) == 0) + return; + + if (Parent.PartialContainer.Kind == Kind.Struct) { + Report.Error (666, Location, "`{0}': Structs cannot contain protected members", + GetSignatureForError ()); + return; + } + + if ((Parent.ModFlags & Modifiers.STATIC) != 0) { + Report.Error (1057, Location, "`{0}': Static classes cannot contain protected members", + GetSignatureForError ()); + return; + } + + if (((Parent.ModFlags & Modifiers.SEALED) != 0) && + ((ModFlags & Modifiers.OVERRIDE) == 0) && (Name != "Finalize")) { + Report.Warning (628, 4, Location, "`{0}': new protected member declared in sealed class", + GetSignatureForError ()); + return; + } + } public abstract bool Define (); @@ -433,9 +427,9 @@ namespace Mono.CSharp { public virtual string GetSignatureForError () { if (Parent == null || Parent.Parent == null) - return member_name.ToString (); + return member_name.GetSignatureForError (); - return String.Concat (Parent.GetSignatureForError (), '.', member_name.ToString ()); + return Parent.GetSignatureForError () + "." + member_name.GetSignatureForError (); } /// @@ -470,7 +464,7 @@ namespace Mono.CSharp { caching_flags &= ~Flags.Obsolete_Undetected; - if (OptAttributes == null) + if (OptAttributes == null || TypeManager.obsolete_attribute_type == null) return null; Attribute obsolete_attr = OptAttributes.Search ( @@ -502,6 +496,159 @@ namespace Mono.CSharp { AttributeTester.Report_ObsoleteMessage (oa, GetSignatureForError (), loc); } + // Access level of a type. + const int X = 1; + enum AccessLevel + { // Each column represents `is this scope larger or equal to Blah scope' + // Public Assembly Protected + Protected = (0 << 0) | (0 << 1) | (X << 2), + Public = (X << 0) | (X << 1) | (X << 2), + Private = (0 << 0) | (0 << 1) | (0 << 2), + Internal = (0 << 0) | (X << 1) | (0 << 2), + ProtectedOrInternal = (0 << 0) | (X << 1) | (X << 2), + } + + static AccessLevel GetAccessLevelFromModifiers (int flags) + { + if ((flags & Modifiers.INTERNAL) != 0) { + + if ((flags & Modifiers.PROTECTED) != 0) + return AccessLevel.ProtectedOrInternal; + else + return AccessLevel.Internal; + + } else if ((flags & Modifiers.PROTECTED) != 0) + return AccessLevel.Protected; + else if ((flags & Modifiers.PRIVATE) != 0) + return AccessLevel.Private; + else + return AccessLevel.Public; + } + + // + // Returns the access level for type `t' + // + static AccessLevel GetAccessLevelFromType (Type t) + { + if (t.IsPublic) + return AccessLevel.Public; + if (t.IsNestedPrivate) + return AccessLevel.Private; + if (t.IsNotPublic) + return AccessLevel.Internal; + + if (t.IsNestedPublic) + return AccessLevel.Public; + if (t.IsNestedAssembly) + return AccessLevel.Internal; + if (t.IsNestedFamily) + return AccessLevel.Protected; + if (t.IsNestedFamORAssem) + return AccessLevel.ProtectedOrInternal; + if (t.IsNestedFamANDAssem) + throw new NotImplementedException ("NestedFamANDAssem not implemented, cant make this kind of type from c# anyways"); + + // nested private is taken care of + + throw new Exception ("I give up, what are you?"); + } + + // + // Checks whether the type P is as accessible as this member + // + public bool IsAccessibleAs (Type p) + { + // + // if M is private, its accessibility is the same as this declspace. + // we already know that P is accessible to T before this method, so we + // may return true. + // + if ((mod_flags & Modifiers.PRIVATE) != 0) + return true; + + while (p.IsArray || p.IsPointer || p.IsByRef) + p = TypeManager.GetElementType (p); + +#if GMCS_SOURCE + if (p.IsGenericParameter) + return true; + + if (TypeManager.IsGenericType (p)) { + foreach (Type t in p.GetGenericArguments ()) { + if (!IsAccessibleAs (t)) + return false; + } + } +#endif + + for (Type p_parent = null; p != null; p = p_parent) { + p_parent = p.DeclaringType; + AccessLevel pAccess = GetAccessLevelFromType (p); + if (pAccess == AccessLevel.Public) + continue; + + bool same_access_restrictions = false; + for (MemberCore mc = this; !same_access_restrictions && mc != null && mc.Parent != null; mc = mc.Parent) { + AccessLevel al = GetAccessLevelFromModifiers (mc.ModFlags); + switch (pAccess) { + case AccessLevel.Internal: + if (al == AccessLevel.Private || al == AccessLevel.Internal) + same_access_restrictions = TypeManager.IsThisOrFriendAssembly (p.Assembly); + + break; + + case AccessLevel.Protected: + if (al == AccessLevel.Protected) { + same_access_restrictions = mc.Parent.IsBaseType (p_parent); + break; + } + + if (al == AccessLevel.Private) { + // + // When type is private and any of its parents derives from + // protected type then the type is accessible + // + while (mc.Parent != null) { + if (mc.Parent.IsBaseType (p_parent)) + same_access_restrictions = true; + mc = mc.Parent; + } + } + + break; + + case AccessLevel.ProtectedOrInternal: + if (al == AccessLevel.Protected) + same_access_restrictions = mc.Parent.IsBaseType (p_parent); + else if (al == AccessLevel.Internal) + same_access_restrictions = TypeManager.IsThisOrFriendAssembly (p.Assembly); + else if (al == AccessLevel.ProtectedOrInternal) + same_access_restrictions = mc.Parent.IsBaseType (p_parent) && + TypeManager.IsThisOrFriendAssembly (p.Assembly); + + break; + + case AccessLevel.Private: + // + // Both are private and share same parent + // + if (al == AccessLevel.Private) + same_access_restrictions = TypeManager.IsEqual (mc.Parent.TypeBuilder, p_parent); + + break; + + default: + throw new InternalErrorException (al.ToString ()); + } + } + + if (!same_access_restrictions) + return false; + } + + return true; + } + /// /// Analyze whether CLS-Compliant verification must be execute for this MemberCore. /// @@ -548,7 +695,7 @@ namespace Mono.CSharp { caching_flags &= ~Flags.HasCompliantAttribute_Undetected; - if (OptAttributes != null) { + if (OptAttributes != null && TypeManager.cls_compliant_attribute_type != null) { Attribute cls_attribute = OptAttributes.Search ( TypeManager.cls_compliant_attribute_type); if (cls_attribute != null) { @@ -559,6 +706,10 @@ namespace Mono.CSharp { return value; } } + + // It's null for TypeParameter + if (Parent == null) + return false; if (Parent.GetClsCompliantAttributeValue ()) { caching_flags |= Flags.ClsCompliantAttributeTrue; @@ -572,14 +723,17 @@ namespace Mono.CSharp { /// protected bool HasClsCompliantAttribute { get { + if ((caching_flags & Flags.HasCompliantAttribute_Undetected) != 0) + GetClsCompliantAttributeValue (); + return (caching_flags & Flags.HasClsCompliantAttribute) != 0; } } /// - /// It helps to handle error 102 & 111 detection + /// Returns true when a member supports multiple overloads (methods, indexers, etc) /// - public virtual bool MarkForDuplicationCheck () + public virtual bool EnableOverloadChecks (MemberCore overload) { return false; } @@ -593,7 +747,7 @@ namespace Mono.CSharp { protected virtual bool VerifyClsCompliance () { if (!IsClsComplianceRequired ()) { - if (HasClsCompliantAttribute && RootContext.WarningLevel >= 2) { + if (HasClsCompliantAttribute && Report.WarningLevel >= 2) { if (!IsExposedFromAssembly ()) Report.Warning (3019, 2, Location, "CLS compliance checking will not be performed on `{0}' because it is not visible from outside this assembly", GetSignatureForError ()); if (!CodeGen.Assembly.IsClsCompliant) @@ -649,7 +803,11 @@ namespace Mono.CSharp { // internal virtual void GenerateDocComment (DeclSpace ds) { - DocUtil.GenerateDocComment (this, ds); + try { + DocUtil.GenerateDocComment (this, ds); + } catch (Exception e) { + throw new InternalErrorException (this, e); + } } public override IResolveContext ResolveContext { @@ -723,9 +881,8 @@ namespace Mono.CSharp { public TypeContainer PartialContainer; - readonly bool is_generic; + protected readonly bool is_generic; readonly int count_type_params; - readonly int count_current_type_params; // // Whether we are Generic @@ -753,7 +910,7 @@ namespace Mono.CSharp { PartialContainer = null; if (name.TypeArguments != null) { is_generic = true; - count_type_params = count_current_type_params = name.TypeArguments.Count; + count_type_params = name.TypeArguments.Count; } if (parent != null) count_type_params += parent.count_type_params; @@ -775,7 +932,7 @@ namespace Mono.CSharp { return true; } - if (symbol.MarkForDuplicationCheck () && mc.MarkForDuplicationCheck ()) + if (symbol.EnableOverloadChecks (mc)) return true; Report.SymbolRelatedToPreviousError (mc); @@ -873,10 +1030,23 @@ namespace Mono.CSharp { type.GetSignatureForError ()); } + public override void Emit () + { +#if GMCS_SOURCE + if (type_params != null) { + int offset = count_type_params - type_params.Length; + for (int i = offset; i < type_params.Length; i++) + CurrentTypeParameters [i - offset].Emit (); + } +#endif + + base.Emit (); + } + public override string GetSignatureForError () { if (IsGeneric) { - return SimpleName.RemoveGenericArity (Name) + TypeParameter.GetSignatureForError (CurrentTypeParameters); + return SimpleName.RemoveGenericArity (Name) + TypeParameter.GetSignatureForError (type_params); } // Parent.GetSignatureForError return Name; @@ -924,11 +1094,8 @@ namespace Mono.CSharp { // However, this is invoked again later -- so safe to return true. // May also be null when resolving top-level attributes. return true; - // - // This test should probably use the declaringtype. - // - return check_type.Assembly == TypeBuilder.Assembly || - TypeManager.IsFriendAssembly (check_type.Assembly); + + return TypeManager.IsThisOrFriendAssembly (check_type.Assembly); case TypeAttributes.NestedPublic: return true; @@ -943,18 +1110,15 @@ namespace Mono.CSharp { return FamilyAccessible (tb, check_type); case TypeAttributes.NestedFamANDAssem: - return ((check_type.Assembly == tb.Assembly) || - TypeManager.IsFriendAssembly (check_type.Assembly)) && + return TypeManager.IsThisOrFriendAssembly (check_type.Assembly) && FamilyAccessible (tb, check_type); case TypeAttributes.NestedFamORAssem: - return (check_type.Assembly == tb.Assembly) || - FamilyAccessible (tb, check_type) || - TypeManager.IsFriendAssembly (check_type.Assembly); + return FamilyAccessible (tb, check_type) || + TypeManager.IsThisOrFriendAssembly (check_type.Assembly); case TypeAttributes.NestedAssembly: - return check_type.Assembly == tb.Assembly || - TypeManager.IsFriendAssembly (check_type.Assembly); + return TypeManager.IsThisOrFriendAssembly (check_type.Assembly); } Console.WriteLine ("HERE: " + check_attr); @@ -975,124 +1139,43 @@ namespace Mono.CSharp { return TypeManager.IsNestedFamilyAccessible (TypeBuilder, declaring); } - // Access level of a type. - const int X = 1; - enum AccessLevel { // Each column represents `is this scope larger or equal to Blah scope' - // Public Assembly Protected - Protected = (0 << 0) | (0 << 1) | (X << 2), - Public = (X << 0) | (X << 1) | (X << 2), - Private = (0 << 0) | (0 << 1) | (0 << 2), - Internal = (0 << 0) | (X << 1) | (0 << 2), - ProtectedOrInternal = (0 << 0) | (X << 1) | (X << 2), - } - - static AccessLevel GetAccessLevelFromModifiers (int flags) - { - if ((flags & Modifiers.INTERNAL) != 0) { - - if ((flags & Modifiers.PROTECTED) != 0) - return AccessLevel.ProtectedOrInternal; - else - return AccessLevel.Internal; - - } else if ((flags & Modifiers.PROTECTED) != 0) - return AccessLevel.Protected; - else if ((flags & Modifiers.PRIVATE) != 0) - return AccessLevel.Private; - else - return AccessLevel.Public; - } - - // What is the effective access level of this? - // TODO: Cache this? - AccessLevel EffectiveAccessLevel { - get { - AccessLevel myAccess = GetAccessLevelFromModifiers (ModFlags); - if (!IsTopLevel && (Parent != null)) - return myAccess & Parent.EffectiveAccessLevel; - return myAccess; - } - } - - // Return the access level for type `t' - static AccessLevel TypeEffectiveAccessLevel (Type t) + public bool IsBaseType (Type baseType) { - if (t.IsPublic) - return AccessLevel.Public; - if (t.IsNestedPrivate) - return AccessLevel.Private; - if (t.IsNotPublic) - return AccessLevel.Internal; - - // By now, it must be nested - AccessLevel parent_level = TypeEffectiveAccessLevel (t.DeclaringType); - - if (t.IsNestedPublic) - return parent_level; - if (t.IsNestedAssembly) - return parent_level & AccessLevel.Internal; - if (t.IsNestedFamily) - return parent_level & AccessLevel.Protected; - if (t.IsNestedFamORAssem) - return parent_level & AccessLevel.ProtectedOrInternal; - if (t.IsNestedFamANDAssem) - throw new NotImplementedException ("NestedFamANDAssem not implemented, cant make this kind of type from c# anyways"); - - // nested private is taken care of - - throw new Exception ("I give up, what are you?"); - } - - // - // This answers `is the type P, as accessible as a member M which has the - // accessability @flags which is declared as a nested member of the type T, this declspace' - // - public bool AsAccessible (Type p, int flags) - { - // - // 1) if M is private, its accessability is the same as this declspace. - // we already know that P is accessible to T before this method, so we - // may return true. - // - - if ((flags & Modifiers.PRIVATE) != 0) - return true; - - while (p.IsArray || p.IsPointer || p.IsByRef) - p = TypeManager.GetElementType (p); + if (TypeManager.IsInterfaceType (baseType)) + throw new NotImplementedException (); -#if GMCS_SOURCE - if (p.IsGenericParameter) - return true; + Type type = TypeBuilder; + while (type != null) { + if (TypeManager.IsEqual (type, baseType)) + return true; - if (TypeManager.IsGenericType (p)) { - foreach (Type t in p.GetGenericArguments ()) { - if (!AsAccessible (t, flags)) - return false; - } + type = type.BaseType; } -#endif - AccessLevel pAccess = TypeEffectiveAccessLevel (p); - AccessLevel mAccess = this.EffectiveAccessLevel & - GetAccessLevelFromModifiers (flags); - - // for every place from which we can access M, we must - // be able to access P as well. So, we want - // For every bit in M and P, M_i -> P_1 == true - // or, ~ (M -> P) == 0 <-> ~ ( ~M | P) == 0 - - return ~ (~ mAccess | pAccess) == 0; + + return false; } private Type LookupNestedTypeInHierarchy (string name) { + Type t = null; // if the member cache has been created, lets use it. // the member cache is MUCH faster. - if (MemberCache != null) - return MemberCache.FindNestedType (name); + if (MemberCache != null) { + t = MemberCache.FindNestedType (name); + if (t == null) + return null; + + // + // FIXME: This hack is needed because member cache does not work + // with nested base generic types, it does only type name copy and + // not type construction + // +#if !GMCS_SOURCE + return t; +#endif + } // no member cache. Do it the hard way -- reflection - Type t = null; for (Type current_type = TypeBuilder; current_type != null && current_type != TypeManager.object_type; current_type = current_type.BaseType) { @@ -1128,7 +1211,7 @@ namespace Mono.CSharp { return null; } - public virtual ExtensionMethodGroupExpr LookupExtensionMethod (Type extensionType, string name) + public virtual ExtensionMethodGroupExpr LookupExtensionMethod (Type extensionType, string name, Location loc) { return null; } @@ -1146,6 +1229,7 @@ namespace Mono.CSharp { return (FullNamedExpression) Cache [name]; FullNamedExpression e; + int errors = Report.Errors; Type t = LookupNestedTypeInHierarchy (name); if (t != null) e = new TypeExpression (t, Location.Null); @@ -1154,7 +1238,9 @@ namespace Mono.CSharp { else e = NamespaceEntry.LookupNamespaceOrType (this, name, loc, ignore_cs0104); - Cache [name] = e; + if (errors == Report.Errors) + Cache [name] = e; + return e; } @@ -1163,8 +1249,13 @@ namespace Mono.CSharp { /// be used while the type is still being created since it doesn't use the cache /// and relies on the filter doing the member name check. /// - public abstract MemberList FindMembers (MemberTypes mt, BindingFlags bf, - MemberFilter filter, object criteria); + /// + // [Obsolete ("Only MemberCache approach should be used")] + public virtual MemberList FindMembers (MemberTypes mt, BindingFlags bf, + MemberFilter filter, object criteria) + { + throw new NotSupportedException (); + } /// /// If we have a MemberCache, return it. This property may return null if the @@ -1186,22 +1277,9 @@ namespace Mono.CSharp { // // Extensions for generics // - TypeParameter[] type_params; + protected TypeParameter[] type_params; TypeParameter[] type_param_list; - protected string GetInstantiationName () - { - StringBuilder sb = new StringBuilder (Name); - sb.Append ("<"); - for (int i = 0; i < type_param_list.Length; i++) { - if (i > 0) - sb.Append (","); - sb.Append (type_param_list [i].Name); - } - sb.Append (">"); - return sb.ToString (); - } - bool check_type_parameter (ArrayList list, int start, string name) { for (int i = 0; i < start; i++) { @@ -1324,12 +1402,12 @@ namespace Mono.CSharp { get { if (!IsGeneric) throw new InvalidOperationException (); - if ((PartialContainer != null) && (PartialContainer != this)) - return PartialContainer.CurrentTypeParameters; - if (type_params != null) - return type_params; - else + + // TODO: Something is seriously broken here + if (type_params == null) return new TypeParameter [0]; + + return type_params; } } @@ -1339,12 +1417,6 @@ namespace Mono.CSharp { } } - public int CountCurrentTypeParameters { - get { - return count_current_type_params; - } - } - public TypeParameterExpr LookupGeneric (string name, Location loc) { if (!IsGeneric) @@ -1452,7 +1524,7 @@ namespace Mono.CSharp { List = list; } - public static readonly MemberList Empty = new MemberList (new ArrayList ()); + public static readonly MemberList Empty = new MemberList (new ArrayList (0)); /// /// Cast the MemberList into a MemberInfo[] array. @@ -1620,13 +1692,6 @@ namespace Mono.CSharp { /// this method is called multiple times with different BindingFlags. /// MemberList GetMembers (MemberTypes mt, BindingFlags bf); - - /// - /// Return the container's member cache. - /// - MemberCache MemberCache { - get; - } } /// @@ -1682,6 +1747,15 @@ namespace Mono.CSharp { Timer.StopTimer (TimerType.CacheInit); } + public MemberCache (Type baseType, IMemberContainer container) + { + this.Container = container; + if (baseType == null) + this.member_hash = new Hashtable (); + else + this.member_hash = SetupCache (TypeManager.LookupMemberCache (baseType)); + } + public MemberCache (Type[] ifaces) { // @@ -1725,18 +1799,36 @@ namespace Mono.CSharp { /// static Hashtable SetupCache (MemberCache base_class) { - Hashtable hash = new Hashtable (); - if (base_class == null) - return hash; + return new Hashtable (); + Hashtable hash = new Hashtable (base_class.member_hash.Count); IDictionaryEnumerator it = base_class.member_hash.GetEnumerator (); while (it.MoveNext ()) { - hash [it.Key] = ((ArrayList) it.Value).Clone (); + hash.Add (it.Key, ((ArrayList) it.Value).Clone ()); } return hash; } + + // + // Converts ModFlags to BindingFlags + // + static BindingFlags GetBindingFlags (int modifiers) + { + BindingFlags bf; + if ((modifiers & Modifiers.STATIC) != 0) + bf = BindingFlags.Static; + else + bf = BindingFlags.Instance; + + if ((modifiers & Modifiers.PRIVATE) != 0) + bf |= BindingFlags.NonPublic; + else + bf |= BindingFlags.Public; + + return bf; + } /// /// Add the contents of `cache' to the member_hash. @@ -1789,13 +1881,35 @@ namespace Mono.CSharp { AddMembers (mt, BindingFlags.Instance | BindingFlags.NonPublic, container); } + public void AddMember (MemberInfo mi, MemberCore mc) + { + AddMember (mi.MemberType, GetBindingFlags (mc.ModFlags), Container, mi.Name, mi); + } + + public void AddGenericMember (MemberInfo mi, MemberCore mc) + { + AddMember (mi.MemberType, GetBindingFlags (mc.ModFlags), Container, mc.MemberName.Basename, mi); + } + + public void AddNestedType (DeclSpace type) + { + AddMember (MemberTypes.NestedType, GetBindingFlags (type.ModFlags), (IMemberContainer) type.Parent, + type.TypeBuilder.Name, type.TypeBuilder); + } + + public void AddInterface (MemberCache baseCache) + { + if (baseCache.member_hash.Count > 0) + AddCacheContents (baseCache); + } + void AddMember (MemberTypes mt, BindingFlags bf, IMemberContainer container, string name, MemberInfo member) { // We use a name-based hash table of ArrayList's. ArrayList list = (ArrayList) member_hash [name]; if (list == null) { - list = new ArrayList (); + list = new ArrayList (1); member_hash.Add (name, list); } @@ -1856,7 +1970,7 @@ namespace Mono.CSharp { // We use a name-based hash table of ArrayList's. ArrayList list = (ArrayList) method_hash [name]; if (list == null) { - list = new ArrayList (); + list = new ArrayList (1); method_hash.Add (name, list); } @@ -2048,7 +2162,7 @@ namespace Mono.CSharp { { if (using_global) throw new Exception (); - + bool declared_only = (bf & BindingFlags.DeclaredOnly) != 0; bool method_search = mt == MemberTypes.Method; // If we have a method cache and we aren't already doing a method-only search, @@ -2392,7 +2506,7 @@ namespace Mono.CSharp { // // Check for assembly methods // - if (mi.DeclaringType.Assembly != CodeGen.Assembly.Builder) + if (!TypeManager.IsThisOrFriendAssembly (mi.DeclaringType.Assembly)) continue; break; } @@ -2556,5 +2670,164 @@ namespace Mono.CSharp { throw new NotImplementedException (result.ToString ()); } } + + public bool CheckExistingMembersOverloads (MemberCore member, string name, Parameters parameters) + { + ArrayList entries = (ArrayList)member_hash [name]; + if (entries == null) + return true; + + int method_param_count = parameters.Count; + for (int i = entries.Count - 1; i >= 0; --i) { + CacheEntry ce = (CacheEntry) entries [i]; + + if (ce.Container != member.Parent.PartialContainer) + return true; + + Type [] p_types; + ParameterData pd = null; + if ((ce.EntryType & EntryType.Property) != 0) { + p_types = TypeManager.GetArgumentTypes ((PropertyInfo) ce.Member); + } else { + MethodBase mb = (MethodBase) ce.Member; +#if GMCS_SOURCE + // TODO: This is more like a hack, because we are adding generic methods + // twice with and without arity name + if (mb.IsGenericMethod && !member.MemberName.IsGeneric) + continue; +#endif + pd = TypeManager.GetParameterData (mb); + p_types = pd.Types; + } + + if (p_types.Length != method_param_count) + continue; + + if (method_param_count > 0) { + int ii = method_param_count - 1; + Type type_a, type_b; + do { + type_a = parameters.ParameterType (ii); + type_b = p_types [ii]; +#if GMCS_SOURCE + if (type_a.IsGenericParameter && type_a.DeclaringMethod != null) + type_a = null; + + if (type_b.IsGenericParameter && type_b.DeclaringMethod != null) + type_b = null; +#endif + } while (type_a == type_b && ii-- != 0); + + if (ii >= 0) + continue; + + // + // Operators can differ in return type only + // + if (member is Operator) { + Operator op = TypeManager.GetMethod ((MethodBase) ce.Member) as Operator; + if (op != null && op.ReturnType != ((Operator) member).ReturnType) + continue; + } + + // + // Report difference in parameter modifiers only + // + if (pd != null && !(member is AbstractPropertyEventMethod)) { + ii = method_param_count; + while (ii-- != 0 && parameters.ParameterModifier (ii) == pd.ParameterModifier (ii) && + parameters.ExtensionMethodType == pd.ExtensionMethodType); + + if (ii >= 0) { + MethodCore mc = TypeManager.GetMethod ((MethodBase) ce.Member) as MethodCore; + Report.SymbolRelatedToPreviousError (ce.Member); + if ((member.ModFlags & Modifiers.PARTIAL) != 0 && (mc.ModFlags & Modifiers.PARTIAL) != 0) { + if (parameters.HasParams || pd.HasParams) { + Report.Error (758, member.Location, + "A partial method declaration and partial method implementation cannot differ on use of `params' modifier"); + } else { + Report.Error (755, member.Location, + "A partial method declaration and partial method implementation must be both an extension method or neither"); + } + } else { + Report.Error (663, member.Location, + "An overloaded method `{0}' cannot differ on use of parameter modifiers only", + member.GetSignatureForError ()); + } + return false; + } + } + } + + if ((ce.EntryType & EntryType.Method) != 0) { + Method method_a = member as Method; + Method method_b = TypeManager.GetMethod ((MethodBase) ce.Member) as Method; + if (method_a != null && method_b != null && (method_a.ModFlags & method_b.ModFlags & Modifiers.PARTIAL) != 0) { + const int partial_modifiers = Modifiers.STATIC | Modifiers.UNSAFE; + if (method_a.IsPartialDefinition == method_b.IsPartialImplementation) { + if ((method_a.ModFlags & partial_modifiers) == (method_b.ModFlags & partial_modifiers) || + method_a.Parent.IsInUnsafeScope && method_b.Parent.IsInUnsafeScope) { + if (method_a.IsPartialImplementation) { + method_a.SetPartialDefinition (method_b); + entries.RemoveAt (i); + } else { + method_b.SetPartialDefinition (method_a); + } + continue; + } + + if ((method_a.ModFlags & Modifiers.STATIC) != (method_b.ModFlags & Modifiers.STATIC)) { + Report.SymbolRelatedToPreviousError (ce.Member); + Report.Error (763, member.Location, + "A partial method declaration and partial method implementation must be both `static' or neither"); + } + + Report.SymbolRelatedToPreviousError (ce.Member); + Report.Error (764, member.Location, + "A partial method declaration and partial method implementation must be both `unsafe' or neither"); + return false; + } + + Report.SymbolRelatedToPreviousError (ce.Member); + if (method_a.IsPartialDefinition) { + Report.Error (756, member.Location, "A partial method `{0}' declaration is already defined", + member.GetSignatureForError ()); + } + + Report.Error (757, member.Location, "A partial method `{0}' implementation is already defined", + member.GetSignatureForError ()); + return false; + } + + Report.SymbolRelatedToPreviousError (ce.Member); + IMethodData duplicate_member = TypeManager.GetMethod ((MethodBase) ce.Member); + if (member is Operator && duplicate_member is Operator) { + Report.Error (557, member.Location, "Duplicate user-defined conversion in type `{0}'", + member.Parent.GetSignatureForError ()); + return false; + } + + bool is_reserved_a = member is AbstractPropertyEventMethod || member is Operator; + bool is_reserved_b = duplicate_member is AbstractPropertyEventMethod || duplicate_member is Operator; + + if (is_reserved_a || is_reserved_b) { + Report.Error (82, member.Location, "A member `{0}' is already reserved", + is_reserved_a ? + TypeManager.GetFullNameSignature (ce.Member) : + member.GetSignatureForError ()); + return false; + } + } else { + Report.SymbolRelatedToPreviousError (ce.Member); + } + + Report.Error (111, member.Location, + "A member `{0}' is already defined. Rename this member or use different parameter types", + member.GetSignatureForError ()); + return false; + } + + return true; + } } }