// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
+#if !FULL_AOT_RUNTIME
using System.Reflection;
using System.Reflection.Emit;
using System.Collections;
using System.Runtime.CompilerServices;
using System.Globalization;
using System.Runtime.Serialization;
-
-#if NET_2_0 || BOOTSTRAP_NET_2_0
+using System.Text;
+using System.Runtime.InteropServices;
namespace System.Reflection
{
* NotImplementedException for many of the methods but we can't do that as gmcs
* depends on them.
*/
- internal class MonoGenericClass : MonoType
+ [StructLayout (LayoutKind.Sequential)]
+ internal class MonoGenericClass : Type
{
#region Keep in sync with object-internals.h
#pragma warning disable 649
- internal TypeBuilder generic_type;
+ internal Type generic_type;
+ Type[] type_arguments;
bool initialized;
#pragma warning restore 649
#endregion
Hashtable fields, ctors, methods;
internal MonoGenericClass ()
- : base (null)
{
// this should not be used
throw new InvalidOperationException ();
}
- [MethodImplAttribute(MethodImplOptions.InternalCall)]
- extern void initialize (MethodInfo[] methods, ConstructorInfo[] ctors, FieldInfo[] fields, PropertyInfo[] properties, EventInfo[] events);
+ internal MonoGenericClass (Type tb, Type[] args)
+ {
+ this.generic_type = tb;
+ this.type_arguments = args;
+ /*
+ This is a temporary hack until we can fix the rest of the runtime
+ to properly handle this class to be a complete UT.
+
+ We must not regisrer this with the runtime after the type is created
+ otherwise created_type.MakeGenericType will return an instance of MonoGenericClass,
+ which is very very broken.
+ */
+ if (tb is TypeBuilder && !(tb as TypeBuilder).is_created)
+ register_with_runtime (this);
+
+ }
+
+ internal override Type InternalResolve ()
+ {
+ Type gtd = generic_type.InternalResolve ();
+ Type[] args = new Type [type_arguments.Length];
+ for (int i = 0; i < type_arguments.Length; ++i)
+ args [i] = type_arguments [i].InternalResolve ();
+ return gtd.MakeGenericType (args);
+ }
[MethodImplAttribute(MethodImplOptions.InternalCall)]
- extern MethodInfo GetCorrespondingInflatedMethod (MethodInfo generic);
-
- [MethodImplAttribute(MethodImplOptions.InternalCall)]
- extern EventInfo[] GetEvents_internal (Type reflected_type);
+ extern void initialize (FieldInfo[] fields);
+
+ [MethodImplAttribute(MethodImplOptions.InternalCall)]
+ internal static extern void register_with_runtime (Type type);
+
+ internal bool IsCreated {
+ get {
+ TypeBuilder tb = generic_type as TypeBuilder;
+ return tb != null ? tb.is_created : true;
+ }
+ }
private const BindingFlags flags = BindingFlags.Public | BindingFlags.NonPublic |
BindingFlags.Static | BindingFlags.Instance | BindingFlags.DeclaredOnly;
MonoGenericClass parent = GetParentType () as MonoGenericClass;
if (parent != null)
parent.initialize ();
-
- initialize (generic_type.GetMethods (flags),
- generic_type.GetConstructorsInternal (flags),
- generic_type.GetFields (flags),
- generic_type.GetProperties (flags),
- generic_type.GetEvents_internal (flags));
+
+ initialize (generic_type.GetFields (flags));
initialized = true;
}
return InflateType (generic_type.BaseType);
}
- [MethodImplAttribute(MethodImplOptions.InternalCall)]
- private extern Type InflateType_internal (Type type);
-
internal Type InflateType (Type type)
+ {
+ return InflateType (type, type_arguments, null);
+ }
+
+ internal Type InflateType (Type type, Type[] method_args)
+ {
+ return InflateType (type, type_arguments, method_args);
+ }
+
+ internal static Type InflateType (Type type, Type[] type_args, Type[] method_args)
{
if (type == null)
return null;
if (!type.IsGenericParameter && !type.ContainsGenericParameters)
return type;
- return InflateType_internal (type);
+ if (type.IsGenericParameter) {
+ if (type.DeclaringMethod == null)
+ return type_args == null ? type : type_args [type.GenericParameterPosition];
+ return method_args == null ? type : method_args [type.GenericParameterPosition];
+ }
+ if (type.IsPointer)
+ return InflateType (type.GetElementType (), type_args, method_args).MakePointerType ();
+ if (type.IsByRef)
+ return InflateType (type.GetElementType (), type_args, method_args).MakeByRefType ();
+ if (type.IsArray) {
+ if (type.GetArrayRank () > 1)
+ return InflateType (type.GetElementType (), type_args, method_args).MakeArrayType (type.GetArrayRank ());
+
+ if (type.ToString ().EndsWith ("[*]", StringComparison.Ordinal)) /*FIXME, the reflection API doesn't offer a way around this*/
+ return InflateType (type.GetElementType (), type_args, method_args).MakeArrayType (1);
+ return InflateType (type.GetElementType (), type_args, method_args).MakeArrayType ();
+ }
+
+ Type[] args = type.GetGenericArguments ();
+ for (int i = 0; i < args.Length; ++i)
+ args [i] = InflateType (args [i], type_args, method_args);
+
+ Type gtd = type.IsGenericTypeDefinition ? type : type.GetGenericTypeDefinition ();
+ return gtd.MakeGenericType (args);
}
public override Type BaseType {
- get {
- Type parent = GetParentType ();
- return parent != null ? parent : generic_type.BaseType;
- }
- }
-
- Type[] GetInterfacesInternal ()
- {
- if (generic_type.interfaces == null)
- return new Type [0];
- Type[] res = new Type [generic_type.interfaces.Length];
- for (int i = 0; i < res.Length; ++i)
- res [i] = InflateType (generic_type.interfaces [i]);
- return res;
+ get { return generic_type.BaseType; }
}
public override Type[] GetInterfaces ()
{
- if (!generic_type.IsCompilerContext)
- throw new NotSupportedException ();
- return GetInterfacesInternal ();
+ throw new NotSupportedException ();
}
protected override bool IsValueTypeImpl ()
{
initialize ();
- if (!(fromNoninstanciated is MethodBuilder))
- throw new InvalidOperationException ("Inflating non MethodBuilder objects is not supported: " + fromNoninstanciated.GetType ());
-
- if (fromNoninstanciated is MethodBuilder) {
- MethodBuilder mb = (MethodBuilder)fromNoninstanciated;
-
- // FIXME: We can't yet handle creating generic instantiations of
- // MethodOnTypeBuilderInst objects
- // Also, mono_image_get_method_on_inst_token () can't handle generic
- // methods
- if (!mb.IsGenericMethodDefinition) {
- if (methods == null)
- methods = new Hashtable ();
- if (!methods.ContainsKey (mb))
- methods [mb] = new MethodOnTypeBuilderInst (this, mb);
- return (MethodInfo)methods [mb];
- }
- }
-
- return GetCorrespondingInflatedMethod (fromNoninstanciated);
+ if (methods == null)
+ methods = new Hashtable ();
+ if (!methods.ContainsKey (fromNoninstanciated))
+ methods [fromNoninstanciated] = new MethodOnTypeBuilderInst (this, fromNoninstanciated);
+ return (MethodInfo)methods [fromNoninstanciated];
}
internal override ConstructorInfo GetConstructor (ConstructorInfo fromNoninstanciated)
{
initialize ();
- if (!(fromNoninstanciated is ConstructorBuilder))
- throw new InvalidOperationException ("Inflating non ConstructorBuilder objects is not supported: " + fromNoninstanciated.GetType ());
-
- ConstructorBuilder cb = (ConstructorBuilder)fromNoninstanciated;
if (ctors == null)
ctors = new Hashtable ();
- if (!ctors.ContainsKey (cb))
- ctors [cb] = new ConstructorOnTypeBuilderInst (this, cb);
- return (ConstructorInfo)ctors [cb];
+ if (!ctors.ContainsKey (fromNoninstanciated))
+ ctors [fromNoninstanciated] = new ConstructorOnTypeBuilderInst (this, fromNoninstanciated);
+ return (ConstructorInfo)ctors [fromNoninstanciated];
}
internal override FieldInfo GetField (FieldInfo fromNoninstanciated)
{
initialize ();
-
- if (!(fromNoninstanciated is FieldBuilder))
- throw new InvalidOperationException ("Inflating non FieldBuilder objects is not supported: " + fromNoninstanciated.GetType ());
-
- FieldBuilder fb = (FieldBuilder)fromNoninstanciated;
if (fields == null)
fields = new Hashtable ();
- if (!fields.ContainsKey (fb))
- fields [fb] = new FieldOnTypeBuilderInst (this, fb);
- return (FieldInfo)fields [fb];
+ if (!fields.ContainsKey (fromNoninstanciated))
+ fields [fromNoninstanciated] = new FieldOnTypeBuilderInst (this, fromNoninstanciated);
+ return (FieldInfo)fields [fromNoninstanciated];
}
public override MethodInfo[] GetMethods (BindingFlags bf)
{
- if (!generic_type.IsCompilerContext)
- throw new NotSupportedException ();
-
- ArrayList l = new ArrayList ();
-
- //
- // Walk up our class hierarchy and retrieve methods from our
- // parent classes.
- //
-
- Type current_type = this;
- do {
- MonoGenericClass gi = current_type as MonoGenericClass;
- if (gi != null)
- l.AddRange (gi.GetMethodsInternal (bf, this));
- else if (current_type is TypeBuilder)
- l.AddRange (current_type.GetMethods (bf));
- else {
- // If we encounter a `MonoType', its
- // GetMethodsByName() will return all the methods
- // from its parent type(s), so we can stop here.
- MonoType mt = (MonoType) current_type;
- l.AddRange (mt.GetMethodsByName (null, bf, false, this));
- break;
- }
-
- if ((bf & BindingFlags.DeclaredOnly) != 0)
- break;
- current_type = current_type.BaseType;
- } while (current_type != null);
-
- MethodInfo[] result = new MethodInfo [l.Count];
- l.CopyTo (result);
- return result;
+ throw new NotSupportedException ();
}
- MethodInfo[] GetMethodsInternal (BindingFlags bf, MonoGenericClass reftype)
+ public override ConstructorInfo[] GetConstructors (BindingFlags bf)
{
- if (generic_type.num_methods == 0)
- return new MethodInfo [0];
-
- ArrayList l = new ArrayList ();
- bool match;
- MethodAttributes mattrs;
- MethodInfo accessor;
+ throw new NotSupportedException ();
+ }
- initialize ();
+ public override FieldInfo[] GetFields (BindingFlags bf)
+ {
+ throw new NotSupportedException ();
+ }
- for (int i = 0; i < generic_type.num_methods; ++i) {
- MethodInfo c = generic_type.methods [i];
+ public override PropertyInfo[] GetProperties (BindingFlags bf)
+ {
+ throw new NotSupportedException ();
+ }
- match = false;
- mattrs = c.Attributes;
- if ((mattrs & MethodAttributes.MemberAccessMask) == MethodAttributes.Public) {
- if ((bf & BindingFlags.Public) != 0)
- match = true;
- } else {
- if ((bf & BindingFlags.NonPublic) != 0)
- match = true;
- }
- if (!match)
- continue;
- match = false;
- if ((mattrs & MethodAttributes.Static) != 0) {
- if ((bf & BindingFlags.Static) != 0)
- match = true;
- } else {
- if ((bf & BindingFlags.Instance) != 0)
- match = true;
- }
- if (!match)
- continue;
- c = TypeBuilder.GetMethod (this, c);
- l.Add (c);
- }
+ public override EventInfo[] GetEvents (BindingFlags bf)
+ {
+ throw new NotSupportedException ();
+ }
- MethodInfo[] result = new MethodInfo [l.Count];
- l.CopyTo (result);
- return result;
+ public override Type[] GetNestedTypes (BindingFlags bf)
+ {
+ throw new NotSupportedException ();
}
- public override ConstructorInfo[] GetConstructors (BindingFlags bf)
+ public override bool IsAssignableFrom (Type c)
{
- if (!generic_type.IsCompilerContext)
- throw new NotSupportedException ();
+ throw new NotSupportedException ();
+ }
- ArrayList l = new ArrayList ();
-
- Type current_type = this;
- do {
- MonoGenericClass gi = current_type as MonoGenericClass;
- if (gi != null)
- l.AddRange (gi.GetConstructorsInternal (bf, this));
- else if (current_type is TypeBuilder)
- l.AddRange (current_type.GetConstructors (bf));
- else {
- MonoType mt = (MonoType) current_type;
- l.AddRange (mt.GetConstructors_internal (bf, this));
- break;
- }
+ public override Type UnderlyingSystemType {
+ get { return this; }
+ }
- if ((bf & BindingFlags.DeclaredOnly) != 0)
- break;
- current_type = current_type.BaseType;
- } while (current_type != null);
+ public override Assembly Assembly {
+ get { return generic_type.Assembly; }
+ }
- ConstructorInfo[] result = new ConstructorInfo [l.Count];
- l.CopyTo (result);
- return result;
+ public override Module Module {
+ get { return generic_type.Module; }
}
- ConstructorInfo[] GetConstructorsInternal (BindingFlags bf, MonoGenericClass reftype)
- {
- if (generic_type.ctors == null)
- return new ConstructorInfo [0];
+ public override string Name {
+ get { return generic_type.Name; }
+ }
- ArrayList l = new ArrayList ();
- bool match;
- MethodAttributes mattrs;
+ public override string Namespace {
+ get { return generic_type.Namespace; }
+ }
- initialize ();
+ public override string FullName {
+ get { return format_name (true, false); }
+ }
- for (int i = 0; i < generic_type.ctors.Length; i++) {
- ConstructorInfo c = generic_type.ctors [i];
+ public override string AssemblyQualifiedName {
+ get { return format_name (true, true); }
+ }
+
+ public override Guid GUID {
+ get { throw new NotSupportedException (); }
+ }
- match = false;
- mattrs = c.Attributes;
- if ((mattrs & MethodAttributes.MemberAccessMask) == MethodAttributes.Public) {
- if ((bf & BindingFlags.Public) != 0)
- match = true;
+ string format_name (bool full_name, bool assembly_qualified)
+ {
+ StringBuilder sb = new StringBuilder (generic_type.FullName);
+
+ sb.Append ("[");
+ for (int i = 0; i < type_arguments.Length; ++i) {
+ if (i > 0)
+ sb.Append (",");
+
+ string name;
+ if (full_name) {
+ string assemblyName = type_arguments [i].Assembly.FullName;
+ name = type_arguments [i].FullName;
+ if (name != null && assemblyName != null)
+ name = name + ", " + assemblyName;
} else {
- if ((bf & BindingFlags.NonPublic) != 0)
- match = true;
+ name = type_arguments [i].ToString ();
}
- if (!match)
- continue;
- match = false;
- if ((mattrs & MethodAttributes.Static) != 0) {
- if ((bf & BindingFlags.Static) != 0)
- match = true;
- } else {
- if ((bf & BindingFlags.Instance) != 0)
- match = true;
+ if (name == null) {
+ return null;
}
- if (!match)
- continue;
- l.Add (TypeBuilder.GetConstructor (this, c));
+ if (full_name)
+ sb.Append ("[");
+ sb.Append (name);
+ if (full_name)
+ sb.Append ("]");
+ }
+ sb.Append ("]");
+ if (assembly_qualified) {
+ sb.Append (", ");
+ sb.Append (generic_type.Assembly.FullName);
}
+ return sb.ToString ();
+ }
+
+ public override string ToString ()
+ {
+ return format_name (false, false);
+ }
- ConstructorInfo[] result = new ConstructorInfo [l.Count];
- l.CopyTo (result);
- return result;
+ public override Type GetGenericTypeDefinition ()
+ {
+ return generic_type;
}
- public override FieldInfo[] GetFields (BindingFlags bf)
+ public override Type[] GetGenericArguments ()
{
- if (!generic_type.IsCompilerContext)
- throw new NotSupportedException ();
+ Type[] ret = new Type [type_arguments.Length];
+ type_arguments.CopyTo (ret, 0);
+ return ret;
+ }
- ArrayList l = new ArrayList ();
-
- Type current_type = this;
- do {
- MonoGenericClass gi = current_type as MonoGenericClass;
- if (gi != null)
- l.AddRange (gi.GetFieldsInternal (bf, this));
- else if (current_type is TypeBuilder)
- l.AddRange (current_type.GetFields (bf));
- else {
- MonoType mt = (MonoType) current_type;
- l.AddRange (mt.GetFields_internal (bf, this));
- break;
+ public override bool ContainsGenericParameters {
+ get {
+ foreach (Type t in type_arguments) {
+ if (t.ContainsGenericParameters)
+ return true;
}
+ return false;
+ }
+ }
- if ((bf & BindingFlags.DeclaredOnly) != 0)
- break;
- current_type = current_type.BaseType;
- } while (current_type != null);
+ public override bool IsGenericTypeDefinition {
+ get { return false; }
+ }
+
+ public override bool IsGenericType {
+ get { return true; }
+ }
+
+ public override Type DeclaringType {
+ get { return generic_type.DeclaringType; }
+ }
- FieldInfo[] result = new FieldInfo [l.Count];
- l.CopyTo (result);
- return result;
+ public override RuntimeTypeHandle TypeHandle {
+ get {
+ throw new NotSupportedException ();
+ }
}
- FieldInfo[] GetFieldsInternal (BindingFlags bf, MonoGenericClass reftype)
+ public override Type MakeArrayType ()
{
- if (generic_type.num_fields == 0)
- return new FieldInfo [0];
+ return new ArrayType (this, 0);
+ }
- ArrayList l = new ArrayList ();
- bool match;
- FieldAttributes fattrs;
+ public override Type MakeArrayType (int rank)
+ {
+ if (rank < 1)
+ throw new IndexOutOfRangeException ();
+ return new ArrayType (this, rank);
+ }
- initialize ();
+ public override Type MakeByRefType ()
+ {
+ return new ByRefType (this);
+ }
- for (int i = 0; i < generic_type.num_fields; i++) {
- FieldInfo c = generic_type.fields [i];
+ public override Type MakePointerType ()
+ {
+ return new PointerType (this);
+ }
- match = false;
- fattrs = c.Attributes;
- if ((fattrs & FieldAttributes.FieldAccessMask) == FieldAttributes.Public) {
- if ((bf & BindingFlags.Public) != 0)
- match = true;
- } else {
- if ((bf & BindingFlags.NonPublic) != 0)
- match = true;
- }
- if (!match)
- continue;
- match = false;
- if ((fattrs & FieldAttributes.Static) != 0) {
- if ((bf & BindingFlags.Static) != 0)
- match = true;
- } else {
- if ((bf & BindingFlags.Instance) != 0)
- match = true;
- }
- if (!match)
- continue;
- l.Add (TypeBuilder.GetField (this, c));
- }
+ public override Type GetElementType ()
+ {
+ throw new NotSupportedException ();
+ }
- FieldInfo[] result = new FieldInfo [l.Count];
- l.CopyTo (result);
- return result;
+ protected override bool HasElementTypeImpl ()
+ {
+ return false;
}
- public override PropertyInfo[] GetProperties (BindingFlags bf)
+ protected override bool IsCOMObjectImpl ()
{
- if (!generic_type.IsCompilerContext)
- throw new NotSupportedException ();
+ return false;
+ }
- ArrayList l = new ArrayList ();
-
- Type current_type = this;
- do {
- MonoGenericClass gi = current_type as MonoGenericClass;
- if (gi != null)
- l.AddRange (gi.GetPropertiesInternal (bf, this));
- else if (current_type is TypeBuilder)
- l.AddRange (current_type.GetProperties (bf));
- else {
- MonoType mt = (MonoType) current_type;
- l.AddRange (mt.GetPropertiesByName (null, bf, false, this));
- break;
- }
+ protected override bool IsPrimitiveImpl ()
+ {
+ return false;
+ }
- if ((bf & BindingFlags.DeclaredOnly) != 0)
- break;
- current_type = current_type.BaseType;
- } while (current_type != null);
+ protected override bool IsArrayImpl ()
+ {
+ return false;
+ }
- PropertyInfo[] result = new PropertyInfo [l.Count];
- l.CopyTo (result);
- return result;
+ protected override bool IsByRefImpl ()
+ {
+ return false;
}
- PropertyInfo[] GetPropertiesInternal (BindingFlags bf, MonoGenericClass reftype)
+ protected override bool IsPointerImpl ()
{
- if (generic_type.properties == null)
- return new PropertyInfo [0];
+ return false;
+ }
- ArrayList l = new ArrayList ();
- bool match;
- MethodAttributes mattrs;
- MethodInfo accessor;
+ protected override TypeAttributes GetAttributeFlagsImpl ()
+ {
+ return generic_type.Attributes;
+ }
- initialize ();
+ //stuff that throws
+ public override Type GetInterface (string name, bool ignoreCase)
+ {
+ throw new NotSupportedException ();
+ }
- foreach (PropertyInfo pinfo in generic_type.properties) {
- match = false;
- accessor = pinfo.GetGetMethod (true);
- if (accessor == null)
- accessor = pinfo.GetSetMethod (true);
- if (accessor == null)
- continue;
- mattrs = accessor.Attributes;
- if ((mattrs & MethodAttributes.MemberAccessMask) == MethodAttributes.Public) {
- if ((bf & BindingFlags.Public) != 0)
- match = true;
- } else {
- if ((bf & BindingFlags.NonPublic) != 0)
- match = true;
- }
- if (!match)
- continue;
- match = false;
- if ((mattrs & MethodAttributes.Static) != 0) {
- if ((bf & BindingFlags.Static) != 0)
- match = true;
- } else {
- if ((bf & BindingFlags.Instance) != 0)
- match = true;
- }
- if (!match)
- continue;
- l.Add (new PropertyOnTypeBuilderInst (reftype, pinfo));
- }
- PropertyInfo[] result = new PropertyInfo [l.Count];
- l.CopyTo (result);
- return result;
+ public override EventInfo GetEvent (string name, BindingFlags bindingAttr)
+ {
+ throw new NotSupportedException ();
}
- public override EventInfo[] GetEvents (BindingFlags bf)
+ public override FieldInfo GetField( string name, BindingFlags bindingAttr)
{
- if (!generic_type.IsCompilerContext)
- throw new NotSupportedException ();
+ throw new NotSupportedException ();
+ }
- ArrayList l = new ArrayList ();
-
- Type current_type = this;
- do {
- MonoGenericClass gi = current_type as MonoGenericClass;
- if (gi != null)
- l.AddRange (gi.GetEvents_impl (bf, this));
- else if (current_type is TypeBuilder)
- l.AddRange (current_type.GetEvents (bf));
- else {
- MonoType mt = (MonoType) current_type;
- l.AddRange (mt.GetEvents (bf));
- break;
- }
+ public override MemberInfo[] GetMembers (BindingFlags bindingAttr)
+ {
+ throw new NotSupportedException ();
+ }
- if ((bf & BindingFlags.DeclaredOnly) != 0)
- break;
- current_type = current_type.BaseType;
- } while (current_type != null);
+ public override Type GetNestedType (string name, BindingFlags bindingAttr)
+ {
+ throw new NotSupportedException ();
+ }
- EventInfo[] result = new EventInfo [l.Count];
- l.CopyTo (result);
- return result;
+ public override object InvokeMember (string name, BindingFlags invokeAttr,
+ Binder binder, object target, object[] args,
+ ParameterModifier[] modifiers,
+ CultureInfo culture, string[] namedParameters)
+ {
+ throw new NotSupportedException ();
}
- protected EventInfo[] GetEvents_impl (BindingFlags bf, Type reftype)
+ protected override MethodInfo GetMethodImpl (string name, BindingFlags bindingAttr, Binder binder,
+ CallingConventions callConvention, Type[] types,
+ ParameterModifier[] modifiers)
{
- ArrayList l = new ArrayList ();
- bool match;
- MethodAttributes mattrs;
- MethodInfo accessor;
+ throw new NotSupportedException ();
+ }
- initialize ();
+ protected override PropertyInfo GetPropertyImpl (string name, BindingFlags bindingAttr, Binder binder,
+ Type returnType, Type[] types, ParameterModifier[] modifiers)
+ {
+ throw new NotSupportedException ();
+ }
- EventInfo[] events = GetEvents_internal (reftype);
-
- for (int i = 0; i < events.Length; i++) {
- EventInfo c = events [i];
-
- match = false;
- accessor = c.GetAddMethod (true);
- if (accessor == null)
- accessor = c.GetRemoveMethod (true);
- if (accessor == null)
- continue;
- mattrs = accessor.Attributes;
- if ((mattrs & MethodAttributes.MemberAccessMask) == MethodAttributes.Public) {
- if ((bf & BindingFlags.Public) != 0)
- match = true;
- } else {
- if ((bf & BindingFlags.NonPublic) != 0)
- match = true;
- }
- if (!match)
- continue;
- match = false;
- if ((mattrs & MethodAttributes.Static) != 0) {
- if ((bf & BindingFlags.Static) != 0)
- match = true;
- } else {
- if ((bf & BindingFlags.Instance) != 0)
- match = true;
- }
- if (!match)
- continue;
- l.Add (c);
- }
- EventInfo[] result = new EventInfo [l.Count];
- l.CopyTo (result);
- return result;
+ protected override ConstructorInfo GetConstructorImpl (BindingFlags bindingAttr,
+ Binder binder,
+ CallingConventions callConvention,
+ Type[] types,
+ ParameterModifier[] modifiers)
+ {
+ throw new NotSupportedException ();
}
- public override Type[] GetNestedTypes (BindingFlags bf)
+ //MemberInfo
+ public override bool IsDefined (Type attributeType, bool inherit)
{
- return generic_type.GetNestedTypes (bf);
+ throw new NotSupportedException ();
}
- public override bool IsAssignableFrom (Type c)
+ public override object [] GetCustomAttributes (bool inherit)
{
- if (c == this)
- return true;
+ throw new NotSupportedException ();
+ }
- Type[] interfaces = GetInterfacesInternal ();
+ public override object [] GetCustomAttributes (Type attributeType, bool inherit)
+ {
+ throw new NotSupportedException ();
+ }
- if (c.IsInterface) {
- if (interfaces == null)
- return false;
- foreach (Type t in interfaces)
- if (c.IsAssignableFrom (t))
+ internal override bool IsUserType {
+ get {
+ foreach (var t in type_arguments) {
+ if (t.IsUserType)
return true;
+ }
return false;
}
-
- Type parent = GetParentType ();
- if (parent == null)
- return c == typeof (object);
- else
- return c.IsAssignableFrom (parent);
}
+
}
}
projects / mono.git / blobdiff