X-Git-Url: http://wien.tomnetworks.com/gitweb/?a=blobdiff_plain;f=mcs%2Fmcs%2Fpending.cs;h=9761f2c1023954d9eeddd70f40429617d23f35e6;hb=72e4b412877dbfae80b149c068ed1f0715b2bfe1;hp=79c0fb5e24f3469ef33c96939545ae16571cee89;hpb=da4f9e9b2afb23791029d0bb09d78b868aabd870;p=mono.git diff --git a/mcs/mcs/pending.cs b/mcs/mcs/pending.cs index 79c0fb5e24f..9761f2c1023 100644 --- a/mcs/mcs/pending.cs +++ b/mcs/mcs/pending.cs @@ -1,25 +1,27 @@ // // pending.cs: Pending method implementation // -// Author: +// Authors: // Miguel de Icaza (miguel@gnu.org) +// Marek Safar (marek.safar@gmail.com) // -// Licensed under the terms of the GNU GPL -// -// (C) 2001, 2002 Ximian, Inc (http://www.ximian.com) +// Dual licensed under the terms of the MIT X11 or GNU GPL // +// Copyright 2001, 2002 Ximian, Inc (http://www.ximian.com) +// Copyright 2003-2008 Novell, Inc. // using System; -using System.Collections; +using System.Collections.Generic; using System.Reflection; using System.Reflection.Emit; +using System.Linq; namespace Mono.CSharp { struct TypeAndMethods { - public Type type; - public MethodInfo [] methods; + public TypeSpec type; + public IList methods; // // Whether it is optional, this is used to allow the explicit/implicit @@ -30,218 +32,70 @@ namespace Mono.CSharp { // class X : IA { } class Y : X, IA { IA.Explicit (); } // public bool optional; - - // Far from ideal, but we want to avoid creating a copy - // of methods above. - public Type [][] args; - - //This is used to store the modifiers of arguments - public Parameter.Modifier [][] mods; - + // // This flag on the method says `We found a match, but // because it was private, we could not use the match // - public bool [] found; + public MethodData [] found; // If a method is defined here, then we always need to // create a proxy for it. This is used when implementing // an interface's indexer with a different IndexerName. - public MethodInfo [] need_proxy; - - // - // The name of the indexer (if it exists), precompute set/get, because - // they would be recomputed many times inside a loop later on. - // - public string set_indexer_name; - public string get_indexer_name; + public MethodSpec [] need_proxy; } - public class PendingImplementation { + public class PendingImplementation + { /// /// The container for this PendingImplementation /// TypeContainer container; - /// - /// This filter is used by FindMembers, and it is used to - /// extract only virtual/abstract fields - /// - static MemberFilter virtual_method_filter; - /// /// This is the array of TypeAndMethods that describes the pending implementations /// (both interfaces and abstract methods in base class) /// TypeAndMethods [] pending_implementations; - static bool IsVirtualFilter (MemberInfo m, object filterCriteria) - { - MethodInfo mi = m as MethodInfo; - return (mi == null) ? false : mi.IsVirtual; - } - - /// - /// Inits the virtual_method_filter - /// - static PendingImplementation () + PendingImplementation (TypeContainer container, MissingInterfacesInfo[] missing_ifaces, MethodSpec[] abstract_methods, int total) { - virtual_method_filter = new MemberFilter (IsVirtualFilter); - } - - // - // Returns a list of the abstract methods that are exposed by all of our - // bases that we must implement. Notice that this `flattens' the - // method search space, and takes into account overrides. - // - static ArrayList GetAbstractMethods (Type t) - { - ArrayList list = null; - bool searching = true; - Type current_type = t; - - do { - MemberList mi; - - mi = TypeContainer.FindMembers ( - current_type, MemberTypes.Method, - BindingFlags.Public | BindingFlags.NonPublic | - BindingFlags.Instance | BindingFlags.DeclaredOnly, - virtual_method_filter, null); - - if (current_type == TypeManager.object_type) - searching = false; - else { - current_type = current_type.BaseType; - if (!current_type.IsAbstract) - searching = false; - } - - if (mi.Count == 0) - continue; - - if (mi.Count == 1 && !(mi [0] is MethodBase)) - searching = false; - else - list = TypeManager.CopyNewMethods (list, mi); - } while (searching); - - if (list == null) - return null; - - for (int i = 0; i < list.Count; i++){ - while (list.Count > i && !((MethodInfo) list [i]).IsAbstract) - list.RemoveAt (i); - } - - if (list.Count == 0) - return null; - - return list; - } - - PendingImplementation (TypeContainer container, MissingInterfacesInfo [] missing_ifaces, ArrayList abstract_methods, int total) - { - TypeBuilder type_builder = container.TypeBuilder; + var type_builder = container.Definition; this.container = container; pending_implementations = new TypeAndMethods [total]; int i = 0; - foreach (MissingInterfacesInfo missing in missing_ifaces){ - MethodInfo [] mi; - Type t = missing.Type; - - if (!t.IsInterface) - continue; + if (abstract_methods != null) { + int count = abstract_methods.Length; + pending_implementations [i].methods = new MethodSpec [count]; + pending_implementations [i].need_proxy = new MethodSpec [count]; - if (t is TypeBuilder){ - TypeContainer iface; + pending_implementations [i].methods = abstract_methods; + pending_implementations [i].found = new MethodData [count]; + pending_implementations [i].type = type_builder; + ++i; + } - iface = TypeManager.LookupInterface (t); - - mi = iface.GetMethods (); - } else - mi = t.GetMethods (); - - int count = mi.Length; - pending_implementations [i].type = t; + foreach (MissingInterfacesInfo missing in missing_ifaces) { + var iface = missing.Type; + var mi = MemberCache.GetInterfaceMembers (iface); + + int count = mi.Count; + pending_implementations [i].type = iface; pending_implementations [i].optional = missing.Optional; pending_implementations [i].methods = mi; - pending_implementations [i].args = new Type [count][]; - pending_implementations [i].mods = new Parameter.Modifier [count][]; - pending_implementations [i].found = new bool [count]; - pending_implementations [i].need_proxy = new MethodInfo [count]; - string indexer_name = TypeManager.IndexerPropertyName (t); - - pending_implementations [i].set_indexer_name = "set_" + indexer_name; - pending_implementations [i].get_indexer_name = "get_" + indexer_name; - - int j = 0; - foreach (MethodInfo m in mi){ - pending_implementations [i].args [j] = Type.EmptyTypes; - pending_implementations [i].mods [j] = null; - - // If there is a previous error, just ignore - if (m == null) - continue; - - ParameterData pd = TypeManager.GetParameterData (m); - pending_implementations [i].args [j] = pd.Types; - - if (pd.Count > 0){ - Parameter.Modifier [] pm = new Parameter.Modifier [pd.Count]; - for (int k = 0; k < pd.Count; k++) - pm [k] = pd.ParameterModifier (k); - pending_implementations [i].mods [j] = pm; - } - - j++; - } + pending_implementations [i].found = new MethodData [count]; + pending_implementations [i].need_proxy = new MethodSpec [count]; i++; } - - if (abstract_methods != null){ - int count = abstract_methods.Count; - pending_implementations [i].methods = new MethodInfo [count]; - pending_implementations [i].need_proxy = new MethodInfo [count]; - - abstract_methods.CopyTo (pending_implementations [i].methods, 0); - pending_implementations [i].found = new bool [count]; - pending_implementations [i].args = new Type [count][]; - pending_implementations [i].mods = new Parameter.Modifier [count][]; - pending_implementations [i].type = type_builder; - - string indexer_name = TypeManager.IndexerPropertyName (type_builder); - pending_implementations [i].set_indexer_name = "set_" + indexer_name; - pending_implementations [i].get_indexer_name = "get_" + indexer_name; - - int j = 0; - foreach (MemberInfo m in abstract_methods){ - MethodInfo mi = (MethodInfo) m; - - ParameterData pd = TypeManager.GetParameterData (mi); - Type [] types = pd.Types; - - pending_implementations [i].args [j] = types; - pending_implementations [i].mods [j] = null; - if (pd.Count > 0){ - Parameter.Modifier [] pm = new Parameter.Modifier [pd.Count]; - for (int k = 0; k < pd.Count; k++) - pm [k] = pd.ParameterModifier (k); - pending_implementations [i].mods [j] = pm; - } - - j++; - } - } } struct MissingInterfacesInfo { - public Type Type; + public TypeSpec Type; public bool Optional; - public MissingInterfacesInfo (Type t) + public MissingInterfacesInfo (TypeSpec t) { Type = t; Optional = false; @@ -250,42 +104,40 @@ namespace Mono.CSharp { static MissingInterfacesInfo [] EmptyMissingInterfacesInfo = new MissingInterfacesInfo [0]; - static MissingInterfacesInfo [] GetMissingInterfaces (TypeBuilder type_builder) + static MissingInterfacesInfo [] GetMissingInterfaces (TypeContainer container) { // - // Notice that TypeBuilders will only return the interfaces that the Type + // Notice that Interfaces will only return the interfaces that the Type // is supposed to implement, not all the interfaces that the type implements. // - // Even better -- on MS it returns an empty array, no matter what. - // - // Completely broken. So we do it ourselves! - // - Type [] impl = TypeManager.GetExplicitInterfaces (type_builder); + var impl = container.Definition.Interfaces; - if (impl == null || impl.Length == 0) + if (impl == null || impl.Count == 0) return EmptyMissingInterfacesInfo; - MissingInterfacesInfo [] ret = new MissingInterfacesInfo [impl.Length]; + MissingInterfacesInfo[] ret = new MissingInterfacesInfo[impl.Count]; - for (int i = 0; i < impl.Length; i++) + for (int i = 0; i < impl.Count; i++) ret [i] = new MissingInterfacesInfo (impl [i]); // we really should not get here because Object doesnt implement any // interfaces. But it could implement something internal, so we have // to handle that case. - if (type_builder.BaseType == null) + if (container.BaseType == null) return ret; - Type [] base_impls = TypeManager.GetInterfaces (type_builder.BaseType); - - foreach (Type t in base_impls) { - for (int i = 0; i < ret.Length; i ++) { - if (t == ret [i].Type) { - ret [i].Optional = true; - break; + var base_impls = container.BaseType.Interfaces; + if (base_impls != null) { + foreach (TypeSpec t in base_impls) { + for (int i = 0; i < ret.Length; i++) { + if (t == ret[i].Type) { + ret[i].Optional = true; + break; + } } } } + return ret; } @@ -298,11 +150,9 @@ namespace Mono.CSharp { // static public PendingImplementation GetPendingImplementations (TypeContainer container) { - TypeBuilder type_builder = container.TypeBuilder; - MissingInterfacesInfo [] missing_interfaces; - Type b = type_builder.BaseType; + TypeSpec b = container.BaseType; - missing_interfaces = GetMissingInterfaces (type_builder); + var missing_interfaces = GetMissingInterfaces (container); // // If we are implementing an abstract class, and we are not @@ -312,14 +162,18 @@ namespace Mono.CSharp { // // We also pre-compute the methods. // - bool implementing_abstract = ((b != null) && b.IsAbstract && !type_builder.IsAbstract); - ArrayList abstract_methods = null; + bool implementing_abstract = ((b != null) && b.IsAbstract && (container.ModFlags & Modifiers.ABSTRACT) == 0); + MethodSpec[] abstract_methods = null; if (implementing_abstract){ - abstract_methods = GetAbstractMethods (b); - - if (abstract_methods == null) + var am = MemberCache.GetNotImplementedAbstractMethods (b); + + if (am == null) { implementing_abstract = false; + } else { + abstract_methods = new MethodSpec[am.Count]; + am.CopyTo (abstract_methods, 0); + } } int total = missing_interfaces.Length + (implementing_abstract ? 1 : 0); @@ -340,28 +194,16 @@ namespace Mono.CSharp { /// /// Whether the specified method is an interface method implementation /// - public MethodInfo IsInterfaceMethod (Type t, string name, Type ret_type, ParameterData args) + public MethodSpec IsInterfaceMethod (MemberName name, TypeSpec ifaceType, MethodData method) { - return InterfaceMethod (t, name, ret_type, args, Operation.Lookup, null); + return InterfaceMethod (name, ifaceType, method, Operation.Lookup); } - public MethodInfo IsInterfaceIndexer (Type t, Type ret_type, ParameterData args) + public void ImplementMethod (MemberName name, TypeSpec ifaceType, MethodData method, bool clear_one) { - return InterfaceMethod (t, null, ret_type, args, Operation.Lookup, null); + InterfaceMethod (name, ifaceType, method, clear_one ? Operation.ClearOne : Operation.ClearAll); } - public void ImplementMethod (Type t, string name, Type ret_type, ParameterData args, bool clear_one) - { - InterfaceMethod (t, name, ret_type, args, - clear_one ? Operation.ClearOne : Operation.ClearAll, null); - } - - public void ImplementIndexer (Type t, MethodInfo mi, Type ret_type, ParameterData args, bool clear_one) - { - InterfaceMethod (t, null, ret_type, args, - clear_one ? Operation.ClearOne : Operation.ClearAll, mi); - } - /// /// If a method in Type `t' (or null to look in all interfaces /// and the base abstract class) with name `Name', return type `ret_type' and @@ -379,27 +221,45 @@ namespace Mono.CSharp { /// that was used in the interface, then we always need to create a proxy for it. /// /// - public MethodInfo InterfaceMethod (Type t, string name, Type ret_type, ParameterData args, - Operation op, MethodInfo need_proxy) + public MethodSpec InterfaceMethod (MemberName name, TypeSpec iType, MethodData method, Operation op) { - int arg_len = args.Count; - if (pending_implementations == null) return null; + TypeSpec ret_type = method.method.ReturnType; + ParametersCompiled args = method.method.ParameterInfo; + bool is_indexer = method.method is Indexer.SetIndexerMethod || method.method is Indexer.GetIndexerMethod; + foreach (TypeAndMethods tm in pending_implementations){ - if (!(t == null || tm.type == t)) + if (!(iType == null || tm.type == iType)) continue; - int method_count = tm.methods.Length; - MethodInfo m; + int method_count = tm.methods.Count; + MethodSpec m; for (int i = 0; i < method_count; i++){ m = tm.methods [i]; if (m == null) continue; - string mname = TypeManager.GetMethodName (m); + if (is_indexer) { + if (!m.IsAccessor || m.Parameters.IsEmpty) + continue; + } else { + if (name.Name != m.Name) + continue; + + if (m.Arity != name.Arity) + continue; + } + + if (!TypeSpecComparer.Override.IsEqual (m.Parameters, args)) + continue; + + if (!TypeSpecComparer.Override.IsEqual (m.ReturnType, ret_type)) { + tm.found[i] = method; + continue; + } // // `need_proxy' is not null when we're implementing an @@ -409,60 +269,21 @@ namespace Mono.CSharp { // signature and not on the name (this is done in the Lookup // for an interface indexer). // - if (name == null){ - if (mname != tm.get_indexer_name && mname != tm.set_indexer_name) - continue; - } else if ((need_proxy == null) && (name != mname)) - continue; - - if (!TypeManager.IsEqual (ret_type, m.ReturnType) && - !(ret_type == null && m.ReturnType == TypeManager.void_type) && - !(m.ReturnType == null && ret_type == TypeManager.void_type)) - continue; - - // - // Check if we have the same parameters - // - - if (tm.args [i] == null && arg_len != 0) - continue; - if (tm.args [i] != null && tm.args [i].Length != arg_len) - continue; - - int j; - - for (j = 0; j < arg_len; j++) { - if (!TypeManager.IsEqual (tm.args [i][j], args.ParameterType (j))) - break; - if (tm.mods [i][j] == args.ParameterModifier (j)) - continue; - // The modifiers are different, but if one of them - // is a PARAMS modifier, and the other isn't, ignore - // the difference. - if (tm.mods [i][j] != Parameter.Modifier.PARAMS && - args.ParameterModifier (j) != Parameter.Modifier.PARAMS) - break; - } - if (j != arg_len) - continue; - - if (op != Operation.Lookup){ + if (op != Operation.Lookup) { // If `t != null', then this is an explicitly interface // implementation and we can always clear the method. // `need_proxy' is not null if we're implementing an // interface indexer. In this case, we need to create // a proxy if the implementation's IndexerName doesn't // match the IndexerName in the interface. - bool name_matches = false; - if (name == mname || mname == tm.get_indexer_name || mname == tm.set_indexer_name) - name_matches = true; - - if ((t == null) && (need_proxy != null) && !name_matches) - tm.need_proxy [i] = need_proxy; - else - tm.methods [i] = null; + if (m.DeclaringType.IsInterface && iType == null && name.Name != m.Name) { // TODO: This is very expensive comparison + tm.need_proxy[i] = method.method.Spec; + } else { + tm.methods[i] = null; + } + } else { + tm.found [i] = method; } - tm.found [i] = true; // // Lookups and ClearOne return @@ -472,7 +293,7 @@ namespace Mono.CSharp { } // If a specific type was requested, we can stop now. - if (tm.type == t) + if (tm.type == iType) return null; } return null; @@ -487,39 +308,48 @@ namespace Mono.CSharp { /// For that case, we create an explicit implementation function /// I.M in Y. /// - void DefineProxy (Type iface, MethodInfo base_method, MethodInfo iface_method, - Type [] args) + void DefineProxy (TypeSpec iface, MethodSpec base_method, MethodSpec iface_method) { - MethodBuilder proxy; + // TODO: Handle nested iface names + string proxy_name; + var ns = iface.MemberDefinition.Namespace; + if (string.IsNullOrEmpty (ns)) + proxy_name = iface.MemberDefinition.Name + "." + iface_method.Name; + else + proxy_name = ns + "." + iface.MemberDefinition.Name + "." + iface_method.Name; - string proxy_name = SimpleName.RemoveGenericArity (iface.Name) + '.' + iface_method.Name; + var param = iface_method.Parameters; - proxy = container.TypeBuilder.DefineMethod ( + MethodBuilder proxy = container.TypeBuilder.DefineMethod ( proxy_name, MethodAttributes.HideBySig | MethodAttributes.NewSlot | + MethodAttributes.CheckAccessOnOverride | MethodAttributes.Virtual, CallingConventions.Standard | CallingConventions.HasThis, - base_method.ReturnType, args); + base_method.ReturnType.GetMetaInfo (), param.GetMetaInfo ()); + + if (iface_method.IsGeneric) { + var gnames = iface_method.GenericDefinition.TypeParameters.Select (l => l.Name).ToArray (); + proxy.DefineGenericParameters (gnames); + } - ParameterData pd = TypeManager.GetParameterData (iface_method); - proxy.DefineParameter (0, ParameterAttributes.None, ""); - for (int i = 0; i < pd.Count; i++) { - string name = pd.ParameterName (i); - ParameterAttributes attr = Parameter.GetParameterAttributes (pd.ParameterModifier (i)); + for (int i = 0; i < param.Count; i++) { + string name = param.FixedParameters [i].Name; + ParameterAttributes attr = ParametersCompiled.GetParameterAttribute (param.FixedParameters [i].ModFlags); proxy.DefineParameter (i + 1, attr, name); } - int top = args.Length; - ILGenerator ig = proxy.GetILGenerator (); + int top = param.Count; + var ec = new EmitContext (null, proxy.GetILGenerator (), null); for (int i = 0; i <= top; i++) - ParameterReference.EmitLdArg (ig, i); + ParameterReference.EmitLdArg (ec, i); - ig.Emit (OpCodes.Call, base_method); - ig.Emit (OpCodes.Ret); + ec.Emit (OpCodes.Call, base_method); + ec.Emit (OpCodes.Ret); - container.TypeBuilder.DefineMethodOverride (proxy, iface_method); + container.TypeBuilder.DefineMethodOverride (proxy, (MethodInfo) iface_method.GetMetaInfo ()); } /// @@ -527,35 +357,26 @@ namespace Mono.CSharp { /// the given method (which turns out, it is valid to have an interface /// implementation in a base /// - bool BaseImplements (Type iface_type, MethodInfo mi) + bool BaseImplements (TypeSpec iface_type, MethodSpec mi, out MethodSpec base_method) { - MethodSignature ms; - - Type [] args = TypeManager.GetParameterData (mi).Types; - ms = new MethodSignature (mi.Name, mi.ReturnType, args); - MemberList list = TypeContainer.FindMembers ( - container.TypeBuilder.BaseType, MemberTypes.Method | MemberTypes.Property, - BindingFlags.Public | BindingFlags.Instance, - MethodSignature.method_signature_filter, ms); - - if (list.Count == 0) - return false; + var base_type = container.BaseType; + base_method = (MethodSpec) MemberCache.FindMember (base_type, new MemberFilter (mi), BindingRestriction.None); - if (TypeManager.ImplementsInterface (container.TypeBuilder.BaseType, iface_type)) - return true; - - // - // FIXME: We should be creating fewer proxies. The runtime can handle most cases. - // At worst, if we can't avoid creating the proxy, we may need to make the - // proxy use Callvirt. - // - MethodInfo base_method = (MethodInfo) list [0]; + if (base_method == null || (base_method.Modifiers & Modifiers.PUBLIC) == 0) + return false; if (base_method.DeclaringType.IsInterface) return false; + // Why was it here ???? + //if (TypeManager.ImplementsInterface (base_type, iface_type)) { + // return true; + //} + if (!base_method.IsAbstract && !base_method.IsVirtual) - DefineProxy (iface_type, base_method, mi, args); + // FIXME: We can avoid creating a proxy if base_method can be marked 'final virtual' instead. + // However, it's too late now, the MethodBuilder has already been created (see bug 377519) + DefineProxy (iface_type, base_method, mi); return true; } @@ -564,68 +385,76 @@ namespace Mono.CSharp { /// Verifies that any pending abstract methods or interface methods /// were implemented. /// - public bool VerifyPendingMethods () + public bool VerifyPendingMethods (Report Report) { int top = pending_implementations.Length; bool errors = false; int i; for (i = 0; i < top; i++){ - Type type = pending_implementations [i].type; - int j = 0; + TypeSpec type = pending_implementations [i].type; bool base_implements_type = type.IsInterface && - container.TypeBuilder.BaseType != null && - TypeManager.ImplementsInterface (container.TypeBuilder.BaseType, type); + container.BaseType != null && + container.BaseType.ImplementsInterface (type); - foreach (MethodInfo mi in pending_implementations [i].methods){ + for (int j = 0; j < pending_implementations [i].methods.Count; ++j) { + var mi = pending_implementations[i].methods[j]; if (mi == null) continue; if (type.IsInterface){ - MethodInfo need_proxy = + var need_proxy = pending_implementations [i].need_proxy [j]; if (need_proxy != null) { - Type [] args = TypeManager.GetParameterData (mi).Types; - DefineProxy (type, need_proxy, mi, args); + DefineProxy (type, need_proxy, mi); continue; } - if (base_implements_type || BaseImplements (type, mi)) - continue; - if (pending_implementations [i].optional) continue; + MethodSpec candidate = null; + if (base_implements_type || BaseImplements (type, mi, out candidate)) + continue; + + if (candidate == null) { + MethodData md = pending_implementations [i].found [j]; + if (md != null) + candidate = md.method.Spec; + } + Report.SymbolRelatedToPreviousError (mi); - if (pending_implementations [i].found [j]) { - if (mi.IsSpecialName) { - string name = TypeManager.CSharpName (mi.DeclaringType) + '.' + mi.Name.Substring (4); - Report.Error (551, container.Location, "Explicit interface implementation `{0}.{1}' is missing accessor `{2}'", - container.GetSignatureForError (), name, TypeManager.CSharpSignature (mi, true)); + if (candidate != null) { + Report.SymbolRelatedToPreviousError (candidate); + if (candidate.IsStatic) { + Report.Error (736, container.Location, + "`{0}' does not implement interface member `{1}' and the best implementing candidate `{2}' is static", + container.GetSignatureForError (), mi.GetSignatureForError (), TypeManager.CSharpSignature (candidate)); + } else if ((candidate.Modifiers & Modifiers.PUBLIC) == 0) { + Report.Error (737, container.Location, + "`{0}' does not implement interface member `{1}' and the best implementing candidate `{2}' in not public", + container.GetSignatureForError (), mi.GetSignatureForError (), candidate.GetSignatureForError ()); } else { - string[] methodLabel = TypeManager.CSharpSignature (mi).Split ('.'); - Report.Error (536, container.Location, - "`{0}' does not implement interface member `{1}'. `{2}.{3}' " + - "is either static, not public, or has the wrong return type", - container.Name, TypeManager.CSharpSignature (mi), - container.Name, methodLabel[methodLabel.Length - 1]); + Report.Error (738, container.Location, + "`{0}' does not implement interface member `{1}' and the best implementing candidate `{2}' return type `{3}' does not match interface member return type `{4}'", + container.GetSignatureForError (), mi.GetSignatureForError (), TypeManager.CSharpSignature (candidate), + TypeManager.CSharpName (candidate.ReturnType), TypeManager.CSharpName (mi.ReturnType)); } - } - else { + } else { Report.Error (535, container.Location, "`{0}' does not implement interface member `{1}'", - container.GetSignatureForError (), TypeManager.CSharpSignature (mi)); + container.GetSignatureForError (), mi.GetSignatureForError ()); } } else { + Report.SymbolRelatedToPreviousError (mi); Report.Error (534, container.Location, "`{0}' does not implement inherited abstract member `{1}'", - container.GetSignatureForError (), TypeManager.CSharpSignature (mi, true)); + container.GetSignatureForError (), mi.GetSignatureForError ()); } errors = true; - j++; } } return errors; } - } /* end of class */ + } }