struct TypeAndMethods {
public Type type;
public MethodInfo [] methods;
+
+ //
+ // Whether it is optional, this is used to allow the explicit/implicit
+ // implementation when a base 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 {
/// <summary>
/// This is the array of TypeAndMethods that describes the pending implementations
- /// (both interfaces and abstract methods in parent class)
+ /// (both interfaces and abstract methods in base class)
/// </summary>
TypeAndMethods [] pending_implementations;
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>
// <remarks>
// Returns a list of the abstract methods that are exposed by all of our
- // parents that we must implement. Notice that this `flattens' the
+ // bases that we must implement. Notice that this `flattens' the
// method search space, and takes into account overrides.
// </remarks>
static ArrayList GetAbstractMethods (Type t)
Type current_type = t;
do {
- MemberInfo [] mi;
+ MemberList mi;
mi = TypeContainer.FindMembers (
current_type, MemberTypes.Method,
- BindingFlags.Public | BindingFlags.Instance |
- BindingFlags.DeclaredOnly,
+ BindingFlags.Public | BindingFlags.NonPublic |
+ BindingFlags.Instance | BindingFlags.DeclaredOnly,
virtual_method_filter, null);
if (current_type == TypeManager.object_type)
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);
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;
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.IsInterface)
+ continue;
- 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++;
+ 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].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;
+
+ // If there is a previous error, just ignore
+ if (m == null)
+ types = TypeManager.NoTypes;
+ else
+ 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){
}
}
}
+
+ 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!
+ //
+ Type [] 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]);
+
+ // 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;
+
+ 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;
+ }
+ }
+ }
+ return ret;
+ }
//
// Factory method: if there are pending implementation methods, we return a PendingImplementation
static public PendingImplementation GetPendingImplementations (TypeContainer container)
{
TypeBuilder type_builder = container.TypeBuilder;
- Type [] ifaces = type_builder.GetInterfaces ();
+ MissingInterfacesInfo [] missing_interfaces;
Type b = type_builder.BaseType;
- int icount = 0;
-#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
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 {
//
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>
/// 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;
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;
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;
//
/// For that case, we create an explicit implementation function
/// I.M in Y.
/// </summary>
- void DefineProxy (Type iface, MethodInfo parent_method, MethodInfo iface_method,
+ void DefineProxy (Type iface, MethodInfo base_method, MethodInfo iface_method,
Type [] args)
{
MethodBuilder proxy;
MethodAttributes.NewSlot |
MethodAttributes.Virtual,
CallingConventions.Standard | CallingConventions.HasThis,
- parent_method.ReturnType, args);
+ base_method.ReturnType, args);
int top = args.Length;
ILGenerator ig = proxy.GetILGenerator ();
- ig.Emit (OpCodes.Ldarg_0);
- for (int i = 0; i < top; i++){
- switch (i){
- case 0:
- ig.Emit (OpCodes.Ldarg_1); break;
- case 1:
- ig.Emit (OpCodes.Ldarg_2); break;
- case 2:
- ig.Emit (OpCodes.Ldarg_3); break;
- default:
- ig.Emit (OpCodes.Ldarg, i - 1); break;
- }
- }
- ig.Emit (OpCodes.Call, parent_method);
+ for (int i = 0; i <= top; i++)
+ ParameterReference.EmitLdArg (ig, i);
+
+ ig.Emit (OpCodes.Call, base_method);
ig.Emit (OpCodes.Ret);
container.TypeBuilder.DefineMethodOverride (proxy, iface_method);
}
/// <summary>
- /// This function tells whether one of our parent classes implements
+ /// This function tells whether one of our base classes implements
/// the given method (which turns out, it is valid to have an interface
- /// implementation in a parent
+ /// implementation in a base
/// </summary>
- bool ParentImplements (Type iface_type, MethodInfo mi)
+ bool BaseImplements (Type iface_type, MethodInfo mi)
{
MethodSignature ms;
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 base_method = (MethodInfo) list [0];
+ if (!base_method.IsAbstract)
+ DefineProxy (iface_type, base_method, mi, args);
return true;
}
-
+
/// <summary>
/// Verifies that any pending abstract methods or interface methods
/// were implemented.
for (i = 0; i < top; i++){
Type type = pending_implementations [i].type;
int j = 0;
-
+
foreach (MethodInfo mi in pending_implementations [i].methods){
if (mi == null)
continue;
if (type.IsInterface){
- if (ParentImplements (type, mi))
+ 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;
-
- string extra = "";
-
- 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 (BaseImplements (type, mi))
+ continue;
+
+ if (pending_implementations [i].optional)
+ continue;
+
+ 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 '{1}'",
+ container.Name, name);
+ } 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]);
+ }
+ }
+ 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++;