[640722] Consider delegate parameters when checking member hiding

diff --git a/mcs/mcs/delegate.cs b/mcs/mcs/delegate.cs
index d329c2f42fd6a06e99a64ec04381881bc1bb66b4..c91164d6e4143254c2c08479d72d2ca315323ad0 100644 (file)
--- a/mcs/mcs/delegate.cs
+++ b/mcs/mcs/delegate.cs
@@ -22,10 +22,10 @@ namespace Mono.CSharp {
        //
        // Delegate container implementation
        //
-       public class Delegate : TypeContainer
+       public class Delegate : TypeContainer, IParametersMember
        {
                FullNamedExpression ReturnType;
-               public readonly ParametersCompiled Parameters;
+               readonly ParametersCompiled parameters;
 
                Constructor Constructor;
                Method InvokeBuilder;
@@ -59,10 +59,24 @@ namespace Mono.CSharp {
                        ModFlags        = ModifiersExtensions.Check (AllowedModifiers, mod_flags,
                                                           IsTopLevel ? Modifiers.INTERNAL :
                                                           Modifiers.PRIVATE, name.Location, Report);
-                       Parameters      = param_list;
+                       parameters      = param_list;
                        spec = new TypeSpec (Kind, null, this, null, ModFlags | Modifiers.SEALED);
                }
 
+               #region Properties
+               public TypeSpec MemberType {
+                       get {
+                               return ReturnType.Type;
+                       }
+               }
+
+               public AParametersCollection Parameters {
+                       get {
+                               return parameters;
+                       }
+               }
+               #endregion
+
                public override void ApplyAttributeBuilder (Attribute a, MethodSpec ctor, byte[] cdata, PredefinedAttributes pa)
                {
                        if (a.Target == AttributeTargets.ReturnValue) {
@@ -105,7 +119,7 @@ namespace Mono.CSharp {
                        // First, call the `out of band' special method for
                        // defining recursively any types we need:
                        //
-                       var p = Parameters;
+                       var p = parameters;
 
                        if (!p.Resolve (this))
                                return false;
@@ -222,7 +236,7 @@ namespace Mono.CSharp {
 
                                int param = 0;
                                for (int i = 0; i < Parameters.FixedParameters.Length; ++i) {
-                                       Parameter p = Parameters [i];
+                                       Parameter p = parameters [i];
                                        if ((p.ModFlags & Parameter.Modifier.ISBYREF) == 0)
                                                continue;
 
@@ -251,7 +265,7 @@ namespace Mono.CSharp {
                public override void DefineConstants ()
                {
                        if (!Parameters.IsEmpty) {
-                               Parameters.ResolveDefaultValues (this);
+                               parameters.ResolveDefaultValues (this);
                        }
                }
 
@@ -272,7 +286,7 @@ namespace Mono.CSharp {
                                }
                        }
 
-                       Parameters.ApplyAttributes (this, InvokeBuilder.MethodBuilder);
+                       parameters.ApplyAttributes (this, InvokeBuilder.MethodBuilder);
                        
                        Constructor.ConstructorBuilder.SetImplementationFlags (MethodImplAttributes.Runtime);
                        InvokeBuilder.MethodBuilder.SetImplementationFlags (MethodImplAttributes.Runtime);
@@ -319,7 +333,7 @@ namespace Mono.CSharp {
                                return false;
                        }
 
-                       Parameters.VerifyClsCompliance (this);
+                       parameters.VerifyClsCompliance (this);
 
                        if (!ReturnType.Type.IsCLSCompliant ()) {
                                Report.Warning (3002, 1, Location, "Return type of `{0}' is not CLS-compliant",

diff --git a/mcs/mcs/membercache.cs b/mcs/mcs/membercache.cs
index 7a5b09e0361435b8ffc5d85a52ab0b03d3bc6da1..0dabf85b80f696ca392f8a65fb6d88001c0e8292 100644 (file)
--- a/mcs/mcs/membercache.cs
+++ b/mcs/mcs/membercache.cs
@@ -510,10 +510,18 @@ namespace Mono.CSharp {
                                                }
 
                                                //
-                                               // Is the member of the correct type ?
-                                               // Destructors are ignored as they cannot be overridden by user
+                                               // Is the member of same type ?
+                                               //
                                                if ((entry.Kind & ~MemberKind.Destructor & mkind & MemberKind.MaskType) == 0) {
-                                                       if ((entry.Kind & MemberKind.Destructor) == 0 && (member_param == null || !(entry is IParametersMember))) {
+                                                       // Destructors are ignored as they cannot be overridden by user
+                                                       if ((entry.Kind & MemberKind.Destructor) != 0)
+                                                               continue;
+
+                                                       // Only different arity methods hide
+                                                       if (mkind != MemberKind.Method && member.MemberName.Arity != entry.Arity)
+                                                               continue;
+                                                       
+                                                       if ((member_param == null || !(entry is IParametersMember))) {
                                                                bestCandidate = entry;
                                                                return null;
                                                        }
@@ -535,13 +543,21 @@ namespace Mono.CSharp {
                                                                continue;
 
                                                        var pm = entry as IParametersMember;
-                                                       if (pm == null)
-                                                               continue;
+                                                       AParametersCollection entry_parameters;
+                                                       if (pm == null) {
+                                                               if (entry.Kind != MemberKind.Delegate)
+                                                                       continue;
+
+                                                               // TODO: I don't have DelegateSpec
+                                                               entry_parameters = Delegate.GetParameters (member.Compiler, (TypeSpec) entry);
+                                                       } else {
+                                                               entry_parameters = pm.Parameters;
+                                                       }
 
                                                        if (entry.IsAccessor != member is AbstractPropertyEventMethod)
                                                                continue;
 
-                                                       if (!TypeSpecComparer.Override.IsEqual (pm.Parameters, member_param))
+                                                       if (!TypeSpecComparer.Override.IsEqual (entry_parameters, member_param))
                                                                continue;
                                                }