X-Git-Url: http://wien.tomnetworks.com/gitweb/?a=blobdiff_plain;f=mcs%2Fmcs%2Fdecl.cs;h=13ec8e6c86ce9d322b1c28f1ed46e80374e28b52;hb=cc21ca3500fc936982e24d92f616165106c9e628;hp=413eba518117fbf00d115f9d20286acdce5d346c;hpb=a8888227da8d14a9ae95ce43d57894f7ecabceb2;p=mono.git diff --git a/mcs/mcs/decl.cs b/mcs/mcs/decl.cs index 413eba51811..13ec8e6c86c 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); } 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; - } } /// @@ -314,9 +282,19 @@ namespace Mono.CSharp { /// /// Modifier flags that the user specified in the source code /// - public int ModFlags; + private int mod_flags; + public int ModFlags { + set { + mod_flags = value; + if ((value & Modifiers.COMPILER_GENERATED) != 0) + caching_flags = Flags.IsUsed | Flags.IsAssigned; + } + get { + return mod_flags; + } + } - public readonly DeclSpace Parent; + public /*readonly*/ DeclSpace Parent; /// /// Location where this declaration happens @@ -348,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 } /// @@ -373,6 +352,65 @@ namespace Mono.CSharp { cached_name = null; } + protected bool CheckAbstractAndExtern (bool has_block) + { + if (Parent.PartialContainer.Kind == Kind.Interface) + return true; + + if (has_block) { + if ((ModFlags & Modifiers.EXTERN) != 0) { + Report.Error (179, Location, "`{0}' cannot declare a body because it is marked extern", + GetSignatureForError ()); + return false; + } + + if ((ModFlags & Modifiers.ABSTRACT) != 0) { + Report.Error (500, Location, "`{0}' cannot declare a body because it is marked abstract", + GetSignatureForError ()); + return false; + } + } else { + if ((ModFlags & (Modifiers.ABSTRACT | Modifiers.EXTERN | Modifiers.PARTIAL)) == 0) { + if (RootContext.Version >= LanguageVersion.LINQ && this is Property.PropertyMethod && + !(this is Indexer.GetIndexerMethod || this is Indexer.SetIndexerMethod)) { + 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, extern, or partial", + GetSignatureForError ()); + } + return false; + } + } + + 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 (); public virtual string DocComment { @@ -390,9 +428,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 (); } /// @@ -427,7 +465,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 ( @@ -459,6 +497,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. /// @@ -505,7 +696,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) { @@ -516,6 +707,10 @@ namespace Mono.CSharp { return value; } } + + // It's null for TypeParameter + if (Parent == null) + return false; if (Parent.GetClsCompliantAttributeValue ()) { caching_flags |= Flags.ClsCompliantAttributeTrue; @@ -529,14 +724,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; } @@ -550,7 +748,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) @@ -606,7 +804,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 { @@ -680,9 +882,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 @@ -710,7 +911,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; @@ -732,7 +933,7 @@ namespace Mono.CSharp { return true; } - if (symbol.MarkForDuplicationCheck () && mc.MarkForDuplicationCheck ()) + if (symbol.EnableOverloadChecks (mc)) return true; Report.SymbolRelatedToPreviousError (mc); @@ -830,10 +1031,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; @@ -881,11 +1095,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; @@ -900,18 +1111,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); @@ -932,148 +1140,81 @@ 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) - { - 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 parentLevel = TypeEffectiveAccessLevel (t.DeclaringType); - - if (t.IsNestedPublic) - return parentLevel; - if (t.IsNestedAssembly) - return parentLevel & AccessLevel.Internal; - if (t.IsNestedFamily) - return parentLevel & AccessLevel.Protected; - if (t.IsNestedFamORAssem) - return parentLevel & 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) + public bool IsBaseType (Type baseType) { - // - // 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) { - current_type = TypeManager.DropGenericTypeArguments (current_type); - if (current_type is TypeBuilder) { - TypeContainer tc = current_type == TypeBuilder - ? PartialContainer - : TypeManager.LookupTypeContainer (current_type); + + Type ct = TypeManager.DropGenericTypeArguments (current_type); + if (ct is TypeBuilder) { + TypeContainer tc = ct == TypeBuilder + ? PartialContainer : TypeManager.LookupTypeContainer (ct); if (tc != null) t = tc.FindNestedType (name); } else { - t = TypeManager.GetNestedType (current_type, name); + t = TypeManager.GetNestedType (ct, name); } - if (t != null && CheckAccessLevel (t)) + if ((t == null) || !CheckAccessLevel (t)) + continue; + +#if GMCS_SOURCE + if (!TypeManager.IsGenericType (current_type)) return t; + + Type[] args = TypeManager.GetTypeArguments (current_type); + Type[] targs = TypeManager.GetTypeArguments (t); + for (int i = 0; i < args.Length; i++) + targs [i] = args [i]; + + t = t.MakeGenericType (targs); +#endif + + return t; } return null; } - public virtual ExtensionMethodGroupExpr LookupExtensionMethod (Type extensionType, string name) + public virtual ExtensionMethodGroupExpr LookupExtensionMethod (Type extensionType, string name, Location loc) { - return NamespaceEntry.LookupExtensionMethod (extensionType, true, name); + return null; } // @@ -1089,6 +1230,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); @@ -1097,7 +1239,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; } @@ -1106,8 +1250,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 @@ -1129,22 +1278,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++) { @@ -1254,6 +1390,8 @@ namespace Mono.CSharp { get { if (!IsGeneric) throw new InvalidOperationException (); + if ((PartialContainer != null) && (PartialContainer != this)) + return PartialContainer.TypeParameters; if (type_param_list == null) initialize_type_params (); @@ -1265,10 +1403,12 @@ namespace Mono.CSharp { get { if (!IsGeneric) throw new InvalidOperationException (); - 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; } } @@ -1278,12 +1418,6 @@ namespace Mono.CSharp { } } - public int CountCurrentTypeParameters { - get { - return count_current_type_params; - } - } - public TypeParameterExpr LookupGeneric (string name, Location loc) { if (!IsGeneric) @@ -1391,7 +1525,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. @@ -1559,13 +1693,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; - } } /// @@ -1621,6 +1748,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) { // @@ -1664,18 +1800,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. @@ -1728,6 +1882,46 @@ 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 (1); + member_hash.Add (name, list); + } + + // When this method is called for the current class, the list will + // already contain all inherited members from our base classes. + // We cannot add new members in front of the list since this'd be an + // expensive operation, that's why the list is sorted in reverse order + // (ie. members from the current class are coming last). + list.Add (new CacheEntry (container, member, mt, bf)); + } + /// /// Add all members from class `container' with the requested MemberTypes and /// BindingFlags to the cache. This method is called multiple times with different @@ -1740,23 +1934,13 @@ namespace Mono.CSharp { foreach (MemberInfo member in members) { string name = member.Name; - int pos = name.IndexOf ('<'); - if (pos > 0) - name = name.Substring (0, pos); + AddMember (mt, bf, container, name, member); - // We use a name-based hash table of ArrayList's. - ArrayList list = (ArrayList) member_hash [name]; - if (list == null) { - list = new ArrayList (); - member_hash.Add (name, list); + if (member is MethodInfo) { + string gname = TypeManager.GetMethodName ((MethodInfo) member); + if (gname != name) + AddMember (mt, bf, container, gname, member); } - - // When this method is called for the current class, the list will - // already contain all inherited members from our base classes. - // We cannot add new members in front of the list since this'd be an - // expensive operation, that's why the list is sorted in reverse order - // (ie. members from the current class are coming last). - list.Add (new CacheEntry (container, member, mt, bf)); } } @@ -1787,7 +1971,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); } @@ -1979,7 +2163,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, @@ -2127,7 +2311,7 @@ namespace Mono.CSharp { return null; } - public MemberInfo FindBaseEvent (Type invocationType, string name) + public MemberInfo FindBaseEvent (Type invocation_type, string name) { ArrayList applicable = (ArrayList) member_hash [name]; if (applicable == null) @@ -2152,7 +2336,7 @@ namespace Mono.CSharp { // // Looks for extension methods with defined name and extension type // - public ArrayList FindExtensionMethods (Type extensionType, string name) + public ArrayList FindExtensionMethods (Type extensionType, string name, bool publicOnly) { ArrayList entries; if (method_hash != null) @@ -2163,9 +2347,15 @@ namespace Mono.CSharp { if (entries == null) return null; + EntryType entry_type = EntryType.Static | EntryType.Method | EntryType.NotExtensionMethod; + if (publicOnly) { + entry_type |= EntryType.Public; + } + EntryType found_entry_type = entry_type & ~EntryType.NotExtensionMethod; + ArrayList candidates = null; foreach (CacheEntry entry in entries) { - if ((entry.EntryType & (EntryType.Static | EntryType.Method | EntryType.NotExtensionMethod)) == (EntryType.Static | EntryType.Method)) { + if ((entry.EntryType & entry_type) == found_entry_type) { MethodBase mb = (MethodBase)entry.Member; IMethodData md = TypeManager.GetMethod (mb); @@ -2178,11 +2368,11 @@ namespace Mono.CSharp { continue; } - if (ex_type == extensionType || TypeManager.IsGenericParameter (ex_type)) { + //if (implicit conversion between ex_type and extensionType exist) { if (candidates == null) candidates = new ArrayList (2); candidates.Add (mb); - } + //} } } @@ -2190,14 +2380,14 @@ namespace Mono.CSharp { } // - // This finds the method or property for us to override. invocationType is the type where + // This finds the method or property for us to override. invocation_type is the type where // the override is going to be declared, name is the name of the method/property, and - // paramTypes is the parameters, if any to the method or property + // param_types is the parameters, if any to the method or property // // Because the MemberCache holds members from this class and all the base classes, // we can avoid tons of reflection stuff. // - public MemberInfo FindMemberToOverride (Type invocationType, string name, Type [] paramTypes, GenericMethod genericMethod, bool is_property) + public MemberInfo FindMemberToOverride (Type invocation_type, string name, Type [] param_types, GenericMethod generic_method, bool is_property) { ArrayList applicable; if (method_hash != null && !is_property) @@ -2219,7 +2409,7 @@ namespace Mono.CSharp { PropertyInfo pi = null; MethodInfo mi = null; FieldInfo fi = null; - Type [] cmpAttrs = null; + Type [] cmp_attrs = null; if (is_property) { if ((entry.EntryType & EntryType.Field) != 0) { @@ -2227,14 +2417,14 @@ namespace Mono.CSharp { // TODO: For this case we ignore member type //fb = TypeManager.GetField (fi); - //cmpAttrs = new Type[] { fb.MemberType }; + //cmp_attrs = new Type[] { fb.MemberType }; } else { pi = (PropertyInfo) entry.Member; - cmpAttrs = TypeManager.GetArgumentTypes (pi); + cmp_attrs = TypeManager.GetArgumentTypes (pi); } } else { mi = (MethodInfo) entry.Member; - cmpAttrs = TypeManager.GetParameterData (mi).Types; + cmp_attrs = TypeManager.GetParameterData (mi).Types; } if (fi != null) { @@ -2248,8 +2438,8 @@ namespace Mono.CSharp { // A private method is Ok if we are a nested subtype. // The spec actually is not very clear about this, see bug 52458. // - if (!invocationType.Equals (entry.Container.Type) && - !TypeManager.IsNestedChildOf (invocationType, entry.Container.Type)) + if (!invocation_type.Equals (entry.Container.Type) && + !TypeManager.IsNestedChildOf (invocation_type, entry.Container.Type)) continue; break; case FieldAttributes.FamANDAssem: @@ -2267,14 +2457,14 @@ namespace Mono.CSharp { // // Check the arguments // - if (cmpAttrs.Length != paramTypes.Length) + if (cmp_attrs.Length != param_types.Length) continue; int j; - for (j = 0; j < cmpAttrs.Length; ++j) - if (!TypeManager.IsEqual (paramTypes [j], cmpAttrs [j])) + for (j = 0; j < cmp_attrs.Length; ++j) + if (!TypeManager.IsEqual (param_types [j], cmp_attrs [j])) break; - if (j < cmpAttrs.Length) + if (j < cmp_attrs.Length) continue; // @@ -2282,9 +2472,9 @@ namespace Mono.CSharp { // if (mi != null) { Type [] cmpGenArgs = TypeManager.GetGenericArguments (mi); - if (genericMethod == null && cmpGenArgs.Length != 0) + if (generic_method == null && cmpGenArgs.Length != 0) continue; - if (genericMethod != null && cmpGenArgs.Length != genericMethod.TypeParameters.Length) + if (generic_method != null && cmpGenArgs.Length != generic_method.TypeParameters.Length) continue; } @@ -2308,8 +2498,8 @@ namespace Mono.CSharp { // A private method is Ok if we are a nested subtype. // The spec actually is not very clear about this, see bug 52458. // - if (!invocationType.Equals (entry.Container.Type) && - !TypeManager.IsNestedChildOf (invocationType, entry.Container.Type)) + if (!invocation_type.Equals (entry.Container.Type) && + !TypeManager.IsNestedChildOf (invocation_type, entry.Container.Type)) continue; break; case MethodAttributes.FamANDAssem: @@ -2317,7 +2507,7 @@ namespace Mono.CSharp { // // Check for assembly methods // - if (mi.DeclaringType.Assembly != CodeGen.Assembly.Builder) + if (!TypeManager.IsThisOrFriendAssembly (mi.DeclaringType.Assembly)) continue; break; } @@ -2481,5 +2671,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; + } } }