// 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
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);
int j = 0;
foreach (MethodInfo m in mi){
- Type [] types;
-
+ pending_implementations [i].args [j] = TypeManager.NoTypes;
+ pending_implementations [i].mods [j] = null;
+
// 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;
+ continue;
+
+ pending_implementations [i].args [j] = TypeManager.GetArgumentTypes (m);
+
+ ParameterData pd = TypeManager.GetParameterData (m);
+
+ 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++;
}
i++;
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);
MethodInfo mi = (MethodInfo) m;
Type [] types = TypeManager.GetArgumentTypes (mi);
+ ParameterData pd = TypeManager.GetParameterData (mi);
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++;
}
}
/// <summary>
/// Whether the specified method is an interface method implementation
/// </summary>
- public MethodInfo IsInterfaceMethod (Type t, string name, Type ret_type, Type [] args)
+ public MethodInfo IsInterfaceMethod (Type t, string name, Type ret_type, ParameterData args)
{
return InterfaceMethod (t, name, ret_type, args, Operation.Lookup, null);
}
- public MethodInfo IsInterfaceIndexer (Type t, Type ret_type, Type [] args)
+ public MethodInfo IsInterfaceIndexer (Type t, Type ret_type, ParameterData 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)
+ 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, Type [] args, bool clear_one)
+ 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);
/// 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,
+ public MethodInfo InterfaceMethod (Type t, string name, Type ret_type, ParameterData args,
Operation op, MethodInfo need_proxy)
{
- int arg_len = args.Length;
+ int arg_len = args.Count;
if (pending_implementations == null)
return null;
} 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)))
- continue;
- }
+ if (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].Length != arg_len)
+
+ if (tm.args [i] == null && arg_len != 0)
+ continue;
+ if (tm.args [i] != null && tm.args [i].Length != arg_len)
continue;
- int j, top = args.Length;
- bool fail = false;
-
- for (j = 0; j < top; j++){
- if (tm.args [i][j] != args[j]){
- fail = true;
+ int j;
+
+ for (j = 0; j < arg_len; j++) {
+ if (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 (fail)
+ if (j != arg_len)
continue;
if (op != Operation.Lookup){
if (list.Count == 0)
return false;
+ 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.IsAbstract)
+
+ if (!base_method.IsAbstract && !base_method.IsVirtual)
DefineProxy (iface_type, base_method, mi, args);
+
return true;
}
if (BaseImplements (type, mi))
continue;
-
+
if (pending_implementations [i].optional)
continue;
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);
+ Report.Error (551, container.Location, "Explicit interface implementation `{0}.{1}' is missing accessor `{2}'",
+ container.GetSignatureForError (), name, TypeManager.CSharpSignature (mi, true));
} else {
string[] methodLabel = TypeManager.CSharpSignature (mi).Split ('.');
Report.Error (536, container.Location,
- "'{0}' does not implement interface member '{1}'. '{2}.{3}' " +
+ "`{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));
+ Report.Error (535, container.Location, "`{0}' does not implement interface member `{1}'",
+ container.GetSignatureForError (), TypeManager.CSharpSignature (mi));
}
} else {
- Report.Error (534, container.Location, "'{0}' does not implement inherited abstract member '{1}'",
- container.Name, TypeManager.CSharpSignature (mi));
+ Report.Error (534, container.Location, "`{0}' does not implement inherited abstract member `{1}'",
+ container.GetSignatureForError (), TypeManager.CSharpSignature (mi, true));
}
errors = true;
j++;
projects / mono.git / blobdiff