Merge pull request #3066 from alexanderkyte/pedump_sgen

[mono.git] / mcs / class / corlib / System / RuntimeTypeHandle.cs

diff --git a/mcs/class/corlib/System/RuntimeTypeHandle.cs b/mcs/class/corlib/System/RuntimeTypeHandle.cs
index 4a4cabd60bb0ad71eb359c9d5513fb308376e5fa..eb6c42f097648ff77d290c66f24e2a600768da87 100644 (file)
--- a/mcs/class/corlib/System/RuntimeTypeHandle.cs
+++ b/mcs/class/corlib/System/RuntimeTypeHandle.cs
@@ -32,10 +32,16 @@
 //
 
 using System.Runtime.Serialization;
+using System.Runtime.InteropServices;
+using System.Runtime.ConstrainedExecution;
+using System.Threading;
+using System.Runtime.CompilerServices;
+using System.Reflection;
+using System.Diagnostics.Contracts;
 
 namespace System
 {
-       [MonoTODO ("Serialization needs tests")]
+       [ComVisible (true)]
        [Serializable]
        public struct RuntimeTypeHandle : ISerializable
        {
@@ -46,12 +52,17 @@ namespace System
                        value = val;
                }
 
+               internal RuntimeTypeHandle (RuntimeType type)
+                       : this (type._impl.value)
+               {
+               }
+
                RuntimeTypeHandle (SerializationInfo info, StreamingContext context)
                {
                        if (info == null)
                                throw new ArgumentNullException ("info");
 
-                       MonoType mt = ((MonoType) info.GetValue ("TypeObj", typeof (MonoType)));
+                       RuntimeType mt = ((RuntimeType) info.GetValue ("TypeObj", typeof (RuntimeType)));
                        value = mt.TypeHandle.Value;
                        if (value == IntPtr.Zero)
                                throw new SerializationException (Locale.GetText ("Insufficient state."));
@@ -68,10 +79,13 @@ namespace System
                        if (info == null)
                                throw new ArgumentNullException ("info");
 
-                       info.AddValue ("TypeObj", Type.GetTypeHandle (this), typeof (MonoType));
-               }
+                       if (value == IntPtr.Zero)
+                               throw new SerializationException ("Object fields may not be properly initialized");
 
+                       info.AddValue ("TypeObj", Type.GetTypeHandle (this), typeof (RuntimeType));
+               }
 
+               [ReliabilityContractAttribute (Consistency.WillNotCorruptState, Cer.Success)]
                public override bool Equals (object obj)
                {
                        if (obj == null || GetType () != obj.GetType ())
@@ -80,6 +94,7 @@ namespace System
                        return value == ((RuntimeTypeHandle)obj).Value;
                }
 
+               [ReliabilityContractAttribute (Consistency.WillNotCorruptState, Cer.Success)]
                public bool Equals (RuntimeTypeHandle handle)
                {
                        return value == handle.Value;
@@ -90,11 +105,143 @@ namespace System
                        return value.GetHashCode ();
                }
 
-#if NET_2_0
+               public static bool operator == (RuntimeTypeHandle left, Object right)
+               {
+                       return (right != null) && (right is RuntimeTypeHandle) && left.Equals ((RuntimeTypeHandle)right);
+               }
+
+               public static bool operator != (RuntimeTypeHandle left, Object right)
+               {
+                       return (right == null) || !(right is RuntimeTypeHandle) || !left.Equals ((RuntimeTypeHandle)right);
+               }
+
+               public static bool operator == (Object left, RuntimeTypeHandle right)
+               {
+                       return (left != null) && (left is RuntimeTypeHandle) && ((RuntimeTypeHandle)left).Equals (right);
+               }
+
+               public static bool operator != (Object left, RuntimeTypeHandle right)
+               {
+                       return (left == null) || !(left is RuntimeTypeHandle) || !((RuntimeTypeHandle)left).Equals (right);
+               }
+
+               [MethodImplAttribute(MethodImplOptions.InternalCall)]
+               internal static extern TypeAttributes GetAttributes (RuntimeType type);
+
                [CLSCompliant (false)]
-               public ModuleHandle GetModuleHandle () {
+               [ReliabilityContractAttribute (Consistency.WillNotCorruptState, Cer.Success)]
+               public ModuleHandle GetModuleHandle ()
+               {
+                       // Although MS' runtime is crashing here, we prefer throwing an exception.
+                       // The check is needed because Type.GetTypeFromHandle returns null
+                       // for zero handles.
+                       if (value == IntPtr.Zero)
+                               throw new InvalidOperationException ("Object fields may not be properly initialized");
+
                        return Type.GetTypeFromHandle (this).Module.ModuleHandle;
                }
-#endif
+
+               [MethodImplAttribute(MethodImplOptions.InternalCall)]
+               static extern int GetMetadataToken (RuntimeType type);
+
+               internal static int GetToken (RuntimeType type)
+               {
+                       return GetMetadataToken (type);
+               }
+
+               [MethodImplAttribute(MethodImplOptions.InternalCall)]
+               extern static Type GetGenericTypeDefinition_impl (RuntimeType type);
+
+               internal static Type GetGenericTypeDefinition (RuntimeType type)
+               {
+                       return GetGenericTypeDefinition_impl (type);
+               }
+
+               internal static bool HasElementType (RuntimeType type)
+               {
+                       return IsArray (type) || IsByRef (type) || IsPointer (type);
+               }
+
+               internal static bool HasProxyAttribute (RuntimeType type)
+               {
+                       throw new NotImplementedException ("HasProxyAttribute");
+               }
+
+               [MethodImplAttribute(MethodImplOptions.InternalCall)]
+               internal extern static bool HasInstantiation (RuntimeType type);
+
+               [MethodImplAttribute(MethodImplOptions.InternalCall)]
+               internal extern static bool IsArray(RuntimeType type);
+
+               [MethodImplAttribute(MethodImplOptions.InternalCall)]
+               internal extern static bool IsByRef (RuntimeType type);
+
+               [MethodImplAttribute (MethodImplOptions.InternalCall)]
+               internal extern static bool IsComObject (RuntimeType type);
+
+               [MethodImplAttribute(MethodImplOptions.InternalCall)]
+               internal extern static bool IsInstanceOfType (RuntimeType type, Object o);              
+
+               [MethodImplAttribute(MethodImplOptions.InternalCall)]
+               internal extern static bool IsPointer (RuntimeType type);
+
+               [MethodImplAttribute(MethodImplOptions.InternalCall)]
+               internal extern static bool IsPrimitive (RuntimeType type);
+
+               internal static bool IsComObject (RuntimeType type, bool isGenericCOM)
+               {
+                       return isGenericCOM ? false : IsComObject (type);
+               }
+
+               internal static bool IsContextful (RuntimeType type)
+               {
+                       return typeof (ContextBoundObject).IsAssignableFrom (type);
+               }
+
+               internal static bool IsEquivalentTo (RuntimeType rtType1, RuntimeType rtType2)
+               {
+                       // refence check is done earlier and we don't recognize anything else
+                       return false;
+               }               
+
+               internal static bool IsSzArray(RuntimeType type)
+               {
+                       // TODO: Better check
+                       return IsArray (type) && type.GetArrayRank () == 1;
+               }
+
+               internal static bool IsInterface (RuntimeType type)
+               {
+                       return (type.Attributes & TypeAttributes.ClassSemanticsMask) == TypeAttributes.Interface;
+               }
+
+               [MethodImplAttribute(MethodImplOptions.InternalCall)]
+               internal extern static int GetArrayRank(RuntimeType type);
+
+               [MethodImplAttribute(MethodImplOptions.InternalCall)]
+               internal extern static RuntimeAssembly GetAssembly (RuntimeType type);
+
+               [MethodImplAttribute(MethodImplOptions.InternalCall)]
+               internal extern static RuntimeType GetElementType (RuntimeType type);
+
+               [MethodImplAttribute(MethodImplOptions.InternalCall)]
+               internal extern static RuntimeModule GetModule (RuntimeType type);
+
+               [MethodImplAttribute(MethodImplOptions.InternalCall)]
+               internal extern static bool IsGenericVariable (RuntimeType type);
+
+               [MethodImplAttribute(MethodImplOptions.InternalCall)]
+               internal extern static RuntimeType GetBaseType (RuntimeType type);
+
+               internal static bool CanCastTo (RuntimeType type, RuntimeType target)
+               {
+                       return type_is_assignable_from (target, type);
+               }
+
+               [MethodImplAttribute(MethodImplOptions.InternalCall)]
+               static extern bool type_is_assignable_from (Type a, Type b);
+
+               [MethodImplAttribute(MethodImplOptions.InternalCall)]
+               internal extern static bool IsGenericTypeDefinition (RuntimeType type);
        }
 }