?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
2010-04-06 Jb Evain <jbevain@novell.com>
[mcs.git] / mcs / pending.cs
blobe2aed9a1cf31e5fd7bebe0deb14a21c3dfbf6624
1 //
2 // pending.cs: Pending method implementation
3 //
4 // Author:
5 // Miguel de Icaza (miguel@gnu.org)
6 //
7 // Dual licensed under the terms of the MIT X11 or GNU GPL
8 //
9 // Copyright 2001, 2002 Ximian, Inc (http://www.ximian.com)
10 // Copyright 2003-2008 Novell, Inc.
11 //
12
13 using System;
14 using System.Collections.Generic;
15 using System.Reflection;
16 using System.Reflection.Emit;
17
18 namespace Mono.CSharp {
19
20 struct TypeAndMethods {
21 public Type type;
22 public MethodInfo [] methods;
23
24 //
25 // Whether it is optional, this is used to allow the explicit/implicit
26 // implementation when a base class already implements an interface.
27 //
28 // For example:
29 //
30 // class X : IA { } class Y : X, IA { IA.Explicit (); }
31 //
32 public bool optional;
33
34 // Far from ideal, but we want to avoid creating a copy
35 // of methods above.
36 public Type [][] args;
37
38 //This is used to store the modifiers of arguments
39 public Parameter.Modifier [][] mods;
40
41 //
42 // This flag on the method says `We found a match, but
43 // because it was private, we could not use the match
44 //
45 public MethodData [] found;
46
47 // If a method is defined here, then we always need to
48 // create a proxy for it. This is used when implementing
49 // an interface's indexer with a different IndexerName.
50 public MethodInfo [] need_proxy;
51 }
52
53 public class PendingImplementation {
54 /// <summary>
55 /// The container for this PendingImplementation
56 /// </summary>
57 TypeContainer container;
58
59 /// <summary>
60 /// This filter is used by FindMembers, and it is used to
61 /// extract only virtual/abstract fields
62 /// </summary>
63 static MemberFilter virtual_method_filter;
64
65 /// <summary>
66 /// This is the array of TypeAndMethods that describes the pending implementations
67 /// (both interfaces and abstract methods in base class)
68 /// </summary>
69 TypeAndMethods [] pending_implementations;
70
71 static bool IsVirtualFilter (MemberInfo m, object filterCriteria)
72 {
73 MethodInfo mi = m as MethodInfo;
74 return (mi == null) ? false : mi.IsVirtual;
75 }
76
77 /// <summary>
78 /// Inits the virtual_method_filter
79 /// </summary>
80 static PendingImplementation ()
81 {
82 virtual_method_filter = new MemberFilter (IsVirtualFilter);
83 }
84
85 // <remarks>
86 // Returns a list of the abstract methods that are exposed by all of our
87 // bases that we must implement. Notice that this `flattens' the
88 // method search space, and takes into account overrides.
89 // </remarks>
90 static IList<MethodBase> GetAbstractMethods (Type t)
91 {
92 List<MethodBase> list = null;
93 bool searching = true;
94 Type current_type = t;
95
96 do {
97 MemberList mi;
98
99 mi = TypeContainer.FindMembers (
100 current_type, MemberTypes.Method,
101 BindingFlags.Public | BindingFlags.NonPublic |
102 BindingFlags.Instance | BindingFlags.DeclaredOnly,
103 virtual_method_filter, null);
104
105 if (current_type == TypeManager.object_type)
106 searching = false;
107 else {
108 current_type = current_type.BaseType;
109 if (!current_type.IsAbstract)
110 searching = false;
111 }
112
113 if (mi.Count == 0)
114 continue;
115
116 if (mi.Count == 1 && !(mi [0] is MethodBase))
117 searching = false;
118 else
119 list = TypeManager.CopyNewMethods (list, mi);
120 } while (searching);
121
122 if (list == null)
123 return null;
124
125 for (int i = 0; i < list.Count; i++){
126 while (list.Count > i && !((MethodInfo) list [i]).IsAbstract)
127 list.RemoveAt (i);
128 }
129
130 if (list.Count == 0)
131 return null;
132
133 return list;
134 }
135
136 PendingImplementation (TypeContainer container, MissingInterfacesInfo[] missing_ifaces, IList<MethodBase> abstract_methods, int total)
137 {
138 TypeBuilder type_builder = container.TypeBuilder;
139
140 this.container = container;
141 pending_implementations = new TypeAndMethods [total];
142
143 int i = 0;
144 if (abstract_methods != null) {
145 int count = abstract_methods.Count;
146 pending_implementations [i].methods = new MethodInfo [count];
147 pending_implementations [i].need_proxy = new MethodInfo [count];
148
149 abstract_methods.CopyTo (pending_implementations [i].methods, 0);
150 pending_implementations [i].found = new MethodData [count];
151 pending_implementations [i].args = new Type [count][];
152 pending_implementations [i].mods = new Parameter.Modifier [count][];
153 pending_implementations [i].type = type_builder;
154
155 int j = 0;
156 foreach (MemberInfo m in abstract_methods) {
157 MethodInfo mi = (MethodInfo) m;
158
159 AParametersCollection pd = TypeManager.GetParameterData (mi);
160 Type [] types = pd.Types;
161
162 pending_implementations [i].args [j] = types;
163 pending_implementations [i].mods [j] = null;
164 if (pd.Count > 0) {
165 Parameter.Modifier [] pm = new Parameter.Modifier [pd.Count];
166 for (int k = 0; k < pd.Count; k++)
167 pm [k] = pd.FixedParameters[k].ModFlags;
168 pending_implementations [i].mods [j] = pm;
169 }
170
171 j++;
172 }
173 ++i;
174 }
175
176 foreach (MissingInterfacesInfo missing in missing_ifaces) {
177 MethodInfo [] mi;
178 Type t = missing.Type;
179
180 if (!t.IsInterface)
181 continue;
182
183 if (t is TypeBuilder){
184 TypeContainer iface;
185
186 iface = TypeManager.LookupInterface (t);
187
188 mi = iface.GetMethods ();
189 } else
190 mi = t.GetMethods ();
191
192 int count = mi.Length;
193 pending_implementations [i].type = t;
194 pending_implementations [i].optional = missing.Optional;
195 pending_implementations [i].methods = mi;
196 pending_implementations [i].args = new Type [count][];
197 pending_implementations [i].mods = new Parameter.Modifier [count][];
198 pending_implementations [i].found = new MethodData [count];
199 pending_implementations [i].need_proxy = new MethodInfo [count];
200
201 int j = 0;
202 foreach (MethodInfo m in mi){
203 pending_implementations [i].args [j] = Type.EmptyTypes;
204 pending_implementations [i].mods [j] = null;
205
206 // If there is a previous error, just ignore
207 if (m == null)
208 continue;
209
210 AParametersCollection pd = TypeManager.GetParameterData (m);
211 pending_implementations [i].args [j] = pd.Types;
212
213 if (pd.Count > 0){
214 Parameter.Modifier [] pm = new Parameter.Modifier [pd.Count];
215 for (int k = 0; k < pd.Count; k++)
216 pm [k] = pd.FixedParameters [k].ModFlags;
217 pending_implementations [i].mods [j] = pm;
218 }
219
220 j++;
221 }
222 i++;
223 }
224 }
225
226 struct MissingInterfacesInfo {
227 public Type Type;
228 public bool Optional;
229
230 public MissingInterfacesInfo (Type t)
231 {
232 Type = t;
233 Optional = false;
234 }
235 }
236
237 static MissingInterfacesInfo [] EmptyMissingInterfacesInfo = new MissingInterfacesInfo [0];
238
239 static MissingInterfacesInfo [] GetMissingInterfaces (TypeBuilder type_builder)
240 {
241 //
242 // Notice that TypeBuilders will only return the interfaces that the Type
243 // is supposed to implement, not all the interfaces that the type implements.
244 //
245 // Even better -- on MS it returns an empty array, no matter what.
246 //
247 // Completely broken. So we do it ourselves!
248 //
249 Type [] impl = TypeManager.GetExplicitInterfaces (type_builder);
250
251 if (impl == null || impl.Length == 0)
252 return EmptyMissingInterfacesInfo;
253
254 MissingInterfacesInfo [] ret = new MissingInterfacesInfo [impl.Length];
255
256 for (int i = 0; i < impl.Length; i++)
257 ret [i] = new MissingInterfacesInfo (impl [i]);
258
259 // we really should not get here because Object doesnt implement any
260 // interfaces. But it could implement something internal, so we have
261 // to handle that case.
262 if (type_builder.BaseType == null)
263 return ret;
264
265 Type [] base_impls = TypeManager.GetInterfaces (type_builder.BaseType);
266
267 foreach (Type t in base_impls) {
268 for (int i = 0; i < ret.Length; i ++) {
269 if (t == ret [i].Type) {
270 ret [i].Optional = true;
271 break;
272 }
273 }
274 }
275 return ret;
276 }
277
278 //
279 // Factory method: if there are pending implementation methods, we return a PendingImplementation
280 // object, otherwise we return null.
281 //
282 // Register method implementations are either abstract methods
283 // flagged as such on the base class or interface methods
284 //
285 static public PendingImplementation GetPendingImplementations (TypeContainer container)
286 {
287 TypeBuilder type_builder = container.TypeBuilder;
288 MissingInterfacesInfo [] missing_interfaces;
289 Type b = type_builder.BaseType;
290
291 missing_interfaces = GetMissingInterfaces (type_builder);
292
293 //
294 // If we are implementing an abstract class, and we are not
295 // ourselves abstract, and there are abstract methods (C# allows
296 // abstract classes that have no abstract methods), then allocate
297 // one slot.
298 //
299 // We also pre-compute the methods.
300 //
301 bool implementing_abstract = ((b != null) && b.IsAbstract && !type_builder.IsAbstract);
302 IList<MethodBase> abstract_methods = null;
303
304 if (implementing_abstract){
305 abstract_methods = GetAbstractMethods (b);
306
307 if (abstract_methods == null)
308 implementing_abstract = false;
309 }
310
311 int total = missing_interfaces.Length + (implementing_abstract ? 1 : 0);
312 if (total == 0)
313 return null;
314
315 return new PendingImplementation (container, missing_interfaces, abstract_methods, total);
316 }
317
318 public enum Operation {
319 //
320 // If you change this, review the whole InterfaceMethod routine as there
321 // are a couple of assumptions on these three states
322 //
323 Lookup, ClearOne, ClearAll
324 }
325
326 /// <summary>
327 /// Whether the specified method is an interface method implementation
328 /// </summary>
329 public MethodInfo IsInterfaceMethod (string name, Type ifaceType, MethodData method)
330 {
331 return InterfaceMethod (name, ifaceType, method, Operation.Lookup);
332 }
333
334 public void ImplementMethod (string name, Type ifaceType, MethodData method, bool clear_one)
335 {
336 InterfaceMethod (name, ifaceType, method, clear_one ? Operation.ClearOne : Operation.ClearAll);
337 }
338
339 /// <remarks>
340 /// If a method in Type `t' (or null to look in all interfaces
341 /// and the base abstract class) with name `Name', return type `ret_type' and
342 /// arguments `args' implements an interface, this method will
343 /// return the MethodInfo that this method implements.
344 ///
345 /// If `name' is null, we operate solely on the method's signature. This is for
346 /// instance used when implementing indexers.
347 ///
348 /// The `Operation op' controls whether to lookup, clear the pending bit, or clear
349 /// all the methods with the given signature.
350 ///
351 /// The `MethodInfo need_proxy' is used when we're implementing an interface's
352 /// indexer in a class. If the new indexer's IndexerName does not match the one
353 /// that was used in the interface, then we always need to create a proxy for it.
354 ///
355 /// </remarks>
356 public MethodInfo InterfaceMethod (string name, Type iType, MethodData method, Operation op)
357 {
358 if (pending_implementations == null)
359 return null;
360
361 Type ret_type = method.method.ReturnType;
362 ParametersCompiled args = method.method.ParameterInfo;
363 int arg_len = args.Count;
364 bool is_indexer = method.method is Indexer.SetIndexerMethod || method.method is Indexer.GetIndexerMethod;
365
366 foreach (TypeAndMethods tm in pending_implementations){
367 if (!(iType == null || tm.type == iType))
368 continue;
369
370 int method_count = tm.methods.Length;
371 MethodInfo m;
372 for (int i = 0; i < method_count; i++){
373 m = tm.methods [i];
374
375 if (m == null)
376 continue;
377
378 //
379 // Check if we have the same parameters
380 //
381
382 if (tm.args [i] == null && arg_len != 0)
383 continue;
384 if (tm.args [i] != null && tm.args [i].Length != arg_len)
385 continue;
386
387 string mname = TypeManager.GetMethodName (m);
388
389 //
390 // `need_proxy' is not null when we're implementing an
391 // interface indexer and this is Clear(One/All) operation.
392 //
393 // If `name' is null, then we do a match solely based on the
394 // signature and not on the name (this is done in the Lookup
395 // for an interface indexer).
396 //
397
398 if (is_indexer) {
399 IMethodData md = TypeManager.GetMethod (m);
400 if (md != null) {
401 if (!(md is Indexer.SetIndexerMethod || md is Indexer.GetIndexerMethod))
402 continue;
403 } else {
404 if (TypeManager.GetPropertyFromAccessor (m) == null)
405 continue;
406 }
407 } else if (name != mname) {
408 continue;
409 }
410
411 int j;
412
413 for (j = 0; j < arg_len; j++) {
414 if (!TypeManager.IsEqual (tm.args [i][j], args.Types [j]))
415 break;
416 if (tm.mods [i][j] == args.FixedParameters [j].ModFlags)
417 continue;
418 // The modifiers are different, but if one of them
419 // is a PARAMS modifier, and the other isn't, ignore
420 // the difference.
421 if (tm.mods [i][j] != Parameter.Modifier.PARAMS &&
422 args.FixedParameters [j].ModFlags != Parameter.Modifier.PARAMS)
423 break;
424 }
425 if (j != arg_len)
426 continue;
427
428 Type rt = TypeManager.TypeToCoreType (m.ReturnType);
429 if (!TypeManager.IsEqual (ret_type, rt) &&
430 !(ret_type == null && rt == TypeManager.void_type) &&
431 !(rt == null && ret_type == TypeManager.void_type)) {
432 tm.found [i] = method;
433 continue;
434 }
435
436 if (op != Operation.Lookup) {
437 // If `t != null', then this is an explicitly interface
438 // implementation and we can always clear the method.
439 // `need_proxy' is not null if we're implementing an
440 // interface indexer. In this case, we need to create
441 // a proxy if the implementation's IndexerName doesn't
442 // match the IndexerName in the interface.
443 if (iType == null && name != mname)
444 tm.need_proxy [i] = method.MethodBuilder;
445 else
446 tm.methods [i] = null;
447 } else {
448 tm.found [i] = method;
449 }
450
451 //
452 // Lookups and ClearOne return
453 //
454 if (op != Operation.ClearAll)
455 return m;
456 }
457
458 // If a specific type was requested, we can stop now.
459 if (tm.type == iType)
460 return null;
461 }
462 return null;
463 }
464
465 /// <summary>
466 /// C# allows this kind of scenarios:
467 /// interface I { void M (); }
468 /// class X { public void M (); }
469 /// class Y : X, I { }
470 ///
471 /// For that case, we create an explicit implementation function
472 /// I.M in Y.
473 /// </summary>
474 void DefineProxy (Type iface, MethodInfo base_method, MethodInfo iface_method,
475 AParametersCollection param)
476 {
477 // TODO: Handle nested iface names
478 string proxy_name = SimpleName.RemoveGenericArity (iface.FullName) + "." + iface_method.Name;
479
480 MethodBuilder proxy = container.TypeBuilder.DefineMethod (
481 proxy_name,
482 MethodAttributes.HideBySig |
483 MethodAttributes.NewSlot |
484 MethodAttributes.CheckAccessOnOverride |
485 MethodAttributes.Virtual,
486 CallingConventions.Standard | CallingConventions.HasThis,
487 base_method.ReturnType, param.GetEmitTypes ());
488
489 Type[] gargs = TypeManager.GetGenericArguments (iface_method);
490 if (gargs.Length > 0) {
491 string[] gnames = new string[gargs.Length];
492 for (int i = 0; i < gargs.Length; ++i)
493 gnames[i] = gargs[i].Name;
494
495 proxy.DefineGenericParameters (gnames);
496 }
497
498 for (int i = 0; i < param.Count; i++) {
499 string name = param.FixedParameters [i].Name;
500 ParameterAttributes attr = ParametersCompiled.GetParameterAttribute (param.FixedParameters [i].ModFlags);
501 proxy.DefineParameter (i + 1, attr, name);
502 }
503
504 int top = param.Count;
505 ILGenerator ig = proxy.GetILGenerator ();
506
507 for (int i = 0; i <= top; i++)
508 ParameterReference.EmitLdArg (ig, i);
509
510 ig.Emit (OpCodes.Call, base_method);
511 ig.Emit (OpCodes.Ret);
512
513 container.TypeBuilder.DefineMethodOverride (proxy, iface_method);
514 }
515
516 /// <summary>
517 /// This function tells whether one of our base classes implements
518 /// the given method (which turns out, it is valid to have an interface
519 /// implementation in a base
520 /// </summary>
521 bool BaseImplements (Type iface_type, MethodInfo mi, out MethodInfo base_method)
522 {
523 MethodSignature ms;
524
525 AParametersCollection param = TypeManager.GetParameterData (mi);
526 ms = new MethodSignature (mi.Name, TypeManager.TypeToCoreType (mi.ReturnType), param.Types);
527 MemberList list = TypeContainer.FindMembers (
528 container.TypeBuilder.BaseType, MemberTypes.Method | MemberTypes.Property,
529 BindingFlags.Public | BindingFlags.Instance,
530 MethodSignature.method_signature_filter, ms);
531
532 if (list.Count == 0) {
533 base_method = null;
534 return false;
535 }
536
537 if (TypeManager.ImplementsInterface (container.TypeBuilder.BaseType, iface_type)) {
538 base_method = null;
539 return true;
540 }
541
542 base_method = (MethodInfo) list [0];
543
544 if (base_method.DeclaringType.IsInterface)
545 return false;
546
547 if (!base_method.IsPublic)
548 return false;
549
550 if (!base_method.IsAbstract && !base_method.IsVirtual)
551 // FIXME: We can avoid creating a proxy if base_method can be marked 'final virtual' instead.
552 // However, it's too late now, the MethodBuilder has already been created (see bug 377519)
553 DefineProxy (iface_type, base_method, mi, param);
554
555 return true;
556 }
557
558 /// <summary>
559 /// Verifies that any pending abstract methods or interface methods
560 /// were implemented.
561 /// </summary>
562 public bool VerifyPendingMethods (Report Report)
563 {
564 int top = pending_implementations.Length;
565 bool errors = false;
566 int i;
567
568 for (i = 0; i < top; i++){
569 Type type = pending_implementations [i].type;
570 int j = 0;
571
572 bool base_implements_type = type.IsInterface &&
573 container.TypeBuilder.BaseType != null &&
574 TypeManager.ImplementsInterface (container.TypeBuilder.BaseType, type);
575
576 foreach (MethodInfo mi in pending_implementations [i].methods){
577 if (mi == null)
578 continue;
579
580 if (type.IsInterface){
581 MethodInfo need_proxy =
582 pending_implementations [i].need_proxy [j];
583
584 if (need_proxy != null) {
585 DefineProxy (type, need_proxy, mi, TypeManager.GetParameterData (mi));
586 continue;
587 }
588
589 if (pending_implementations [i].optional)
590 continue;
591
592 MethodInfo candidate = null;
593 if (base_implements_type || BaseImplements (type, mi, out candidate))
594 continue;
595
596 if (candidate == null) {
597 MethodData md = pending_implementations [i].found [j];
598 if (md != null)
599 candidate = md.MethodBuilder;
600 }
601
602 Report.SymbolRelatedToPreviousError (mi);
603 if (candidate != null) {
604 Report.SymbolRelatedToPreviousError (candidate);
605 if (candidate.IsStatic) {
606 Report.Error (736, container.Location,
607 "`{0}' does not implement interface member `{1}' and the best implementing candidate `{2}' is static",
608 container.GetSignatureForError (), TypeManager.CSharpSignature (mi, true), TypeManager.CSharpSignature (candidate));
609 } else if (!candidate.IsPublic) {
610 Report.Error (737, container.Location,
611 "`{0}' does not implement interface member `{1}' and the best implementing candidate `{2}' in not public",
612 container.GetSignatureForError (), TypeManager.CSharpSignature (mi, true), TypeManager.CSharpSignature (candidate, true));
613 } else {
614 Report.Error (738, container.Location,
615 "`{0}' does not implement interface member `{1}' and the best implementing candidate `{2}' return type `{3}' does not match interface member return type `{4}'",
616 container.GetSignatureForError (), TypeManager.CSharpSignature (mi, true), TypeManager.CSharpSignature (candidate),
617 TypeManager.CSharpName (candidate.ReturnType), TypeManager.CSharpName (mi.ReturnType));
618 }
619 } else {
620 Report.Error (535, container.Location, "`{0}' does not implement interface member `{1}'",
621 container.GetSignatureForError (), TypeManager.CSharpSignature (mi, true));
622 }
623 } else {
624 Report.Error (534, container.Location, "`{0}' does not implement inherited abstract member `{1}'",
625 container.GetSignatureForError (), TypeManager.CSharpSignature (mi, true));
626 }
627 errors = true;
628 j++;
629 }
630 }
631 return errors;
632 }
633 } /* end of class */
634 }
git-svn mirror of mcs