mirah 0.1.0.pre-java → 0.1.1-java

data/test/jvm/bytecode_test_helper.rb

@@ -1,4 +1,4 @@
-# Copyright (c) 2010 The Mirah project authors. All Rights Reserved.
+# 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");
@@ -13,78 +13,73 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 require 'test_helper'
-require 'stringio'
-require 'fileutils'
+require 'set'
 
 module JVMCompiler
+  TEST_DEST = File.expand_path(File.dirname(__FILE__)+'/../../tmp_test/') + "/"
+  $CLASSPATH << TEST_DEST
+
   import java.lang.System
   import java.io.PrintStream
   include Mirah
 
   def new_state
     state = Mirah::Util::CompilationState.new
-    state.save_extensions = false
+    state.save_extensions = true
+    state.destination = TEST_DEST
+    state.classpath =  TEST_DEST
+    state.type_system = type_system if type_system
     state
   end
 
+  def type_system
+    nil
+  end
 
-#  def create_transformer
-#    state = Mirah::Util::CompilationState.new
-#    state.save_extensions = false
-#
-#    transformer = Mirah::Transform::Transformer.new(state)
-#    Java::MirahImpl::Builtin.initialize_builtins(transformer)
-#    transformer
-#  end
-
-
-  def clear_tmp_files
+  def clean_tmp_files
     return unless @tmp_classes
-
     File.unlink(*@tmp_classes)
-    @tmp_classes.clear
   end
 
   def compiler_type
     JVM::Compiler::JVMBytecode
   end
 
+  def compiler_name
+    "original"
+  end
+
   def parse name, code, transformer
     AST.parse(code, name, true, transformer)
   end
 
- def infer_and_resolve_types ast, generator
-   scoper, typer = generator.infer_asts(ast, true)
-   ast
- end
-
- def parse_and_resolve_types name, code
-   clear_tmp_files
-
-   state = new_state
-
-   generator = Mirah::Generator.new(state, compiler_type, false, false)
-   transformer = Mirah::Transform::Transformer.new(state, generator.typer)
+  def infer_and_resolve_types ast, generator
+    scoper, typer = generator.infer_asts(ast, true)
+    ast
+  end
 
-   #Java::MirahImpl::Builtin.initialize_builtins(transformer)
+  def parse_and_resolve_types name, code
+    state = new_state
 
-   ast = [AST.parse(code, name, true, transformer)]
+    generator = Mirah::Generator.new(state, compiler_type, false, false)
+    transformer = Mirah::Transform::Transformer.new(state, generator.typer)
 
-   infer_and_resolve_types ast, generator
+    ast = [AST.parse(code, name, true, transformer)]
 
-   ast
- end
+    infer_and_resolve_types ast, generator
 
+    ast
+  end
 
   def generate_classes compiler_results
     classes = {}
 
     compiler_results.each do |result|
       bytes = result.bytes
-
-      FileUtils.mkdir_p(File.dirname(result.filename))
-      File.open(result.filename, 'wb') { |f| f.write(bytes) }
-
+      filename = "#{TEST_DEST}#{result.filename}"
+      FileUtils.mkdir_p(File.dirname(filename))
+      File.open(filename, 'wb') { |f| f.write(bytes) }
+      @tmp_classes << filename
       classes[result.filename[0..-7]] = Mirah::Util::ClassLoader.binary_string bytes
     end
 
@@ -92,29 +87,24 @@ module JVMCompiler
 
     classes.keys.map do |name|
       cls = loader.load_class(name.tr('/', '.'))
-      proxy = JavaUtilities.get_proxy_class(cls.name)
-      @tmp_classes << "#{name}.class"
-      proxy
+      JavaUtilities.get_proxy_class(cls.name)
     end
   end
 
-  #def compile_ast  ast
-  #  compiler = create_compiler
-  #  compiler.compile(ast)
-  #  compiler
-  #end
-
-  def compile(code, name = tmp_script_name)
-    clear_tmp_files
+  def compile(code, options = {})
+    name = options.delete :name
+    name ||= tmp_script_name
 
     state = new_state
+    java_version = options.delete :java_version
+    if java_version
+      state.set_jvm_version java_version
+    end
 
     generator = Mirah::Generator.new(state, compiler_type, false, false)
     transformer = Mirah::Transform::Transformer.new(state, generator.typer)
 
-    #Java::MirahImpl::Builtin.initialize_builtins(transformer)
-
-    ast = [AST.parse(code, name, true, transformer)]
+    ast = [AST.parse_ruby(nil, code, name)]
 
     scoper, typer = generator.infer_asts(ast, true)
     compiler_results = generator.compiler.compile_asts(ast, scoper, typer)
@@ -123,7 +113,7 @@ module JVMCompiler
   end
 
   def tmp_script_name
-    "script" + System.nano_time.to_s
+    "script#{name.gsub(/\)|\(/,'_').capitalize}#{System.nano_time}"
   end
 end
 
@@ -156,17 +146,41 @@ module CommonAssertions
     assert_equal(expected, capture_output(&block))
   end
 
+  def assert_raise_java(type, message=nil)
+    begin
+      yield
+    rescue Exception => e
+      ex = e
+    end
+    ex = ex.cause if ex.is_a? NativeException
+    assert_equal type, ex.class
+    if message
+      assert_equal message,
+                   ex.message.to_s,
+                  "expected error message to be '#{message}' but was '#{ex.message}'"
+    end
+    ex
+  end
+end
+
+module DebuggingHelp
+  def with_finest_logging
+    Mirah::Logging::MirahLogger.level = Mirah::Logging::Level::FINEST
+    yield
+  ensure
+    Mirah::Logging::MirahLogger.level = Mirah::Logging::Level::INFO
+  end
 end
 
 class Test::Unit::TestCase
   include JVMCompiler
+  include DebuggingHelp
 
   def setup
-    @tmp_classes = []
+    @tmp_classes = Set.new
   end
 
-  def teardown
-    #reset_type_factory
-    clear_tmp_files
+  def cleanup
+    clean_tmp_files
   end
 end

data/test/jvm/cast_test.rb

@@ -0,0 +1,162 @@
+# Copyright (c) 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.
+
+class CastTest < Test::Unit::TestCase
+
+  def test_cast
+    cls, = compile(<<-EOF)
+      def f2b; byte(1.0); end
+      def f2s; short(1.0); end
+      def f2c; char(1.0); end
+      def f2i; int(1.0); end
+      def f2l; long(1.0); end
+      def f2d; int(1.0); end
+
+      def i2b; byte(1); end
+      def i2s; short(1); end
+      def i2c; char(1); end
+      def i2l; long(1); end
+      def i2f; float(1); end
+      def i2d; int(1); end
+
+      def b2s; short(byte(1)); end
+      def b2c; char(byte(1)); end
+      def b2i; int(byte(1)); end
+      def b2l; long(byte(1)); end
+      def b2f; float(byte(1)); end
+      def b2d; double(byte(1)); end
+
+      def s2b; byte(short(1)); end
+      def s2c; char(short(1)); end
+      def s2i; int(short(1)); end
+      def s2l; long(short(1)); end
+      def s2f; float(short(1)); end
+      def s2d; double(short(1)); end
+
+      def c2b; byte(char(1)); end
+      def c2s; short(char(1)); end
+      def c2i; int(char(1)); end
+      def c2l; long(char(1)); end
+      def c2f; float(char(1)); end
+      def c2d; double(char(1)); end
+
+      def l2b; byte(long(1)); end
+      def l2c; char(long(1)); end
+      def l2i; int(long(1)); end
+      def l2l; long(long(1)); end
+      def l2f; float(long(1)); end
+      def l2d; double(long(1)); end
+
+      def d2b; byte(1.0); end
+      def d2s; short(1.0); end
+      def d2c; char(1.0); end
+      def d2i; int(1.0); end
+      def d2l; long(1.0); end
+      def d2f; float(1.0); end
+
+      def hard_i2f(a:int)
+        float(if a < 0
+          a *= -1
+          a * 2
+        else
+          a * 2
+        end)
+      end
+    EOF
+
+    assert_equal 1, cls.b2s
+    assert_equal 1, cls.b2c
+    assert_equal 1, cls.b2i
+    assert_equal 1, cls.b2l
+    assert_equal 1.0, cls.b2f
+    assert_equal 1.0, cls.b2d
+
+    assert_equal 1, cls.s2b
+    assert_equal 1, cls.s2c
+    assert_equal 1, cls.s2i
+    assert_equal 1, cls.s2l
+    assert_equal 1.0, cls.s2f
+    assert_equal 1.0, cls.s2d
+
+    assert_equal 1, cls.c2b
+    assert_equal 1, cls.c2s
+    assert_equal 1, cls.c2i
+    assert_equal 1, cls.c2l
+    assert_equal 1.0, cls.c2f
+    assert_equal 1.0, cls.c2d
+
+    assert_equal 1, cls.i2b
+    assert_equal 1, cls.i2s
+    assert_equal 1, cls.i2c
+    assert_equal 1, cls.i2l
+    assert_equal 1.0, cls.i2f
+    assert_equal 1.0, cls.i2d
+
+    assert_equal 1, cls.f2b
+    assert_equal 1, cls.f2s
+    assert_equal 1, cls.f2c
+    assert_equal 1, cls.f2i
+    assert_equal 1, cls.f2l
+    assert_equal 1.0, cls.f2d
+
+    assert_equal 1, cls.d2b
+    assert_equal 1, cls.d2s
+    assert_equal 1, cls.d2c
+    assert_equal 1, cls.d2i
+    assert_equal 1, cls.d2l
+    assert_equal 1.0, cls.d2f
+
+    assert_equal 2.0, cls.hard_i2f(1)
+    assert_equal 4.0, cls.hard_i2f(-2)
+  end
+
+  def test_java_lang_cast
+    cls, = compile(<<-EOF)
+      def foo(a:Object)
+        Integer(a).intValue
+      end
+    EOF
+
+    assert_equal(2, cls.foo(java.lang.Integer.new(2)))
+  end
+
+  def test_array_cast
+    cls, = compile(<<-EOF)
+      def foo(a:Object)
+        bar(String[].cast(a))
+      end
+
+      def bar(a:String[])
+        a[0]
+      end
+    EOF
+
+    assert_equal("foo", cls.foo(["foo", "bar"].to_java(:string)))
+  end
+
+  def test_array_cast_primitive
+    cls, = compile(<<-EOF)
+      def foo(a:Object)
+        bar(int[].cast(a))
+      end
+
+      def bar(a:int[])
+        a[0]
+      end
+    EOF
+
+    assert_equal(2, cls.foo([2, 3].to_java(:int)))
+  end
+end

data/test/jvm/constructors_test.rb

@@ -73,6 +73,54 @@ class ConstructorsTest < Test::Unit::TestCase
     end
   end
 
+  def test_super_constructor_inferred_args_like_ruby
+    sc_a, sc_b = compile(<<-EOF)
+      class SuperCA
+        def initialize(a: int)
+          System.out.println "A \#{a}"
+        end
+      end
+
+      class SuperCB < SuperCA
+        def initialize a: int
+          super
+          System.out.println "B \#{a}"
+        end
+      end
+    EOF
+    assert_output("A 1\nB 1\n") do
+      sc_b.new 1
+    end
+  end
+
+  def test_when_inferred_args_dont_match_super_has_error
+    error = assert_raises Mirah::MirahError do
+      compile(<<-EOF)
+        class SuperCA
+          def initialize(a: int);end
+        end
+
+        class SuperCB < SuperCA
+          def initialize; super; end
+        end
+      EOF
+    end
+    assert_equal "Cannot find instance method initialize() on SuperCA", error.message
+  end
+
+
+  def test_when_inferred_args_dont_match_java_super_has_error
+    error = assert_raises Mirah::MirahError do
+      compile(<<-EOF)
+        import java.util.ArrayList
+        class SuperArray < ArrayList
+          def initialize str: String; super; end
+        end
+      EOF
+    end
+    assert_equal "Cannot find instance method initialize(java.lang.String) on java.util.ArrayList", error.message
+  end
+
   def test_empty_constructor
     foo, = compile(<<-EOF)
       class Foo6

data/test/jvm/enumerable_test.rb

@@ -135,7 +135,7 @@ class EnumerableTest < Test::Unit::TestCase
     end
   end
 
-  def test_times
+  def test_times_with_arg
     cls, = compile(<<-EOF)
       def foo(i:int)
         i.times {|x| System.out.println x }
@@ -145,7 +145,9 @@ class EnumerableTest < Test::Unit::TestCase
     assert_output("0\n1\n2\n") do
       cls.foo(3)
     end
+  end
 
+  def test_times_without_arg
     cls, = compile(<<-EOF)
       def foo(i:int)
         i.times { System.out.println "Hi" }
@@ -157,7 +159,7 @@ class EnumerableTest < Test::Unit::TestCase
     end
   end
 
-  def test_general_loop
+  def test_normal_while_loop
     cls, = compile(<<-EOF)
       def foo(x:boolean)
         a = StringBuilder.new
@@ -168,7 +170,9 @@ class EnumerableTest < Test::Unit::TestCase
       end
     EOF
     assert_equal("", cls.foo(false))
+  end
 
+  def test_postfix_while_loop
     cls, = compile(<<-EOF)
       def foo
         a = StringBuilder.new
@@ -179,7 +183,9 @@ class EnumerableTest < Test::Unit::TestCase
       end
     EOF
     assert_equal("<body>", cls.foo)
+  end
 
+  def test_general_loop
     cls, = compile(<<-EOF)
       def foo(x:boolean)
         a = StringBuilder.new
@@ -239,8 +245,7 @@ class EnumerableTest < Test::Unit::TestCase
     assert_equal("<init><pre><post><pre><body><post>", cls.foo)
   end
 
-
-    def test_each
+  def test_each
     cls, = compile(<<-EOF)
       def foo
         [1,2,3].each {|x| System.out.println x}
@@ -260,7 +265,6 @@ class EnumerableTest < Test::Unit::TestCase
     assert_output("thrice\nthrice\nthrice\n") do
       cls.foo
     end
-
   end
 
   def test_any
@@ -276,7 +280,7 @@ class EnumerableTest < Test::Unit::TestCase
     end
   end
 
-  def test_all
+  def test_all_empty_block_and_not_with_cast
     cls, = compile(<<-EOF)
       import java.lang.Integer
       def foo
@@ -287,7 +291,8 @@ class EnumerableTest < Test::Unit::TestCase
     assert_output("true\nfalse\n") do
       cls.foo
     end
-
+  end
+  def test_all_with_block_with_no_cast
     cls, = compile(<<-EOF)
       def foo
         System.out.println [1,2,3].all? {|x| x.intValue > 3}
@@ -298,6 +303,130 @@ class EnumerableTest < Test::Unit::TestCase
     end
   end
 
+  def test_map
+    cls, = compile(<<-EOF)
+      def foo
+        System.out.println [1,2,3].map {|x:Integer| x.intValue + 1}
+        System.out.println [1,2,3].map {|x| x}
+        System.out.println [1].map { 'a' }
+        System.out.println [].map { 'b' }
+      end
+    EOF
+    assert_output("[2, 3, 4]\n[1, 2, 3]\n[a]\n[]\n") do
+      cls.foo
+    end
+  end
+
+  def test_zip
+    cls, = compile(<<-'EOF')
+      def bar
+        [1,2,3].zip([4]) {|x, y| puts "#{x}, #{y}"}
+      end
+    EOF
+    assert_output("1, 4\n2, null\n3, null\n") do
+      cls.bar
+    end
+
+    cls, = compile(<<-'EOF')
+      def foo
+        [1,2,3].zip([4, 5, 6]) do |x:Integer, y:Integer|
+          puts "#{x} + #{y} = #{x.intValue + y.intValue}"
+        end
+      end
+    EOF
+    assert_output("1 + 4 = 5\n2 + 5 = 7\n3 + 6 = 9\n") do
+      cls.foo
+    end
+  end
+
+  def test_reduce_with_string_array
+    cls, = compile(<<-'EOF')
+      def foo
+        x = ["a", "b", "c"].reduce {|a, b| "#{a}#{b}"}
+        puts x
+      end
+    EOF
+    assert_output("abc\n") do
+      cls.foo
+    end
+  end
+
+  def test_reduce_with_multiple_typed_block_parameters
+    cls, = compile(<<-'EOF')
+      def foo
+        puts [1, 2, 3].reduce {|a:Integer, b:Integer| Integer.new(a.intValue + b.intValue)}
+      end
+    EOF
+    assert_output("6\n") do
+      cls.foo
+    end
+  end
+
+  def test_reduce_with_one_typed_block_parameters
+    cls, = compile(<<-'EOF')
+      def foo
+        puts ["a", "b", "c"].reduce {|a:Integer| "#{a}a"}
+      end
+    EOF
+    assert_output("aaa\n") do
+      cls.foo
+    end
+  end
+
+  def test_reduce_with_no_arguments
+    cls, = compile(<<-'EOF')
+      def foo
+        ["a", "b", "c"].reduce {puts "x"}
+      end
+    EOF
+    assert_output("x\nx\n") do
+      cls.foo
+    end
+  end
+
+  def test_reduce_of_single_element_list_does_not_execute_block
+   cls, = compile(<<-'EOF')
+      def foo
+        puts ["a"].reduce { puts "x"}
+      end
+    EOF
+    assert_output("a\n") do
+      cls.foo
+    end
+  end
+
+  def test_reduce_of_empty_list_with_some_variable_name_as_outer_scope_does_not_effect_outer_scope
+    cls, = compile(<<-'EOF')
+      def foo
+        a = "foo"
+        [].reduce {|a| "#{a}a"}
+        puts a
+      end
+    EOF
+    assert_output("null\n") do
+      cls.foo
+    end
+  end
+
+  def test_reduce_with_int_array
+    if compiler_name == 'new'
+      cls, = compile(<<-'EOF')
+        def baz
+          a = int[3]
+          a[0] = 1
+          a[1] = 2
+          a[2] = 4
+          puts a.reduce {|x, y| x * y}
+        end
+      EOF
+      assert_output("8\n") do
+        cls.baz
+      end
+    else
+      pend 'Generated bad bytecode'
+    end
+  end
+
   def test_mirah_iterable
     cls, = compile(<<-EOF)
       import java.util.Iterator