mirah 0.0.12-java → 0.1.0-java

data/test/core/util/argument_processor_test.rb

@@ -27,16 +27,16 @@ class ArgumentProcessorTest < Test::Unit::TestCase
     assert_equal 1, processor.exit_status_code
   end
 
-  def test_arg_bootclasspath_sets_bootclasspath_on_type_factory_ugh
-    Mirah::AST.type_factory = Mirah::JVM::Types::TypeFactory.new # global state grumble grumble
-
-    path = "class:path"
-    state = Mirah::Util::CompilationState.new
-    processor = Mirah::Util::ArgumentProcessor.new state, ["--bootclasspath", path]
-    processor.process
-
-    assert_equal path, Mirah::AST.type_factory.bootclasspath
-  end
+#  def test_arg_bootclasspath_sets_bootclasspath_on_type_factory_ugh
+#    Mirah::AST.type_factory = Mirah::JVM::Types::TypeFactory.new # global state grumble grumble
+#
+#    path = "class:path"
+#    state = Mirah::Util::CompilationState.new
+#    processor = Mirah::Util::ArgumentProcessor.new state, ["--bootclasspath", path]
+#    processor.process
+#
+#    assert_equal path, Mirah::AST.type_factory.bootclasspath
+#  end
 
   def test_dash_j_fails_when_not_compiling
     state = Mirah::Util::CompilationState.new

data/test/core/util/class_loader_test.rb

@@ -16,13 +16,14 @@ class ClassLoaderTest < Test::Unit::TestCase
   def test_mirah_class_loader_w_missing_class_raises_class_not_found
     class_loader = Mirah::Util::ClassLoader.new nil, {}
 
-    ex = assert_raise NativeException do
-      class_loader.find_class 'org.doesnt.exist.Class'
+    begin
+      klass = class_loader.find_class 'org.doesnt.exist.Class'
+      fail 'Expected ClassNotFoundException'
+    rescue java.lang.ClassNotFoundException
+      # expected
     end
-    assert_equal java.lang.ClassNotFoundException, ex.cause.class
   end
-  
-  
+
   def test_isolated_resource_loader_only_finds_resources_given_to_it
     loader = Mirah::Util::IsolatedResourceLoader.new [java.net.URL.new("file:#{FIXTURES}")]
     url = loader.get_resource "my.properties"

data/test/fixtures/org/foo/LowerCaseInnerClass.java

@@ -0,0 +1,7 @@
+package org.foo;
+
+public class LowerCaseInnerClass {
+    public static final class inner {
+	public static final int field = 1234;
+    }
+}

data/test/jvm/annotations_test.rb

@@ -14,16 +14,16 @@ class AnnotationsTest < Test::Unit::TestCase
     assert_not_nil cls.java_class.java_method('foo').annotation(deprecated)
     assert_nil cls.java_class.annotation(deprecated)
   end
-  
+
   def test_annotation_on_a_class
-    script, cls = compile(<<-EOF)
+    cls, = compile(<<-EOF)
       $Deprecated
       class Annotated
       end
     EOF
     assert_not_nil cls.java_class.annotation(deprecated)
   end
-  
+
   def test_annotation_on_a_field
     cls, = compile(<<-EOF)
       class AnnotatedField
@@ -36,7 +36,7 @@ class AnnotationsTest < Test::Unit::TestCase
 
     assert_not_nil cls.java_class.declared_fields[0].annotation(deprecated)
   end
-  
+
   def test_annotation_with_an_integer
     jruby_method = Java::OrgJrubyAnno::JRubyMethod.java_class
 
@@ -46,7 +46,7 @@ class AnnotationsTest < Test::Unit::TestCase
       import org.jruby.runtime.*
       import org.jruby.runtime.builtin.*
 
-      $JRubyMethod["name" => "bar", "optional" => 1]
+      $JRubyMethod["name" => ["bar"], "optional" => 1]
       def bar(baz:int)
       end
     EOF

data/test/jvm/blocks_test.rb

@@ -15,12 +15,6 @@
 
 class BlocksTest < Test::Unit::TestCase
 
-  def setup
-    super
-    clear_tmp_files
-    reset_type_factory
-  end
-  
   def parse_and_type code, name=tmp_script_name
     parse_and_resolve_types name, code
   end
@@ -30,8 +24,9 @@ class BlocksTest < Test::Unit::TestCase
     assert_nothing_raised do
       parse_and_type(<<-CODE)
         interface Bar do;def run:void;end;end
-      
+
         class Foo
+          def initialize; end
           def foo(a:Bar)
             1
           end
@@ -41,34 +36,16 @@ class BlocksTest < Test::Unit::TestCase
       CODE
     end
   end
-  
+
   def test_non_empty_block_parses_and_types_without_error
     assert_nothing_raised do
       parse_and_type(<<-CODE)
-        interface Bar do;def run:void;end;end
-      
-        class Foo
-          def foo(a:Bar)
-            1
-          end
-        end
-        Foo.new.foo do
-          1
+        interface Bar
+          def run:void; end
         end
-      CODE
-    end
-  end
 
-
-  def test_block_impling_interface_w_multiple_methods
-    assert_raises Mirah::NodeError do
-      parse_and_type(<<-CODE)
-        interface Bar do
-          def run:void;end
-          def run2:void;end;
-        end
-        
         class Foo
+          def initialize; end
           def foo(a:Bar)
             1
           end
@@ -76,93 +53,59 @@ class BlocksTest < Test::Unit::TestCase
         Foo.new.foo do
           1
         end
-        CODE
+      CODE
     end
   end
 
-  def test_block_with_no_params_on_interface_with
-    assert_raises Mirah::NodeError do
-      parse_and_type(<<-CODE)
-        interface Bar do
-          def run(a:string):void;end
-        end
-        
-        class Foo
-          def foo(a:Bar)
-            1
-          end
-        end
-        Foo.new.foo do
-          1
-        end
-        CODE
-      end
-  end
-
-  def test_block_with_too_many_params
-    assert_raises Mirah::NodeError do
-      parse_and_type(<<-CODE)
-        interface Bar do
-          def run(a:string):void;end
-        end
-        
-        class Foo
-          def foo(a:Bar)
-            1
-          end
-        end
-        Foo.new.foo do |a, b|
-          1
-        end
-        CODE
-      end
-  end
 
-  def test_block
+  def test_simple_block
     cls, = compile(<<-EOF)
       thread = Thread.new do
-        puts "Hello"
+        System.out.println "Hello"
       end
       begin
         thread.run
         thread.join
       rescue
-        puts "Uh Oh!"
+        System.out.println "Uh Oh!"
       end
     EOF
     assert_output("Hello\n") do
       cls.main([].to_java :string)
     end
+  end
 
+  def test_arg_types_inferred_from_interface
     script, cls = compile(<<-EOF)
       import java.util.Observable
       class MyObservable < Observable
         def initialize
-          super
           setChanged
         end
       end
 
       o = MyObservable.new
-      o.addObserver {|x, a| puts a}
+      o.addObserver {|x, a| System.out.println a}
       o.notifyObservers("Hello Observer")
     EOF
     assert_output("Hello Observer\n") do
       script.main([].to_java :string)
     end
+  end
 
+  def test_closure
     cls, = compile(<<-EOF)
       def foo
         a = "Hello"
         thread = Thread.new do
-          puts a
+          System.out.println a
         end
         begin
           a = a + " Closures"
           thread.run
           thread.join
         rescue
-          puts "Uh Oh!"
+          System.out.println "Uh Oh!"
         end
         return
       end
@@ -170,7 +113,9 @@ class BlocksTest < Test::Unit::TestCase
     assert_output("Hello Closures\n") do
       cls.foo
     end
+  end
 
+  def test_int_closure
     cls, = compile(<<-EOF)
       def run(x:Runnable)
         x.run
@@ -197,7 +142,7 @@ class BlocksTest < Test::Unit::TestCase
           String(a).compareToIgnoreCase(String(b))
         end
       end
-      list.each {|x| puts x}
+      list.each {|x| System.out.println x}
     EOF
 
     assert_output("a\nABC\nb\nCats\n") do
@@ -209,33 +154,32 @@ class BlocksTest < Test::Unit::TestCase
     # Comparator interface also defines equals(Object) as abstract,
     # but it can be inherited from Object. We test that here.
     cls, = compile(<<-EOF)
-      import java.util.ArrayList
       import java.util.Collections
-      list = ArrayList.new(["a", "ABC", "Cats", "b"])
-      Collections.sort(list) do |a, b|
-        String(a).compareToIgnoreCase(String(b))
+      import java.util.List
+      def sort(l:List)
+        Collections.sort(l) do |a:Object, b:Object|
+          String(a).compareToIgnoreCase(String(b))
+        end
+        l
       end
-      list.each {|x| puts x}
     EOF
 
-    assert_output("a\nABC\nb\nCats\n") do
-      cls.main(nil)
-    end
+    assert_equal(["a", "ABC", "b", "Cats"], cls.sort(["a", "ABC", "Cats", "b"]))
   end
-  
+
   def test_block_with_no_arguments_and_return_value
     cls, = compile(<<-EOF)
       import java.util.concurrent.Callable
       def foo c:Callable
-        throws Exception
-         puts c.call
+        # throws Exception
+         System.out.println c.call
       end
       begin
       foo do
         "an object"
       end
       rescue
-        puts "never get here"
+        System.out.println "never get here"
       end
     EOF
     assert_output("an object\n") do
@@ -243,10 +187,118 @@ class BlocksTest < Test::Unit::TestCase
     end
   end
 
+  def test_parameter_used_in_block
+    cls, = compile(<<-EOF)
+      def foo(x:String):void
+        thread = Thread.new do
+          System.out.println "Hello \#{x}"
+        end
+        begin
+          thread.run
+          thread.join
+        rescue
+          System.out.println "Uh Oh!"
+        end
+      end
+
+      foo('there')
+    EOF
+    assert_output("Hello there\n") do
+      cls.main(nil)
+    end
+  end
+
+  def test_block_with_mirah_interface
+    cls, interface = compile(<<-EOF)
+      interface MyProc do
+        def call:void; end
+      end
+      def foo(b:MyProc)
+        b.call
+      end
+      def bar
+        foo {System.out.println "Hi"}
+      end
+    EOF
+    assert_output("Hi\n") do
+      cls.bar
+    end
+  end
+
+  def assert_jraise(klass)
+    assert_block("#{klass} expected, but none thrown") do
+      begin
+        yield
+      rescue klass
+        break
+      end
+      false
+    end
+  end
+
+  def test_block_impling_interface_w_multiple_methods
+    assert_jraise java.lang.UnsupportedOperationException do
+      parse_and_type(<<-CODE)
+        interface Bar do
+          def run:void;end
+          def run2:void;end;
+        end
+
+        class Foo
+          def foo(a:Bar)
+            1
+          end
+        end
+        Foo.new.foo do
+          1
+        end
+        CODE
+    end
+  end
+
+  def test_block_with_missing_params
+    cls, = compile(<<-CODE)
+        interface Bar do
+          def run(a:string):void;end
+        end
+
+        class TakesABar
+          def foo(a:Bar)
+            a.run("x")
+          end
+        end
+        TakesABar.new.foo do
+          puts "hi"
+        end
+        CODE
+    assert_output "hi\n" do
+      cls.main(nil)
+    end
+  end
+
+  def test_block_with_too_many_params
+    assert_raises Mirah::MirahError do
+      parse_and_type(<<-CODE)
+        interface SingleArgMethod do
+          def run(a:string):void;end
+        end
+
+        class ExpectsSingleArgMethod
+          def foo(a:SingleArgMethod)
+            1
+          end
+        end
+        ExpectsSingleArgMethod.new.foo do |a, b|
+          1
+        end
+        CODE
+      end
+  end
+
   def test_closure_in_closure_doesnt_raise_error
     parse_and_type(<<-CODE)
         interface Bar do;def run:void;end;end
-      
+
         class Foo
           def foo(a:Bar)
             1

data/test/jvm/bytecode_test_helper.rb

@@ -16,135 +16,153 @@ require 'test_helper'
 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
-
-
-
 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 create_transformer
+
+  def new_state
     state = Mirah::Util::CompilationState.new
-    state.save_extensions = false
-    
-    transformer = Mirah::Transform::Transformer.new(state)
-    Java::MirahImpl::Builtin.initialize_builtins(transformer)
-    transformer
-  end
-  
-  def reset_type_factory
-    AST.type_factory = Mirah::JVM::Types::TypeFactory.new
+    state.save_extensions = true
+    state.destination = TEST_DEST
+    state.classpath =  TEST_DEST
+    state
   end
-  
-  def clear_tmp_files
-    File.unlink(*@tmp_classes)
-    @tmp_classes.clear
+
+  def clean_tmp_files
+    return unless @tmp_classes
+    File.unlink(*@tmp_classes.uniq)
   end
-  
-  def create_compiler
-    JVM::Compiler::JVMBytecode.new
+
+  def compiler_type
+    JVM::Compiler::JVMBytecode
   end
-  
+
   def parse name, code, transformer
     AST.parse(code, name, true, transformer)
   end
-  
-  def infer_and_resolve_types ast, transformer
-    typer = JVM::Typer.new(transformer)
-    
-    ast.infer(typer, true)
-    
-    typer.resolve(true)
+
+  def infer_and_resolve_types ast, generator
+    scoper, typer = generator.infer_asts(ast, true)
+    ast
   end
-  
-  def parse_and_resolve_types name, code    
-    transformer = create_transformer
-    
-    ast  = parse name, code, transformer
-    
-    infer_and_resolve_types ast, transformer
-    
+
+  def parse_and_resolve_types name, code
+    state = new_state
+
+    generator = Mirah::Generator.new(state, compiler_type, false, false)
+    transformer = Mirah::Transform::Transformer.new(state, generator.typer)
+
+    ast = [AST.parse(code, name, true, transformer)]
+
+    infer_and_resolve_types ast, generator
+
     ast
   end
-    
-  
-  def generate_classes compiler
+
+  def generate_classes compiler_results
     classes = {}
 
-    compiler.generate do |filename, builder|
-      bytes = builder.generate
+    compiler_results.each do |result|
+      bytes = result.bytes
+      filename = "#{TEST_DEST}#{result.filename}"
       FileUtils.mkdir_p(File.dirname(filename))
-      open("#{filename}", "wb") do |f|
-        f << bytes
-      end
-      classes[filename[0..-7]] = Mirah::Util::ClassLoader.binary_string bytes
+      File.open(filename, 'wb') { |f| f.write(bytes) }
+      @tmp_classes << filename
+      classes[result.filename[0..-7]] = Mirah::Util::ClassLoader.binary_string bytes
     end
 
     loader = Mirah::Util::ClassLoader.new(JRuby.runtime.jruby_class_loader, classes)
+
     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(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)
+
+    ast = AST.parse(code, name, true, transformer)
+
+    scoper, typer = generator.infer_asts([ast], true)
+    compiler_results = generator.compiler.compile_asts([ast], scoper, typer)
+
+    generate_classes compiler_results
   end
-  
-  def compile_ast  ast
-    compiler = create_compiler
-    compiler.compile(ast)
-    compiler
+
+  def tmp_script_name
+    "script#{name.gsub(/\)|\(/,'_').capitalize}#{System.nano_time}"
   end
-  
-  def compile(code, name = tmp_script_name)
-    clear_tmp_files
-    reset_type_factory
-    
-    ast = parse_and_resolve_types name, code
-    
-    compiler = compile_ast ast
-    
-    generate_classes compiler
+end
+
+
+module CommonAssertions
+  import java.lang.System
+  import java.io.PrintStream
+
+  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 tmp_script_name
-    "script" + System.nano_time.to_s
+
+  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 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
 
 class Test::Unit::TestCase
   include JVMCompiler
-  
+
   def setup
     @tmp_classes = []
   end
 
-  def teardown
-    reset_type_factory
-    clear_tmp_files
+  def cleanup
+    clean_tmp_files
   end
 end