Add test from Jb Evain to test biner with user method types
[mono.git] / mcs / class / corlib / System.Reflection / MethodBase.cs
1 //
2 // System.Reflection/MethodBase.cs
3 //
4 // Author:
5 //   Paolo Molaro (lupus@ximian.com)
6 //
7 // (C) 2001 Ximian, Inc.  http://www.ximian.com
8 // Copyright (C) 2004-2005 Novell, Inc (http://www.novell.com)
9 // Copyright 2011 Xamarin Inc (http://www.xamarin.com).
10 //
11 // Permission is hereby granted, free of charge, to any person obtaining
12 // a copy of this software and associated documentation files (the
13 // "Software"), to deal in the Software without restriction, including
14 // without limitation the rights to use, copy, modify, merge, publish,
15 // distribute, sublicense, and/or sell copies of the Software, and to
16 // permit persons to whom the Software is furnished to do so, subject to
17 // the following conditions:
18 // 
19 // The above copyright notice and this permission notice shall be
20 // included in all copies or substantial portions of the Software.
21 // 
22 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
23 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
24 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
25 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
26 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
27 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
28 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
29 //
30
31 using System.Diagnostics;
32 using System.Globalization;
33 #if !FULL_AOT_RUNTIME
34 using System.Reflection.Emit;
35 #endif
36 using System.Runtime.CompilerServices;
37 using System.Runtime.InteropServices;
38
39 namespace System.Reflection {
40
41         [ComVisible (true)]
42         [ComDefaultInterfaceAttribute (typeof (_MethodBase))]
43         [Serializable]
44         [ClassInterface(ClassInterfaceType.None)]
45 #if MOBILE
46         public abstract class MethodBase: MemberInfo {
47 #else
48         public abstract class MethodBase: MemberInfo, _MethodBase {
49 #endif
50                 [MethodImplAttribute (MethodImplOptions.InternalCall)]
51                 public extern static MethodBase GetCurrentMethod ();
52
53                 internal static MethodBase GetMethodFromHandleNoGenericCheck (RuntimeMethodHandle handle)
54                 {
55                         return GetMethodFromIntPtr (handle.Value, IntPtr.Zero);
56                 }
57
58                 static MethodBase GetMethodFromIntPtr (IntPtr handle, IntPtr declaringType)
59                 {
60                         if (handle == IntPtr.Zero)
61                                 throw new ArgumentException ("The handle is invalid.");
62                         MethodBase res = GetMethodFromHandleInternalType (handle, declaringType);
63                         if (res == null)
64                                 throw new ArgumentException ("The handle is invalid.");                 
65                         return res;
66                 }
67
68                 public static MethodBase GetMethodFromHandle (RuntimeMethodHandle handle)
69                 {
70                         MethodBase res = GetMethodFromIntPtr (handle.Value, IntPtr.Zero);
71                         Type t = res.DeclaringType;
72                         if (t.IsGenericType || t.IsGenericTypeDefinition)
73                                 throw new ArgumentException ("Cannot resolve method because it's declared in a generic class.");
74                         return res;
75                 }
76
77                 [MethodImplAttribute (MethodImplOptions.InternalCall)]
78                 private extern static MethodBase GetMethodFromHandleInternalType (IntPtr method_handle, IntPtr type_handle);
79
80                 [ComVisible (false)]
81                 public static MethodBase GetMethodFromHandle (RuntimeMethodHandle handle, RuntimeTypeHandle declaringType)
82                 {
83                         return GetMethodFromIntPtr (handle.Value, declaringType.Value);
84                 }
85
86                 public abstract MethodImplAttributes GetMethodImplementationFlags();
87
88                 public abstract ParameterInfo[] GetParameters();
89                 
90                 //
91                 // This is a quick version for our own use. We should override
92                 // it where possible so that it does not allocate an array.
93                 // They cannot be abstract otherwise we break public contract
94                 //
95                 internal virtual ParameterInfo[] GetParametersInternal ()
96                 {
97                         // Override me
98                         return GetParameters ();
99                 }
100
101                 internal virtual int GetParametersCount ()
102                 {
103                         // Override me
104                         return GetParametersInternal ().Length;
105                 }
106
107                 internal virtual Type GetParameterType (int pos) {
108                         throw new NotImplementedException ();
109                 }
110
111                 [DebuggerHidden]
112                 [DebuggerStepThrough]           
113                 public Object Invoke(Object obj, Object[] parameters) {
114                         return Invoke (obj, 0, null, parameters, null);
115                 }
116
117                 public abstract Object Invoke(Object obj, BindingFlags invokeAttr, Binder binder, Object[] parameters, CultureInfo culture);
118
119                 protected MethodBase()
120                 {
121                 }
122
123                 public abstract RuntimeMethodHandle MethodHandle { get; }
124                 public abstract MethodAttributes Attributes { get; }
125                 public virtual CallingConventions CallingConvention { get {return CallingConventions.Standard;} }
126                 public Boolean IsPublic { 
127                         get {
128                                 return (Attributes & MethodAttributes.MemberAccessMask) == MethodAttributes.Public;
129                         }
130                 }
131                 public Boolean IsPrivate {
132                         get {
133                                 return (Attributes & MethodAttributes.MemberAccessMask) == MethodAttributes.Private;
134                         }
135                 }
136                 public Boolean IsFamily {
137                         get {
138                                 return (Attributes & MethodAttributes.MemberAccessMask) == MethodAttributes.Family;
139                         }
140                 }
141                 public Boolean IsAssembly {
142                         get {
143                                 return (Attributes & MethodAttributes.MemberAccessMask) == MethodAttributes.Assembly;
144                         }
145                 }
146                 public Boolean IsFamilyAndAssembly {
147                         get {
148                                 return (Attributes & MethodAttributes.MemberAccessMask) == MethodAttributes.FamANDAssem;
149                         }
150                 }
151                 public Boolean IsFamilyOrAssembly {
152                         get {
153                                 return (Attributes & MethodAttributes.MemberAccessMask) == MethodAttributes.FamORAssem;
154                         }
155                 }
156                 public Boolean IsStatic {
157                         get {
158                                 return (Attributes & MethodAttributes.Static) != 0;
159                         }
160                 }
161                 public Boolean IsFinal {
162                         get {
163                                 return (Attributes & MethodAttributes.Final) != 0;
164                         }
165                 }
166                 public Boolean IsVirtual {
167                         get {
168                                 return (Attributes & MethodAttributes.Virtual) != 0;
169                         }
170                 }
171                 public Boolean IsHideBySig {
172                         get {
173                                 return (Attributes & MethodAttributes.HideBySig) != 0;
174                         }
175                 }
176                 public Boolean IsAbstract {
177                         get {
178                                 return (Attributes & MethodAttributes.Abstract) != 0;
179                         }
180                 }
181                 public Boolean IsSpecialName {
182                         get {
183                                 int attr = (int)Attributes;
184                                 return (attr & (int)MethodAttributes.SpecialName) != 0;
185                         }
186                 }
187                 [ComVisibleAttribute (true)]
188                 public Boolean IsConstructor {
189                         get {
190                                 int attr = (int)Attributes;
191                                 return ((attr & (int)MethodAttributes.RTSpecialName) != 0
192                                         && (Name == ".ctor"));
193                         }
194                 }
195
196                 internal virtual int get_next_table_index (object obj, int table, bool inc) {
197 #if !FULL_AOT_RUNTIME
198                         if (this is MethodBuilder) {
199                                 MethodBuilder mb = (MethodBuilder)this;
200                                 return mb.get_next_table_index (obj, table, inc);
201                         }
202                         if (this is ConstructorBuilder) {
203                                 ConstructorBuilder mb = (ConstructorBuilder)this;
204                                 return mb.get_next_table_index (obj, table, inc);
205                         }
206 #endif
207                         throw new Exception ("Method is not a builder method");
208                 }
209
210                 [ComVisible (true)]
211                 public virtual Type [] GetGenericArguments ()
212                 {
213                         throw new NotSupportedException ();
214                 }
215
216                 public virtual bool ContainsGenericParameters {
217                         get {
218                                 return false;
219                         }
220                 }
221
222                 public virtual bool IsGenericMethodDefinition {
223                         get {
224                                 return false;
225                         }
226                 }
227
228                 public virtual bool IsGenericMethod {
229                         get {
230                                 return false;
231                         }
232                 }
233
234                 [MethodImplAttribute (MethodImplOptions.InternalCall)]
235                 internal extern static MethodBody GetMethodBodyInternal (IntPtr handle);
236
237                 internal static MethodBody GetMethodBody (IntPtr handle) {
238                         return GetMethodBodyInternal (handle);
239                 }
240
241                 public virtual MethodBody GetMethodBody () {
242                         throw new NotSupportedException ();
243                 }
244
245 #if NET_4_0
246                 public override bool Equals (object obj)
247                 {
248                         return obj == (object) this;
249                 }
250
251                 public override int GetHashCode ()
252                 {
253                         return base.GetHashCode ();
254                 }
255
256                 public static bool operator == (MethodBase left, MethodBase right)
257                 {
258                         if ((object)left == (object)right)
259                                 return true;
260                         if ((object)left == null ^ (object)right == null)
261                                 return false;
262                         return left.Equals (right);
263                 }
264
265                 public static bool operator != (MethodBase left, MethodBase right)
266                 {
267                         if ((object)left == (object)right)
268                                 return false;
269                         if ((object)left == null ^ (object)right == null)
270                                 return true;
271                         return !left.Equals (right);
272                 }
273                 
274                 public virtual bool IsSecurityCritical {
275                         get {
276                                 throw new NotImplementedException ();
277                         }
278                 }
279                 
280                 public virtual bool IsSecuritySafeCritical {
281                         get {
282                                 throw new NotImplementedException ();
283                         }
284                 }
285
286                 public virtual bool IsSecurityTransparent {
287                         get {
288                                 throw new NotImplementedException ();
289                         }
290                 }
291 #endif
292
293 #if !MOBILE
294                 void _MethodBase.GetIDsOfNames ([In] ref Guid riid, IntPtr rgszNames, uint cNames, uint lcid, IntPtr rgDispId)
295                 {
296                         throw new NotImplementedException ();
297                 }
298
299                 Type _MethodBase.GetType ()
300                 {
301                         // Required or object::GetType becomes virtual final
302                         return base.GetType ();
303                 }               
304
305                 void _MethodBase.GetTypeInfo (uint iTInfo, uint lcid, IntPtr ppTInfo)
306                 {
307                         throw new NotImplementedException ();
308                 }
309
310                 void _MethodBase.GetTypeInfoCount (out uint pcTInfo)
311                 {
312                         throw new NotImplementedException ();
313                 }
314
315                 void _MethodBase.Invoke (uint dispIdMember, [In] ref Guid riid, uint lcid, short wFlags, IntPtr pDispParams, IntPtr pVarResult, IntPtr pExcepInfo, IntPtr puArgErr)
316                 {
317                         throw new NotImplementedException ();
318                 }
319 #endif
320         }
321 }