//
// Copyright 2001, 2002 Ximian, Inc (http://www.ximian.com)
// Copyright 2003-2008 Novell, Inc.
+// Copyright 2011 Xamarin Inc
//
using System;
public MethodSpec [] need_proxy;
}
+ struct ProxyMethodContext : IMemberContext
+ {
+ readonly TypeContainer container;
+
+ public ProxyMethodContext (TypeContainer container)
+ {
+ this.container = container;
+ }
+
+ public TypeSpec CurrentType {
+ get {
+ throw new NotImplementedException ();
+ }
+ }
+
+ public TypeParameters CurrentTypeParameters {
+ get {
+ throw new NotImplementedException ();
+ }
+ }
+
+ public MemberCore CurrentMemberDefinition {
+ get {
+ throw new NotImplementedException ();
+ }
+ }
+
+ public bool IsObsolete {
+ get {
+ return false;
+ }
+ }
+
+ public bool IsUnsafe {
+ get {
+ throw new NotImplementedException ();
+ }
+ }
+
+ public bool IsStatic {
+ get {
+ return false;
+ }
+ }
+
+ public ModuleContainer Module {
+ get {
+ return container.Module;
+ }
+ }
+
+ public string GetSignatureForError ()
+ {
+ throw new NotImplementedException ();
+ }
+
+ public ExtensionMethodCandidates LookupExtensionMethod (TypeSpec extensionType, string name, int arity)
+ {
+ throw new NotImplementedException ();
+ }
+
+ public FullNamedExpression LookupNamespaceOrType (string name, int arity, LookupMode mode, Location loc)
+ {
+ throw new NotImplementedException ();
+ }
+
+ public FullNamedExpression LookupNamespaceAlias (string name)
+ {
+ throw new NotImplementedException ();
+ }
+ }
+
public class PendingImplementation
{
/// <summary>
/// The container for this PendingImplementation
/// </summary>
- readonly TypeContainer container;
+ readonly TypeDefinition container;
/// <summary>
/// This is the array of TypeAndMethods that describes the pending implementations
/// </summary>
TypeAndMethods [] pending_implementations;
- PendingImplementation (TypeContainer container, MissingInterfacesInfo[] missing_ifaces, MethodSpec[] abstract_methods, int total)
+ PendingImplementation (TypeDefinition container, MissingInterfacesInfo[] missing_ifaces, MethodSpec[] abstract_methods, int total)
{
var type_builder = container.Definition;
static readonly MissingInterfacesInfo [] EmptyMissingInterfacesInfo = new MissingInterfacesInfo [0];
- static MissingInterfacesInfo [] GetMissingInterfaces (TypeContainer container)
+ static MissingInterfacesInfo [] GetMissingInterfaces (TypeDefinition container)
{
//
- // Notice that Interfaces will only return the interfaces that the Type
- // is supposed to implement, not all the interfaces that the type implements.
+ // Interfaces will return all interfaces that the container
+ // implements including any inherited interfaces
//
var impl = container.Definition.Interfaces;
if (impl == null || impl.Count == 0)
return EmptyMissingInterfacesInfo;
- MissingInterfacesInfo[] ret = new MissingInterfacesInfo[impl.Count];
+ var ret = new MissingInterfacesInfo[impl.Count];
- for (int i = 0; i < impl.Count; i++)
+ for (int i = 0; i < ret.Length; i++)
ret [i] = new MissingInterfacesInfo (impl [i]);
// we really should not get here because Object doesnt implement any
// Register method implementations are either abstract methods
// flagged as such on the base class or interface methods
//
- static public PendingImplementation GetPendingImplementations (TypeContainer container)
+ static public PendingImplementation GetPendingImplementations (TypeDefinition container)
{
TypeSpec b = container.BaseType;
//
// First check exact modifiers match
//
- const Parameter.Modifier ref_out = Parameter.Modifier.REF | Parameter.Modifier.OUT;
- if ((cp[pi].ModFlags & ref_out) == (tp[pi].ModFlags & ref_out))
+ if ((cp[pi].ModFlags & Parameter.Modifier.RefOutMask) == (tp[pi].ModFlags & Parameter.Modifier.RefOutMask))
continue;
- if ((cp[pi].ModFlags & tp[pi].ModFlags & Parameter.Modifier.ISBYREF) != 0) {
+ if (((cp[pi].ModFlags | tp[pi].ModFlags) & Parameter.Modifier.RefOutMask) == Parameter.Modifier.RefOutMask) {
ref_only_difference = true;
continue;
}
/// <summary>
/// Whether the specified method is an interface method implementation
/// </summary>
- public MethodSpec IsInterfaceMethod (MemberName name, TypeSpec ifaceType, MethodData method, out MethodSpec ambiguousCandidate)
+ public MethodSpec IsInterfaceMethod (MemberName name, TypeSpec ifaceType, MethodData method, out MethodSpec ambiguousCandidate, ref bool optional)
{
- return InterfaceMethod (name, ifaceType, method, Operation.Lookup, out ambiguousCandidate);
+ return InterfaceMethod (name, ifaceType, method, Operation.Lookup, out ambiguousCandidate, ref optional);
}
- public void ImplementMethod (MemberName name, TypeSpec ifaceType, MethodData method, bool clear_one, out MethodSpec ambiguousCandidate)
+ public void ImplementMethod (MemberName name, TypeSpec ifaceType, MethodData method, bool clear_one, out MethodSpec ambiguousCandidate, ref bool optional)
{
- InterfaceMethod (name, ifaceType, method, clear_one ? Operation.ClearOne : Operation.ClearAll, out ambiguousCandidate);
+ InterfaceMethod (name, ifaceType, method, clear_one ? Operation.ClearOne : Operation.ClearAll, out ambiguousCandidate, ref optional);
}
/// <remarks>
/// that was used in the interface, then we always need to create a proxy for it.
///
/// </remarks>
- public MethodSpec InterfaceMethod (MemberName name, TypeSpec iType, MethodData method, Operation op, out MethodSpec ambiguousCandidate)
+ public MethodSpec InterfaceMethod (MemberName name, TypeSpec iType, MethodData method, Operation op, out MethodSpec ambiguousCandidate, ref bool optional)
{
ambiguousCandidate = null;
}
} else {
tm.found [i] = method;
+ optional = tm.optional;
}
- if (op == Operation.Lookup && name.Left != null && ambiguousCandidate == null) {
+ if (op == Operation.Lookup && name.ExplicitInterface != null && ambiguousCandidate == null) {
ambiguousCandidate = m;
continue;
}
}
int top = param.Count;
- var ec = new EmitContext (null, proxy.GetILGenerator (), null);
+ var ec = new EmitContext (new ProxyMethodContext (container), proxy.GetILGenerator (), null, null);
+ ec.EmitThis ();
// TODO: GetAllParametersArguments
- for (int i = 0; i <= top; i++)
- ParameterReference.EmitLdArg (ec, i);
+ for (int i = 0; i < top; i++)
+ ec.EmitArgumentLoad (i);
ec.Emit (OpCodes.Call, base_method);
ec.Emit (OpCodes.Ret);
// about mismatch at return type when the check bellow rejects them
//
var parameters = mi.Parameters;
+ MethodSpec close_match = null;
+
while (true) {
var candidates = MemberCache.FindMembers (base_type, mi.Name, false);
- if (candidates == null)
+ if (candidates == null) {
+ base_method = close_match;
return false;
+ }
MethodSpec similar_candidate = null;
foreach (var candidate in candidates) {
continue;
var candidate_param = ((MethodSpec) candidate).Parameters;
- if (!TypeSpecComparer.Override.IsSame (parameters.Types, candidate_param.Types))
+ if (!TypeSpecComparer.Override.IsEqual (parameters.Types, candidate_param.Types))
continue;
bool modifiers_match = true;
//
// First check exact ref/out match
//
- const Parameter.Modifier ref_out = Parameter.Modifier.REF | Parameter.Modifier.OUT;
- if ((parameters.FixedParameters[i].ModFlags & ref_out) == (candidate_param.FixedParameters[i].ModFlags & ref_out))
+ if ((parameters.FixedParameters[i].ModFlags & Parameter.Modifier.RefOutMask) == (candidate_param.FixedParameters[i].ModFlags & Parameter.Modifier.RefOutMask))
continue;
modifiers_match = false;
//
// Different in ref/out only
//
- if ((parameters.FixedParameters[i].ModFlags & candidate_param.FixedParameters[i].ModFlags & Parameter.Modifier.ISBYREF) != 0) {
+ if ((parameters.FixedParameters[i].ModFlags & Parameter.Modifier.RefOutMask) != (candidate_param.FixedParameters[i].ModFlags & Parameter.Modifier.RefOutMask)) {
if (similar_candidate == null) {
if (!candidate.IsPublic)
break;
continue;
//
- // From this point on the candidate is used for detailed error reporting
+ // From this point the candidate is used for detailed error reporting
// because it's very close match to what we are looking for
//
- base_method = (MethodSpec) candidate;
+ var m = (MethodSpec) candidate;
- if (!candidate.IsPublic)
- return false;
+ if (!m.IsPublic) {
+ if (close_match == null)
+ close_match = m;
- if (!TypeSpecComparer.Override.IsEqual (mi.ReturnType, base_method.ReturnType))
- return false;
- }
+ continue;
+ }
+ if (!TypeSpecComparer.Override.IsEqual (mi.ReturnType, m.ReturnType)) {
+ if (close_match == null)
+ close_match = m;
+
+ continue;
+ }
+
+ base_method = m;
+
+ if (mi.IsGeneric && !Method.CheckImplementingMethodConstraints (container, m, mi)) {
+ return true;
+ }
+ }
+
if (base_method != null) {
if (similar_candidate != null) {
Report.SymbolRelatedToPreviousError (similar_candidate);
}
base_type = candidates[0].DeclaringType.BaseType;
- if (base_type == null)
+ if (base_type == null) {
+ base_method = close_match;
return false;
+ }
}
if (!base_method.IsVirtual) {
if (pending_implementations [i].optional)
continue;
- MethodSpec candidate = null;
+ MethodSpec candidate;
if (base_implements_type || BaseImplements (type, mi, out candidate))
continue;
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));
+ container.GetSignatureForError (), mi.GetSignatureForError (), candidate.GetSignatureForError ());
} 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",
+ "`{0}' does not implement interface member `{1}' and the best implementing candidate `{2}' is not public",
container.GetSignatureForError (), mi.GetSignatureForError (), candidate.GetSignatureForError ());
} else {
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));
+ container.GetSignatureForError (), mi.GetSignatureForError (), candidate.GetSignatureForError (),
+ candidate.ReturnType.GetSignatureForError (), mi.ReturnType.GetSignatureForError ());
}
} else {
Report.Error (535, container.Location, "`{0}' does not implement interface member `{1}'",
projects / mono.git / blobdiff