// 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
// 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 {
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>
MethodInfo [] mi;
Type t = missing.Type;
+ if (!t.IsInterface)
+ continue;
+
if (t is TypeBuilder){
- Interface iface;
+ TypeContainer iface;
iface = TypeManager.LookupInterface (t);
- mi = iface.GetMethods (container);
+ mi = iface.GetMethods ();
} else
mi = t.GetMethods ();
int count = mi.Length;
- pending_implementations [i].type = missing.Type;
+ 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){
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){
// 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.
+ // Even better -- on MS it returns an empty array, no matter what.
//
- Type [] implementing_ifaces = type_builder.GetInterfaces ();
- int count = implementing_ifaces.Length;
+ // Completely broken. So we do it ourselves!
+ //
+ Type [] impl = TypeManager.GetExplicitInterfaces (type_builder);
- if (implementing_ifaces.Length == 0)
+ if (impl == null || impl.Length == 0)
return EmptyMissingInterfacesInfo;
- MissingInterfacesInfo [] missing_info = new MissingInterfacesInfo [count];
+ MissingInterfacesInfo [] ret = new MissingInterfacesInfo [impl.Length];
+
+ for (int i = 0; i < impl.Length; i++)
+ ret [i] = new MissingInterfacesInfo (impl [i]);
- for (int i = 0; i < count; i++)
- missing_info [i] = new MissingInterfacesInfo (implementing_ifaces [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 [] parent_impls = TypeManager.GetInterfaces (type_builder.BaseType);
- //
- // Now, we have to extract the interfaces implements by our parents, and
- // remove them from the implementing_ifaces array.
- //
- for (Type t = type_builder.BaseType; t != null; t = t.BaseType){
- Type [] base_ifaces = t.GetInterfaces ();
-
- foreach (Type base_iface in base_ifaces){
- for (int i = 0; i < count; i++){
- if (implementing_ifaces [i] == base_iface)
- missing_info [i].Optional = true;
+ foreach (Type t in parent_impls) {
+ for (int i = 0; i < ret.Length; i ++) {
+ if (t == ret [i].Type) {
+ ret [i].Optional = true;
+ break;
}
}
-
- //
- // When we reach a `Type' instead of `TypeBuilder', the GetInterfaces
- // call would have returned all of the parent implementations, so we can end.
- //
- if (!(t is TypeBuilder))
- break;
}
-
- return missing_info;
+ return ret;
}
//
public void ImplementIndexer (Type t, MethodInfo mi, Type ret_type, Type [] args, bool clear_one)
{
- InterfaceMethod (t, mi.Name, ret_type, args,
+ InterfaceMethod (t, null, ret_type, args,
clear_one ? Operation.ClearOne : Operation.ClearAll, mi);
}
if (m == null)
continue;
+ string mname = TypeManager.GetMethodName (m);
+
+ //
// `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) && (need_proxy == null) && (name != m.Name))
+ //
+ if (name == null){
+ if (mname != tm.get_indexer_name && mname != tm.set_indexer_name)
+ continue;
+ } else if ((need_proxy == null) && (name != mname))
continue;
- if (!ret_type.IsAssignableFrom (m.ReturnType)){
+ if (!TypeManager.IsEqual (ret_type, m.ReturnType)){
if (!((ret_type == null && m.ReturnType == TypeManager.void_type) ||
(m.ReturnType == null && ret_type == TypeManager.void_type)))
continue;
int j, top = args.Length;
bool fail = false;
-
+
for (j = 0; j < top; j++){
- if (!tm.args [i][j].IsAssignableFrom (args[j])){
+ if (!TypeManager.IsEqual (tm.args [i][j], args[j])){
fail = true;
break;
}
// interface indexer. In this case, we need to create
// a proxy if the implementation's IndexerName doesn't
// match the IndexerName in the interface.
- if ((t == null) && (need_proxy != null) && (name != m.Name))
+ 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;
CallingConventions.Standard | CallingConventions.HasThis,
parent_method.ReturnType, args);
+ ParameterData pd = Invocation.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));
+ ParameterBuilder pb = proxy.DefineParameter (i + 1, attr, name);
+ }
+
int top = args.Length;
ILGenerator ig = proxy.GetILGenerator ();
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 (pending_implementations [i].optional)
continue;
- string extra = "";
-
- if (pending_implementations [i].found [j])
- extra = ". (method might be non-public 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++;