In the comments on the previous entry, Stuart asks:
Given an instance of System.Type, how do I determine what the typename is in Java?
This is tricky and my (lame) answer is that you shouldn't have to. Do you have a specific scenario in mind? Having said that, in your comment you're on the right track, there is no one-to-one mapping between System.Type instances and java.lang.Class instances. What I think you're after is the fact that you'll never encounter cli.System.Object or cli.System.Exception as field types or in method signatures. The only way to get the class object for these types, is by calling getClass() on an instance or by calling Class.getSuperclass() on a subclass of them.
Note that the above behaviour isn't actually implemented yet. At the moment cli.System.Object and cli.System.Exception are simply helper classes with static methods and you'll never encounter them as field types, in method signatures or as instance types.
As to which one to use from Java, you're right when you say java.lang.* is the answer is most cases. The only times you want to use cli.System.Object or cli.System.Exception is when you subclass them from Java to make your Java class look more .NET like to .NET consumers.
What would be really nice would be if there were something in the IK.VM.NET.dll that would let me answer this question authoritatively with a simple call...
There is the NativeCode.java.lang.VMClass.getClassFromType() method that is used by the runtime internally (it's public, so you could call it), but I can't really guarantee that it'll stay around or behave consistently over time. At some point in the future there'll probably be a utility class in the ikvm.lang package that will contain conversion method to go from System.Type to java.lang.Class and vice versa (but it probably will require you to specify to context for the mapping).
Oh, one other thing that occurred to me would be a nice feature: if a class implemented in Java could put itself into the cli.* package and thereby make itself look to other Java code as if it were a .NET type, without actually putting it in a cli.* namespace in .NET. In other words, a Java class cli.Foo.Bar would be compiled as namespace Foo.Bar *without* the attribute that preserves its name in Java, so that Foo.Bar then gets translated back to cli.Foo.Bar when Java code sees it.
Sort of the inverse of the attribute for turning name mangling off on the .NET side.
Can you explain why and when you'd want to use this?
Are there any tasks for a CS scrub like myself to work on with IKVM?
Here is a partial list of things that need to be done:
- Implement the AWT peers
- Implement the missing JNI methods
- Build a framework to test the verifier / bytecode compiler
- Write a Java implementation of String.valueOf(float) and String.valueOf(double)
- Search the source for // TODO for things that seem doable (or write test cases that show the current code is broken)
- Write documentation
- Design a logo
- Design a website
If you (or anyone) decides to work on something, please send e-mail to the ikvm-developers list, so we can coordinate.