X-Git-Url: http://wien.tomnetworks.com/gitweb/?a=blobdiff_plain;f=mcs%2Fmcs%2Fdecl.cs;h=77d17f631de97d5e493e9555a3e2b29af65c8f65;hb=3fecd568954d5eec99a7ee3e64dd67d4c6617060;hp=05d8f5df85958a082a14386259e751ce7625aa82;hpb=8c7dd00b195c461ea5fe09181a09ad8730aceba4;p=mono.git diff --git a/mcs/mcs/decl.cs b/mcs/mcs/decl.cs index 05d8f5df859..77d17f631de 100644 --- a/mcs/mcs/decl.cs +++ b/mcs/mcs/decl.cs @@ -4,12 +4,11 @@ // 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 // using System; @@ -19,7 +18,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; @@ -27,6 +26,9 @@ using System.Xml; namespace Mono.CSharp { + // + // Better name would be DottenName + // public class MemberName { public readonly string Name; public readonly TypeArguments TypeArguments; @@ -51,7 +53,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 +81,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) @@ -94,6 +97,7 @@ namespace Mono.CSharp { this.Left = (right.Left == null) ? left : new MemberName (left, right.Left); } + // TODO: Remove public string GetName () { return GetName (false); @@ -113,44 +117,25 @@ namespace Mono.CSharp { public string GetName (bool is_generic) { string name = is_generic ? Basename : Name; - string connect = is_double_colon ? "::" : "."; if (Left != null) - return Left.GetName (is_generic) + connect + name; - else - return name; - } + return Left.GetName (is_generic) + (is_double_colon ? "::" : ".") + name; - public string GetTypeName () - { - string connect = is_double_colon ? "::" : "."; - if (Left != null) - return Left.GetTypeName () + connect + MakeName (Name, TypeArguments); - else - return MakeName (Name, TypeArguments); + return name; } - 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 (); @@ -167,37 +152,17 @@ namespace Mono.CSharp { get { if (TypeArguments != null) return MakeName (Name, TypeArguments); - else - return Name; - } - } - - public string FullName { - get { - if (TypeArguments != null) - return Name + "<" + TypeArguments + ">"; - else - return Name; + return Name; } } - public string MethodName { - get { - string connect = is_double_colon ? "::" : "."; - if (Left != null) - return Left.FullName + connect + Name; - else - return Name; - } - } - - public override string ToString () + 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 +208,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; } } @@ -254,37 +221,14 @@ namespace Mono.CSharp { { if (args == null) return name; - else - return name + "`" + args.Count; + + return name + "`" + args.Count; } public static string MakeName (string name, int count) { 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; - } } /// @@ -297,6 +241,7 @@ namespace Mono.CSharp { /// protected string cached_name; + // TODO: Remove in favor of MemberName public string Name { get { if (cached_name == null) @@ -314,9 +259,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 +303,12 @@ 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 + HasStructLayout = 1 << 15 // Has StructLayoutAttribute } /// @@ -373,6 +330,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 +406,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 (); } /// @@ -403,7 +419,17 @@ namespace Mono.CSharp { if (!RootContext.VerifyClsCompliance) return; - VerifyClsCompliance (); + if (Report.WarningLevel > 0) + VerifyClsCompliance (); + } + + public bool IsCompilerGenerated { + get { + if ((mod_flags & Modifiers.COMPILER_GENERATED) != 0) + return true; + + return Parent == null ? false : Parent.IsCompilerGenerated; + } } public virtual bool IsUsed { @@ -420,26 +446,24 @@ namespace Mono.CSharp { /// public virtual ObsoleteAttribute GetObsoleteAttribute () { - // ((flags & (Flags.Obsolete_Undetected | Flags.Obsolete)) == 0) is slower, but why ? - if ((caching_flags & Flags.Obsolete_Undetected) == 0 && (caching_flags & Flags.Obsolete) == 0) { + if ((caching_flags & (Flags.Obsolete_Undetected | Flags.Obsolete)) == 0) return null; - } caching_flags &= ~Flags.Obsolete_Undetected; - if (OptAttributes == null) + if (OptAttributes == null || TypeManager.obsolete_attribute_type == null) return null; - Attribute obsolete_attr = OptAttributes.Search ( - TypeManager.obsolete_attribute_type); + Attribute obsolete_attr = OptAttributes.Search (TypeManager.obsolete_attribute_type); if (obsolete_attr == null) return null; + caching_flags |= Flags.Obsolete; + ObsoleteAttribute obsolete = obsolete_attr.GetObsoleteAttribute (); if (obsolete == null) return null; - caching_flags |= Flags.Obsolete; return obsolete; } @@ -448,15 +472,162 @@ namespace Mono.CSharp { /// public virtual void CheckObsoleteness (Location loc) { - if (Parent != null) - Parent.CheckObsoleteness (loc); - ObsoleteAttribute oa = GetObsoleteAttribute (); - if (oa == null) { - return; + if (oa != null) + 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 (TypeManager.HasElementType (p)) + 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; - AttributeTester.Report_ObsoleteMessage (oa, GetSignatureForError (), loc); + 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; } /// @@ -505,7 +676,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 +687,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 +704,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 +728,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) @@ -561,7 +739,7 @@ namespace Mono.CSharp { if (HasClsCompliantAttribute) { if (CodeGen.Assembly.ClsCompliantAttribute == null && !CodeGen.Assembly.IsClsCompliant) { - Report.Error (3014, Location, + Report.Warning (3014, 1, Location, "`{0}' cannot be marked as CLS-compliant because the assembly is not marked as CLS-compliant", GetSignatureForError ()); return false; @@ -575,7 +753,7 @@ namespace Mono.CSharp { } if (member_name.Name [0] == '_') { - Report.Error (3008, Location, "Identifier `{0}' is not CLS-compliant", GetSignatureForError () ); + Report.Warning (3008, 1, Location, "Identifier `{0}' is not CLS-compliant", GetSignatureForError () ); } return true; } @@ -606,7 +784,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 +862,10 @@ 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; + protected TypeParameter[] type_params; + TypeParameter[] type_param_list; // // Whether we are Generic @@ -710,7 +893,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 +915,7 @@ namespace Mono.CSharp { return true; } - if (symbol.MarkForDuplicationCheck () && mc.MarkForDuplicationCheck ()) + if (symbol.EnableOverloadChecks (mc)) return true; Report.SymbolRelatedToPreviousError (mc); @@ -747,7 +930,7 @@ namespace Mono.CSharp { ((DeclSpace)symbol).NamespaceEntry.GetSignatureForError (), symbol.MemberName.Name); } else if (symbol is TypeParameter) { Report.Error (692, symbol.Location, - "Duplicate type parameter `{0}'", name); + "Duplicate type parameter `{0}'", symbol.GetSignatureForError ()); } else { Report.Error (102, symbol.Location, "The type `{0}' already contains a definition for `{1}'", @@ -757,6 +940,11 @@ namespace Mono.CSharp { return false; } + protected void RemoveFromContainer (string name) + { + defined_names.Remove (name); + } + /// /// Returns the MemberCore associated with a given name in the declaration /// space. It doesn't return method based symbols !! @@ -810,19 +998,6 @@ namespace Mono.CSharp { /// public abstract TypeBuilder DefineType (); - /// - /// Define all members, but don't apply any attributes or do anything which may - /// access not-yet-defined classes. This method also creates the MemberCache. - /// - public virtual bool DefineMembers () - { - if (((ModFlags & Modifiers.NEW) != 0) && IsTopLevel) { - Report.Error (1530, Location, "Keyword `new' is not allowed on namespace elements"); - return false; - } - return true; - } - protected void Error_MissingPartialModifier (MemberCore type) { Report.Error (260, type.Location, @@ -830,32 +1005,44 @@ 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 (); + } + + if ((ModFlags & Modifiers.COMPILER_GENERATED) != 0 && !Parent.IsCompilerGenerated) + TypeBuilder.SetCustomAttribute (TypeManager.GetCompilerGeneratedAttribute (Location)); +#endif + + base.Emit (); + } + public override string GetSignatureForError () { - if (IsGeneric) { - return SimpleName.RemoveGenericArity (Name) + TypeParameter.GetSignatureForError (CurrentTypeParameters); - } - // Parent.GetSignatureForError - return Name; + return MemberName.GetSignatureForError (); } public bool CheckAccessLevel (Type check_type) { - TypeBuilder tb; - if (this is GenericMethod) + TypeBuilder tb = TypeBuilder; +#if GMCS_SOURCE + if (this is GenericMethod) { tb = Parent.TypeBuilder; - else - tb = TypeBuilder; + + // FIXME: Generic container does not work with nested generic + // anonymous method stories + if (TypeBuilder == null) + return true; + } +#endif check_type = TypeManager.DropGenericTypeArguments (check_type); if (check_type == tb) return true; - - if (TypeBuilder == null) - // FIXME: TypeBuilder will be null when invoked by Class.GetNormalBases(). - // However, this is invoked again later -- so safe to return true. - // May also be null when resolving top-level attributes. - return true; // // Broken Microsoft runtime, return public for arrays, no matter what @@ -865,9 +1052,6 @@ namespace Mono.CSharp { if (check_type.IsArray || check_type.IsPointer) return CheckAccessLevel (TypeManager.GetElementType (check_type)); - if (TypeManager.IsGenericParameter(check_type)) - return true; // FIXME - TypeAttributes check_attr = check_type.Attributes & TypeAttributes.VisibilityMask; switch (check_attr){ @@ -875,23 +1059,14 @@ namespace Mono.CSharp { return true; case TypeAttributes.NotPublic: - - if (TypeBuilder == null) - // FIXME: TypeBuilder will be null when invoked by Class.GetNormalBases(). - // 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; + return CheckAccessLevel (check_type.DeclaringType); case TypeAttributes.NestedPrivate: - return NestedAccessible (tb, check_type); + Type declaring = check_type.DeclaringType; + return tb == declaring || TypeManager.IsNestedChildOf (tb, declaring); case TypeAttributes.NestedFamily: // @@ -900,156 +1075,63 @@ 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); - return false; - + throw new NotImplementedException (check_attr.ToString ()); } - protected bool NestedAccessible (Type tb, Type check_type) + static bool FamilyAccessible (Type tb, Type check_type) { Type declaring = check_type.DeclaringType; - return TypeBuilder == declaring || - TypeManager.IsNestedChildOf (TypeBuilder, declaring); + return TypeManager.IsNestedFamilyAccessible (tb, declaring); } - protected bool FamilyAccessible (Type tb, Type check_type) + public bool IsBaseType (Type baseType) { - Type declaring = check_type.DeclaringType; - return TypeManager.IsNestedFamilyAccessible (TypeBuilder, declaring); - } + if (TypeManager.IsInterfaceType (baseType)) + throw new NotImplementedException (); - // 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; - } + Type type = TypeBuilder; + while (type != null) { + if (TypeManager.IsEqual (type, baseType)) + return true; - // 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; + type = type.BaseType; } - } - - // 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 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 GMCS_SOURCE - if (p.IsGenericParameter) - return true; - - if (TypeManager.IsGenericType (p)) { - foreach (Type t in p.GetGenericArguments ()) { - if (!AsAccessible (t, flags)) - return false; - } - } -#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) { @@ -1085,7 +1167,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; } @@ -1103,6 +1185,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); @@ -1111,7 +1194,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; } @@ -1120,8 +1205,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 @@ -1140,45 +1230,6 @@ namespace Mono.CSharp { TypeBuilder.SetCustomAttribute (cb); } - // - // Extensions for generics - // - 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++) { - TypeParameter param = (TypeParameter) list [i]; - - if (param.Name != name) - continue; - - Report.SymbolRelatedToPreviousError (Parent); - // TODO: Location is wrong (parent instead of child) - Report.Warning (693, 3, Location, - "Type parameter `{0}' has the same name as the type parameter from outer type `{1}'", - name, Parent.GetSignatureForError ()); - - return false; - } - - return true; - } - TypeParameter[] initialize_type_params () { if (type_param_list != null) @@ -1188,20 +1239,28 @@ namespace Mono.CSharp { if (this is GenericMethod) the_parent = null; - int start = 0; ArrayList list = new ArrayList (); if (the_parent != null && the_parent.IsGeneric) { // FIXME: move generics info out of DeclSpace TypeParameter[] parent_params = the_parent.PartialContainer.TypeParameters; - start = parent_params.Length; list.AddRange (parent_params); } int count = type_params != null ? type_params.Length : 0; for (int i = 0; i < count; i++) { TypeParameter param = type_params [i]; - check_type_parameter (list, start, param.Name); list.Add (param); + if (Parent.IsGeneric) { + foreach (TypeParameter tp in Parent.PartialContainer.CurrentTypeParameters) { + if (tp.Name != param.Name) + continue; + + Report.SymbolRelatedToPreviousError (tp.Location, null); + Report.Warning (693, 3, param.Location, + "Type parameter `{0}' has the same name as the type parameter from outer type `{1}'", + param.Name, Parent.GetSignatureForError ()); + } + } } type_param_list = new TypeParameter [list.Count]; @@ -1281,12 +1340,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; } } @@ -1296,12 +1355,6 @@ namespace Mono.CSharp { } } - public int CountCurrentTypeParameters { - get { - return count_current_type_params; - } - } - public TypeParameterExpr LookupGeneric (string name, Location loc) { if (!IsGeneric) @@ -1369,11 +1422,8 @@ namespace Mono.CSharp { else { Report.SymbolRelatedToPreviousError ((DeclSpace)val); } -#if GMCS_SOURCE + Report.Warning (3005, 1, Location, "Identifier `{0}' differing only in case is not CLS-compliant", GetSignatureForError ()); -#else - Report.Error (3005, Location, "Identifier `{0}' differing only in case is not CLS-compliant", GetSignatureForError ()); -#endif return true; } } @@ -1409,7 +1459,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. @@ -1577,13 +1627,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; - } } /// @@ -1639,6 +1682,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) { // @@ -1682,18 +1734,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. @@ -1746,13 +1816,36 @@ 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, InterfaceMemberBase mc) + { + AddMember (mi.MemberType, GetBindingFlags (mc.ModFlags), Container, + MemberName.MakeName (mc.GetFullName (mc.MemberName), mc.MemberName.TypeArguments), 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); } @@ -1813,7 +1906,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); } @@ -2005,7 +2098,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, @@ -2201,7 +2294,7 @@ namespace Mono.CSharp { MethodBase mb = (MethodBase)entry.Member; IMethodData md = TypeManager.GetMethod (mb); - ParameterData pd = md == null ? + AParametersCollection pd = md == null ? TypeManager.GetParameterData (mb) : md.ParameterInfo; Type ex_type = pd.ExtensionMethodType; @@ -2229,7 +2322,7 @@ namespace Mono.CSharp { // Because the MemberCache holds members from this class and all the base classes, // we can avoid tons of reflection stuff. // - public MemberInfo FindMemberToOverride (Type invocation_type, string name, Type [] param_types, GenericMethod generic_method, bool is_property) + public MemberInfo FindMemberToOverride (Type invocation_type, string name, AParametersCollection parameters, GenericMethod generic_method, bool is_property) { ArrayList applicable; if (method_hash != null && !is_property) @@ -2251,22 +2344,19 @@ namespace Mono.CSharp { PropertyInfo pi = null; MethodInfo mi = null; FieldInfo fi = null; - Type [] cmp_attrs = null; + AParametersCollection cmp_attrs; if (is_property) { if ((entry.EntryType & EntryType.Field) != 0) { fi = (FieldInfo)entry.Member; - - // TODO: For this case we ignore member type - //fb = TypeManager.GetField (fi); - //cmp_attrs = new Type[] { fb.MemberType }; + cmp_attrs = Parameters.EmptyReadOnlyParameters; } else { pi = (PropertyInfo) entry.Member; - cmp_attrs = TypeManager.GetArgumentTypes (pi); + cmp_attrs = TypeManager.GetParameterData (pi); } } else { mi = (MethodInfo) entry.Member; - cmp_attrs = TypeManager.GetParameterData (mi).Types; + cmp_attrs = TypeManager.GetParameterData (mi); } if (fi != null) { @@ -2299,14 +2389,23 @@ namespace Mono.CSharp { // // Check the arguments // - if (cmp_attrs.Length != param_types.Length) + if (cmp_attrs.Count != parameters.Count) continue; int j; - for (j = 0; j < cmp_attrs.Length; ++j) - if (!TypeManager.IsEqual (param_types [j], cmp_attrs [j])) + for (j = 0; j < cmp_attrs.Count; ++j) { + // + // LAMESPEC: No idea why `params' modifier is ignored + // + if ((parameters.FixedParameters [j].ModFlags & ~Parameter.Modifier.PARAMS) != + (cmp_attrs.FixedParameters [j].ModFlags & ~Parameter.Modifier.PARAMS)) break; - if (j < cmp_attrs.Length) + + if (!TypeManager.IsEqual (parameters.Types [j], cmp_attrs.Types [j])) + break; + } + + if (j < cmp_attrs.Count) continue; // @@ -2314,9 +2413,9 @@ namespace Mono.CSharp { // if (mi != null) { Type [] cmpGenArgs = TypeManager.GetGenericArguments (mi); - if (generic_method == null && cmpGenArgs.Length != 0) + if (generic_method == null && cmpGenArgs != null && cmpGenArgs.Length != 0) continue; - if (generic_method != null && cmpGenArgs.Length != generic_method.TypeParameters.Length) + if (generic_method != null && cmpGenArgs != null && cmpGenArgs.Length != generic_method.TypeParameters.Length) continue; } @@ -2349,7 +2448,7 @@ namespace Mono.CSharp { // // Check for assembly methods // - if (mi.DeclaringType.Assembly != CodeGen.Assembly.Builder) + if (!TypeManager.IsThisOrFriendAssembly (mi.DeclaringType.Assembly)) continue; break; } @@ -2394,8 +2493,8 @@ namespace Mono.CSharp { // Does exist easier way how to detect indexer ? if ((entry.EntryType & EntryType.Property) != 0) { - Type[] arg_types = TypeManager.GetArgumentTypes ((PropertyInfo)entry.Member); - if (arg_types.Length > 0) + AParametersCollection arg_types = TypeManager.GetParameterData ((PropertyInfo)entry.Member); + if (arg_types.Count > 0) continue; } } @@ -2427,31 +2526,31 @@ namespace Mono.CSharp { // TODO: Does anyone know easier way how to detect that member is internal ? switch (member_entry.EntryType & EntryType.MaskType) { - case EntryType.Constructor: - continue; - - case EntryType.Field: - if ((((FieldInfo)member_entry.Member).Attributes & (FieldAttributes.Assembly | FieldAttributes.Public)) == FieldAttributes.Assembly) - continue; - break; - - case EntryType.Method: - if ((((MethodInfo)member_entry.Member).Attributes & (MethodAttributes.Assembly | MethodAttributes.Public)) == MethodAttributes.Assembly) - continue; - break; - - case EntryType.Property: - PropertyInfo pi = (PropertyInfo)member_entry.Member; - if (pi.GetSetMethod () == null && pi.GetGetMethod () == null) - continue; - break; - - case EntryType.Event: - EventInfo ei = (EventInfo)member_entry.Member; - MethodInfo mi = ei.GetAddMethod (); - if ((mi.Attributes & (MethodAttributes.Assembly | MethodAttributes.Public)) == MethodAttributes.Assembly) - continue; - break; + case EntryType.Constructor: + continue; + + case EntryType.Field: + if ((((FieldInfo)member_entry.Member).Attributes & (FieldAttributes.Assembly | FieldAttributes.Public)) == FieldAttributes.Assembly) + continue; + break; + + case EntryType.Method: + if ((((MethodInfo)member_entry.Member).Attributes & (MethodAttributes.Assembly | MethodAttributes.Public)) == MethodAttributes.Assembly) + continue; + break; + + case EntryType.Property: + PropertyInfo pi = (PropertyInfo)member_entry.Member; + if (pi.GetSetMethod () == null && pi.GetGetMethod () == null) + continue; + break; + + case EntryType.Event: + EventInfo ei = (EventInfo)member_entry.Member; + MethodInfo mi = ei.GetAddMethod (); + if ((mi.Attributes & (MethodAttributes.Assembly | MethodAttributes.Public)) == MethodAttributes.Assembly) + continue; + break; } string lcase = ((string)entry.Key).ToLower (System.Globalization.CultureInfo.InvariantCulture); locase_table [lcase] = member_entry.Member; @@ -2488,7 +2587,7 @@ namespace Mono.CSharp { MethodBase method_to_compare = (MethodBase)entry.Member; AttributeTester.Result result = AttributeTester.AreOverloadedMethodParamsClsCompliant ( - method.ParameterTypes, TypeManager.GetParameterData (method_to_compare).Types); + method.Parameters, TypeManager.GetParameterData (method_to_compare)); if (result == AttributeTester.Result.Ok) continue; @@ -2502,16 +2601,185 @@ namespace Mono.CSharp { Report.SymbolRelatedToPreviousError (entry.Member); switch (result) { - case AttributeTester.Result.RefOutArrayError: - Report.Error (3006, method.Location, "Overloaded method `{0}' differing only in ref or out, or in array rank, is not CLS-compliant", method.GetSignatureForError ()); - continue; - case AttributeTester.Result.ArrayArrayError: - Report.Error (3007, method.Location, "Overloaded method `{0}' differing only by unnamed array types is not CLS-compliant", method.GetSignatureForError ()); - continue; + case AttributeTester.Result.RefOutArrayError: + Report.Warning (3006, 1, method.Location, + "Overloaded method `{0}' differing only in ref or out, or in array rank, is not CLS-compliant", + method.GetSignatureForError ()); + continue; + case AttributeTester.Result.ArrayArrayError: + Report.Warning (3007, 1, method.Location, + "Overloaded method `{0}' differing only by unnamed array types is not CLS-compliant", + method.GetSignatureForError ()); + continue; } 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; + AParametersCollection pd; + if ((ce.EntryType & EntryType.Property) != 0) { + pd = TypeManager.GetParameterData ((PropertyInfo) ce.Member); + p_types = pd.Types; + } 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.Types [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 + if ((pd.FixedParameters [ii].ModFlags & Parameter.Modifier.ISBYREF) != + (parameters.FixedParameters [ii].ModFlags & Parameter.Modifier.ISBYREF)) + type_a = null; + + } 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 MethodCore) { + ii = method_param_count; + while (ii-- != 0 && parameters.FixedParameters [ii].ModFlags == pd.FixedParameters [ii].ModFlags && + 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; + } } }