From 7d0d8be096796aac43fcb66008c2788ae45ff13f Mon Sep 17 00:00:00 2001 From: jfrijters Date: Mon, 25 May 2009 13:42:15 +0000 Subject: [PATCH] When building for .NET 4.0 we can derived ModuleBuilder from Module and AssemblyBuilder from Assembly. --- ikvmc/CompilerClassLoader.cs | 2 +- refemit/AssemblyBuilder.cs | 28 ++++++++++---- refemit/ConstructorBuilder.cs | 7 ++++ refemit/FieldBuilder.cs | 6 +++ refemit/IkvmAssembly.cs | 28 ++++++++++++++ refemit/Impl/TypeBase.cs | 14 +++++++ refemit/MethodBuilder.cs | 7 ++++ refemit/ModuleBuilder.cs | 64 +++++++++++++++++++++++++++---- refemit/TypeBuilder.cs | 72 +++++++++++++++++++++++++++++++++++ runtime/ReflectUtil.cs | 6 +-- 10 files changed, 214 insertions(+), 20 deletions(-) diff --git a/ikvmc/CompilerClassLoader.cs b/ikvmc/CompilerClassLoader.cs index b92290aa..110e5655 100644 --- a/ikvmc/CompilerClassLoader.cs +++ b/ikvmc/CompilerClassLoader.cs @@ -2442,7 +2442,7 @@ namespace IKVM.Internal } if (compiler.options.sharedclassloader[0] != compiler) { - compiler.GetTypeWrapperFactory().ModuleBuilder.Assembly.SetCustomAttribute(mainAssembly); + ((AssemblyBuilder)compiler.GetTypeWrapperFactory().ModuleBuilder.Assembly).SetCustomAttribute(mainAssembly); } } int rc = compiler.Compile(); diff --git a/refemit/AssemblyBuilder.cs b/refemit/AssemblyBuilder.cs index 9bb91e04..174105e2 100644 --- a/refemit/AssemblyBuilder.cs +++ b/refemit/AssemblyBuilder.cs @@ -33,7 +33,12 @@ using System.Security; namespace IKVM.Reflection.Emit { - public sealed class AssemblyBuilder : IkvmAssembly + public sealed class AssemblyBuilder : +#if NET_4_0 + Assembly +#else + IkvmAssembly +#endif { private readonly AssemblyName name; private readonly string dir; @@ -71,15 +76,16 @@ namespace IKVM.Reflection.Emit public static AssemblyBuilder DefineDynamicAssembly(AssemblyName name, AssemblyBuilderAccess access, string dir) { - return DefineDynamicAssembly(name, access, dir, null, null, null); + return new AssemblyBuilder(name, dir, null, null, null); } + [Obsolete] public static AssemblyBuilder DefineDynamicAssembly(AssemblyName name, AssemblyBuilderAccess access, string dir, PermissionSet requiredPermissions, PermissionSet optionalPermissions, PermissionSet refusedPermissions) { return new AssemblyBuilder(name, dir, requiredPermissions, optionalPermissions, refusedPermissions); } - public AssemblyName GetName() + public override AssemblyName GetName() { AssemblyName n = new AssemblyName(); n.Name = name.Name; @@ -96,7 +102,7 @@ namespace IKVM.Reflection.Emit return n; } - public string FullName + public override string FullName { get { return GetName().FullName; } } @@ -175,17 +181,23 @@ namespace IKVM.Reflection.Emit } int token = 0x20000000 + manifestModule.Tables.Assembly.AddRecord(assemblyRecord); +#pragma warning disable 618 + // this values are obsolete, but we already know that so we disable the warning + System.Security.Permissions.SecurityAction requestMinimum = System.Security.Permissions.SecurityAction.RequestMinimum; + System.Security.Permissions.SecurityAction requestOptional = System.Security.Permissions.SecurityAction.RequestOptional; + System.Security.Permissions.SecurityAction requestRefuse = System.Security.Permissions.SecurityAction.RequestRefuse; +#pragma warning restore 618 if (requiredPermissions != null) { - manifestModule.AddDeclaritiveSecurity(token, System.Security.Permissions.SecurityAction.RequestMinimum, requiredPermissions); + manifestModule.AddDeclaritiveSecurity(token, requestMinimum, requiredPermissions); } if (optionalPermissions != null) { - manifestModule.AddDeclaritiveSecurity(token, System.Security.Permissions.SecurityAction.RequestOptional, optionalPermissions); + manifestModule.AddDeclaritiveSecurity(token, requestOptional, optionalPermissions); } if (refusedPermissions != null) { - manifestModule.AddDeclaritiveSecurity(token, System.Security.Permissions.SecurityAction.RequestRefuse, refusedPermissions); + manifestModule.AddDeclaritiveSecurity(token, requestRefuse, refusedPermissions); } ByteBuffer versionInfoData = null; @@ -303,7 +315,7 @@ namespace IKVM.Reflection.Emit return null; } - public string ImageRuntimeVersion + public override string ImageRuntimeVersion { get { return imageRuntimeVersion; } } diff --git a/refemit/ConstructorBuilder.cs b/refemit/ConstructorBuilder.cs index 8c208345..245b6773 100644 --- a/refemit/ConstructorBuilder.cs +++ b/refemit/ConstructorBuilder.cs @@ -125,6 +125,13 @@ namespace IKVM.Reflection.Emit get { return methodBuilder.MetadataToken; } } +#if NET_4_0 + public override Module Module + { + get { return methodBuilder.Module; } + } +#endif + internal ModuleBuilder ModuleBuilder { get { return methodBuilder.ModuleBuilder; } diff --git a/refemit/FieldBuilder.cs b/refemit/FieldBuilder.cs index c3c9280c..2a4b4b7a 100644 --- a/refemit/FieldBuilder.cs +++ b/refemit/FieldBuilder.cs @@ -213,6 +213,12 @@ namespace IKVM.Reflection.Emit return MethodBuilder.Copy(requiredCustomModifiers); } +#if NET_4_0 + public override Module Module + { + get { return typeBuilder.Module; } + } +#endif internal void WriteFieldRecords(MetadataWriter mw) { mw.Write((short)attribs); diff --git a/refemit/IkvmAssembly.cs b/refemit/IkvmAssembly.cs index 6d01628a..47164ca8 100644 --- a/refemit/IkvmAssembly.cs +++ b/refemit/IkvmAssembly.cs @@ -28,6 +28,15 @@ using IKVM.Reflection.Emit.Impl; namespace IKVM.Reflection.Emit { +#if NET_4_0 + public static class IkvmAssembly + { + public static Assembly GetAssembly(Type type) + { + return type.Assembly; + } + } +#else public abstract class IkvmAssembly { private static readonly Dictionary assemblies = new Dictionary(); @@ -47,6 +56,21 @@ namespace IKVM.Reflection.Emit { return asm.GetType(typeName); } + + public override string FullName + { + get { return asm.FullName; } + } + + public override AssemblyName GetName() + { + return asm.GetName(); + } + + public override string ImageRuntimeVersion + { + get { return asm.ImageRuntimeVersion; } + } } public static IkvmAssembly GetAssembly(Type type) @@ -66,5 +90,9 @@ namespace IKVM.Reflection.Emit } public abstract Type GetType(string typeName); + public abstract string FullName { get; } + public abstract AssemblyName GetName(); + public abstract string ImageRuntimeVersion { get; } } +#endif } diff --git a/refemit/Impl/TypeBase.cs b/refemit/Impl/TypeBase.cs index b34ef918..ddd08101 100644 --- a/refemit/Impl/TypeBase.cs +++ b/refemit/Impl/TypeBase.cs @@ -28,10 +28,17 @@ namespace IKVM.Reflection.Emit.Impl { public abstract class TypeBase : Type { +#if NET_4_0 + public abstract override Assembly Assembly + { + get; + } +#else public sealed override Assembly Assembly { get { throw new NotSupportedException(); } } +#endif public abstract override string AssemblyQualifiedName { @@ -158,10 +165,17 @@ namespace IKVM.Reflection.Emit.Impl return false; } +#if NET_4_0 + public abstract override Module Module + { + get; + } +#else public sealed override Module Module { get { throw new NotSupportedException(); } } +#endif public override Type UnderlyingSystemType { diff --git a/refemit/MethodBuilder.cs b/refemit/MethodBuilder.cs index 52216179..37aa9188 100644 --- a/refemit/MethodBuilder.cs +++ b/refemit/MethodBuilder.cs @@ -434,6 +434,13 @@ namespace IKVM.Reflection.Emit get { return pseudoToken; } } +#if NET_4_0 + public override Module Module + { + get { return typeBuilder.Module; } + } +#endif + internal void Bake() { if (ilgen != null) diff --git a/refemit/ModuleBuilder.cs b/refemit/ModuleBuilder.cs index a64ac132..661bb53c 100644 --- a/refemit/ModuleBuilder.cs +++ b/refemit/ModuleBuilder.cs @@ -34,7 +34,35 @@ using System.Runtime.CompilerServices; namespace IKVM.Reflection.Emit { - public sealed class ModuleBuilder : ITypeOwner +#if !NET_4_0 + public abstract class IkvmModule + { + public abstract Type GetType(string className); + public abstract Type GetType(string className, bool throwOnError, bool ignoreCase); + public abstract string FullyQualifiedName { get; } + public abstract Guid ModuleVersionId { get; } + public abstract Type ResolveType(int metadataToken, Type[] genericTypeArguments, Type[] genericMethodArguments); + public abstract MethodBase ResolveMethod(int metadataToken, Type[] genericTypeArguments, Type[] genericMethodArguments); + + public Type ResolveType(int metadataToken) + { + return ResolveType(metadataToken, null, null); + } + + public MethodBase ResolveMethod(int metadataToken) + { + return ResolveMethod(metadataToken, null, null); + } + } +#endif + + public sealed class ModuleBuilder : +#if NET_4_0 + Module, +#else + IkvmModule, +#endif + ITypeOwner { private readonly Guid mvid = Guid.NewGuid(); private readonly AssemblyBuilder asm; @@ -364,17 +392,24 @@ namespace IKVM.Reflection.Emit manifestResources.Position = savePosition; } - public AssemblyBuilder Assembly +#if NET_4_0 + public override Assembly Assembly { get { return asm; } } +#else + public IkvmAssembly Assembly + { + get { return asm; } + } +#endif - public Type GetType(string className) + public override Type GetType(string className) { return GetType(className, false, false); } - public Type GetType(string className, bool throwOnError, bool ignoreCase) + public override Type GetType(string className, bool throwOnError, bool ignoreCase) { if (ignoreCase) { @@ -951,13 +986,26 @@ namespace IKVM.Reflection.Emit get { return this; } } - public Type ResolveType(int metadataToken) + public new Type ResolveType(int metadataToken) { return types[(metadataToken & 0xFFFFFF) - 1]; } - public MethodBase ResolveMethod(int metadataToken) + public override Type ResolveType(int metadataToken, Type[] genericTypeArguments, Type[] genericMethodArguments) { + if (genericTypeArguments != null || genericMethodArguments != null) + { + throw new NotImplementedException(); + } + return types[(metadataToken & 0xFFFFFF) - 1]; + } + + public override MethodBase ResolveMethod(int metadataToken, Type[] genericTypeArguments, Type[] genericMethodArguments) + { + if (genericTypeArguments != null || genericMethodArguments != null) + { + throw new NotImplementedException(); + } // HACK if we're given a SymbolToken, we need to convert back if ((metadataToken & 0xFF000000) == 0x06000000) { @@ -975,7 +1023,7 @@ namespace IKVM.Reflection.Emit return ((TypeBuilder)moduleType).LookupMethod(metadataToken); } - public string FullyQualifiedName + public override string FullyQualifiedName { get { @@ -983,7 +1031,7 @@ namespace IKVM.Reflection.Emit } } - public Guid ModuleVersionId + public override Guid ModuleVersionId { get { diff --git a/refemit/TypeBuilder.cs b/refemit/TypeBuilder.cs index da2958af..c4a6b192 100644 --- a/refemit/TypeBuilder.cs +++ b/refemit/TypeBuilder.cs @@ -126,6 +126,18 @@ namespace IKVM.Reflection.Emit { get { return method; } } + +#if NET_4_0 + public override Assembly Assembly + { + get { return moduleBuilder.Assembly; } + } + + public override Module Module + { + get { return moduleBuilder; } + } +#endif } public sealed class TypeBuilder : Impl.TypeBase, ITypeOwner @@ -675,6 +687,18 @@ namespace IKVM.Reflection.Emit } return null; } + +#if NET_4_0 + public override Assembly Assembly + { + get { return owner.ModuleBuilder.Assembly; } + } + + public override Module Module + { + get { return owner.ModuleBuilder; } + } +#endif } sealed class ArrayType : Impl.TypeBase @@ -769,6 +793,18 @@ namespace IKVM.Reflection.Emit } return token; } + +#if NET_4_0 + public override Assembly Assembly + { + get { return type.Assembly; } + } + + public override Module Module + { + get { return type.Module; } + } +#endif } sealed class BakedType : Impl.TypeBase @@ -908,6 +944,18 @@ namespace IKVM.Reflection.Emit { get { return typeBuilder.ModuleBuilder; } } + +#if NET_4_0 + public override Assembly Assembly + { + get { return typeBuilder.Assembly; } + } + + public override Module Module + { + get { return typeBuilder.Module; } + } +#endif } sealed class GenericType : Impl.TypeBase @@ -1040,6 +1088,18 @@ namespace IKVM.Reflection.Emit { get { return typeBuilder.ModuleBuilder; } } + +#if NET_4_0 + public override Assembly Assembly + { + get { return typeBuilder.Assembly; } + } + + public override Module Module + { + get { return typeBuilder.Module; } + } +#endif } public sealed class MonoHackGenericType : Impl.TypeBase @@ -1173,5 +1233,17 @@ namespace IKVM.Reflection.Emit { get { return null; } } + +#if NET_4_0 + public override Assembly Assembly + { + get { return null; } + } + + public override Module Module + { + get { return null; } + } +#endif } } diff --git a/runtime/ReflectUtil.cs b/runtime/ReflectUtil.cs index 1d43063c..de651bb7 100644 --- a/runtime/ReflectUtil.cs +++ b/runtime/ReflectUtil.cs @@ -35,14 +35,14 @@ namespace IKVM.Internal { internal static bool IsSameAssembly(Type type1, Type type2) { -#if IKVM_REF_EMIT +#if IKVM_REF_EMIT && !NET_4_0 return IkvmAssembly.GetAssembly(type1) == IkvmAssembly.GetAssembly(type2); #else return type1.Assembly.Equals(type2.Assembly); #endif } -#if IKVM_REF_EMIT +#if IKVM_REF_EMIT && !NET_4_0 internal static bool IsFromAssembly(Type type, IkvmAssembly assembly) { return IkvmAssembly.GetAssembly(type) == assembly; @@ -54,7 +54,7 @@ namespace IKVM.Internal } #endif -#if IKVM_REF_EMIT +#if IKVM_REF_EMIT && !NET_4_0 internal static IkvmAssembly GetAssembly(Type type) { return IkvmAssembly.GetAssembly(type);