I did another pass on compiler2, and managed to wire in signature support. So let's look at a couple examples:

class MyRubyClass
 def helloWorld
   puts "Hello from Ruby"
 end
 def goodbyeWorld(a)
   puts a
 end

 signature :helloWorld, [] => Java::void
 signature :goodbyeWorld, [java.lang.String] => Java::void
end

In this case we have our friend MyRubyClass once again, with helloWorld and goodbyeWorld methods. You'll recall from my previous post that these two methods originally compiled as returning IRubyObject, and goodbyeWorld compiled as receiving a single IRubyObject parameter.

But with signature support, things are so much cooler! The two "signature" lines at the bottom of the class (syntax and structure are totally up for debate) associated signatures with the two methods. helloWorld receives no parameters and has a void return type. goodbyeWorld receives a single String parameter and has a void return type.

The compiler takes this new information, and produces a more normal-looking set of Java signatures:

Compiled from "MyObject.java.rb"
public class MyObject extends org.jruby.RubyObject{
   static {};
   public MyObject();
   public void helloWorld();
   public void goodbyeWorld(java.lang.String);
}

Huzzah! There's almost nothing here to give away that we're actually dealing with Ruby code under the covers. And the code that consumes this is just as simple:

public class MyObjectTest {
 public static void main(String[] args) {
   MyObject obj = new MyObject();
   obj.helloWorld();
   obj.goodbyeWorld("hello");
 }
}

And that's literally all there is to it. Here's a more advanced example:

class MyRubyClass
 %w[boolean byte short char int long float double].each do |type|
   java_type = Java.send type
   eval "def #{type}Method(a); a; end"
   signature "#{type}Method", [java_type] => java_type
 end
end

This time we're actually *generating* the methods, looping over a list of Java primitives and eval'ing a method for each. So this is *runtime* generation of methods, like any good Rubyist loves to do. And of course, this is absolutely no problem for compiler2:

Compiled from "MyObject2.java.rb"
public class MyObject2 extends org.jruby.RubyObject{
   static {};
   public MyObject2();
   public double doubleMethod(double);
   public int intMethod(int);
   public char charMethod(char);
   public short shortMethod(short);
   public boolean booleanMethod(boolean);
   public float floatMethod(float);
   public long longMethod(long);
   public byte byteMethod(byte);
}

All the methods are there, just as you'd expect them! Fantastic!!! (Though the ordering is a little peculiar; I think that's because we don't have an ordered method table in our class impl. Does it matter?)

Even better, the above methods are doing the same type coercion on the way in and out that we do for any other Java-based method calling. So your integral numerics are presented to Ruby as Fixnums, floating-point numerics are Floats, and booleans come through as Ruby true or false.

There's certainly more work to be done:

• There's no support for overloads at the moment, but I'll likely provide a method aliasing facility so you can define multiple Ruby methods and then say which one maps to which overload. And of course, you'll be able to define multiple overloads that go to the same method body if you wish.
• I also have not wired in varargs, but it will be an easy match to Ruby's restargs. And optional arguments could automatically generate different-arity Java signatures.
• Annotations will also be trivial to add; it's just a matter of attaching appropriate metadata and having compiler2 emit them. So you'll be able to use JavaEE 5, JUnit4, and any other frameworks that depend on having annotations present.

Of course this is all checked into JRuby trunk, so feel free to give it a try. Stop by JRuby mailing lists or IRC if you have questions. And it's all still written in Ruby; signature support bloated the compiler up to a whopping 178 lines of code, most of that for dealing with the JVM opcodes for primitive types.