mirah 0.0.12-java → 0.1.0-java

data/test/jvm/list_extensions_test.rb

@@ -0,0 +1,23 @@
+class ListExtensionsTest < Test::Unit::TestCase
+  def test_bracket_getter
+    cls, = compile(<<-EOF)
+      x = [1,2]
+      puts x[0]
+    EOF
+    assert_output("1\n") do
+      cls.main(nil)
+    end
+  end
+
+  def test_bracket_assignment
+    cls, = compile(<<-EOF)
+      import java.util.ArrayList # literals are immutable
+      x = ArrayList.new
+      x[0]= "2"
+      puts x
+    EOF
+    assert_output("[2]\n") do
+      cls.main(nil)
+    end
+  end
+end

data/test/jvm/macros_test.rb

@@ -14,12 +14,66 @@
 # limitations under the License.
 
 class MacrosTest < Test::Unit::TestCase
-  def test_defmacro
+  def test_vcall_macro
     cls, = compile(<<-EOF)
-      defmacro bar(x) do
+      macro def foo
+        mirah::lang::ast::Null.new
+      end
+
+      System.out.println(foo)
+    EOF
+
+    assert_output("null\n") {cls.main(nil)}
+    assert(!cls.respond_to?(:foo))
+  end
+
+  def test_imported_constants_available_in_macros
+    cls, = compile(<<-EOF)
+      import java.util.LinkedList
+      macro def foo
+        LinkedList.new
+        Node(nil)
+      end
+
+      foo
+    EOF
+
+    assert_output("") {cls.main(nil)}
+    assert(!cls.respond_to?(:foo))
+  end
+
+  def test_fcall_macro
+    cls, = compile(<<-EOF)
+      macro def foo
+        mirah::lang::ast::Null.new
+      end
+
+      System.out.println(foo())
+    EOF
+
+    assert_output("null\n") {cls.main(nil)}
+    assert(!cls.respond_to?(:foo))
+  end
+
+  def test_quote
+    cls, = compile(<<-EOF)
+      macro def foo
+        quote { nil }
+      end
+
+      System.out.println(foo)
+    EOF
+
+    assert_output("null\n") {cls.main(nil)}
+    assert(!cls.respond_to?(:foo))
+  end
+
+  def test_macro_def_with_arg
+    cls, = compile(<<-EOF)
+      macro def bar(x)
         x
       end
-      
+
       def foo
         bar("bar")
       end
@@ -28,10 +82,8 @@ class MacrosTest < Test::Unit::TestCase
     assert_equal("bar", cls.foo)
     assert(!cls.respond_to?(:bar))
   end
-  
-  
-  def test_instance_macro
-    # TODO fix annotation output and create a duby.anno.Extensions annotation.
+
+  def test_instance_macro_call
     script, cls = compile(<<-EOF)
       class InstanceMacros
         def foobar
@@ -39,39 +91,98 @@ class MacrosTest < Test::Unit::TestCase
         end
 
         macro def macro_foobar
-          quote {foobar}
+          quote {`@call.target`.foobar}
+        end
+      end
+
+      def macro
+        InstanceMacros.new.macro_foobar
+      end
+    EOF
+
+    assert_equal("foobar", script.macro)
+  end
+
+  def test_instance_macro_vcall
+    script, cls = compile(<<-EOF)
+      class InstanceMacros2
+        def foobar
+          "foobar"
+        end
+
+        macro def macro_foobar
+          quote {`@call.target`.foobar}
         end
-      
+
         def call_foobar
           macro_foobar
         end
       end
 
+      def function
+        InstanceMacros2.new.call_foobar
+      end
+    EOF
+
+    assert_equal("foobar", script.function)
+  end
+
+
+  def test_static_macro_call
+    script, cls = compile(<<-EOF)
+      class StaticMacros
+        def self.foobar
+          "foobar"
+        end
+
+        macro def self.macro_foobar
+          quote {`@call.target`.foobar}
+        end
+      end
+
       def macro
-        InstanceMacros.new.macro_foobar
+        StaticMacros.macro_foobar
+      end
+    EOF
+
+    assert_equal("foobar", script.macro)
+  end
+
+  def test_static_macro_vcall
+    script, cls = compile(<<-EOF)
+      class StaticMacros2
+        def foobar
+          "foobar"
+        end
+
+        macro def self.macro_foobar
+          quote {`@call.target`.new.foobar}
+        end
+
+        def self.call_foobar
+          macro_foobar
+        end
       end
 
       def function
-        InstanceMacros.new.call_foobar
+        StaticMacros2.call_foobar
       end
     EOF
 
     assert_equal("foobar", script.function)
-    assert_equal("foobar", script.macro)
   end
 
-  def test_unquote_method_definitions_with_main
-    # TODO fix annotation output and create a duby.anno.Extensions annotation.
 
+  def test_unquote_method_definitions_with_main
     script, cls = compile(<<-'EOF')
       class UnquoteMacros
-        macro def make_attr(name_node, type)
-          name = name_node.string_value
+        macro def self.make_attr(name_node:Identifier, type:TypeName)
+          name = name_node.identifier
           quote do
             def `name`
               @`name`
             end
-            def `"#{name}_set"`(`name`:`type`)
+            def `"#{name}_set"`(`name`: `type`)
               @`name` = `name`
             end
           end
@@ -81,14 +192,16 @@ class MacrosTest < Test::Unit::TestCase
       end
 
       x = UnquoteMacros.new
-      puts x.foo
+      System.out.println x.foo
       x.foo = 3
-      puts x.foo
+      System.out.println x.foo
     EOF
     assert_output("0\n3\n") {script.main(nil)}
   end
 
   def test_macro_hygene
+    # TODO hygenic macros?
+    return
     cls, = compile(<<-EOF)
       macro def doubleIt(arg)
         quote do
@@ -100,24 +213,45 @@ class MacrosTest < Test::Unit::TestCase
 
       def foo
         x = "1"
-        puts doubleIt(x)
-        puts x
+        System.out.println doubleIt(x)
+        System.out.println x
       end
     EOF
 
     assert_output("11\n1\n") {cls.foo}
   end
 
+  def test_gensym
+    # TODO hygenic macros?
+    return
+    cls, = compile(<<-EOF)
+      macro def doubleIt(arg)
+        x = gensym
+        quote do
+          `x` = `arg`
+          `x` = `x` + `x`
+          `x`
+        end
+      end
+
+      def foo
+        x = 1
+        System.out.println doubleIt(x)
+        System.out.println x
+      end
+    EOF
+
+    assert_output("2\n1\n") {cls.foo}
+  end
 
   def test_add_args_in_macro
     cls, = compile(<<-EOF)
-      macro def foo(a)
-        import duby.lang.compiler.Node
-        quote { bar "1", `Node(a.child_nodes.get(0)).child_nodes`, "2"}
+      macro def foo(a:Array)
+        quote { bar "1", `a.values`, "2"}
       end
 
       def bar(a:String, b:String, c:String, d:String)
-        puts "\#{a} \#{b} \#{c} \#{d}"
+        System.out.println "\#{a} \#{b} \#{c} \#{d}"
       end
 
       foo(["a", "b"])
@@ -127,11 +261,11 @@ class MacrosTest < Test::Unit::TestCase
       cls.main(nil)
     end
   end
-  
+
   def test_block_parameter_uses_outer_scope
     cls, = compile(<<-EOF)
-      macro def foo(&block)
-        quote { z = `block.body`; puts z }
+      macro def foo(block:Block)
+        quote { z = `block.body`; System.out.println z }
       end
       apple = 1
       foo do
@@ -145,14 +279,15 @@ class MacrosTest < Test::Unit::TestCase
   end
 
   def test_method_def_after_macro_def_with_same_name_raises_error
-    assert_raises Mirah::InferenceError do
+    assert_raises Mirah::MirahError do
       compile(<<-EOF)
-        macro def foo
-          quote { puts :z }
+        macro def self.foo
+          quote { System.out.println :z }
         end
         def foo
           :bar
         end
+        foo
       EOF
     end
   end
@@ -160,7 +295,7 @@ class MacrosTest < Test::Unit::TestCase
   def test_macro_def_unquote_named_method_without_main
     cls, = compile <<-EOF
       class FooHaver
-        macro def null_method name
+        macro def self.null_method(name)
           quote {
             def `name`
             end
@@ -171,4 +306,34 @@ class MacrosTest < Test::Unit::TestCase
     EOF
     assert_equal nil, cls.new.testing
   end
+  
+  def test_attr_accessor
+    script, cls = compile(<<-EOF)
+      class AttrAccessorTest
+        attr_accessor foo: int
+      end
+
+      x = AttrAccessorTest.new
+      System.out.println x.foo
+      x.foo = 3
+      System.out.println x.foo
+    EOF
+    assert_output("0\n3\n") {script.main(nil)}
+  end
+
+  def test_separate_compilation
+    compile(<<-CODE)
+      class InlineOneSayer
+        macro def say_one
+          quote do
+            puts "one"
+          end
+        end
+      end
+    CODE
+    script, _ =compile(<<-CODE)
+      InlineOneSayer.new.say_one
+    CODE
+    assert_output("one\n") {script.main(nil)}
+  end
 end

data/test/jvm/main_method_test.rb

@@ -3,11 +3,11 @@ class MainMethodTest < Test::Unit::TestCase
     code = <<-EOC
       class WithMain
       end
-      puts 'bar'
+      System.out.println 'bar'
     EOC
-    
-    main_class, = compile code, 'with_main'
-    
+
+    main_class, = compile code, :name => 'with_main'
+
     assert_output "bar\n" do
       main_class.main(nil)
     end

data/test/jvm/numeric_extensions_test.rb

@@ -0,0 +1,13 @@
+class NumericExtensionsTest < Test::Unit::TestCase
+  def test_power_macro
+    cls, = compile(<<-EOF)
+      def run(n1:int, n2:int)
+        puts n1 ** n2
+      end
+    EOF
+
+    assert_output("16.0\n") do
+      cls.run(4, 2)
+    end
+  end
+end

data/test/jvm/rescue_test.rb

@@ -19,9 +19,9 @@ class RescueTest < Test::Unit::TestCase
     cls, = compile(<<-EOF)
       def foo
         begin
-          puts "body"
+          System.out.println "body"
         rescue
-          puts "rescue"
+          System.out.println "rescue"
         end
       end
     EOF
@@ -34,10 +34,10 @@ class RescueTest < Test::Unit::TestCase
     cls, = compile(<<-EOF)
       def foo
         begin
-          puts "body"
+          System.out.println "body"
           raise
         rescue
-          puts "rescue"
+          System.out.println "rescue"
         end
       end
     EOF
@@ -50,16 +50,16 @@ class RescueTest < Test::Unit::TestCase
     cls, = compile(<<-EOF)
       def foo(a:int)
         begin
-          puts "body"
+          System.out.println "body"
           if a == 0
             raise IllegalArgumentException
           else
             raise
           end
         rescue IllegalArgumentException
-          puts "IllegalArgumentException"
+          System.out.println "IllegalArgumentException"
         rescue
-          puts "rescue"
+          System.out.println "rescue"
         end
       end
     EOF
@@ -73,7 +73,7 @@ class RescueTest < Test::Unit::TestCase
     cls, = compile(<<-EOF)
       def foo(a:int)
         begin
-          puts "body"
+          System.out.println "body"
           if a == 0
             raise IllegalArgumentException
           elsif a == 1
@@ -81,10 +81,10 @@ class RescueTest < Test::Unit::TestCase
           else
             raise
           end
-        rescue IllegalArgumentException, RuntimeException
-          puts "multi"
+        rescue IllegalArgumentException, Exception
+          System.out.println "multi"
         rescue Throwable
-          puts "other"
+          System.out.println "other"
         end
       end
     EOF
@@ -101,7 +101,7 @@ class RescueTest < Test::Unit::TestCase
         begin
           raise "foo"
         rescue => ex
-          puts ex.getMessage
+          System.out.println ex.getMessage
         end
       end
     EOF
@@ -114,7 +114,7 @@ class RescueTest < Test::Unit::TestCase
 
     cls, = compile(<<-EOF)
       def foo(x:boolean)
-        throws Exception
+        # throws Exception
         if x
           raise Exception, "x"
         end
@@ -126,10 +126,9 @@ class RescueTest < Test::Unit::TestCase
     EOF
 
     assert_equal "x", cls.foo(true)
-    ex = assert_raise NativeException do
+    assert_raise_java java.lang.Exception, "!x" do
       cls.foo(false)
     end
-    assert_equal "java.lang.Exception: !x", ex.message
 
     cls, = compile(<<-EOF)
       def foo:long
@@ -174,10 +173,68 @@ class RescueTest < Test::Unit::TestCase
           end
         rescue
         ensure
-          puts 'ensuring'
+          System.out.println 'ensuring'
         end
         ""
       end
     EOF
   end
+
+
+  def test_ensure
+    cls, = compile(<<-EOF)
+      def foo
+        1
+      ensure
+        System.out.println "Hi"
+      end
+    EOF
+    output = capture_output do
+      assert_equal(1, cls.foo)
+    end
+    assert_equal "Hi\n", output
+
+    cls, = compile(<<-EOF)
+      def foo
+        return 1
+      ensure
+        System.out.println "Hi"
+      end
+    EOF
+    output = capture_output do
+      assert_equal(1, cls.foo)
+    end
+    assert_equal "Hi\n", output
+
+    cls, = compile(<<-EOF)
+      def foo
+        begin
+          break
+        ensure
+          System.out.println "Hi"
+        end while false
+      end
+    EOF
+    output = capture_output do
+      cls.foo
+    end
+    assert_equal "Hi\n", output
+  end
+
+  def test_loop_in_ensure
+    cls, = compile(<<-EOF)
+    begin
+      System.out.println "a"
+      begin
+        System.out.println "b"
+        break
+      end while false
+      System.out.println "c"
+    ensure
+      System.out.println "ensure"
+    end
+    EOF
+
+    assert_output("a\nb\nc\nensure\n") { cls.main(nil) }
+  end
 end