mirah 0.1.4-java → 0.2.0-java

data/test/jvm/main_method_test.rb

@@ -8,8 +8,6 @@ class MainMethodTest < Test::Unit::TestCase
 
     main_class, = compile code, :name => 'with_main'
 
-    assert_output "bar\n" do
-      main_class.main(nil)
-    end
+    assert_run_output("bar\n", main_class)
   end
 end

data/test/jvm/new_backend_test_helper.rb

@@ -17,6 +17,7 @@ require 'test_helper'
 module JVMCompiler
   java_import 'org.mirah.tool.RunCommand'
   java_import 'org.mirah.util.SimpleDiagnostics'
+  
   System = java.lang.System
   JVM_VERSION = ENV['MIRAH_TEST_JVM_VERSION'] || '1.7'
 
@@ -24,7 +25,22 @@ module JVMCompiler
     java_import 'java.util.Locale'
     def report(diagnostic)
       if diagnostic.kind.name == "ERROR"
-        raise Mirah::MirahError, diagnostic.getMessage(Locale.getDefault)
+        source =  if diagnostic.source
+
+                    line_no = [0, diagnostic.getLineNumber - diagnostic.source.initial_line].max
+                    line = diagnostic.source.contents.lines.to_a[line_no]
+                    start_col = if line_no == 0
+                                  diagnostic.column_number - diagnostic.source.initial_column
+                                else
+                                  diagnostic.column_number - 1
+                                end
+                    end_col = [start_col + (diagnostic.end_position - diagnostic.start_position),
+                               line.size - 1].min
+                    line[start_col..end_col]
+                  else
+                    "<unknown>"
+                  end
+        raise Mirah::MirahError.new(diagnostic.getMessage(Locale.getDefault), source, diagnostic)
       end
       super
     end
@@ -38,13 +54,23 @@ module JVMCompiler
   def compile(code, options = {})
     name = options.fetch :name, tmp_script_name
 
-    java_version = options.fetch :java_version, JVMCompiler::JVM_VERSION
     args = ["-d", TEST_DEST,
             "--vmodule", "org.mirah.jvm.compiler.ClassCompiler=OFF",
+           # "--verbose",
             "--classpath", Mirah::Env.encode_paths([FIXTURE_TEST_DEST, TEST_DEST]) ]
+
+    java_version = options.fetch :java_version, JVMCompiler::JVM_VERSION
     if java_version
       args += ["--jvm", java_version]
     end
+    if options[:verbose]
+      args << '--verbose'
+    end
+    if options[:separate_macro_dest]
+      macro_dest = TEST_DEST.sub('classes','macro_classes')
+      args += ["--macro-dest", macro_dest,
+               "--macroclasspath", Mirah::Env.encode_paths([macro_dest])]
+    end
 
     cmd = build_command name, code
     compile_or_raise cmd, args
@@ -56,7 +82,13 @@ module JVMCompiler
 
   def build_command(name, code)
     cmd = RunCommand.new
-    cmd.addFakeFile(name, code)
+    if code.is_a?(Array)
+      code.each.with_index do |c,i|
+        cmd.addFakeFile("#{name}_#{i}", c)
+      end
+    else
+      cmd.addFakeFile(name, code)
+    end
     cmd.setDiagnostics(TestDiagnostics.new(false))
     cmd
   end
@@ -65,9 +97,6 @@ module JVMCompiler
     if 0 != cmd.compile(args)
       raise Mirah::MirahError, "Compilation failed"
     end
-  rescue => e
-    raise e.cause if e.respond_to?(:cause) && e.cause
-    raise e
   end
 
   def compiler_name
@@ -76,7 +105,11 @@ module JVMCompiler
 
   def clean_tmp_files
     return unless @tmp_classes
-    File.unlink(*@tmp_classes)
+    begin
+      File.unlink(*@tmp_classes)
+    rescue 
+      JavaFile.unlink *@tmp_classes      
+    end
   end
 
   def dump_class_files class_map
@@ -107,6 +140,20 @@ module JVMCompiler
     end
     ex
   end
+  
+  class JavaFile
+    java_import 'java.io.File'
+    
+    def self.unlink *files            
+      files.each do |f| 
+        jf = File.new(f)
+        unless jf.delete 
+          jf.deleteOnExit
+          puts "\nwarn: locked #{jf}"
+        end
+      end            
+    end
+  end
 end
 
 class Test::Unit::TestCase

data/test/jvm/rescue_test.rb

@@ -1,4 +1,4 @@
-# Copyright (c) 2010 The Mirah project authors. All Rights Reserved.
+# 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");
@@ -15,6 +15,23 @@
 
 class RescueTest < Test::Unit::TestCase
 
+  def test_rescue_with_import
+    cls, = compile(<<-EOF)
+      def foo
+        begin
+          raise "some error"
+        rescue Exception => e
+          import java.util.Collections
+          x = [3, 1, 2]
+          Collections.sort x
+          x
+        end
+      end
+    EOF
+
+    assert_equal [1, 2, 3], cls.foo.to_a
+  end
+
   def test_rescue_with_no_raise_runs_begin_and_not_rescue
     cls, = compile(<<-EOF)
       def foo
@@ -254,9 +271,7 @@ class RescueTest < Test::Unit::TestCase
         puts "else"
       end
     EOF
-    assert_output "else\n" do
-      cls.main nil
-    end
+    assert_run_output("else\n", cls)
   end
 
   def test_ensure
@@ -313,6 +328,6 @@ class RescueTest < Test::Unit::TestCase
     end
     EOF
 
-    assert_output("a\nb\nc\nensure\n") { cls.main(nil) }
+    assert_run_output("a\nb\nc\nensure\n", cls)
   end
 end

data/test/jvm/static_fields_test.rb

@@ -1,4 +1,4 @@
-# Copyright (c) 2014 The Mirah project authors. All Rights Reserved.
+# 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");
@@ -21,9 +21,7 @@ class StaticFieldsTest < Test::Unit::TestCase
       puts GregorianCalendar.AM
     EOF
 
-    assert_output "0\n" do
-      cls.main(nil)
-    end
+    assert_run_output("0\n", cls)
   end
 
   def test_static_field_inheritance_lookup_with_double_colon
@@ -34,9 +32,7 @@ class StaticFieldsTest < Test::Unit::TestCase
       puts GregorianCalendar::AM
     EOF
 
-    assert_output "0\n" do
-      cls.main(nil)
-    end
+    assert_run_output("0\n", cls)
     }
   end
 
@@ -45,8 +41,54 @@ class StaticFieldsTest < Test::Unit::TestCase
       CONSTANT = 1
       puts CONSTANT
     EOF
-    assert_output "1\n" do
-      cls.main(nil)
-    end
+    assert_run_output("1\n", cls)
+  end
+  
+  def test_static_final_constant
+    cls, = compile(<<-EOF)
+      class Bar
+      
+        static_final :serialVersionUID, -1234567890123456789
+        
+        class << self
+          def reflect
+            field = Bar.class.getDeclaredField("serialVersionUID")
+            puts field.getModifiers
+            puts field.get(nil)
+          end
+        end
+      end
+      
+      Bar.reflect
+    EOF
+    assert_run_output("26\n-1234567890123456789\n", cls)
+  end
+  
+  def test_transient
+    cls, = compile(%q[
+      class Bar implements java::io::Serializable
+      
+        static_final :serialVersionUID, -1234567890123456789
+        
+        transient :b
+        
+        def initialize(a:int,b:int)
+          @a = a
+          @b = b
+        end
+        
+        def toString
+          "Bar(#{@a},#{@b})"
+        end
+      end
+      
+      bout = java::io::ByteArrayOutputStream.new
+      oout = java::io::ObjectOutputStream.new(bout)
+      oout.writeObject(Bar.new(5,7))
+      oout.close
+      bin  = java::io::ObjectInputStream.new(java::io::ByteArrayInputStream.new(bout.toByteArray))
+      puts Bar(bin.readObject)
+    ])
+    assert_run_output("Bar(5,0)\n", cls) # b=7 should be forgotten, because b is a transient field. 
   end
 end

data/test/jvm/{mirror_compilation_test_helper.rb → string_test.rb}

@@ -1,4 +1,4 @@
-# Copyright (c) 2010 The Mirah project authors. All Rights Reserved.
+# 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");
@@ -12,13 +12,14 @@
 # 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
+class StringTest < Test::Unit::TestCase
+
+  def test_string_interpolation_subsequence
+    cls, = compile(%q[
+      puts "#{begin; "a"; "b"; "c"; end}"
+    ])
+    assert_run_output("c\n", cls)
   end
-end
+end
+

data/test/jvm/varargs_test.rb

@@ -1,4 +1,4 @@
-# Copyright (c) 2010 The Mirah project authors. All Rights Reserved.
+# 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");
@@ -19,36 +19,28 @@ class VarargsTest < Test::Unit::TestCase
     cls, = compile(<<-EOF)
       puts String.format("%s %s's", "rocking", "banana")
     EOF
-    assert_output "rocking banana's\n" do
-      cls.main nil
-    end
+    assert_run_output("rocking banana's\n", cls)
   end
 
   def test_varargs_method_with_passed_including_int_varargs
     cls, = compile(<<-EOF)
       puts String.format("%s %d's", "rocking", 3)
     EOF
-    assert_output "rocking 3's\n" do
-      cls.main nil
-    end
+    assert_run_output("rocking 3's\n", cls)
   end
 
   def test_varargs_method_with_passed_including_integer_varargs
     cls, = compile(<<-EOF)
       puts String.format("%s %d's", "rocking", Integer.valueOf(3))
     EOF
-    assert_output "rocking 3's\n" do
-      cls.main nil
-    end
+    assert_run_output("rocking 3's\n", cls)
   end
 
   def test_varargs_method_lookup_without_passed_varargs
     cls, = compile(<<-EOF)
       puts String.format("rocking with no args")
     EOF
-    assert_output "rocking with no args\n" do
-      cls.main nil
-    end
+    assert_run_output("rocking with no args\n", cls)
   end
 
   def test_varargs_method_lookup_when_passed_array
@@ -57,9 +49,7 @@ class VarargsTest < Test::Unit::TestCase
       args[0] = "an array"
       puts String.format("rocking with %s", args)
     EOF
-    assert_output "rocking with an array\n" do
-      cls.main nil
-    end
+    assert_run_output("rocking with an array\n", cls)
   end
 
 end

data/test/mirrors/base_type_test.rb

@@ -13,14 +13,13 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-require 'test/unit'
-require 'java'
-require 'dist/mirahc.jar'
+require 'test_helper'
 
 class BaseTypeTest < Test::Unit::TestCase
   java_import 'org.objectweb.asm.Type'
   java_import 'org.objectweb.asm.Opcodes'
   java_import 'org.mirah.jvm.mirrors.BaseType'
+  java_import 'org.mirah.jvm.mirrors.VoidType'
   java_import 'org.mirah.jvm.mirrors.Member'
   java_import 'org.mirah.jvm.mirrors.MirrorTypeSystem'
   java_import 'org.mirah.jvm.types.MemberKind'
@@ -29,7 +28,7 @@ class BaseTypeTest < Test::Unit::TestCase
   def setup
     @types = MirrorTypeSystem.new
     @type = BaseType.new(@types.context, Type.getType("LFooBar;"), 0, nil)
-    @void = BaseType.new(@types.context, Type.getType("V"), 0, nil)
+    @void = VoidType.new
   end
 
   def type(name)
@@ -89,9 +88,23 @@ class BaseTypeTest < Test::Unit::TestCase
     assert_equal(object, map.widen(int))
   end
 
-  def test_widen_error
+  def test_widen_void_to_map_is_error
     map = type('java.util.Map')
-    assert(@void.widen(map).isError)
-    assert(map.widen(@void).isError)
+    assert(@void.widen(map).isError, @void.widen(map).to_s)
+  end
+
+  def test_widen_to_void_is_error
+    map = type('java.util.Map')
+    assert(map.widen(@void).isError, map.widen(@void).to_s)
+  end
+
+  def test_void_assignable_from_map
+    map = type('java.util.Map')
+    refute(@void.assignableFrom(map))
+  end
+
+  def test_map_assignable_from_void
+    map = type('java.util.Map')
+    refute(map.assignableFrom(@void))
   end
 end

data/test/mirrors/bytecode_mirror_test.rb

@@ -13,9 +13,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-require 'test/unit'
-require 'java'
-require 'dist/mirahc.jar'
+require 'test_helper'
 
 class BytecodeMirrorTest < Test::Unit::TestCase
   java_import 'org.objectweb.asm.Type'
@@ -83,6 +81,13 @@ class BytecodeMirrorTest < Test::Unit::TestCase
     assert_equal('FIELD_ACCESS', field.kind.name)
   end
 
+  def test_declared_field_signature
+    mirror = load(Type.getType("Ljava/lang/String;"))
+    field = mirror.getDeclaredField 'CASE_INSENSITIVE_ORDER'
+
+    assert_equal('Ljava/util/Comparator<Ljava/lang/String;>;', field.signature)
+  end
+
   def test_array
     mirror = load(Type.getType("[Ljava/lang/Object;"))
     assert(JVMTypeUtils.isArray(mirror))

data/test/mirrors/generics_test.rb

@@ -16,26 +16,30 @@
 require 'java'
 require 'test/unit'
 require 'java'
-require 'dist/mirahc.jar'
+require ENV.fetch('MIRAHC_JAR',File.expand_path("../../../dist/mirahc.jar",__FILE__))
+require File.expand_path("../../jvm/new_backend_test_helper",__FILE__)
 
 class GenericsTest < Test::Unit::TestCase
   java_import 'java.util.HashSet'
+  java_import 'javax.lang.model.util.Types'
+  java_import 'org.objectweb.asm.Type'
+
+  java_import 'org.mirah.jvm.mirrors.BaseType'
   java_import 'org.mirah.jvm.mirrors.generics.Constraints'
   java_import 'org.mirah.jvm.mirrors.generics.LubFinder'
+  java_import 'org.mirah.jvm.mirrors.generics.TypeInvocation'
+  java_import 'org.mirah.jvm.mirrors.generics.TypeInvoker'
   java_import 'org.mirah.jvm.mirrors.generics.TypeParameterInference'
   java_import 'org.mirah.jvm.mirrors.generics.TypeVariable'
-  java_import 'org.mirah.jvm.mirrors.generics.TypeInvocation'
   java_import 'org.mirah.jvm.mirrors.generics.Wildcard'
-  java_import 'org.mirah.jvm.mirrors.BaseType'
-  java_import 'org.mirah.jvm.mirrors.NullType'
   java_import 'org.mirah.jvm.mirrors.MirrorTypeSystem'
+  java_import 'org.mirah.jvm.mirrors.NullType'
   java_import 'org.mirah.jvm.model.Cycle'
   java_import 'org.mirah.jvm.model.IntersectionType'
   java_import 'org.mirah.typer.BaseTypeFuture'
-  java_import 'org.objectweb.asm.Type'
-  java_import 'javax.lang.model.util.Types'
 
   def setup
+    super
     @types = MirrorTypeSystem.new
     @type_utils = @types.context.get(Types.java_class)
     @tpi = TypeParameterInference.new(@type_utils)
@@ -57,7 +61,7 @@ class GenericsTest < Test::Unit::TestCase
   def g(name, params)
     klass = future(name)
     params = params.map {|x| future(x)}
-    @types.parameterize(klass, params).resolve
+    @types.parameterize(klass, params, {}).resolve
   end
 
   def future(x)
@@ -310,7 +314,7 @@ class GenericsTest < Test::Unit::TestCase
     assert_nil(@tpi.findMatchingSupertype(string, abstract_list))
     
     array_list = @types.loadNamedType('java.util.ArrayList').resolve
-    assert_equal(abstract_list, @tpi.findMatchingSupertype(array_list, abstract_list))
+    assert_equal(abstract_list.name, @tpi.findMatchingSupertype(array_list, abstract_list).name)
   end
 
   def test_equal_variable
@@ -666,7 +670,7 @@ class GenericsTest < Test::Unit::TestCase
     a = @types.getArrayType(s)
     assert_equal('java.util.Set<java.lang.String>[]', a.toString)
     supertypes = a.directSupertypes
-    assert_equal('[java.util.Set[], java.util.Collection<java.lang.String>[]]',
+    assert_equal('[java.lang.Object, java.util.Set[], java.util.Collection<java.lang.String>[]]',
                  supertypes.toString)
 
   end
@@ -782,4 +786,79 @@ class GenericsTest < Test::Unit::TestCase
     assert_equal(["java.lang.Comparable<java.lang.String>"],
                  interfaces.grep(/Comparable/))
   end
-end
+  
+  def test_type_invoker_simple_signature
+    invoker = invoker_for_signature('Ljava/lang/Object;')
+    assert_equal(0,invoker.getFormalTypeParameters.size)
+  end
+  
+  def test_type_invoker_array_as_type_parameter_signature
+    invoker = invoker_for_signature('<T:Ljava/lang/Object;>Ljava/lang/Class<[TT;>;')
+    assert_equal(1,invoker.getFormalTypeParameters.size)
+  end
+  
+  def test_type_invoker_class_with_self_referential_bounds
+    invoker = invoker_for_signature('<P:LAnotherClassWithSelfReferencingTypeParameter<TP;>;>Ljava/lang/Object;')
+    assert_equal(1,invoker.getFormalTypeParameters.size)
+  end
+  
+  def test_ClassWithSelfReferencingTypeParameter
+    cls, = compile(%q[
+      import org.foo.ClassWithSelfReferencingTypeParameter
+      
+      ClassWithSelfReferencingTypeParameter.new.foo.bar.baz
+    ])
+    assert_run_output("baz\n", cls)
+  end
+  
+  def test_issue_417_npe
+    omit_if JVMCompiler::JVM_VERSION.to_f < 1.8
+    pend "fix NPE in generic inference" do
+    cls, = compile(%q[
+      import org.foo.TypeFixtureJava8
+      import java.util.function.BiConsumer
+      import java.util.Map
+      import java.util.List
+
+      class Issue417Test
+
+         def initialize(filters:List, flags:int)
+            @filters = filters
+            @flags = flags
+            @loader = TypeFixtureJava8.new
+            @future = nil
+         end
+
+         def run():void
+             @future = @loader.load(@filters, @flags)
+         end
+
+         def handle(block:BiConsumer):Issue417Test
+            @future.whenComplete(block)
+            self
+         end
+
+         def join():void
+            @future.join
+         end
+
+      end
+    ])
+    end
+  end
+  
+  def test_type_invoker_recursive_reference_signature
+    omit_if JVMCompiler::JVM_VERSION.to_f < 1.8
+    # Stream API is needed here
+    invoker = invoker_for_signature('<T:Ljava/lang/Object;S::Ljava/util/stream/BaseStream<TT;TS;>;>Ljava/lang/Object;Ljava/lang/AutoCloseable;')
+    assert_equal(2,invoker.getFormalTypeParameters.size)
+  end
+  
+  def invoker_for_signature(signature)
+    context   = @types.context
+    invoker   = TypeInvoker.new(context, nil, [], {})
+    invoker.read(signature)
+    invoker
+  end
+end
+