mirah 0.0.7-java → 0.0.8-java

data/test/{test_javac_compiler.rb → jvm/javac_test_helper.rb}

@@ -13,21 +13,27 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-$:.unshift File.join(File.dirname(__FILE__),'..','lib')
-
+require 'bundler/setup'
 require 'test/unit'
 require 'mirah'
-require 'mirah/jvm/source_compiler'
-require 'jruby'
-require 'stringio'
-require File.join(File.dirname(__FILE__), 'test_jvm_compiler')
+
+require 'bytecode_test_helper'
+
+
+require 'mirah/jvm/compiler/java_source'
+
 
 # make sure . is in CLASSPATH
 $CLASSPATH << '.'
 
-class TestJavacCompiler < TestJVMCompiler
+
+module JavacCompiler
   import javax.tools.ToolProvider
   import java.util.Arrays
+  import java.lang.System
+  import java.io.PrintStream
+  include Mirah
+  
   def javac(files)
     compiler = ToolProvider.system_java_compiler
     fm = compiler.get_standard_file_manager(nil, nil, nil)
@@ -45,27 +51,25 @@ class TestJavacCompiler < TestJVMCompiler
         cls = loader.define_class(name[0..-6].tr('/', '.'), bytecode.to_java_bytes)
         classes << JavaUtilities.get_proxy_class(cls.name)
         @tmp_classes << name
-        @tmp_classes << classfile 
+        @tmp_classes << classfile
+        pattern = classfile.sub /\.class$/, '$*.class'
+        @tmp_classes.concat(Dir.glob(pattern))
       end
     end
     classes
   end
   
-  def compile(code)
-    File.unlink(*@tmp_classes)
-    @tmp_classes.clear
-    AST.type_factory = Mirah::JVM::Types::TypeFactory.new
-    state = Mirah::CompilationState.new
-    state.save_extensions = false
-    transformer = Mirah::Transform::Transformer.new(state)
-    Java::MirahImpl::Builtin.initialize_builtins(transformer)
-    name = "script" + System.nano_time.to_s
-    ast  = AST.parse(code, name, true, transformer)
-    typer = Typer::JVM.new(transformer)
-    ast.infer(typer, true)
-    typer.resolve(true)
-    compiler = Compiler::JavaSource.new
+  def create_compiler
+    JVM::Compiler::JavaSource.new
+  end
+  
+  def compile_ast ast
+    compiler = create_compiler
     ast.compile(compiler, false)
+    compiler
+  end
+  
+  def generate_classes compiler
     java_files = []
     compiler.generate do |name, builder|
       bytes = builder.generate
@@ -77,4 +81,16 @@ class TestJavacCompiler < TestJVMCompiler
     end
     classes = javac(java_files)
   end
+
+  def clear_tmp_files
+    super
+    # wipe out Script*_xform_* classes, since we're messy
+    File.unlink(*Dir['Script*_xform_*.class'])
+  end
+end
+
+
+class Test::Unit::TestCase
+  include JavacCompiler
+  
 end

data/test/jvm/test_enumerable.rb

@@ -0,0 +1,304 @@
+# Copyright (c) 2010 The Mirah project authors. All Rights Reserved.
+# All contributing project authors may be found in the NOTICE file.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+class TestEnumerable < Test::Unit::TestCase
+  def test_for
+    cls, = compile(<<-EOF)
+      def foo
+        a = int[3]
+        count = 0
+        for x in a
+          count += 1
+        end
+        count
+      end
+    EOF
+
+    cls, = compile(<<-EOF)
+      def foo(a:int[])
+        count = 0
+        for x in a
+          count += x
+        end
+        count
+      end
+    EOF
+
+    assert_equal(9, cls.foo([2, 3, 4].to_java(:int)))
+
+    cls, = compile(<<-EOF)
+      def foo(a:Iterable)
+        a.each do |x|
+          puts x
+        end
+      end
+    EOF
+
+    assert_output("1\n2\n3\n") do
+      list = java.util.ArrayList.new
+      list << "1"
+      list << "2"
+      list << "3"
+      cls.foo(list)
+    end
+
+    cls, = compile(<<-EOF)
+      import java.util.ArrayList
+      def foo(a:ArrayList)
+        a.each do |x|
+          puts x
+        end
+      end
+    EOF
+
+    assert_output("1\n2\n3\n") do
+      list = java.util.ArrayList.new
+      list << "1"
+      list << "2"
+      list << "3"
+      cls.foo(list)
+    end
+
+    cls, = compile(<<-EOF)
+      def foo(a:int[])
+        a.each {|x| x += 1;puts x; redo if x == 2}
+      end
+    EOF
+
+    assert_output("2\n3\n3\n4\n") do
+      cls.foo([1,2,3].to_java(:int))
+    end
+  end
+
+  def test_all
+    cls, = compile(<<-EOF)
+      def foo(a:int[])
+        a.all? {|x| x % 2 == 0}
+      end
+    EOF
+
+    assert_equal(false, cls.foo([2, 3, 4].to_java(:int)))
+    assert_equal(true, cls.foo([2, 0, 4].to_java(:int)))
+
+    cls, = compile(<<-EOF)
+      def foo(a:String[])
+        a.all?
+      end
+    EOF
+
+    assert_equal(true, cls.foo(["a", "", "b"].to_java(:string)))
+    assert_equal(false, cls.foo(["a", nil, "b"].to_java(:string)))
+  end
+
+  def test_downto
+    cls, = compile(<<-EOF)
+      def foo(i:int)
+        i.downto(1) {|x| puts x }
+      end
+    EOF
+
+    assert_output("3\n2\n1\n") do
+      cls.foo(3)
+    end
+  end
+
+  def test_upto
+    cls, = compile(<<-EOF)
+      def foo(i:int)
+        i.upto(3) {|x| puts x }
+      end
+    EOF
+
+    assert_output("1\n2\n3\n") do
+      cls.foo(1)
+    end
+  end
+
+  def test_times
+    cls, = compile(<<-EOF)
+      def foo(i:int)
+        i.times {|x| puts x }
+      end
+    EOF
+
+    assert_output("0\n1\n2\n") do
+      cls.foo(3)
+    end
+
+    cls, = compile(<<-EOF)
+      def foo(i:int)
+        i.times { puts "Hi" }
+      end
+    EOF
+
+    assert_output("Hi\nHi\nHi\n") do
+      cls.foo(3)
+    end
+  end
+
+  def test_general_loop
+    cls, = compile(<<-EOF)
+      def foo(x:boolean)
+        a = ""
+        __gloop__(nil, x, true, nil, nil) {a += "<body>"}
+        a
+      end
+    EOF
+    assert_equal("", cls.foo(false))
+
+    cls, = compile(<<-EOF)
+      def foo
+        a = ""
+        __gloop__(nil, false, false, nil, nil) {a += "<body>"}
+        a
+      end
+    EOF
+    assert_equal("<body>", cls.foo)
+
+    cls, = compile(<<-EOF)
+      def foo(x:boolean)
+        a = ""
+        __gloop__(a += "<init>", x, true, a += "<pre>", a += "<post>") do
+          a += "<body>"
+        end
+        a
+      end
+    EOF
+    assert_equal("<init>", cls.foo(false))
+
+    cls, = compile(<<-EOF)
+      def foo
+        a = ""
+        __gloop__(a += "<init>", false, false, a += "<pre>", a += "<post>") do
+          a += "<body>"
+        end
+        a
+      end
+    EOF
+    assert_equal("<init><pre><body><post>", cls.foo)
+
+    cls, = compile(<<-EOF)
+      def foo
+        a = ""
+        __gloop__(a += "<init>", false, false, a += "<pre>", a += "<post>") do
+          a += "<body>"
+          redo if a.length < 20
+        end
+        a
+      end
+    EOF
+    assert_equal( "<init><pre><body><body><post>", cls.foo)
+
+    cls, = compile(<<-EOF)
+      def foo
+        a = ""
+        __gloop__(a += "<init>", a.length < 20, true, a += "<pre>", a += "<post>") do
+          next if a.length < 17
+          a += "<body>"
+        end
+        a
+      end
+    EOF
+    assert_equal("<init><pre><post><pre><body><post>", cls.foo)
+  end
+
+  
+    def test_each
+    cls, = compile(<<-EOF)
+      def foo
+        [1,2,3].each {|x| puts x}
+      end
+    EOF
+    assert_output("1\n2\n3\n") do
+      cls.foo
+    end
+  end
+  
+  def test_each_without_block_arguments
+    cls, = compile(<<-EOF)
+      def foo
+        [1,2,3].each { puts :thrice }
+      end
+    EOF
+    assert_output("thrice\nthrice\nthrice\n") do
+      cls.foo
+    end
+
+  end
+
+  def test_any
+    cls, = compile(<<-EOF)
+      import java.lang.Integer
+      def foo
+        puts [1,2,3].any?
+        puts [1,2,3].any? {|x| Integer(x).intValue > 3}
+      end
+    EOF
+    assert_output("true\nfalse\n") do
+      cls.foo
+    end
+  end
+
+  def test_all
+    cls, = compile(<<-EOF)
+      import java.lang.Integer
+      def foo
+        puts [1,2,3].all?
+        puts [1,2,3].all? {|x| Integer(x).intValue > 3}
+      end
+    EOF
+    assert_output("true\nfalse\n") do
+      cls.foo
+    end
+  end
+
+  def test_mirah_iterable
+    cls, = compile(<<-EOF)
+      import java.util.Iterator
+      class MyIterator; implements Iterable, Iterator
+        def initialize(x:Object)
+          @next = x
+        end
+
+        def hasNext
+          @next != nil
+        end
+
+        def next
+          result = @next
+          @next = nil
+          result
+        end
+
+        def iterator
+          self
+        end
+
+        def remove
+          raise UnsupportedOperationException
+        end
+
+        def self.test(x:String)
+          MyIterator.new(x).each {|y| puts y}
+        end
+      end
+    EOF
+    
+    assert_output("Hi\n") do
+      cls.test("Hi")
+    end
+  end
+
+end

data/test/{test_java_typer.rb → jvm/test_java_typer.rb}

@@ -13,8 +13,6 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-$:.unshift File.join(File.dirname(__FILE__),'..','lib')
-
 require 'test/unit'
 require 'mirah'
 
@@ -23,8 +21,8 @@ class TestJavaTyper < Test::Unit::TestCase
 
   def setup
     AST.type_factory = Mirah::JVM::Types::TypeFactory.new
-    @typer = Typer::JVM.new(nil)
-    compiler = Mirah::Compiler::JVM.new
+    @typer = Mirah::JVM::Typer.new(nil)
+    compiler = Mirah::JVM::Compiler::JVMBytecode.new
 
     @java_typer = Typer::JavaTyper.new
   end

data/test/{test_jvm_compiler.rb → jvm/test_jvm_compiler.rb}

@@ -13,92 +13,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-$:.unshift File.join(File.dirname(__FILE__),'..','lib')
-
-require 'test/unit'
-require 'mirah'
-require 'jruby'
-require 'stringio'
-require 'fileutils'
-
-unless Mirah::AST.macro "__gloop__"
-  Mirah::AST.defmacro "__gloop__" do |transformer, fcall, parent|
-    Mirah::AST::Loop.new(parent, parent.position, true, false) do |loop|
-      init, condition, check_first, pre, post = fcall.parameters
-      loop.check_first = check_first.literal
-
-      nil_t = Mirah::AST::Null
-      loop.init = init
-      loop.pre = pre
-      loop.post = post
-
-      body = fcall.block.body
-      body.parent = loop
-      [
-        Mirah::AST::Condition.new(loop, parent.position) do |c|
-          condition.parent = c
-          [condition]
-        end,
-        body
-      ]
-    end
-  end
-end
-
 class TestJVMCompiler < Test::Unit::TestCase
-  include Mirah
-  import java.lang.System
-  import java.io.PrintStream
-
-  def setup
-    @tmp_classes = []
-  end
-
-  def teardown
-    AST.type_factory = nil
-    File.unlink(*@tmp_classes)
-  end
-
-  def assert_include(value, array, message=nil)
-    message = build_message message, '<?> does not include <?>', array, value
-    assert_block message do
-      array.include? value
-    end
-  end
-
-  def compile(code)
-    File.unlink(*@tmp_classes)
-    @tmp_classes.clear
-    AST.type_factory = Mirah::JVM::Types::TypeFactory.new
-    name = "script" + System.nano_time.to_s
-    state = Mirah::CompilationState.new
-    state.save_extensions = false
-    transformer = Mirah::Transform::Transformer.new(state)
-    Java::MirahImpl::Builtin.initialize_builtins(transformer)
-    ast  = AST.parse(code, name, true, transformer)
-    typer = Typer::JVM.new(transformer)
-    ast.infer(typer, true)
-    typer.resolve(true)
-    compiler = Compiler::JVM.new
-    compiler.compile(ast)
-    classes = {}
-    loader = Mirah::ClassLoader.new(JRuby.runtime.jruby_class_loader, classes)
-    compiler.generate do |name, builder|
-      bytes = builder.generate
-      FileUtils.mkdir_p(File.dirname(name))
-      open("#{name}", "wb") do |f|
-        f << bytes
-      end
-      classes[name[0..-7]] = bytes
-    end
-
-    classes.keys.map do |name|
-      cls = loader.load_class(name.tr('/', '.'))
-      proxy = JavaUtilities.get_proxy_class(cls.name)
-      @tmp_classes << "#{name}.class"
-      proxy
-    end
-  end
 
   def test_local
     cls, = compile("def foo; a = 1; a; end")
@@ -324,7 +239,7 @@ class TestJVMCompiler < Test::Unit::TestCase
 
     assert_output("Hello there\n") { cls.foo }
 
-    script, a, b = compile(<<-EOF)
+    a, b = compile(<<-EOF)
       class VoidBase
         def foo
           returns void
@@ -342,7 +257,6 @@ class TestJVMCompiler < Test::Unit::TestCase
         end
       end
     EOF
-
     assert_output("foo\nbar\n") { b.foobar }
 
   end
@@ -397,24 +311,7 @@ class TestJVMCompiler < Test::Unit::TestCase
     foo, = compile("class ClassDeclTest;end")
     assert_equal('ClassDeclTest', foo.java_class.name)
   end
-
-  def capture_output
-    saved_output = System.out
-    output = StringIO.new
-    System.setOut(PrintStream.new(output.to_outputstream))
-    begin
-      yield
-      output.rewind
-      output.read
-    ensure
-      System.setOut(saved_output)
-    end
-  end
-
-  def assert_output(expected, &block)
-    assert_equal(expected, capture_output(&block))
-  end
-
+  
   def test_puts
     cls, = compile("def foo;puts 'Hello World!';end")
     output = capture_output do
@@ -637,6 +534,32 @@ class TestJVMCompiler < Test::Unit::TestCase
     cls, = compile(
         'def foo; a = 0; while a < 2; a+=1; end; end')
     assert_equal(nil, cls.foo)
+
+    # TODO: loop doesn't work unless you're explicitly in a class
+    # cls, = compile(<<-EOF)
+    #   def bar(a:fixnum)
+    #     loop do
+    #       a += 1
+    #       break if a > 2
+    #     end
+    #     a
+    #   end
+    # EOF
+    # assert_equal(3, cls.bar(0))
+
+    loopy, = compile(<<-EOF)
+    class Loopy
+      def bar(a:fixnum)
+        loop do
+          a += 1
+          break if a > 2
+        end
+        a
+      end
+    end
+    EOF
+
+    assert_equal(3, loopy.new.bar(0))
   end
 
   def test_break
@@ -852,7 +775,7 @@ class TestJVMCompiler < Test::Unit::TestCase
   end
 
   def test_implements
-    script, cls = compile(<<-EOF)
+    cls, = compile(<<-EOF)
       import java.lang.Iterable
       class Foo; implements Iterable
         def iterator
@@ -900,16 +823,16 @@ class TestJVMCompiler < Test::Unit::TestCase
   end
 
   def test_interface_declaration
-    script, interface = compile('interface A do; end')
+    interface = compile('interface A do; end').first
     assert(interface.java_class.interface?)
     assert_equal('A', interface.java_class.name)
 
-    script, a, b = compile('interface A do; end; interface B < A do; end')
+    a, b = compile('interface A do; end; interface B < A do; end')
     assert_include(a, b.ancestors)
     assert_equal('A', a.java_class.name)
     assert_equal('B', b.java_class.name)
 
-    script, a, b, c = compile(<<-EOF)
+    a, b, c = compile(<<-EOF)
       interface A do
       end
 
@@ -1095,6 +1018,28 @@ class TestJVMCompiler < Test::Unit::TestCase
       cls.foo
     end
     assert_equal("foo\n", output)
+
+
+    cls, = compile(<<-EOF)
+      def foo(x:boolean)
+        throws Exception
+        if x
+          raise Exception, "x"
+        end
+      rescue Exception
+        "x"
+      else
+        raise Exception, "!x"
+      end
+    EOF
+
+    assert_equal "x", cls.foo(true)
+    begin
+      cls.foo(false)
+      fail
+    rescue java.lang.Exception => ex
+      assert_equal "java.lang.Exception: !x", ex.message
+    end
   end
 
   def test_ensure
@@ -1135,7 +1080,6 @@ class TestJVMCompiler < Test::Unit::TestCase
       cls.foo
     end
     assert_equal "Hi\n", output
-
   end
 
   def test_cast
@@ -1266,207 +1210,6 @@ class TestJVMCompiler < Test::Unit::TestCase
     assert_equal(true, cls.foo("a"))
     assert_equal(false, cls.foo(nil))
   end
-
-  def test_for
-    cls, = compile(<<-EOF)
-      def foo
-        a = int[3]
-        count = 0
-        for x in a
-          count += 1
-        end
-        count
-      end
-    EOF
-
-    cls, = compile(<<-EOF)
-      def foo(a:int[])
-        count = 0
-        for x in a
-          count += x
-        end
-        count
-      end
-    EOF
-
-    assert_equal(9, cls.foo([2, 3, 4].to_java(:int)))
-
-    cls, = compile(<<-EOF)
-      def foo(a:Iterable)
-        a.each do |x|
-          puts x
-        end
-      end
-    EOF
-
-    assert_output("1\n2\n3\n") do
-      list = java.util.ArrayList.new
-      list << "1"
-      list << "2"
-      list << "3"
-      cls.foo(list)
-    end
-
-    cls, = compile(<<-EOF)
-      import java.util.ArrayList
-      def foo(a:ArrayList)
-        a.each do |x|
-          puts x
-        end
-      end
-    EOF
-
-    assert_output("1\n2\n3\n") do
-      list = java.util.ArrayList.new
-      list << "1"
-      list << "2"
-      list << "3"
-      cls.foo(list)
-    end
-
-    cls, = compile(<<-EOF)
-      def foo(a:int[])
-        a.each {|x| x += 1;puts x; redo if x == 2}
-      end
-    EOF
-
-    assert_output("2\n3\n3\n4\n") do
-      cls.foo([1,2,3].to_java(:int))
-    end
-  end
-
-  def test_all
-    cls, = compile(<<-EOF)
-      def foo(a:int[])
-        a.all? {|x| x % 2 == 0}
-      end
-    EOF
-
-    assert_equal(false, cls.foo([2, 3, 4].to_java(:int)))
-    assert_equal(true, cls.foo([2, 0, 4].to_java(:int)))
-
-    cls, = compile(<<-EOF)
-      def foo(a:String[])
-        a.all?
-      end
-    EOF
-
-    assert_equal(true, cls.foo(["a", "", "b"].to_java(:string)))
-    assert_equal(false, cls.foo(["a", nil, "b"].to_java(:string)))
-  end
-
-  def test_downto
-    cls, = compile(<<-EOF)
-      def foo(i:int)
-        i.downto(1) {|x| puts x }
-      end
-    EOF
-
-    assert_output("3\n2\n1\n") do
-      cls.foo(3)
-    end
-  end
-
-  def test_upto
-    cls, = compile(<<-EOF)
-      def foo(i:int)
-        i.upto(3) {|x| puts x }
-      end
-    EOF
-
-    assert_output("1\n2\n3\n") do
-      cls.foo(1)
-    end
-  end
-
-  def test_times
-    cls, = compile(<<-EOF)
-      def foo(i:int)
-        i.times {|x| puts x }
-      end
-    EOF
-
-    assert_output("0\n1\n2\n") do
-      cls.foo(3)
-    end
-
-    cls, = compile(<<-EOF)
-      def foo(i:int)
-        i.times { puts "Hi" }
-      end
-    EOF
-
-    assert_output("Hi\nHi\nHi\n") do
-      cls.foo(3)
-    end
-  end
-
-  def test_general_loop
-    cls, = compile(<<-EOF)
-      def foo(x:boolean)
-        a = ""
-        __gloop__(nil, x, true, nil, nil) {a += "<body>"}
-        a
-      end
-    EOF
-    assert_equal("", cls.foo(false))
-
-    cls, = compile(<<-EOF)
-      def foo
-        a = ""
-        __gloop__(nil, false, false, nil, nil) {a += "<body>"}
-        a
-      end
-    EOF
-    assert_equal("<body>", cls.foo)
-
-    cls, = compile(<<-EOF)
-      def foo(x:boolean)
-        a = ""
-        __gloop__(a += "<init>", x, true, a += "<pre>", a += "<post>") do
-          a += "<body>"
-        end
-        a
-      end
-    EOF
-    assert_equal("<init>", cls.foo(false))
-
-    cls, = compile(<<-EOF)
-      def foo
-        a = ""
-        __gloop__(a += "<init>", false, false, a += "<pre>", a += "<post>") do
-          a += "<body>"
-        end
-        a
-      end
-    EOF
-    assert_equal("<init><pre><body><post>", cls.foo)
-
-    cls, = compile(<<-EOF)
-      def foo
-        a = ""
-        __gloop__(a += "<init>", false, false, a += "<pre>", a += "<post>") do
-          a += "<body>"
-          redo if a.length < 20
-        end
-        a
-      end
-    EOF
-    assert_equal( "<init><pre><body><body><post>", cls.foo)
-
-    cls, = compile(<<-EOF)
-      def foo
-        a = ""
-        __gloop__(a += "<init>", a.length < 20, true, a += "<pre>", a += "<post>") do
-          next if a.length < 17
-          a += "<body>"
-        end
-        a
-      end
-    EOF
-    assert_equal("<init><pre><post><pre><body><post>", cls.foo)
-  end
-
   def test_if_expr
     cls, = compile(<<-EOF)
       def foo(a:int)
@@ -1795,7 +1538,7 @@ class TestJVMCompiler < Test::Unit::TestCase
   end
 
   def test_super_constructor
-    cls, a, b = compile(<<-EOF)
+    sc_a, sc_b = compile(<<-EOF)
       class SC_A
         def initialize(a:int)
           puts "A"
@@ -1811,7 +1554,7 @@ class TestJVMCompiler < Test::Unit::TestCase
     EOF
 
     assert_output("A\nB\n") do
-      b.new
+      sc_b.new
     end
   end
 
@@ -2073,44 +1816,28 @@ class TestJVMCompiler < Test::Unit::TestCase
       cls.main(nil)
     end
   end
-
-  def test_each
+  
+  def test_block_with_no_arguments_and_return_value
     cls, = compile(<<-EOF)
-      def foo
-        [1,2,3].each {|x| puts x}
+      import java.util.concurrent.Callable
+      def foo c:Callable
+        throws Exception
+         puts c.call
       end
-    EOF
-    assert_output("1\n2\n3\n") do
-      cls.foo
-    end
-  end
-
-  def test_any
-    cls, = compile(<<-EOF)
-      import java.lang.Integer
-      def foo
-        puts [1,2,3].any?
-        puts [1,2,3].any? {|x| Integer(x).intValue > 3}
+      begin
+      foo do
+        "an object"
       end
-    EOF
-    assert_output("true\nfalse\n") do
-      cls.foo
-    end
-  end
-
-  def test_all
-    cls, = compile(<<-EOF)
-      import java.lang.Integer
-      def foo
-        puts [1,2,3].all?
-        puts [1,2,3].all? {|x| Integer(x).intValue > 3}
+      rescue
+        puts "never get here"
       end
     EOF
-    assert_output("true\nfalse\n") do
-      cls.foo
+    assert_output("an object\n") do
+      cls.main(nil)
     end
   end
 
+
   def test_optional_args
     cls, = compile(<<-EOF)
       def foo(a:int, b:int = 1, c:int = 2)
@@ -2165,7 +1892,7 @@ class TestJVMCompiler < Test::Unit::TestCase
   end
 
   def test_duby_iterable
-    script, cls = compile(<<-EOF)
+    cls, = compile(<<-EOF)
       import java.util.Iterator
       class MyIterator; implements Iterable, Iterator
         def initialize(x:Object)
@@ -2195,6 +1922,7 @@ class TestJVMCompiler < Test::Unit::TestCase
         end
       end
     EOF
+    
     assert_output("Hi\n") do
       cls.test("Hi")
     end
@@ -2318,21 +2046,6 @@ class TestJVMCompiler < Test::Unit::TestCase
     assert_equal("java.lang.Character$UnicodeBlock", subset.java_class.name)
   end
 
-  def test_defmacro
-    cls, = compile(<<-EOF)
-      defmacro bar(x) do
-        x
-      end
-      
-      def foo
-        bar("bar")
-      end
-    EOF
-
-    assert_equal("bar", cls.foo)
-    assert(!cls.respond_to?(:bar))
-  end
-
   def test_default_constructor
     script, cls = compile(<<-EOF)
       class DefaultConstructable
@@ -2377,66 +2090,6 @@ class TestJVMCompiler < Test::Unit::TestCase
     assert_equal(false, cls.dynamic(java.lang.Object, nil))
   end
 
-  def test_instance_macro
-    # TODO fix annotation output and create a duby.anno.Extensions annotation.
-    return if self.class.name == 'TestJavacCompiler'
-    script, cls = compile(<<-EOF)
-      class InstanceMacros
-        def foobar
-          "foobar"
-        end
-
-        macro def macro_foobar
-          quote {foobar}
-        end
-      
-        def call_foobar
-          macro_foobar
-        end
-      end
-
-      def macro
-        InstanceMacros.new.macro_foobar
-      end
-
-      def function
-        InstanceMacros.new.call_foobar
-      end
-    EOF
-
-    assert_equal("foobar", script.function)
-    assert_equal("foobar", script.macro)
-  end
-
-  def test_unquote
-    # TODO fix annotation output and create a duby.anno.Extensions annotation.
-    return if self.class.name == 'TestJavacCompiler'
-
-    script, cls = compile(<<-'EOF')
-      class UnquoteMacros
-        macro def make_attr(name_node, type)
-          name = name_node.string_value
-          quote do
-            def `name`
-              @`name`
-            end
-            def `"#{name}_set"`(`name`:`type`)
-              @`name` = `name`
-            end
-          end
-        end
-
-        make_attr :foo, :int
-      end
-
-      x = UnquoteMacros.new
-      puts x.foo
-      x.foo = 3
-      puts x.foo
-    EOF
-    assert_output("0\n3\n") {script.main(nil)}
-  end
-
   def test_static_import
     cls, = compile(<<-EOF)
       import java.util.Arrays
@@ -2451,7 +2104,7 @@ class TestJVMCompiler < Test::Unit::TestCase
     assert_kind_of(Java::JavaUtil::List, list)
     assert_equal(["1", "2", "3"], list.to_a)
 
-    scripe, cls = compile(<<-EOF)
+    cls, = compile(<<-EOF)
       import java.util.Arrays
       class StaticImports
         include Arrays
@@ -2568,7 +2221,7 @@ class TestJVMCompiler < Test::Unit::TestCase
   end
 
   def test_abstract
-    script, cls1, cls2 = compile(<<-EOF)
+    abstract_class, concrete_class = compile(<<-EOF)
       abstract class Abstract
         abstract def foo:void; end
         def bar; puts "bar"; end
@@ -2579,12 +2232,12 @@ class TestJVMCompiler < Test::Unit::TestCase
     EOF
 
     assert_output("foo\nbar\n") do
-      a = cls2.new
+      a = concrete_class.new
       a.foo
       a.bar
     end
     begin
-      cls1.new
+      abstract_class.new
       fail "Expected InstantiationException"
     rescue java.lang.InstantiationException
       # expected
@@ -2697,26 +2350,6 @@ class TestJVMCompiler < Test::Unit::TestCase
     assert_equal("value", map["key"])
   end
 
-  def test_macro_hygene
-    cls, = compile(<<-EOF)
-      macro def doubleIt(arg)
-        quote do
-          x = `arg`
-          x = x + x
-          x
-        end
-      end
-
-      def foo
-        x = "1"
-        puts doubleIt(x)
-        puts x
-      end
-    EOF
-
-    assert_output("11\n1\n") {cls.foo}
-  end
-
   def test_wide_nonexpressions
     script, cls1, cls2 = compile(<<-EOF)
       class WideA
@@ -2775,4 +2408,74 @@ class TestJVMCompiler < Test::Unit::TestCase
 
     assert_kind_of(java.util.HashSet, cls.foo)
   end
+
+  def test_colon2_cast
+    cls, = compile(<<-EOF)
+      def foo(x:Object)
+        java.util::Map.Entry(x)
+      end
+    EOF
+
+    entry = java.util.HashMap.new(:a => 1).entrySet.iterator.next
+    assert_equal(entry, cls.foo(entry))
+  end
+  
+  def test_covariant_arrays
+    cls, = compile(<<-EOF)
+      puts java::util::Arrays.toString(String[5])
+    EOF
+    
+    assert_output("[null, null, null, null, null]\n") do
+      cls.main(nil)
+    end
+  end
+  
+  def test_getClass_on_object_array
+    cls, = compile(<<-EOF)
+      puts Object[0].getClass.getName
+    EOF
+    
+    assert_output("[Ljava.lang.Object;\n") do
+      cls.main(nil)
+    end
+  end
+
+  def test_nil_assign
+    cls, = compile(<<-EOF)
+    def foo
+      a = nil
+      a = 'hello'
+      a.length
+    end
+    EOF
+
+    assert_equal(5, cls.foo)
+
+    cls, = compile(<<-EOF)
+      a = nil
+      puts a
+    EOF
+
+    assert_output("null\n") do
+      cls.main(nil)
+    end
+  end
+
+  def test_empty_rescues
+    cls, = compile(<<-EOF)
+      begin
+      rescue
+        nil
+      end
+    EOF
+
+    cls, = compile(<<-EOF)
+      begin
+        ""
+      rescue
+        nil
+      end
+      nil
+    EOF
+  end
 end