Bring jbevain/cecil's commit df324526cff399a1a16d9fc62311463d13438981, Make TypeDefin...

diff --git a/mcs/class/Mono.Cecil/Mono.Cecil/AssemblyReader.cs b/mcs/class/Mono.Cecil/Mono.Cecil/AssemblyReader.cs
index 6dc864586ff6714f36830b3c6df7a2571472f54e..9aa5b13658ce7d0a4fee015b4484f9e5f68853cf 100644 (file)
--- a/mcs/class/Mono.Cecil/Mono.Cecil/AssemblyReader.cs
+++ b/mcs/class/Mono.Cecil/Mono.Cecil/AssemblyReader.cs
@@ -1033,7 +1033,7 @@ namespace Mono.Cecil {
                        type.scope = scope;
                        type.DeclaringType = declaring_type;
 
-                       MetadataSystem.TryProcessPrimitiveType (type);
+                       MetadataSystem.TryProcessPrimitiveTypeReference (type);
 
                        return type;
                }

diff --git a/mcs/class/Mono.Cecil/Mono.Cecil/Import.cs b/mcs/class/Mono.Cecil/Mono.Cecil/Import.cs
index 2a8293c0c32193f3d6578acec9ebebd8090ecfc3..4f3ff25c4e1693daa214a7fb03033fd6e9e02b77 100644 (file)
--- a/mcs/class/Mono.Cecil/Mono.Cecil/Import.cs
+++ b/mcs/class/Mono.Cecil/Mono.Cecil/Import.cs
@@ -351,7 +351,7 @@ namespace Mono.Cecil {
                                ImportScope (type.Scope),
                                type.IsValueType);
 
-                       MetadataSystem.TryProcessPrimitiveType (reference);
+                       MetadataSystem.TryProcessPrimitiveTypeReference (reference);
 
                        if (type.IsNested)
                                reference.DeclaringType = ImportType (type.DeclaringType, context);

diff --git a/mcs/class/Mono.Cecil/Mono.Cecil/MetadataSystem.cs b/mcs/class/Mono.Cecil/Mono.Cecil/MetadataSystem.cs
index b1fbaa6eef1cdc4cee5f75f50bc606b22c812479..2e44ad53b27f36e3fc86b4c7d26f29931e342f8c 100644 (file)
--- a/mcs/class/Mono.Cecil/Mono.Cecil/MetadataSystem.cs
+++ b/mcs/class/Mono.Cecil/Mono.Cecil/MetadataSystem.cs
@@ -100,30 +100,46 @@ namespace Mono.Cecil {
                        };
                }
 
-               public static void TryProcessPrimitiveType (TypeReference type)
+               public static void TryProcessPrimitiveTypeReference (TypeReference type)
                {
                        var scope = type.scope;
-                       if (scope == null)
+                       if (scope == null || scope.MetadataScopeType != MetadataScopeType.AssemblyNameReference || scope.Name != "mscorlib")
                                return;
 
-                       if (scope.MetadataScopeType != MetadataScopeType.AssemblyNameReference)
+                       Row<ElementType, bool> primitive_data;
+                       if (!TryGetPrimitiveData (type, out primitive_data))
                                return;
 
-                       if (scope.Name != "mscorlib")
-                               return;
+                       type.etype = primitive_data.Col1;
+                       type.IsValueType = primitive_data.Col2;
+               }
+
+               public static bool TryGetPrimitiveElementType (TypeDefinition type, out ElementType etype)
+               {
+                       etype = ElementType.None;
+
+                       if (!type.HasImage || !type.Module.IsCorlib ())
+                               return false;
+
+                       Row<ElementType, bool> primitive_data;
+                       if (!TryGetPrimitiveData (type, out primitive_data) && primitive_data.Col1.IsPrimitive ())
+                               return false;
+
+                       etype = primitive_data.Col1;
+                       return true;
+               }
+
+               static bool TryGetPrimitiveData (TypeReference type, out Row<ElementType, bool> primitive_data)
+               {
+                       primitive_data = new Row<ElementType, bool> ();
 
                        if (type.Namespace != "System")
-                               return;
+                               return false;
 
                        if (primitive_value_types == null)
                                InitializePrimitives ();
 
-                       Row<ElementType, bool> primitive_data;
-                       if (!primitive_value_types.TryGetValue (type.Name, out primitive_data))
-                               return;
-
-                       type.etype = primitive_data.Col1;
-                       type.IsValueType = primitive_data.Col2;
+                       return primitive_value_types.TryGetValue (type.Name, out primitive_data);
                }
 
                public void Clear ()

diff --git a/mcs/class/Mono.Cecil/Mono.Cecil/ModuleDefinition.cs b/mcs/class/Mono.Cecil/Mono.Cecil/ModuleDefinition.cs
index 0d137e065cbe70a1da958ca4325f17df7ff09df5..76011c16fc136097c8f0ca7caad66ae23e05e257 100644 (file)
--- a/mcs/class/Mono.Cecil/Mono.Cecil/ModuleDefinition.cs
+++ b/mcs/class/Mono.Cecil/Mono.Cecil/ModuleDefinition.cs
@@ -994,6 +994,14 @@ namespace Mono.Cecil {
                        return self != null && self.HasImage;
                }
 
+               public static bool IsCorlib (this ModuleDefinition module)
+               {
+                       if (module.Assembly == null)
+                               return false;
+
+                       return module.Assembly.Name.Name == "mscorlib";
+               }
+
                public static string GetFullyQualifiedName (this Stream self)
                {
 #if !SILVERLIGHT

diff --git a/mcs/class/Mono.Cecil/Mono.Cecil/TypeDefinition.cs b/mcs/class/Mono.Cecil/Mono.Cecil/TypeDefinition.cs
index a1575e1b0ec70f3975ccca8a766cdf3e75dceeb3..f9a12d1f82cad97e283f9306bc13a4a276950806 100644 (file)
--- a/mcs/class/Mono.Cecil/Mono.Cecil/TypeDefinition.cs
+++ b/mcs/class/Mono.Cecil/Mono.Cecil/TypeDefinition.cs
@@ -27,7 +27,7 @@
 //
 
 using System;
-
+using Mono.Cecil.Metadata;
 using Mono.Collections.Generic;
 
 namespace Mono.Cecil {
@@ -433,6 +433,23 @@ namespace Mono.Cecil {
                        }
                }
 
+               public override bool IsPrimitive {
+                       get {
+                               ElementType primitive_etype;
+                               return MetadataSystem.TryGetPrimitiveElementType (this, out primitive_etype);
+                       }
+               }
+
+               public override MetadataType MetadataType {
+                       get {
+                               ElementType primitive_etype;
+                               if (MetadataSystem.TryGetPrimitiveElementType (this, out primitive_etype))
+                                       return (MetadataType) primitive_etype;
+
+                               return base.MetadataType;
+                       }
+               }
+
                public override bool IsDefinition {
                        get { return true; }
                }

diff --git a/mcs/class/Mono.Cecil/Mono.Cecil/TypeParser.cs b/mcs/class/Mono.Cecil/Mono.Cecil/TypeParser.cs
index 733c422d2a70a55ae247f808dffe4384982027ac..06dc935a5841487cb1d9f4fbb1fb382603a6f74c 100644 (file)
--- a/mcs/class/Mono.Cecil/Mono.Cecil/TypeParser.cs
+++ b/mcs/class/Mono.Cecil/Mono.Cecil/TypeParser.cs
@@ -356,7 +356,7 @@ namespace Mono.Cecil {
                        SplitFullName (type_info.type_fullname, out @namespace, out name);
 
                        var type = new TypeReference (@namespace, name, module, scope);
-                       MetadataSystem.TryProcessPrimitiveType (type);
+                       MetadataSystem.TryProcessPrimitiveTypeReference (type);
 
                        AdjustGenericParameters (type);
 

diff --git a/mcs/class/Mono.Cecil/Mono.Cecil/TypeReference.cs b/mcs/class/Mono.Cecil/Mono.Cecil/TypeReference.cs
index 757c83aa60a6a414651ca97121d902048c71b650..ff28c636fe8eae606a1934e449af5f6eced05e21 100644 (file)
--- a/mcs/class/Mono.Cecil/Mono.Cecil/TypeReference.cs
+++ b/mcs/class/Mono.Cecil/Mono.Cecil/TypeReference.cs
@@ -216,28 +216,8 @@ namespace Mono.Cecil {
                        get { return false; }
                }
 
-               public bool IsPrimitive {
-                       get {
-                               switch (etype) {
-                               case ElementType.Boolean:
-                               case ElementType.Char:
-                               case ElementType.I:
-                               case ElementType.U:
-                               case ElementType.I1:
-                               case ElementType.U1:
-                               case ElementType.I2:
-                               case ElementType.U2:
-                               case ElementType.I4:
-                               case ElementType.U4:
-                               case ElementType.I8:
-                               case ElementType.U8:
-                               case ElementType.R4:
-                               case ElementType.R8:
-                                       return true;
-                               default:
-                                       return false;
-                               }
-                       }
+               public virtual bool IsPrimitive {
+                       get { return etype.IsPrimitive (); }
                }
 
                public virtual MetadataType MetadataType {
@@ -288,6 +268,29 @@ namespace Mono.Cecil {
 
        static partial class Mixin {
 
+               public static bool IsPrimitive (this ElementType self)
+               {
+                       switch (self) {
+                       case ElementType.Boolean:
+                       case ElementType.Char:
+                       case ElementType.I:
+                       case ElementType.U:
+                       case ElementType.I1:
+                       case ElementType.U1:
+                       case ElementType.I2:
+                       case ElementType.U2:
+                       case ElementType.I4:
+                       case ElementType.U4:
+                       case ElementType.I8:
+                       case ElementType.U8:
+                       case ElementType.R4:
+                       case ElementType.R8:
+                               return true;
+                       default:
+                               return false;
+                       }
+               }
+
                public static bool IsTypeOf (this TypeReference self, string @namespace, string name)
                {
                        return self.Name == name

diff --git a/mcs/class/Mono.Cecil/Mono.Cecil/TypeSystem.cs b/mcs/class/Mono.Cecil/Mono.Cecil/TypeSystem.cs
index dc20b7b161187b28d69e7424b8d79555dc0eaaa5..60ccae4e5dd3151d5de3f37695a36c5284d17d6b 100644 (file)
--- a/mcs/class/Mono.Cecil/Mono.Cecil/TypeSystem.cs
+++ b/mcs/class/Mono.Cecil/Mono.Cecil/TypeSystem.cs
@@ -158,20 +158,12 @@ namespace Mono.Cecil {
 
                internal static TypeSystem CreateTypeSystem (ModuleDefinition module)
                {
-                       if (IsCorlib (module))
+                       if (module.IsCorlib ())
                                return new CorlibTypeSystem (module);
 
                        return new CommonTypeSystem (module);
                }
 
-               static bool IsCorlib (ModuleDefinition module)
-               {
-                       if (module.Assembly == null)
-                               return false;
-
-                       return module.Assembly.Name.Name == "mscorlib";
-               }
-
                internal abstract TypeReference LookupType (string @namespace, string name);
 
                TypeReference LookupSystemType (string name, ElementType element_type)