CanImport() just returns false, without throwing error.

[mono.git] / mcs / mcs / method.cs

diff --git a/mcs/mcs/method.cs b/mcs/mcs/method.cs
index 90f13cd98f32e1344f6a395e742b0102fd9ee8a8..a5d7bb24a8a41a736800a454dd89cb965d68e7fb 100644 (file)
--- a/mcs/mcs/method.cs
+++ b/mcs/mcs/method.cs
@@ -716,6 +716,12 @@ namespace Mono.CSharp {
 
                #region IMethodData Members
 
+               bool IMethodData.IsAccessor {
+                       get {
+                               return false;
+                       }
+               }
+
                public TypeSpec ReturnType {
                        get {
                                return MemberType;
@@ -1432,7 +1438,15 @@ namespace Mono.CSharp {
                }
 
                public override AttributeTargets AttributeTargets {
-                       get { return AttributeTargets.Constructor; }
+                       get {
+                               return AttributeTargets.Constructor;
+                       }
+               }
+
+               bool IMethodData.IsAccessor {
+                       get {
+                               return false;
+                       }
                }
 
                //
@@ -1621,7 +1635,7 @@ namespace Mono.CSharp {
                        block = null;
                }
 
-               protected override MemberSpec FindBaseMember (out MemberSpec bestCandidate)
+               protected override MemberSpec FindBaseMember (out MemberSpec bestCandidate, ref bool overrides)
                {
                        // Is never override
                        bestCandidate = null;
@@ -1710,6 +1724,7 @@ namespace Mono.CSharp {
                GenericMethod GenericMethod { get; }
                ParametersCompiled ParameterInfo { get; }
                MethodSpec Spec { get; }
+               bool IsAccessor { get; }
 
                Attributes OptAttributes { get; }
                ToplevelBlock Block { get; set; }
@@ -1784,24 +1799,25 @@ namespace Mono.CSharp {
                        TypeContainer container = parent.PartialContainer;
 
                        PendingImplementation pending = container.PendingImplementations;
-                       if (pending != null){
-                               implementing = pending.IsInterfaceMethod (method.MethodName, member.InterfaceType, this);
+                       MethodSpec ambig_iface_method;
+                       if (pending != null) {
+                               implementing = pending.IsInterfaceMethod (method.MethodName, member.InterfaceType, this, out ambig_iface_method);
 
-                               if (member.InterfaceType != null){
-                                       if (implementing == null){
+                               if (member.InterfaceType != null) {
+                                       if (implementing == null) {
                                                if (member is PropertyBase) {
                                                        Report.Error (550, method.Location, "`{0}' is an accessor not found in interface member `{1}{2}'",
-                                                                     method.GetSignatureForError (), TypeManager.CSharpName (member.InterfaceType),
-                                                                     member.GetSignatureForError ().Substring (member.GetSignatureForError ().LastIndexOf ('.')));
+                                                                         method.GetSignatureForError (), TypeManager.CSharpName (member.InterfaceType),
+                                                                         member.GetSignatureForError ().Substring (member.GetSignatureForError ().LastIndexOf ('.')));
 
                                                } else {
                                                        Report.Error (539, method.Location,
-                                                                     "`{0}.{1}' in explicit interface declaration is not a member of interface",
-                                                                     TypeManager.CSharpName (member.InterfaceType), member.ShortName);
+                                                                         "`{0}.{1}' in explicit interface declaration is not a member of interface",
+                                                                         TypeManager.CSharpName (member.InterfaceType), member.ShortName);
                                                }
                                                return false;
                                        }
-                                       if (implementing.IsAccessor && !(method is AbstractPropertyEventMethod)) {
+                                       if (implementing.IsAccessor && !method.IsAccessor) {
                                                Report.SymbolRelatedToPreviousError (implementing);
                                                Report.Error (683, method.Location, "`{0}' explicit method implementation cannot implement `{1}' because it is an accessor",
                                                        member.GetSignatureForError (), TypeManager.CSharpSignature (implementing));
@@ -1809,8 +1825,7 @@ namespace Mono.CSharp {
                                        }
                                } else {
                                        if (implementing != null) {
-                                               AbstractPropertyEventMethod prop_method = method as AbstractPropertyEventMethod;
-                                               if (prop_method == null) {
+                                               if (!method.IsAccessor) {
                                                        if (implementing.IsAccessor) {
                                                                Report.SymbolRelatedToPreviousError (implementing);
                                                                Report.Error (470, method.Location, "Method `{0}' cannot implement interface accessor `{1}'",
@@ -1822,7 +1837,7 @@ namespace Mono.CSharp {
                                                                Report.Error (686, method.Location, "Accessor `{0}' cannot implement interface member `{1}' for type `{2}'. Use an explicit interface implementation",
                                                                        method.GetSignatureForError (), TypeManager.CSharpSignature (implementing), container.GetSignatureForError ());
                                                        } else {
-                                                               PropertyBase.PropertyMethod pm = prop_method as PropertyBase.PropertyMethod;
+                                                               PropertyBase.PropertyMethod pm = method as PropertyBase.PropertyMethod;
                                                                if (pm != null && pm.HasCustomAccessModifier && (pm.ModFlags & Modifiers.PUBLIC) == 0) {
                                                                        Report.SymbolRelatedToPreviousError (implementing);
                                                                        Report.Error (277, method.Location, "Accessor `{0}' must be declared public to implement interface member `{1}'",
@@ -1832,6 +1847,8 @@ namespace Mono.CSharp {
                                                }
                                        }
                                }
+                       } else {
+                               ambig_iface_method = null;
                        }
 
                        //
@@ -1852,6 +1869,15 @@ namespace Mono.CSharp {
                                                Report.Error (466, method.Location, "`{0}': the explicit interface implementation cannot introduce the params modifier",
                                                        method.GetSignatureForError ());
                                        }
+
+                                       if (ambig_iface_method != null) {
+                                               Report.SymbolRelatedToPreviousError (ambig_iface_method);
+                                               Report.SymbolRelatedToPreviousError (implementing);
+                                               Report.Warning (473, 2, method.Location,
+                                                       "Explicit interface implementation `{0}' matches more than one interface member. Consider using a non-explicit implementation instead",
+                                                       method.GetSignatureForError ());
+                                       }
+
                                } else {
                                        if (implementing.DeclaringType.IsInterface) {
                                                //
@@ -1905,7 +1931,7 @@ namespace Mono.CSharp {
                                // clear the pending implementation flag (requires explicit methods to be defined first)
                                //
                                parent.PartialContainer.PendingImplementations.ImplementMethod (method.MethodName,
-                                       member.InterfaceType, this, member.IsExplicitImpl);
+                                       member.InterfaceType, this, member.IsExplicitImpl, out ambig_iface_method);
 
                                //
                                // Update indexer accessor name to match implementing abstract accessor
@@ -2135,6 +2161,12 @@ namespace Mono.CSharp {
                        return new EmitContext (this, ig, ReturnType);
                }
 
+               public bool IsAccessor {
+                       get {
+                               return true;
+                       }
+               }
+
                public bool IsExcluded ()
                {
                        return false;
@@ -2528,7 +2560,7 @@ namespace Mono.CSharp {
                        return true;
                }
 
-               protected override MemberSpec FindBaseMember (out MemberSpec bestCandidate)
+               protected override MemberSpec FindBaseMember (out MemberSpec bestCandidate, ref bool overrides)
                {
                        // Operator cannot be override
                        bestCandidate = null;