/// <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
// 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;
}
}
int top = param.Count;
- var ec = new EmitContext (new ProxyMethodContext (container), 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++)
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;
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,