mirah 0.1.4-java → 0.2.0-java

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

@@ -0,0 +1,12 @@
+package org.foo;
+
+public class InnerInterfaceClass {
+  public static interface InnerInterface {
+    public void foo(Object a);
+  }
+  
+  public static void forward(Object param,InnerInterface i) {
+    i.foo(param);
+  }
+}
+

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

@@ -0,0 +1,10 @@
+package org.foo;
+
+import java.util.List;
+import java.util.concurrent.CompletableFuture;
+
+public class TypeFixtureJava8 {
+    public CompletableFuture<List<Runnable>> load(List filter, int flags){
+        return null;
+    }
+}

data/test/fixtures/utf8_test.mirah

@@ -0,0 +1,7 @@
+class Кирилица
+  def тест
+  end
+  def self.main(args:String[]):void
+    puts 'default utf8 encoding test'
+  end
+end

data/test/jvm/access_levels_test.rb

@@ -0,0 +1,31 @@
+# Copyright (c) 2015 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 'test_helper'
+
+class AccessLevelsTest < Test::Unit::TestCase
+  def test_private_method_inaccessible_externally
+    cls, = compile("private def foo; a = 1; a; end; def bar; foo; end")
+
+    assert_raise NoMethodError  do
+      cls.foo
+    end
+  end
+
+  def test_private_method_accessible_internally
+    cls, = compile("private def foo; a = 1; a; end; def bar; foo; end")
+
+    assert_equal 1, cls.bar
+  end
+end

data/test/jvm/annotations_test.rb

@@ -50,10 +50,9 @@ class AnnotationsTest < Test::Unit::TestCase
       puts anno.value
     EOF
 
-    assert_output "1\n" do
-      cls.main nil
-    end
+    assert_run_output("1\n", cls)
   end
+
   def test_annotation_from_constant
     return
     cls, = compile(<<-EOF)
@@ -69,9 +68,7 @@ class AnnotationsTest < Test::Unit::TestCase
       puts anno.value
     EOF
 
-    assert_output "1\n" do
-      cls.main nil
-    end
+    assert_run_output("1\n", cls)
   end
 
 end

data/test/jvm/blocks_test.rb

@@ -70,9 +70,7 @@ class BlocksTest < Test::Unit::TestCase
         puts "Uh Oh!"
       end
     EOF
-    assert_output("Hello\n") do
-      cls.main([].to_java :string)
-    end
+    assert_run_output("Hello\n", cls)
   end
 
   def test_arg_types_inferred_from_interface
@@ -88,9 +86,7 @@ class BlocksTest < Test::Unit::TestCase
       o.addObserver {|x, a| puts a}
       o.notifyObservers("Hello Observer")
     EOF
-    assert_output("Hello Observer\n") do
-      script.main([].to_java :string)
-    end
+    assert_run_output("Hello Observer\n", script)
   end
 
   def test_closure
@@ -159,9 +155,7 @@ class BlocksTest < Test::Unit::TestCase
       list.each {|x| puts x }
     EOF
 
-    assert_output("a\nABC\nb\nCats\n") do
-      cls.main(nil)
-    end
+    assert_run_output("a\nABC\nb\nCats\n", cls)
   end
 
   def test_block_with_abstract_from_object
@@ -196,8 +190,82 @@ class BlocksTest < Test::Unit::TestCase
         puts "never get here"
       end
     EOF
-    assert_output("an object\n") do
-      cls.main(nil)
+    assert_run_output("an object\n", cls)
+  end
+
+  def test_nesting_with_abstract_class
+    pend 'test_nesting_with_abstract_class' do
+      cls, main = compile(%q{
+      abstract class Nestable
+        abstract def foo(n: Nestable):void;end
+        def create(n: Nestable):void
+           puts "create #{n}"
+           n.foo(n)
+        end
+
+        def toString:String
+           "nestable"
+        end
+      end
+
+      class Main
+        def self.create(b: Nestable):void
+          b.foo(b)
+        end
+
+        def self.main(args: String[]):void
+          create do |x:Nestable|
+            puts "outer foo"
+            create do |m: Nestable|
+              puts "in foo #{m}"
+            end
+          end
+        end
+      end
+})
+      assert_output "outer foo\ncreate nestable\nin foo nestable\n" do
+        main.main([])
+      end
+    end
+  end
+
+  def test_use_abstract_inplace
+      pend "test_use_abstract_inplace" do
+      #with_finest_logging {
+      cls, main, parent =  compile(%q{
+      abstract class A < P
+
+        def self.empty:A
+          create do
+            puts "empty"
+          end
+        end
+
+        def self.create(n: A):void
+           puts "create #{n}"
+           n.execute
+        end
+
+      end
+
+      class Main
+        def self.create(b: Nestable = A.empty):void
+          b.execute
+        end
+
+        def self.main(args: String[]):void
+          create
+          create { puts "not empty"}
+        end
+      end
+
+      abstract class P
+        abstract def execute:void;end
+      end
+})
+      assert_output "outer foo\ncreate nestable\nin foo nestable\n" do
+        main.main([])
+      end
     end
   end
 
@@ -212,9 +280,7 @@ class BlocksTest < Test::Unit::TestCase
 
       foo('there')
     EOF
-    assert_output("Hello there\n") do
-      cls.main(nil)
-    end
+    assert_run_output("Hello there\n", cls)
   end
 
   def test_block_with_mirah_interface
@@ -273,9 +339,7 @@ class BlocksTest < Test::Unit::TestCase
           puts "hi"
         end
         CODE
-    assert_output "hi\n" do
-      cls.main(nil)
-    end
+    assert_run_output("hi\n", cls)
   end
 
   def test_block_with_too_many_params
@@ -300,7 +364,6 @@ class BlocksTest < Test::Unit::TestCase
   end
 
   def test_call_with_block_assigned_to_macro
-    #cls, = with_finest_logging{compile(<<-CODE)}
     cls, = compile(<<-CODE)
         class S
           def initialize(run: Runnable)
@@ -317,9 +380,7 @@ class BlocksTest < Test::Unit::TestCase
           puts b
         end
       CODE
-    assert_output "hey\n{wut=1}\n1\n" do
-      cls.main(nil)
-    end
+    assert_run_output("hey\n{wut=1}\n1\n", cls)
   end
 
   def test_nested_closure_in_closure_doesnt_raise_error
@@ -338,36 +399,121 @@ class BlocksTest < Test::Unit::TestCase
           end
         end
       CODE
-    assert_output "first closure\nsecond closure\n" do
-      cls.main(nil)
-    end
+    assert_run_output("first closure\nsecond closure\n", cls)
   end
 
   def test_nested_closure_with_var_from_outer_closure
-    pend "bindings in nested closures are incorrectly generated" do
-      #cls, = with_finest_logging{compile(<<-'CODE')}
-      cls, = compile(<<-'CODE')
-        interface BarRunner do;def run:void;end;end
+    cls, = compile(<<-'CODE')
+      interface BarRunner do;def run:void;end;end
 
-        class Nestable
-          def foo(a:BarRunner)
-            a.run
-          end
+      class Nestable
+        def foo(a:BarRunner)
+          a.run
         end
+      end
+      Nestable.new.foo do
+        c = "closure"
+        puts "first #{c}"
         Nestable.new.foo do
-          c = "closure"
-          puts "first #{c}"
-          Nestable.new.foo do
-            puts "second #{c}"
+          puts "second #{c}"
+        end
+      end
+    CODE
+    assert_run_output("first closure\nsecond closure\n", cls)
+  end
+
+  def test_nested_closure_with_nested_closed_over_args
+    cls, = compile(<<-'CODE')
+      interface Jogger do;def jog(pace:int):void;end;end
+
+      class Nestable
+        def foo(pace: int, a: Jogger)
+          a.jog(pace)
+        end
+      end
+      Nestable.new.foo 10 do |pace|
+        puts "first #{pace}"
+        Nestable.new.foo 20 do |inner_pace|
+          puts "second #{pace} #{inner_pace}"
+        end
+      end
+    CODE
+    assert_run_output("first 10\nsecond 10 20\n", cls)
+  end
+
+  def test_nested_closure_with_nested_closed_over_args2
+    cls, = compile(%q[
+      interface Jogger do;def jog(param:int):void;end;end
+      
+      class Nestable
+        def operate(blub: int, a: Jogger):void
+          a.jog(blub)
+        end
+      end
+      
+      class Bar
+        def baz(foo:int):void
+          puts "bazstart"
+          Nestable.new.operate(10) do |arg1|
+            puts "first #{arg1} #{foo}"
+            Nestable.new.operate 20 do |inner_pace|
+              puts "second #{arg1} #{inner_pace} #{foo}"
+            end
+            Nestable.new.operate 30 do |inner_pace2|
+              puts "third #{arg1} #{inner_pace2}  #{foo}"
+            end
           end
         end
-      CODE
-      assert_output "first closure\nsecond closure\n" do
-        cls.main(nil)
       end
-    end
+      
+      Bar.new.baz(4)
+    ])
+    assert_run_output("bazstart\nfirst 10 4\nsecond 10 20 4\nthird 10 30  4\n", cls)
   end
 
+  def test_two_closures_capture_different_variables
+    cls, = compile(%q[
+      interface Jogger do;def jog(param:int):void;end;end
+      
+      class Nestable
+        def operate(blub: int, a: Jogger):void
+          a.jog(blub)
+        end
+      end
+      
+      class Bar
+        def baz(foo:int):void
+          puts "bazstart"
+          bar = 7
+          Nestable.new.operate(40) do |arg1|
+            puts bar
+          end
+          Nestable.new.operate(10) do |arg1|
+            puts "first #{arg1} #{foo}"
+          end
+        end
+      end
+      
+      Bar.new.baz(4)
+    ])
+    assert_run_output("bazstart\n7\nfirst 10 4\n", cls)
+  end
+
+  def test_uncastable_block_arg_type_fails
+    error = assert_raises Mirah::MirahError do
+      compile(<<-EOF)
+        import java.io.OutputStream
+        def foo x:OutputStream
+          x.write byte(1)
+        rescue
+        end
+        foo do |b:String|
+          puts "writing"
+        end
+      EOF
+    end
+    assert_equal "Cannot cast java.lang.String to int.", error.message
+  end
 
   def test_method_requiring_subclass_of_abstract_class_finds_abstract_method
     cls, = compile(<<-EOF)
@@ -380,9 +526,7 @@ class BlocksTest < Test::Unit::TestCase
         puts "writing"
       end
     EOF
-    assert_output "writing\n" do
-      cls.main(nil)
-    end
+    assert_run_output("writing\n", cls)
   end
 
   def test_block_with_interface_method_with_2_arguments_with_types
@@ -401,9 +545,7 @@ class BlocksTest < Test::Unit::TestCase
         puts b
       end
     EOF
-    assert_output "hello\n1243\n" do
-      cls.main(nil)
-    end
+    assert_run_output("hello\n1243\n", cls)
   end
 
   def test_block_with_interface_method_with_2_arguments_without_types
@@ -422,11 +564,23 @@ class BlocksTest < Test::Unit::TestCase
         puts b
       end
     EOF
-    assert_output "hello\n1243\n" do
-      cls.main(nil)
-    end
+    assert_run_output("hello\n1243\n", cls)
   end
 
+  def test_closures_with_static_imports
+    cls, = compile(<<-EOF)
+      def foo a:Runnable
+        a.run
+      end
+      foo do
+        x = [2,1]
+        import static java.util.Collections.*
+        sort x
+        puts x
+      end
+    EOF
+    assert_run_output("[1, 2]\n", cls)
+  end
 
   def test_closures_support_non_local_return
     pend "nlr doesnt work right now" do
@@ -443,9 +597,7 @@ class BlocksTest < Test::Unit::TestCase
       end
       puts nlr
     EOF
-    assert_output "NLR!\n" do
-      cls.main(nil)
-    end
+    assert_run_output("NLR!\n", cls)
     end
   end
 
@@ -464,9 +616,7 @@ class BlocksTest < Test::Unit::TestCase
       end
       puts nlr
     EOF
-    assert_output "1234\n" do
-      cls.main(nil)
-    end
+    assert_run_output("1234\n", cls)
     end
   end
 
@@ -503,9 +653,7 @@ class BlocksTest < Test::Unit::TestCase
       foo { return }
       puts "or here"
     EOF
-    assert_output "before\n" do
-      cls.main(nil)
-    end
+    assert_run_output("before\n", cls)
     end
   end
 
@@ -526,9 +674,7 @@ class BlocksTest < Test::Unit::TestCase
       end
       puts ClosureInMethodInClass.new.nlr
     EOF
-    assert_output "before\n1234\n" do
-      cls.main(nil)
-    end
+    assert_run_output("before\n1234\n", cls)
     end
   end
 
@@ -548,9 +694,7 @@ class BlocksTest < Test::Unit::TestCase
       end
       ClosureInVoidMethodInClass.new.nlr
     EOF
-    assert_output "before\n" do
-      cls.main(nil)
-    end
+    assert_run_output("before\n", cls)
     end
   end
 
@@ -570,9 +714,7 @@ class BlocksTest < Test::Unit::TestCase
       puts nlr true
       puts nlr false
     EOF
-    assert_output "NLR!\nNLArrrr\n" do
-      cls.main(nil)
-    end
+    assert_run_output("NLR!\nNLArrrr\n", cls)
     end
   end
 
@@ -596,9 +738,7 @@ class BlocksTest < Test::Unit::TestCase
       puts nlr true
       puts nlr false
     EOF
-    assert_output "NLR!\nNLArrrr\n" do
-      cls.main(nil)
-    end
+    assert_run_output("NLR!\nNLArrrr\n", cls)
     end
   end
 
@@ -620,9 +760,7 @@ class BlocksTest < Test::Unit::TestCase
       puts nlr true
       puts nlr false
     EOF
-    assert_output "NLR!\nmay get here\nNLArrrr\n" do
-      cls.main(nil)
-    end
+    assert_run_output("NLR!\nmay get here\nNLArrrr\n", cls)
     end
   end
 
@@ -648,33 +786,27 @@ class BlocksTest < Test::Unit::TestCase
       Huh.new.wut(Huh.new.regular)
     EOF
 
-    assert_output "Closure!\nfinish\n" do
-      cls.main(nil)
-    end
+    assert_run_output("Closure!\nfinish\n", cls)
   end
 
 
   def test_closure_with_or
-    cls, = with_finest_logging{compile(<<-EOF)}
-    def r(run: Runnable) run.run; end
+    cls, = compile(<<-EOF)
+    def r(run: java.lang.Runnable) run.run; end
     r { puts "a" || "b"}
     EOF
 
-    assert_output "a\n" do
-      cls.main(nil)
-    end
+    assert_run_output("a\n", cls)
   end
 
   def test_closure_with_or_ii
-    cls, = with_finest_logging{compile(<<-EOF)}
+    cls, = compile(<<-EOF)
     interface C; def c(): String;end;end
     def r(cee: C) puts cee.c; end
     r { "a" || "b"}
     EOF
 
-    assert_output "a\n" do
-      cls.main(nil)
-    end
+    assert_run_output("a\n", cls)
   end
 
   def test_two_closures_in_the_same_method
@@ -689,9 +821,7 @@ class BlocksTest < Test::Unit::TestCase
       end
       regular
     EOF
-    assert_output "Closure!\nWe Want it\n" do
-      cls.main(nil)
-    end
+    assert_run_output("Closure!\nWe Want it\n", cls)
   end
 
   def test_closures_in_a_rescue
@@ -710,9 +840,7 @@ class BlocksTest < Test::Unit::TestCase
       end
       regular
     EOF
-    assert_output "Closure!\nWe Want it\n" do
-      cls.main(nil)
-    end
+    assert_run_output("Closure!\nWe Want it\n", cls)
   end
 
   def test_lambda_with_type_defined_before
@@ -723,24 +851,18 @@ class BlocksTest < Test::Unit::TestCase
       x = lambda(Fooable) { puts "hey you" }
       x.foo
     EOF
-    assert_output "hey you\n" do
-      cls.main(nil)
-    end
+    assert_run_output("hey you\n", cls)
   end
 
   def test_lambda_with_type_defined_later
-    pend "I think it'd be nice if this worked" do
-      cls, = compile(<<-EOF)
-        x = lambda(Fooable) { puts "hey you" }
-        interface Fooable
-          def foo: void; end
-        end
-        x.foo
-      EOF
-      assert_output "hey you\n" do
-        cls.main(nil)
+    cls, = compile(<<-EOF)
+      x = lambda(Fooable) { puts "hey you" }
+      interface Fooable
+        def foo: void; end
       end
-    end
+      x.foo
+    EOF
+    assert_run_output("hey you\n", cls)
   end
 
   def test_closure_with_primitive_array_param
@@ -753,28 +875,89 @@ class BlocksTest < Test::Unit::TestCase
       end
       r {|b| puts String.new(b) }
     EOF
-    assert_output "yay\n" do
-      cls.main(nil)
-    end
+    assert_run_output("yay\n", cls)
   end
 
 
+  def test_block_syntax_for_anonymous_class_implementing_inner_interface
+    cls, = compile('
+      import org.foo.InnerInterfaceClass
+      
+      InnerInterfaceClass.forward("foo") do |param|
+        puts param
+      end
+    ')
+    assert_run_output("foo\n", cls)
+  end
+
+  def test_block_syntax_for_abstract_class_invoke_self
+    omit_if JVMCompiler::JVM_VERSION.to_f < 1.8
+    cls, = compile('
+      import org.foo.AbstractExecutorJava8
+
+      AbstractExecutorJava8.execute do
+        puts "foo"
+      end
+    ')
+    assert_run_output("foo\n", cls)
+  end
+
   def test_lambda_closure
-    pend "not working yet" do
-      cls, = compile(<<-EOF)
-        def r b: Runnable
-          b.run
-        end
-        msg = "yay"
-        l = lambda(Runnable) { puts msg }
-        r l
-      EOF
-      assert_output "yay\n" do
-        cls.main(nil)
+    cls, = compile(<<-EOF)
+      def r b: Runnable
+        b.run
       end
-    end
+      msg = "yay"
+      l = lambda(Runnable) { puts msg }
+      r l
+    EOF
+    assert_run_output("yay\n", cls)
   end
 
+
+  def test_binding_in_class_definition_has_right_namespace
+    classes = compile(<<-'EOF')
+      package test
+      class Something
+        def create(a: Runnable):void
+          a.run
+        end
+        def with_binding
+          loc = 1
+          create do
+            puts "test #{loc}"
+          end
+        end
+      end
+    EOF
+    class_names = classes.map(&:java_class).map(&:name)
+    pattern = /test\.Something\$.*?Binding\d*/
+    assert class_names.find{|c| c.match pattern },
+      "generated classes: #{class_names} didn't contain #{pattern}."
+  end
+
+
+  def test_binding_in_script_has_right_namespace
+    classes = compile(<<-'EOF', name: 'MyScript')
+      def create(a: Runnable):void
+        a.run
+      end
+      def with_binding
+        loc = 1
+        create do
+          puts "test #{loc}"
+        end
+      end
+    EOF
+    class_names = classes.map(&:java_class).map(&:name)
+    pattern = /MyScriptTopLevel\$.*?Binding\d*/
+
+    assert class_names.find{|c| c.match pattern },
+      "generated classes: #{class_names} didn't contain #{pattern}."
+  end
+
+
+
   # nested nlr scopes
 
 # works with script as end