//
// (C) Ximian, Inc. http://www.ximian.com
//
-// TODO: Mucho left to implement.
+
+//
+// Copyright (C) 2004 Novell, Inc (http://www.novell.com)
+//
+// Permission is hereby granted, free of charge, to any person obtaining
+// a copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to
+// permit persons to whom the Software is furnished to do so, subject to
+// the following conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
+using System.Diagnostics;
using System.Reflection;
+using System.Reflection.Emit;
using System.Collections;
+using System.Runtime.InteropServices;
using System.Runtime.CompilerServices;
using System.Globalization;
namespace System {
- //
- // FIXME: Implement the various IReflect dependencies
- //
-
- [MonoTODO]
[Serializable]
- public abstract class Type : MemberInfo, IReflect {
+ [ClassInterface (ClassInterfaceType.None)]
+#if NET_2_0
+ [ComVisible (true)]
+ [ComDefaultInterface (typeof (_Type))]
+#endif
+ public abstract class Type : MemberInfo, IReflect, _Type, _MemberInfo {
internal RuntimeTypeHandle _impl;
public static readonly MemberFilter FilterNameIgnoreCase = new MemberFilter (FilterNameIgnoreCase_impl);
public static readonly object Missing;
- private const BindingFlags DefaultBindingFlags =
+ internal const BindingFlags DefaultBindingFlags =
BindingFlags.Public | BindingFlags.Static | BindingFlags.Instance;
/* implementation of the delegates for MemberFilter */
static bool FilterName_impl (MemberInfo m, object filterCriteria)
{
string name = (string) filterCriteria;
- return name.Equals (m.Name);
+ if (name == null || name.Length == 0 )
+ return false; // because m.Name cannot be null or empty
+
+ if (name [name.Length-1] == '*')
+ return string.Compare (name, 0, m.Name, 0, name.Length-1, false, CultureInfo.InvariantCulture) == 0;
+
+ return name.Equals (m.Name);
}
-
+
static bool FilterNameIgnoreCase_impl (MemberInfo m, object filterCriteria)
{
string name = (string) filterCriteria;
- return String.Compare (name, m.Name, true) == 0;
+ if (name == null || name.Length == 0 )
+ return false; // because m.Name cannot be null or empty
+
+ if (name [name.Length-1] == '*')
+ return string.Compare (name, 0, m.Name, 0, name.Length-1, true, CultureInfo.InvariantCulture) == 0;
+
+ return String.Compare (name, m.Name, true, CultureInfo.InvariantCulture) == 0;
}
-
- [MonoTODO]
+
static bool FilterAttribute_impl (MemberInfo m, object filterCriteria)
{
- throw new NotImplementedException ("FilterAttribute_impl");
+ int flags = ((IConvertible)filterCriteria).ToInt32 (null);
+ if (m is MethodInfo)
+ return ((int)((MethodInfo)m).Attributes & flags) != 0;
+ if (m is FieldInfo)
+ return ((int)((FieldInfo)m).Attributes & flags) != 0;
+ if (m is PropertyInfo)
+ return ((int)((PropertyInfo)m).Attributes & flags) != 0;
+ if (m is EventInfo)
+ return ((int)((EventInfo)m).Attributes & flags) != 0;
+ return false;
}
protected Type ()
return GetAttributeFlagsImpl ();
}
}
-
+
/// <summary>
/// Returns the basetype for this type
/// </summary>
public abstract Type BaseType {
get;
}
-
+
/// <summary>
/// Returns the class that declares the member.
/// </summary>
public override Type DeclaringType {
get {
- return this;
+ return null;
}
}
/// <summary>
///
/// </summary>
- [MonoTODO]
public static Binder DefaultBinder {
get {
- return null;
+ return Binder.DefaultBinder;
}
}
-
+
/// <summary>
/// The full name of the type including its namespace
/// </summary>
public bool IsClass {
get {
- if (this == typeof (System.Enum) || this == typeof (System.ValueType))
+ //
+ // This code used to probe for "this == typeof (System.Enum)", but in
+ // The .NET Framework 1.0, the above test return false
+ //
+ if (this == typeof (System.ValueType))
return true;
if (IsInterface)
return false;
- return !type_is_subtype_of (this, typeof (System.ValueType), false);
+ return !is_subtype_of (this, typeof (System.ValueType), false);
}
}
public bool IsEnum {
get {
- return type_is_subtype_of (this, typeof (System.Enum), false) &&
+ // This hack is needed because EnumBuilder's UnderlyingSystemType returns the enum's basetype
+ if (this is EnumBuilder)
+ return true;
+
+ return is_subtype_of (this, typeof (System.Enum), false) &&
this != typeof (System.Enum);
}
}
public bool IsNotPublic {
get {
- return !IsPublic;
+ return (Attributes & TypeAttributes.VisibilityMask) == TypeAttributes.NotPublic;
}
}
public bool IsSerializable {
get {
- return (Attributes & TypeAttributes.Serializable) != 0;
+ // Enums and delegates are always serializable
+ return (Attributes & TypeAttributes.Serializable) != 0 || IsEnum ||
+ is_subtype_of (this, typeof (System.Delegate), false);
}
}
get {return MemberTypes.TypeInfo;}
}
+#if NET_2_0 || BOOTSTRAP_NET_2_0
+ override
+#endif
public abstract Module Module {get;}
public abstract string Namespace {get;}
public override Type ReflectedType {
get {
- return this;
+ return null;
}
}
public abstract RuntimeTypeHandle TypeHandle {get;}
+#if NET_2_0
+ [ComVisible (true)]
+#endif
public ConstructorInfo TypeInitializer {
get {
return GetConstructorImpl (
return false;
return Equals (cmp);
}
-
+
[MethodImplAttribute(MethodImplOptions.InternalCall)]
public extern bool Equals (Type type);
[MethodImplAttribute(MethodImplOptions.InternalCall)]
- private static extern Type internal_from_handle (RuntimeTypeHandle handle);
- [MethodImplAttribute(MethodImplOptions.InternalCall)]
- private static extern Type internal_from_name (string name);
+ private static extern Type internal_from_handle (IntPtr handle);
+ [MethodImplAttribute(MethodImplOptions.InternalCall)]
+ private static extern Type internal_from_name (string name, bool throwOnError, bool ignoreCase);
+
public static Type GetType(string typeName)
{
- return internal_from_name (typeName);
+ if (typeName == null)
+ throw new ArgumentNullException ("typeName");
+
+ return internal_from_name (typeName, false, false);
}
public static Type GetType(string typeName, bool throwOnError)
{
- // LAMESPEC: what kinds of errors cause exception to be thrown?
- return internal_from_name (typeName);
+ if (typeName == null)
+ throw new ArgumentNullException ("typeName");
+
+ Type type = internal_from_name (typeName, throwOnError, false);
+ if (throwOnError && type == null)
+ throw new TypeLoadException ("Error loading '" + typeName + "'");
+
+ return type;
}
- [MonoTODO]
public static Type GetType(string typeName, bool throwOnError, bool ignoreCase)
{
- throw new NotImplementedException ();
+ if (typeName == null)
+ throw new ArgumentNullException ("typeName");
+
+ Type t = internal_from_name (typeName, throwOnError, ignoreCase);
+ if (throwOnError && t == null)
+ throw new TypeLoadException ("Error loading '" + typeName + "'");
+
+ return t;
}
public static Type[] GetTypeArray (object[] args) {
}
[MethodImplAttribute(MethodImplOptions.InternalCall)]
- public extern static TypeCode GetTypeCode (Type type);
+ internal extern static TypeCode GetTypeCodeInternal (Type type);
+
+ public static TypeCode GetTypeCode (Type type) {
+ type = type.UnderlyingSystemType;
+
+ if (!type.IsSystemType)
+ return Type.GetTypeCode (typeof (object));
+ else
+ return GetTypeCodeInternal (type);
+ }
[MonoTODO]
public static Type GetTypeFromCLSID (Guid clsid)
public static Type GetTypeFromHandle (RuntimeTypeHandle handle)
{
- return internal_from_handle (handle);
+ return internal_from_handle (handle.Value);
}
[MonoTODO]
[MethodImplAttribute(MethodImplOptions.InternalCall)]
internal static extern bool type_is_subtype_of (Type a, Type b, bool check_interfaces);
-
+
+ [MethodImplAttribute(MethodImplOptions.InternalCall)]
+ internal static extern bool type_is_assignable_from (Type a, Type b);
+
+ internal static bool is_subtype_of (Type a, Type b, bool check_interfaces)
+ {
+ a = a.UnderlyingSystemType;
+ b = b.UnderlyingSystemType;
+
+ if (!a.IsSystemType || !b.IsSystemType)
+ return false;
+ else
+ return type_is_subtype_of (a, b, check_interfaces);
+ }
+
+#if NET_2_0
+ [ComVisible (true)]
+#endif
public virtual bool IsSubclassOf (Type c)
{
- return type_is_subtype_of (this, c, false);
+ if (c == null)
+ return false;
+
+ return (this != c) && is_subtype_of (this, c, false);
}
- [MonoTODO]
public virtual Type[] FindInterfaces (TypeFilter filter, object filterCriteria)
{
- // FIXME
- throw new NotImplementedException ();
+ if (filter == null)
+ throw new ArgumentNullException ("filter");
+
+ ArrayList ifaces = new ArrayList ();
+ foreach (Type iface in GetInterfaces ()) {
+ if (filter (iface, filterCriteria))
+ ifaces.Add (iface);
+ }
+
+ return (Type []) ifaces.ToArray (typeof (Type));
}
public Type GetInterface (string name) {
public abstract Type GetInterface (string name, bool ignoreCase);
+ [MethodImplAttribute(MethodImplOptions.InternalCall)]
+ internal static extern void GetInterfaceMapData (Type t, Type iface, out MethodInfo[] targets, out MethodInfo[] methods);
+
+#if NET_2_0
+ [ComVisible (true)]
+#endif
public virtual InterfaceMapping GetInterfaceMap (Type interfaceType) {
- throw new NotImplementedException ();
+ InterfaceMapping res;
+ if (interfaceType == null)
+ throw new ArgumentNullException ("interfaceType");
+ if (!interfaceType.IsInterface)
+ throw new ArgumentException (Locale.GetText ("Argument must be an interface."), "interfaceType");
+ res.TargetType = this;
+ res.InterfaceType = interfaceType;
+ GetInterfaceMapData (this, interfaceType, out res.TargetMethods, out res.InterfaceMethods);
+ if (res.TargetMethods == null)
+ throw new ArgumentException (Locale.GetText ("Interface not found"), "interfaceType");
+
+ return res;
}
public abstract Type[] GetInterfaces ();
- [MonoTODO]
public virtual bool IsAssignableFrom (Type c)
{
- // FIXME
- return type_is_subtype_of (c, this, true);
- }
+ if (c == null)
+ return false;
+
+ if (Equals (c))
+ return true;
+
+ if (c is TypeBuilder)
+ return ((TypeBuilder)c).IsAssignableTo (this);
- public virtual bool IsInstanceOfType (object o) {
- if (o != null) {
- return o.GetType().IsSubclassOf (this);
+ /* Handle user defined type classes */
+ if (!IsSystemType) {
+ Type systemType = UnderlyingSystemType;
+ if (!systemType.IsSystemType)
+ return false;
+ return systemType.IsAssignableFrom (c);
}
- return false;
+
+ if (!c.IsSystemType) {
+ Type underlyingType = c.UnderlyingSystemType;
+ if (!underlyingType.IsSystemType)
+ return false;
+ return IsAssignableFrom (underlyingType);
+ }
+
+ return type_is_assignable_from (this, c);
}
+ [MethodImplAttribute(MethodImplOptions.InternalCall)]
+ public extern virtual bool IsInstanceOfType (object o);
+
public virtual int GetArrayRank ()
{
throw new NotSupportedException (); // according to MSDN
return (int)_impl.Value;
}
- public MemberInfo[] GetMember( string name)
+ public MemberInfo[] GetMember (string name)
{
return GetMember (name, DefaultBindingFlags);
}
- public virtual MemberInfo[] GetMember( string name, BindingFlags bindingAttr)
+ public virtual MemberInfo[] GetMember (string name, BindingFlags bindingAttr)
{
return GetMember (name, MemberTypes.All, bindingAttr);
}
- public virtual MemberInfo[] GetMember (string name, MemberTypes type,
- BindingFlags bindingAttr)
+ public virtual MemberInfo[] GetMember (string name, MemberTypes type, BindingFlags bindingAttr)
{
- return FindMembers (type, bindingAttr, FilterName, name);
+ if ((bindingAttr & BindingFlags.IgnoreCase) != 0)
+ return FindMembers (type, bindingAttr, FilterNameIgnoreCase, name);
+ else
+ return FindMembers (type, bindingAttr, FilterName, name);
}
- public MemberInfo[] GetMembers()
+ public MemberInfo[] GetMembers ()
{
return GetMembers (DefaultBindingFlags);
}
return GetMethodImpl (name, bindingAttr, null, CallingConventions.Any, null, null);
}
- [MonoTODO]
public MethodInfo GetMethod (string name, Type[] types)
{
return GetMethod (name, DefaultBindingFlags, null, CallingConventions.Any, types, null);
}
- public MethodInfo GetMethod( string name, Type[] types, ParameterModifier[] modifiers)
+ public MethodInfo GetMethod (string name, Type[] types, ParameterModifier[] modifiers)
{
- return GetMethod (name, DefaultBindingFlags, null,
- CallingConventions.Any, types, modifiers);
+ return GetMethod (name, DefaultBindingFlags, null, CallingConventions.Any, types, modifiers);
}
public MethodInfo GetMethod (string name, BindingFlags bindingAttr, Binder binder,
- Type[] types, ParameterModifier[] modifiers)
+ Type[] types, ParameterModifier[] modifiers)
{
- return GetMethod (name, bindingAttr, binder,
- CallingConventions.Any, types, modifiers);
+ return GetMethod (name, bindingAttr, binder, CallingConventions.Any, types, modifiers);
}
- public MethodInfo GetMethod (string name, BindingFlags bindingAttr,
- Binder binder, CallingConventions callConvention,
- Type[] types, ParameterModifier[] modifiers)
+ public MethodInfo GetMethod (string name, BindingFlags bindingAttr, Binder binder,
+ CallingConventions callConvention, Type[] types, ParameterModifier[] modifiers)
{
if (name == null)
throw new ArgumentNullException ("name");
if (types == null)
throw new ArgumentNullException ("types");
+ for (int i = 0; i < types.Length; i++)
+ if (types[i] == null)
+ throw new ArgumentNullException ("types");
+
return GetMethodImpl (name, bindingAttr, binder, callConvention, types, modifiers);
}
- protected abstract MethodInfo GetMethodImpl (string name, BindingFlags bindingAttr,
- Binder binder,
- CallingConventions callConvention,
- Type[] types, ParameterModifier[] modifiers);
+ protected abstract MethodInfo GetMethodImpl (string name, BindingFlags bindingAttr, Binder binder,
+ CallingConventions callConvention, Type[] types,
+ ParameterModifier[] modifiers);
+ internal MethodInfo GetMethodImplInternal (string name, BindingFlags bindingAttr, Binder binder,
+ CallingConventions callConvention, Type[] types,
+ ParameterModifier[] modifiers)
+ {
+ return GetMethodImpl (name, bindingAttr, binder, callConvention, types, modifiers);
+ }
+
+ internal virtual MethodInfo GetMethod (MethodInfo fromNoninstanciated)
+ {
+ throw new System.InvalidOperationException ("can only be called in generic type");
+ }
+
+ internal virtual ConstructorInfo GetConstructor (ConstructorInfo fromNoninstanciated)
+ {
+ throw new System.InvalidOperationException ("can only be called in generic type");
+ }
+
+ internal virtual FieldInfo GetField (FieldInfo fromNoninstanciated)
+ {
+ throw new System.InvalidOperationException ("can only be called in generic type");
+ }
+
+
public MethodInfo[] GetMethods ()
{
return GetMethods (DefaultBindingFlags);
public abstract PropertyInfo[] GetProperties (BindingFlags bindingAttr);
- [MethodImplAttribute(MethodImplOptions.InternalCall)]
- private static extern PropertyInfo get_property (Type type, string name, Type[] types);
-
public PropertyInfo GetProperty (string name)
{
if (name == null)
throw new ArgumentNullException ("name");
- return GetPropertyImpl (name, DefaultBindingFlags, null, null, new Type[0], null);
+ return GetPropertyImpl (name, DefaultBindingFlags, null, null, null, null);
}
public PropertyInfo GetProperty (string name, BindingFlags bindingAttr)
{
if (name == null)
throw new ArgumentNullException ("name");
- return GetPropertyImpl (name, bindingAttr, null, null, new Type[0], null);
+ return GetPropertyImpl (name, bindingAttr, null, null, null, null);
}
public PropertyInfo GetProperty (string name, Type returnType)
{
if (name == null)
throw new ArgumentNullException ("name");
- return GetPropertyImpl (name, DefaultBindingFlags, null, returnType, new Type[0], null);
+ return GetPropertyImpl (name, DefaultBindingFlags, null, returnType, null, null);
}
- [MonoTODO]
public PropertyInfo GetProperty (string name, Type[] types)
{
- // TODO: return GetProperty (name, DefaultBindingFlags, null, null, types, null);
- return get_property (this, name, types);
+ return GetProperty (name, DefaultBindingFlags, null, null, types, null);
}
public PropertyInfo GetProperty (string name, Type returnType, Type[] types)
return GetProperty (name, DefaultBindingFlags, null, returnType, types, null);
}
- public PropertyInfo GetProperty( string name, Type returnType, Type[] types,
- ParameterModifier[] modifiers)
+ public PropertyInfo GetProperty( string name, Type returnType, Type[] types, ParameterModifier[] modifiers)
{
return GetProperty (name, DefaultBindingFlags, null, returnType, types, modifiers);
}
- public PropertyInfo GetProperty (string name, BindingFlags bindingAttr,
- Binder binder, Type returnType,
- Type[] types, ParameterModifier[] modifiers)
+ public PropertyInfo GetProperty (string name, BindingFlags bindingAttr, Binder binder, Type returnType,
+ Type[] types, ParameterModifier[] modifiers)
{
if (name == null)
throw new ArgumentNullException ("name");
return GetPropertyImpl (name, bindingAttr, binder, returnType, types, modifiers);
}
- protected abstract PropertyInfo GetPropertyImpl (string name,
- BindingFlags bindingAttr,
- Binder binder, Type returnType,
- Type[] types,
- ParameterModifier[] modifiers);
+ protected abstract PropertyInfo GetPropertyImpl (string name, BindingFlags bindingAttr, Binder binder,
+ Type returnType, Type[] types, ParameterModifier[] modifiers);
- [MethodImplAttribute(MethodImplOptions.InternalCall)]
- private static extern ConstructorInfo get_constructor (Type type, Type[] types);
+ internal PropertyInfo GetPropertyImplInternal (string name, BindingFlags bindingAttr, Binder binder,
+ Type returnType, Type[] types, ParameterModifier[] modifiers)
+ {
+ return GetPropertyImpl (name, bindingAttr, binder, returnType, types, modifiers);
+ }
protected abstract ConstructorInfo GetConstructorImpl (BindingFlags bindingAttr,
Binder binder,
protected abstract bool IsCOMObjectImpl ();
protected abstract bool IsPointerImpl ();
protected abstract bool IsPrimitiveImpl ();
- protected abstract bool IsValueTypeImpl ();
+
+ [MethodImplAttribute(MethodImplOptions.InternalCall)]
+ internal static extern bool IsArrayImpl (Type type);
+
+ protected virtual bool IsValueTypeImpl ()
+ {
+ if (this == typeof (Enum) || this == typeof (ValueType))
+ return false;
+
+ return IsSubclassOf (typeof (ValueType));
+ }
protected virtual bool IsContextfulImpl ()
{
return typeof (MarshalByRefObject).IsAssignableFrom (this);
}
- [MonoTODO]
+#if NET_2_0
+ [ComVisible (true)]
+#endif
public ConstructorInfo GetConstructor (Type[] types)
{
- // TODO: return GetConstructor
- // (BindingFlags.Public | BindingFlags.NonPublic, null, types, null);
-
- return get_constructor (this, types);
+ return GetConstructorImpl (
+ DefaultBindingFlags, null, CallingConventions.Any, types, null);
}
+#if NET_2_0
+ [ComVisible (true)]
+#endif
public ConstructorInfo GetConstructor (BindingFlags bindingAttr, Binder binder,
Type[] types, ParameterModifier[] modifiers)
{
- return GetConstructor (
+ return GetConstructorImpl (
bindingAttr, binder, CallingConventions.Any, types, modifiers);
}
+#if NET_2_0
+ [ComVisible (true)]
+#endif
public ConstructorInfo GetConstructor (BindingFlags bindingAttr, Binder binder,
CallingConventions callConvention,
Type[] types, ParameterModifier[] modifiers)
return GetConstructorImpl (bindingAttr, binder, callConvention, types, modifiers);
}
+#if NET_2_0
+ [ComVisible (true)]
+#endif
public ConstructorInfo[] GetConstructors ()
{
- return GetConstructors (BindingFlags.Public | BindingFlags.NonPublic);
+ return GetConstructors (BindingFlags.Public | BindingFlags.Instance);
}
-
+
+#if NET_2_0
+ [ComVisible (true)]
+#endif
public abstract ConstructorInfo[] GetConstructors (BindingFlags bindingAttr);
- [MonoTODO]
public virtual MemberInfo[] GetDefaultMembers ()
{
- throw new NotImplementedException ();
+ object [] att = GetCustomAttributes (typeof (DefaultMemberAttribute), true);
+ if (att.Length == 0)
+ return new MemberInfo [0];
+
+ MemberInfo [] member = GetMember (((DefaultMemberAttribute) att [0]).MemberName);
+ return (member != null) ? member : new MemberInfo [0];
}
public virtual MemberInfo[] FindMembers (MemberTypes memberType, BindingFlags bindingAttr,
return result;
}
- [MonoTODO]
- public object InvokeMember (string name, BindingFlags invokeAttr, Binder binder,
- object target, object[] args)
+ [DebuggerHidden]
+ [DebuggerStepThrough]
+ public object InvokeMember (string name, BindingFlags invokeAttr, Binder binder, object target, object[] args)
{
- throw new NotImplementedException ();
+ return InvokeMember (name, invokeAttr, binder, target, args, null, null, null);
}
- [MonoTODO]
+ [DebuggerHidden]
+ [DebuggerStepThrough]
public object InvokeMember (string name, BindingFlags invokeAttr, Binder binder,
object target, object[] args, CultureInfo culture)
{
- throw new NotImplementedException ();
+ return InvokeMember (name, invokeAttr, binder, target, args, null, culture, null);
}
public abstract object InvokeMember (string name, BindingFlags invokeAttr,
{
return FullName;
}
+
+ internal bool IsSystemType {
+ get {
+ return _impl.Value != IntPtr.Zero;
+ }
+ }
+
+#if NET_2_0 || BOOTSTRAP_NET_2_0
+ public abstract Type[] GetGenericArguments ();
+
+ public abstract bool HasGenericArguments {
+ get;
+ }
+
+ public abstract bool ContainsGenericParameters {
+ get;
+ }
+
+ public extern bool IsGenericTypeDefinition {
+ [MethodImplAttribute(MethodImplOptions.InternalCall)]
+ get;
+ }
+
+ [MethodImplAttribute(MethodImplOptions.InternalCall)]
+ extern Type GetGenericTypeDefinition_impl ();
+
+ public virtual Type GetGenericTypeDefinition ()
+ {
+ Type res = GetGenericTypeDefinition_impl ();
+ if (res == null)
+ throw new InvalidOperationException ();
+
+ return res;
+ }
+
+ public extern bool IsGenericInstance {
+ [MethodImplAttribute(MethodImplOptions.InternalCall)]
+ get;
+ }
+
+ [MethodImplAttribute(MethodImplOptions.InternalCall)]
+ static extern Type BindGenericParameters (Type gt, Type [] types);
+
+#if NET_2_0
+ [ComVisible (true)]
+#endif
+ public Type BindGenericParameters (Type [] types)
+ {
+ if (types == null)
+ throw new ArgumentNullException ("types");
+ foreach (Type t in types) {
+ if (t == null)
+ throw new ArgumentNullException ("types");
+ }
+ Type res = BindGenericParameters (this, types);
+ if (res == null)
+ throw new TypeLoadException ();
+ return res;
+ }
+
+ public Type MakeGenericType (Type[] types)
+ {
+ return BindGenericParameters (types);
+ }
+
+ public abstract bool IsGenericParameter {
+ get;
+ }
+
+ [MethodImplAttribute(MethodImplOptions.InternalCall)]
+ extern int GetGenericParameterPosition ();
+
+ public virtual int GenericParameterPosition {
+ get {
+ int res = GetGenericParameterPosition ();
+ if (res < 0)
+ throw new InvalidOperationException ();
+ return res;
+ }
+ }
+
+ [MethodImplAttribute(MethodImplOptions.InternalCall)]
+ extern GenericParameterAttributes GetGenericParameterAttributes ();
+
+ public virtual GenericParameterAttributes GenericParameterAttributes {
+ get {
+ if (!IsGenericParameter)
+ throw new InvalidOperationException ();
+
+ return GetGenericParameterAttributes ();
+ }
+ }
+
+ [MethodImplAttribute(MethodImplOptions.InternalCall)]
+ extern Type[] GetGenericParameterConstraints_impl ();
+
+ public virtual Type[] GetGenericParameterConstraints ()
+ {
+ if (!IsGenericParameter)
+ throw new InvalidOperationException ();
+
+ return GetGenericParameterConstraints_impl ();
+ }
+
+ public abstract MethodInfo DeclaringMethod {
+ get;
+ }
+
+ [MethodImplAttribute(MethodImplOptions.InternalCall)]
+ extern Type make_array_type (int rank);
+
+ public virtual Type MakeArrayType ()
+ {
+ return MakeArrayType (1);
+ }
+
+ public virtual Type MakeArrayType (int rank)
+ {
+ if (rank < 1)
+ throw new IndexOutOfRangeException ();
+ return make_array_type (rank);
+ }
+
+ [MethodImplAttribute(MethodImplOptions.InternalCall)]
+ extern Type make_byref_type ();
+
+ public virtual Type MakeByRefType ()
+ {
+ return make_byref_type ();
+ }
+
+ [MethodImplAttribute(MethodImplOptions.InternalCall)]
+ public extern virtual Type MakePointerType ();
+
+ [MonoTODO]
+ public static Type ReflectionOnlyGetType (string typeName,
+ bool throwIfNotFound,
+ bool ignoreCase)
+ {
+ throw new NotImplementedException ();
+ }
+
+ [MethodImplAttribute(MethodImplOptions.InternalCall)]
+ extern void GetPacking (out int packing, out int size);
+
+ public virtual StructLayoutAttribute StructLayoutAttribute {
+ get {
+ LayoutKind kind;
+
+ if (IsLayoutSequential)
+ kind = LayoutKind.Sequential;
+ else if (IsExplicitLayout)
+ kind = LayoutKind.Explicit;
+ else
+ kind = LayoutKind.Auto;
+
+ StructLayoutAttribute attr = new StructLayoutAttribute (kind);
+
+ if (IsUnicodeClass)
+ attr.CharSet = CharSet.Unicode;
+ else if (IsAnsiClass)
+ attr.CharSet = CharSet.Ansi;
+ else
+ attr.CharSet = CharSet.Auto;
+
+ if (kind != LayoutKind.Auto)
+ GetPacking (out attr.Pack, out attr.Size);
+
+ return attr;
+ }
+ }
+
+ internal object[] GetPseudoCustomAttributes () {
+ int count = 0;
+
+ if (IsSerializable)
+ count ++;
+
+ if (count == 0)
+ return null;
+ object[] attrs = new object [count];
+ count = 0;
+
+ if (IsSerializable)
+ attrs [count ++] = new SerializableAttribute ();
+
+ return attrs;
+ }
+
+#endif
}
}