In November 2008 I introduced IKVM.Reflection.Emit, today I'm introducing IKVM.Reflection. It superseded IKVM.Reflection.Emit and also includes the ability to read managed assemblies. In addition, I've also added many other features that aren't directly needed for ikvmc, but are useful for other applications. Almost the complete reflection API has now been implemented and there are several API extensions to support managed PE features that reflection doesn't support (well).

Why?

When I started on IKVM.Reflection.Emit, it wasn't at all clear to me that it would be possible to re-implement the System.Reflection.Emit namespace without also re-implementing the System.Reflection namespace, but it turned out it was. I did run into a few snags, such as the inability to subclass Module and Assembly (this was fixed in .NET 4.0) and a couple of Mono bugs, but on the whole IKVM.Reflection.Emit was very successful. So why then re-implement the System.Reflection namespace as well? The main reasons are Silverlight and .NET 4.0. For ikvmc to be able to target versions of the runtime different from the one it is currently running on, it is necessary to avoid using System.Reflection, because System.Reflection can only ever work with the mscorlib version of the current runtime.

ikvmc & ikvmstub

In the coming time, I plan on integrating IKVM.Reflection into ikvmc (most of the work for this has already been done, if you've been following the ikvm-commit list, you may have seen some changes go in and wondered why they are necessary) and ikvmstub (I haven't started on this yet). Currently, ikvmstub uses java reflection to expose members of the .NET types in an assembly. I chose this because it was the easiest way to make sure that what ikvmstub generated matched the ikvm runtime behavior (because it simply used the ikvm runtime to do the mapping). There are two downsides to this approach. The first is the same as mentioned above with ikvmc, you can only generate mscorlib stubs for the runtime you're currently running on. The second is more philosophical, it introduces a cycle in the build process. To build the IKVM.OpenJDK.*.dll assemblies, you need mscorlib.jar and System.jar, but to generate these stubs you need a compiled class library. To solve both these issues, I plan to rewrite ikvmstub to work directly on the internal ikvm runtime representations (with conditional compilation, like ikvmc does).

Features

This list is not exhaustive, but here are some interesting features of IKVM.Reflection (that are not in System.Reflection):

No thread safety. If you want thread safety, you'll have to lock the universe object during every operation.

You can choose what version of mscorlib to load in the universe (using Universe.LoadMscorlib()) and by implementing a Universe.AssemblyResolve handler you can decide the framework assembly unification policy.

Support for querying and emitting .NET 2.0 style declarative security.

Support for defining unmanaged resources from a byte array (in .NET, AssemblyBuilder.DefineUnmanagedResources(byte[]) is broken, only the overload that accepts a filename works).

Support for reading field RVA data (e.g. for the fields that are used by the C# compiler to initialize arrays).

The ability to enable/disable "exception block assistance", or get "clever" assistance.

Support for querying methodimpl mappings.

Support for reference, pointer and array types with custom modifiers (this CLR feature is used by C++/CLI).

Missing Features

Some things are still missing. The most notable being the Emit differences. The emit code was based on the IKVM.Reflection.Emit code and likewise still lacks some of the querying support (for baked types), although the new code is much better than the code in IKVM.Reflection.Emit.dll in this respect.

Here's a list of methods that can still throw a NotImplementedException:

FieldBuilder.__GetDataFromRVA()

ModuleBuilder.ResolveType()

ModuleBuilder.ResolveMethod()

ModuleBuilder.ResolveField()

ModuleBuilder.ResolveMember()

ModuleBuilder.ResolveString()

ModuleBuilder.__ResolveOptionalParameterTypes()

ModuleBuilder.GetArrayMethod()

GenericTypeParameterBuilder.BaseType

GenericTypeParameterBuilder.__GetDeclaredInterfaces()

GenericTypeParameterBuilder.GetGenericParameterConstraints()

GenericTypeParameterBuilder.GenericParameterAttributes

TypeBuilder.CreateType() (when invoked a second time)

TypeBuilder.__GetDeclaredFields()

TypeBuilder.__GetDeclaredEvents()

TypeBuilder.__GetDeclaredProperties()

ISymbolDocumentWriter.SetCheckSum()

ISymbolDocumentWriter.SetSource()

Most methods in ISymbolWriter

ManifestResourceInfo.ResourceLocation (for resources located in another assembly)

AssemblyBuilder.DefineUnmanagedResource(byte[]) (because it is broken)

MethodBuilder.CreateMethodBody()

Everything that doesn't make sense in a ReflectionOnly context.

Concepts that are not implemented:

Most metadata tokens returned by Emit objects are not properly typed (and can't be used for anything, other than comparing them against other metadata tokens).

When defining debugging symbols, a single method can only point to a single source document.

All type/member lookup operations are case sensitive.

Implementing a custom System.Reflection.Binder is not supported.

Modules with unsorted metadata tables are not supported.

When Type.GetMethods() (or __GetDeclaredMethods) is called on Array types it throws a NotImplementedException, instead of returning the special array accessor methods.

Managed function pointer types are not supported. Like System.Reflection, they are returned as System.IntPtr instead.

Linker Prototype

To see if I did miss any important CLR features, I wrote a prototype assembly linker. It is pretty capable, but should not be confused for something that is usable for anything other than exploring. I've used it with C++/CLI (compiled with /clr:pure) to test the more esoteric CLR features. The source for the linker prototype is in the zip linked to below.

The IKVM.Reflection source code is available in cvs. If you just want the binary, the LinkerPrototype.zip contains it.

Oh man I donT code java for 5 years oh so. anyway, I am one of the guys working on nemerle compiler. We had a lot of pain with SRE. And we thought we could replace SRE with IKVM, but it has some missing stuff like EnumBuilder and it doesnt work. Do you plan to make 100% SRE compatible ?

I apologize for the lameness of this, but the comment spam was driving me nuts.
In order to be able to post a comment, you need to answer a simple question. Hopefully this question
is easy enough not to annoy serious commenters, but hard enough to keep the spammers away.

Anti-Spam Question: What method on java.lang.System returns an object's original hashcode (i.e. the
one that would be returned by java.lang.Object.hashCode() if it wasn't overridden)? (case is significant)