diff options
Diffstat (limited to 'mcs/mcs/pending.cs')
| -rwxr-xr-x | mcs/mcs/pending.cs | 323 |
1 files changed, 213 insertions, 110 deletions
diff --git a/mcs/mcs/pending.cs b/mcs/mcs/pending.cs index 68b0cf8c7a2..5c3394f02fe 100755 --- a/mcs/mcs/pending.cs +++ b/mcs/mcs/pending.cs @@ -20,16 +20,38 @@ namespace Mono.CSharp { struct TypeAndMethods { public Type type; public MethodInfo [] methods; + + // + // Whether it is optional, this is used to allow the explicit/implicit + // implementation when a parent class already implements an interface. + // + // For example: + // + // 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 flag on the method says `We found a match, but // because it was private, we could not use the match // public bool [] 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 class PendingImplementation { @@ -52,10 +74,8 @@ namespace Mono.CSharp { static bool IsVirtualFilter (MemberInfo m, object filterCriteria) { - if (!(m is MethodInfo)) - return false; - - return ((MethodInfo) m).IsVirtual; + MethodInfo mi = m as MethodInfo; + return (mi == null) ? false : mi.IsVirtual; } /// <summary> @@ -78,7 +98,7 @@ namespace Mono.CSharp { Type current_type = t; do { - MemberInfo [] mi; + MemberList mi; mi = TypeContainer.FindMembers ( current_type, MemberTypes.Method, @@ -94,14 +114,10 @@ namespace Mono.CSharp { searching = false; } - if (mi == null) - continue; - - int count = mi.Length; - if (count == 0) + if (mi.Count == 0) continue; - if (count == 1 && !(mi [0] is MethodBase)) + if (mi.Count == 1 && !(mi [0] is MethodBase)) searching = false; else list = TypeManager.CopyNewMethods (list, mi); @@ -121,7 +137,7 @@ namespace Mono.CSharp { return list; } - PendingImplementation (TypeContainer container, Type [] ifaces, ArrayList abstract_methods, int total) + PendingImplementation (TypeContainer container, MissingInterfacesInfo [] missing_ifaces, ArrayList abstract_methods, int total) { TypeBuilder type_builder = container.TypeBuilder; @@ -129,44 +145,54 @@ namespace Mono.CSharp { pending_implementations = new TypeAndMethods [total]; int i = 0; - if (ifaces != null){ - foreach (Type t in ifaces){ - MethodInfo [] mi; + foreach (MissingInterfacesInfo missing in missing_ifaces){ + MethodInfo [] mi; + Type t = missing.Type; - if (t is TypeBuilder){ - Interface iface; + if (t is TypeBuilder){ + TypeContainer iface; - iface = TypeManager.LookupInterface (t); - - mi = iface.GetMethods (); - } else - mi = t.GetMethods (); - - int count = mi.Length; - pending_implementations [i].type = t; - pending_implementations [i].methods = mi; - pending_implementations [i].args = new Type [count][]; - pending_implementations [i].found = new bool [count]; - - int j = 0; - foreach (MethodInfo m in mi){ - Type [] types = TypeManager.GetArgumentTypes (m); - - pending_implementations [i].args [j] = types; - j++; - } - i++; + iface = TypeManager.LookupInterface (t); + + mi = iface.GetMethods (); + } else + mi = t.GetMethods (); + + int count = mi.Length; + pending_implementations [i].type = t; + pending_implementations [i].optional = missing.Optional; + pending_implementations [i].methods = mi; + pending_implementations [i].args = new Type [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){ + Type [] types = TypeManager.GetArgumentTypes (m); + + pending_implementations [i].args [j] = types; + j++; } + 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].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){ @@ -179,6 +205,60 @@ namespace Mono.CSharp { } } } + + struct MissingInterfacesInfo { + public Type Type; + public bool Optional; + + public MissingInterfacesInfo (Type t) + { + Type = t; + Optional = false; + } + } + + static MissingInterfacesInfo [] EmptyMissingInterfacesInfo = new MissingInterfacesInfo [0]; + + static MissingInterfacesInfo [] GetMissingInterfaces (TypeBuilder type_builder) + { + // + // Notice that TypeBuilders 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! + // + TypeExpr [] impl = TypeManager.GetExplicitInterfaces (type_builder); + + if (impl == null || impl.Length == 0) + return EmptyMissingInterfacesInfo; + + MissingInterfacesInfo [] ret = new MissingInterfacesInfo [impl.Length]; + + for (int i = 0; i < impl.Length; i++) + ret [i] = new MissingInterfacesInfo (impl [i].Type); + + // 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) + return ret; + + TypeExpr [] parent_impls = TypeManager.GetInterfaces (type_builder.BaseType); + + foreach (TypeExpr te in parent_impls) { + Type t = te.Type; + + for (int i = 0; i < ret.Length; i ++) { + if (t == ret [i].Type) { + ret [i].Optional = true; + break; + } + } + } + return ret; + } // // Factory method: if there are pending implementation methods, we return a PendingImplementation @@ -190,36 +270,10 @@ namespace Mono.CSharp { static public PendingImplementation GetPendingImplementations (TypeContainer container) { TypeBuilder type_builder = container.TypeBuilder; - Type [] ifaces; + MissingInterfacesInfo [] missing_interfaces; Type b = type_builder.BaseType; - int icount = 0; - // - // Notice that TypeBuilders will only return the interfaces that the Type - // is supposed to implement, not all the interfaces that the type implements. - // - // Completely broken. Anyways, we take advantage of this, so we only register - // the implementations that we need, as they are those that are listed by the - // TypeBuilder. - // - ifaces = type_builder.GetInterfaces (); -#if DEBUG - { - Type x = type_builder; - - while (x != null){ - Type [] iff = x.GetInterfaces (); - Console.WriteLine ("Type: " + x.Name); - - foreach (Type tt in iff){ - Console.WriteLine (" Iface: " + tt.Name); - } - x = x.BaseType; - } - } -#endif - - icount = ifaces.Length; + missing_interfaces = GetMissingInterfaces (type_builder); // // If we are implementing an abstract class, and we are not @@ -239,11 +293,11 @@ namespace Mono.CSharp { implementing_abstract = false; } - int total = icount + (implementing_abstract ? 1 : 0); + int total = missing_interfaces.Length + (implementing_abstract ? 1 : 0); if (total == 0) return null; - return new PendingImplementation (container, ifaces, abstract_methods, total); + return new PendingImplementation (container, missing_interfaces, abstract_methods, total); } public enum Operation { @@ -253,18 +307,30 @@ namespace Mono.CSharp { // Lookup, ClearOne, ClearAll } - + /// <summary> /// Whether the specified method is an interface method implementation /// </summary> public MethodInfo IsInterfaceMethod (Type t, string name, Type ret_type, Type [] args) { - return InterfaceMethod (t, name, ret_type, args, Operation.Lookup); + return InterfaceMethod (t, name, ret_type, args, Operation.Lookup, null); + } + + public MethodInfo IsInterfaceIndexer (Type t, Type ret_type, Type [] args) + { + return InterfaceMethod (t, null, ret_type, args, Operation.Lookup, null); } public void ImplementMethod (Type t, string name, Type ret_type, Type [] args, bool clear_one) { - InterfaceMethod (t, name, ret_type, args, clear_one ? Operation.ClearOne : Operation.ClearAll); + InterfaceMethod (t, name, ret_type, args, + clear_one ? Operation.ClearOne : Operation.ClearAll, null); + } + + public void ImplementIndexer (Type t, MethodInfo mi, Type ret_type, Type [] args, bool clear_one) + { + InterfaceMethod (t, null, ret_type, args, + clear_one ? Operation.ClearOne : Operation.ClearAll, mi); } /// <remarks> @@ -273,10 +339,19 @@ namespace Mono.CSharp { /// arguments `args' implements an interface, this method will /// return the MethodInfo that this method implements. /// + /// If `name' is null, we operate solely on the method's signature. This is for + /// instance used when implementing indexers. + /// /// The `Operation op' controls whether to lookup, clear the pending bit, or clear /// all the methods with the given signature. + /// + /// The `MethodInfo need_proxy' is used when we're implementing an interface's + /// indexer in a class. If the new indexer's IndexerName does not match the one + /// that was used in the interface, then we always need to create a proxy for it. + /// /// </remarks> - public MethodInfo InterfaceMethod (Type t, string name, Type ret_type, Type [] args, Operation op) + public MethodInfo InterfaceMethod (Type t, string name, Type ret_type, Type [] args, + Operation op, MethodInfo need_proxy) { int arg_len = args.Length; @@ -287,34 +362,39 @@ namespace Mono.CSharp { if (!(t == null || tm.type == t)) continue; - int i = 0; - foreach (MethodInfo m in tm.methods){ - if (m == null){ - i++; + int method_count = tm.methods.Length; + MethodInfo m; + for (int i = 0; i < method_count; i++){ + m = tm.methods [i]; + + if (m == null) continue; - } - if (name != m.Name){ - i++; + // + // `need_proxy' is not null when we're implementing an + // interface indexer and this is Clear(One/All) operation. + // + // If `name' is null, then we do a match solely based on the + // signature and not on the name (this is done in the Lookup + // for an interface indexer). + // + if (name == null){ + if (m.Name != tm.get_indexer_name && m.Name != tm.set_indexer_name) + continue; + } else if ((need_proxy == null) && (name != m.Name)) continue; - } if (ret_type != m.ReturnType){ if (!((ret_type == null && m.ReturnType == TypeManager.void_type) || (m.ReturnType == null && ret_type == TypeManager.void_type))) - { - i++; continue; - } } // // Check if we have the same parameters // - if (tm.args [i].Length != arg_len){ - i++; + if (tm.args [i].Length != arg_len) continue; - } int j, top = args.Length; bool fail = false; @@ -325,13 +405,25 @@ namespace Mono.CSharp { break; } } - if (fail){ - i++; + if (fail) continue; - } - if (op != Operation.Lookup) - tm.methods [i] = null; + 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 == m.Name || m.Name == tm.get_indexer_name || m.Name == 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; + } tm.found [i] = true; // @@ -405,18 +497,20 @@ namespace Mono.CSharp { Type [] args = TypeManager.GetArgumentTypes (mi); ms = new MethodSignature (mi.Name, mi.ReturnType, args); - MemberInfo [] list = TypeContainer.FindMembers ( + MemberList list = TypeContainer.FindMembers ( container.TypeBuilder.BaseType, MemberTypes.Method | MemberTypes.Property, BindingFlags.Public | BindingFlags.Instance, MethodSignature.method_signature_filter, ms); - if (list == null || list.Length == 0) + if (list.Count == 0) return false; - - DefineProxy (iface_type, (MethodInfo) list [0], mi, args); + + MethodInfo parent = (MethodInfo) list [0]; + if (!parent.IsAbstract) + DefineProxy (iface_type, parent, mi, args); return true; } - + /// <summary> /// Verifies that any pending abstract methods or interface methods /// were implemented. @@ -436,24 +530,33 @@ namespace Mono.CSharp { continue; if (type.IsInterface){ + MethodInfo need_proxy = + pending_implementations [i].need_proxy [j]; + + if (need_proxy != null) { + Type [] args = TypeManager.GetArgumentTypes (mi); + DefineProxy (type, need_proxy, mi, args); + continue; + } + if (ParentImplements (type, mi)) continue; - - string extra = ""; + + if (pending_implementations [i].optional) + continue; - if (pending_implementations [i].found [j]) - extra = ". (method might be private or static)"; - Report.Error ( - 536, container.Location, - "`" + container.Name + "' does not implement " + - "interface member `" + - type.FullName + "." + mi.Name + "'" + extra); + if (pending_implementations [i].found [j]) { + 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]); + } + else { + Report.Error (535, container.Location, "'{0}' does not implement interface member '{1}'", + container.Name, TypeManager.CSharpSignature (mi)); + } } else { - Report.Error ( - 534, container.Location, - "`" + container.Name + "' does not implement " + - "inherited abstract member `" + - type.FullName + "." + mi.Name + "'"); + Report.Error (534, container.Location, "'{0}' does not implement inherited abstract member '{1}'", + container.Name, TypeManager.CSharpSignature (mi)); } errors = true; j++; |