mirah 0.1.0.pre-java → 0.1.1-java

data/test/jvm/macros_test.rb

@@ -20,14 +20,14 @@ class MacrosTest < Test::Unit::TestCase
         mirah::lang::ast::Null.new
       end
 
-      System.out.println(foo)
+      System.out.println(Object(foo))
     EOF
 
     assert_output("null\n") {cls.main(nil)}
     assert(!cls.respond_to?(:foo))
   end
 
-  def test_import
+  def test_imported_constants_available_in_macros
     cls, = compile(<<-EOF)
       import java.util.LinkedList
       macro def foo
@@ -48,7 +48,7 @@ class MacrosTest < Test::Unit::TestCase
         mirah::lang::ast::Null.new
       end
 
-      System.out.println(foo())
+      System.out.println(Object(foo()))
     EOF
 
     assert_output("null\n") {cls.main(nil)}
@@ -61,7 +61,7 @@ class MacrosTest < Test::Unit::TestCase
         quote { nil }
       end
 
-      System.out.println(foo)
+      System.out.println(Object(foo))
     EOF
 
     assert_output("null\n") {cls.main(nil)}
@@ -83,7 +83,6 @@ class MacrosTest < Test::Unit::TestCase
     assert(!cls.respond_to?(:bar))
   end
 
-
   def test_instance_macro_call
     script, cls = compile(<<-EOF)
       class InstanceMacros
@@ -128,8 +127,54 @@ class MacrosTest < Test::Unit::TestCase
     assert_equal("foobar", script.function)
   end
 
-  def test_unquote_method_definitions_with_main
+
+  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
+        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
+        StaticMacros2.call_foobar
+      end
+    EOF
+
+    assert_equal("foobar", script.function)
+  end
+
+
+  def test_unquote_method_definitions_with_main
+    script, cls = compile(<<-'EOF')
       class UnquoteMacros
         macro def self.make_attr(name_node:Identifier, type:TypeName)
           name = name_node.identifier
@@ -275,4 +320,20 @@ class MacrosTest < Test::Unit::TestCase
     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

@@ -6,7 +6,7 @@ class MainMethodTest < Test::Unit::TestCase
       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)

data/test/jvm/mirror_compilation_test_helper.rb

@@ -0,0 +1,24 @@
+# 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.
+require 'new_backend_test_helper'
+require 'stringio'
+require 'fileutils'
+
+module JVMCompiler
+  def type_system
+    # TODO: classpath
+    Java::OrgMirahJvmMirrors::MirrorTypeSystem.new
+  end
+end

data/test/jvm/new_backend_test_helper.rb

@@ -0,0 +1,25 @@
+# Copyright (c) 2010-2013 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.
+require 'bytecode_test_helper'
+
+module JVMCompiler
+  def compiler_type
+    Mirah::JVM::Compiler::Backend
+  end
+
+  def compiler_name
+    "new"
+  end
+end

data/test/jvm/rescue_test.rb

@@ -15,13 +15,13 @@
 
 class RescueTest < Test::Unit::TestCase
 
-  def test_rescue
+  def test_rescue_with_no_raise_runs_begin_and_not_rescue
     cls, = compile(<<-EOF)
       def foo
         begin
-          System.out.println "body"
+          puts "body"
         rescue
-          System.out.println "rescue"
+          puts "rescue"
         end
       end
     EOF
@@ -30,14 +30,16 @@ class RescueTest < Test::Unit::TestCase
       cls.foo
     end
     assert_equal("body\n", output)
+  end
 
+  def test_rescue_with_raise_after_begin_runs_rescue
     cls, = compile(<<-EOF)
       def foo
         begin
-          System.out.println "body"
+          puts "body"
           raise
         rescue
-          System.out.println "rescue"
+          puts "rescue"
         end
       end
     EOF
@@ -46,20 +48,22 @@ class RescueTest < Test::Unit::TestCase
       cls.foo
     end
     assert_equal("body\nrescue\n", output)
+  end
 
+  def test_rescue_with_type_clause_and_untyped_clause
     cls, = compile(<<-EOF)
       def foo(a:int)
         begin
-          System.out.println "body"
+          puts "body"
           if a == 0
             raise IllegalArgumentException
           else
             raise
           end
         rescue IllegalArgumentException
-          System.out.println "IllegalArgumentException"
+          puts "IllegalArgumentException"
         rescue
-          System.out.println "rescue"
+          puts "rescue"
         end
       end
     EOF
@@ -69,11 +73,14 @@ class RescueTest < Test::Unit::TestCase
       cls.foo(0)
     end
     assert_equal("body\nrescue\nbody\nIllegalArgumentException\n", output)
+  end
 
+
+  def test_rescue_with_multiple_types_or_throwable
     cls, = compile(<<-EOF)
       def foo(a:int)
         begin
-          System.out.println "body"
+          puts "body"
           if a == 0
             raise IllegalArgumentException
           elsif a == 1
@@ -82,9 +89,9 @@ class RescueTest < Test::Unit::TestCase
             raise
           end
         rescue IllegalArgumentException, Exception
-          System.out.println "multi"
+          puts "multi"
         rescue Throwable
-          System.out.println "other"
+          puts "other"
         end
       end
     EOF
@@ -95,13 +102,15 @@ class RescueTest < Test::Unit::TestCase
       cls.foo(2)
     end
     assert_equal("body\nmulti\nbody\nother\nbody\nmulti\n", output)
+  end
 
+  def test_rescue_without_type_with_argument
     cls, = compile(<<-EOF)
       def foo
         begin
           raise "foo"
         rescue => ex
-          System.out.println ex.getMessage
+          puts ex.getMessage
         end
       end
     EOF
@@ -110,8 +119,9 @@ class RescueTest < Test::Unit::TestCase
       cls.foo
     end
     assert_equal("foo\n", output)
+  end
 
-
+  def test_implicit_begin_on_method_with_rescue_and_else
     cls, = compile(<<-EOF)
       def foo(x:boolean)
         # throws Exception
@@ -126,11 +136,12 @@ 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
+  end
 
+  def test_rescue_with_return_types_correctly
     cls, = compile(<<-EOF)
       def foo:long
         begin
@@ -148,15 +159,63 @@ class RescueTest < Test::Unit::TestCase
     assert_equal 1, cls.foo
   end
 
-  def test_empty_rescues
+  def test_rescue_with_return_returns_value
+    cls, = compile(<<-EOF)
+      def foo:long
+        begin
+          raise "some error"
+        rescue Exception => e
+          return long(0)
+        end
+      end
+    EOF
+
+    assert_equal 0, cls.foo
+  end
+
+  def test_rescue_with_else_clause_returns_from_else_when_no_exception
     cls, = compile(<<-EOF)
+      def foo:long
+        begin
+          long(0)
+        rescue
+          long(1)
+        else
+          long(2)
+        end
+      end
+    EOF
+
+    assert_equal 2, cls.foo
+  end
+
+  def test_rescue_with_else_clause_returns_from_rescue_when_exception_raised
+    cls, = compile(<<-EOF)
+      def foo:long
+        begin
+          raise "oh, my"
+        rescue
+          long(1)
+        else
+          long(2)
+        end
+      end
+    EOF
+
+    assert_equal 1, cls.foo
+  end
+
+  def test_empty_rescue_body_compiles
+    compile(<<-EOF)
       begin
       rescue
         nil
       end
     EOF
+  end
 
-    cls, = compile(<<-EOF)
+  def test_rescue_thats_not_an_expression_compiles
+    compile(<<-EOF)
       begin
         ""
       rescue
@@ -164,7 +223,9 @@ class RescueTest < Test::Unit::TestCase
       end
       nil
     EOF
+  end
 
+  def test_rescue_containing_while_with_ensure_runs_ensure
     cls, = compile(<<-EOF)
       def empty_with_ensure
         begin
@@ -174,10 +235,84 @@ class RescueTest < Test::Unit::TestCase
           end
         rescue
         ensure
-          System.out.println 'ensuring'
+          puts 'ensuring'
         end
         ""
       end
     EOF
+    assert_output "ensuring\n" do
+      cls.empty_with_ensure
+    end
+  end
+
+  def test_empty_rescue_body_with_else_runs_else
+    cls, = compile(<<-EOF)
+      begin
+      rescue
+        nil
+      else
+        puts "else"
+      end
+    EOF
+    assert_output "else\n" do
+      cls.main nil
+    end
+  end
+
+  def test_ensure
+    cls, = compile(<<-EOF)
+      def foo
+        1
+      ensure
+        puts "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
+        puts "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
+          puts "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
+      puts "a"
+      begin
+        puts "b"
+        break
+      end while false
+      puts "c"
+    ensure
+      puts "ensure"
+    end
+    EOF
+
+    assert_output("a\nb\nc\nensure\n") { cls.main(nil) }
   end
 end