mirah 0.0.12-java → 0.1.0-java

data/test/jvm/example_test.rb

@@ -0,0 +1,53 @@
+# 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.
+
+# these are here to make sure the examples still run.
+#
+class ExampleTest < Test::Unit::TestCase
+  def compile_ex name
+    filename = File.dirname(__FILE__) + "/../../examples/#{name}.mirah"
+    compile(open(filename).read).first
+  end
+
+  def example_test name, output
+    cls = compile_ex name
+    assert_output(output) { cls.main nil }
+  end
+
+  {
+    'simple_class' => "constructor\nHello, \nMirah\n",
+    'macros/square' => "2.0\n8.0\n",
+    'macros/square_int' => "2.0\n8.0\n",
+    'macros/string_each_char' => "l\na\na\nt\n \nd\ne\n \nl\ne\ne\ne\nu\nw\n \nn\ni\ne\nt\n \ni\nn\n \nz\ni\nj\nn\n \nh\ne\nm\np\ni\ne\n \ns\nt\na\na\nn\n"
+  }.each do |example,output|
+    define_method "test_#{example}" do
+      example_test example, output
+    end
+  end
+
+if Float(ENV_JAVA['java.specification.version']) >= 1.7
+  def test_dynamic
+    example_test 'dynamic', "I got a java.util.Collections$UnmodifiableRandomAccessList of size 3\nI got a SizeThing of size 12\n"
+  end
+else
+  def test_dynamic
+    ex = assert_raise Mirah::MirahError do
+      example_test 'dynamic', nil
+    end
+    assert_equal "Target JVM version: 1.6 doesn't support invoke dynamic", ex.message
+  end
+end
+
+end

data/test/jvm/factory_test.rb

@@ -14,9 +14,15 @@
 # limitations under the License.
 
 class FactoryTest < Test::Unit::TestCase
-  def test_bootclass_loader_can_find_things_on_bootclasspath   
+  def test_bootclass_loader_can_find_things_on_bootclasspath
     factory = Mirah::JVM::Types::TypeFactory.new
     factory.bootclasspath = File.expand_path("#{__FILE__}/../../fixtures/") +"/"
     assert factory.bootstrap_loader.get_resource 'org/foo/A.class'
   end
+
+  def test_nil_classpath_is_ok
+    factory = Mirah::JVM::Types::TypeFactory.new
+    factory.classpath = nil
+  end
+
 end

data/test/jvm/generics_test.rb

@@ -0,0 +1,57 @@
+# Copyright (c) 2012 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'
+require 'jvm/bytecode_test_helper'
+class TestGenerics < Test::Unit::TestCase
+
+  def parse_and_type code, name=tmp_script_name
+    parse_and_resolve_types name, code
+  end
+
+  def test_generics_calls_collections
+    cls, = compile(<<-EOF)
+      import java.util.ArrayList
+
+      foo = ArrayList.new()
+      foo.add("first string")
+      foo.add("second string")
+      System.out.println(foo.get(1).substring(2))
+    EOF
+
+    assert_output("cond string\n") do
+      cls.main(nil)
+    end
+  end
+
+  def test_generics_generic_payload
+    cls, = compile(<<-EOF)
+      import java.util.ArrayList
+
+      foo = ArrayList.new()
+      foo.add("first string")
+      foo.add("second string")
+      bar = ArrayList.new()
+      bar.add(foo)
+      System.out.println(bar.get(0).get(1).substring(2))
+    EOF
+
+    assert_output("cond string\n") do
+      cls.main(nil)
+    end
+  end
+
+end
+

data/test/jvm/hash_test.rb

@@ -0,0 +1,106 @@
+# Copyright (c) 2012 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 HashTest < Test::Unit::TestCase
+  def test_hashes
+    cls, = compile(<<-EOF)
+      def foo1
+        {a:"A", b:"B"}
+      end
+      def foo2
+        return {a:"A", b:"B"}
+      end
+    EOF
+
+    map = cls.foo1
+    assert_equal("A", map["a"])
+    assert_equal("B", map["b"])
+    map = cls.foo2
+    assert_equal("A", map["a"])
+    assert_equal("B", map["b"])
+
+    cls, = compile(<<-'EOF')
+      def set(b:Object)
+        map = { }
+        map["key"] = b
+        map["key"]
+      end
+    EOF
+
+    assert_equal("foo", cls.set("foo"))
+  end
+
+  def test_hash_with_value_from_static_method
+    cls, = compile(<<-EOF)
+      def foo1
+        {a: a, b:"B"}
+      end
+      def a
+        return "A"
+      end
+    EOF
+    assert_equal("A", cls.foo1["a"])
+  end
+
+  def test_hash_with_value_from_instance_method
+    cls, = compile(<<-EOF)
+      class HashTesty
+        def foo1
+          {a: a, b:"B"}
+        end
+        def a
+          return "A"
+        end
+      end
+    EOF
+    assert_equal("A", cls.new.foo1["a"])
+  end
+
+  def test_scoped_self_through_method_call
+    cls, = compile(<<-EOF)
+      class ScopedSelfThroughMethodCall
+        def emptyMap
+          {}
+        end
+
+        def foo
+          emptyMap["a"] = "A"
+        end
+      end
+    EOF
+
+    # just make sure it can execute
+    m = cls.new.foo
+  end
+
+  def test_self_call_preserves_scope
+    cls, = compile(<<-EOF)
+      class SelfCallPreservesScope
+        def key
+          "key"
+        end
+
+        def foo
+          map = {}
+          map[key] = "value"
+          map
+        end
+      end
+    EOF
+
+    map = cls.new.foo
+    assert_equal("value", map["key"])
+  end
+end

data/test/jvm/import_test.rb

@@ -0,0 +1,81 @@
+# 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 ImportTest < Test::Unit::TestCase
+
+  def test_quote_import
+    cls, = compile("import 'java.util.ArrayList'; def foo; ArrayList.new; end; foo")
+    assert_equal java.util.ArrayList.java_class, cls.foo.java_class
+  end
+
+  def test_no_quote_import
+    cls, = compile("import java.util.ArrayList; def foo; ArrayList.new; end; foo")
+    assert_equal java.util.ArrayList.java_class, cls.foo.java_class
+  end
+
+  def test_alias_import_as_syntax
+    cls, = compile("import java.util.ArrayList as AL; def foo; AL.new; end; foo")
+    assert_equal java.util.ArrayList.java_class, cls.foo.java_class
+  end
+
+  def test_alias_import_comma_syntax
+    cls, = compile("import 'AL', 'java.util.ArrayList'; def foo; AL.new; end; foo")
+    assert_equal java.util.ArrayList.java_class, cls.foo.java_class
+  end
+
+  def test_imported_decl
+    cls, = compile("import 'java.util.ArrayList'; def foo(a:ArrayList); a.size; end")
+    assert_equal 0, cls.foo(java.util.ArrayList.new)
+  end
+
+  def test_import_package_star
+    cls, = compile(<<-EOF)
+      import java.util.*
+      def foo
+        ArrayList.new
+      end
+    EOF
+    assert_equal java.util.ArrayList.java_class, cls.foo.java_class
+  end
+
+  def test_static_import
+    cls, = compile(<<-EOF)
+      import static java.util.Arrays.*
+      def list(x:Object[])
+        asList(x)
+      end
+    EOF
+
+    o = ["1", "2", "3"].to_java(:object)
+    list = cls.list(o)
+    assert_kind_of(Java::JavaUtil::List, list)
+    assert_equal(["1", "2", "3"], list.to_a)
+
+    cls, = compile(<<-EOF)
+      import java.util.Arrays
+      class StaticImports
+        import static Arrays.*
+        def list(x:Object[])
+          asList(x)
+        end
+      end
+    EOF
+
+    list = cls.new.list(o)
+    assert_kind_of(Java::JavaUtil::List, list)
+    assert_equal(["1", "2", "3"], list.to_a)
+  end
+
+end

data/test/jvm/interface_test.rb

@@ -0,0 +1,73 @@
+# 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.
+
+class InterfaceTest < Test::Unit::TestCase
+  def test_interface
+    cls, = compile(<<-EOF)
+      import 'java.util.concurrent.Callable'
+      def foo(a:Callable)
+        a.call
+      end
+    EOF
+    result = cls.foo {0}
+    assert_equal 0, result
+    m = cls.java_class.java_method 'foo', java.util.concurrent.Callable
+  end
+
+
+  def test_interface_declaration
+    interface = compile('interface A; end').first
+    assert(interface.java_class.interface?)
+    assert_equal('A', interface.java_class.name)
+
+    a, b = compile('interface A; end; interface B < A; end')
+    assert_include(a, b.ancestors)
+    assert_equal('A', a.java_class.name)
+    assert_equal('B', b.java_class.name)
+
+    a, b, c = compile(<<-EOF)
+      interface A
+      end
+
+      interface B
+      end
+
+      interface C < A, B
+      end
+    EOF
+
+    assert_include(a, c.ancestors)
+    assert_include(b, c.ancestors)
+    assert_equal('A', a.java_class.name)
+    assert_equal('B', b.java_class.name)
+    assert_equal('C', c.java_class.name)
+  end
+
+  def test_interface_override_return_type
+    assert_raise_kind_of Mirah::MirahError do
+      compile(<<-EOF)
+        interface AnInterface
+          def a:int; end
+        end
+
+        class AImpl implements AnInterface
+          def a
+            "foo"
+          end
+        end
+      EOF
+    end
+  end
+end

data/test/jvm/java_typer_test.rb

@@ -18,96 +18,118 @@ require 'mirah'
 
 class JavaTyperTest < Test::Unit::TestCase
   include Mirah
+  include Mirah::Util::ProcessErrors
+
+  java_import 'org.mirah.typer.simple.SimpleScoper'
+  java_import 'org.mirah.typer.BaseTypeFuture'
+  java_import 'org.mirah.typer.CallFuture'
+  java_import 'org.mirah.typer.TypeFuture'
 
   def setup
-    AST.type_factory = Mirah::JVM::Types::TypeFactory.new
-    @typer = Mirah::JVM::Typer.new(nil)
-    compiler = Mirah::JVM::Compiler::JVMBytecode.new
+    @types = Mirah::JVM::Types::TypeFactory.new
+    @scopes = SimpleScoper.new {|scoper, node| Mirah::AST::StaticScope.new(node, scoper)}
+    @typer = Mirah::Typer::Typer.new(@types, @scopes, nil)
+    @mirah = Mirah::Transform::Transformer.new(Mirah::Util::CompilationState.new, @typer)
+  end
+
+  def inferred_type(node)
+    type = @typer.infer(node, false).resolve
+    if type.name == ':error'
+      catch(:exit) do
+        process_errors([type])
+      end
+    end
+    type
+  end
 
-    @java_typer = Typer::JavaTyper.new
+  def method_type(target, name, args)
+    target = @types.cache_and_wrap(target)
+    args = args.map {|arg| @types.cache_and_wrap(arg) }
+    call = CallFuture.new(@types, nil, target, name, args, nil, nil)
+    @types.getMethodType(call).return_type
   end
 
-  def teardown
-    AST.type_factory = nil
+  def parse(text)
+    AST.parse(text, '-', false, @mirah)
   end
 
   def test_simple_overtyped_meta_method
-    string_meta = AST.type(nil, 'java.lang.String', false, true)
-    string = AST.type(nil, 'java.lang.String')
+    string_meta = @types.type(nil, 'java.lang.String', false, true)
+    string = @types.type(nil, 'java.lang.String')
 
     # integral types
     ['boolean', 'char', 'double', 'float', 'int', 'long'].each do |type_name|
-      type = AST.type(nil, type_name)
-      return_type = @java_typer.method_type(@typer, string_meta, 'valueOf', [type])
-      assert_equal(string, return_type, "valueOf(#{type}) should return #{string}")
+      type = @types.type(nil, type_name)
+      return_type = method_type(string_meta, 'valueOf', [type])
+      assert_equal(string, return_type.resolve, "valueOf(#{type}) should return #{string}")
     end
 
     # char[]
-    type = AST.type(nil, 'char', true)
-    return_type = @java_typer.method_type(@typer, string_meta, 'valueOf', [type])
-    assert_equal(string, return_type)
+    type = @types.type(nil, 'char', true)
+    return_type = method_type(string_meta, 'valueOf', [type])
+    assert_equal(string, return_type.resolve)
 
     # Object
-    type = AST.type(nil, 'java.lang.Object')
-    return_type = @java_typer.method_type(@typer, string_meta, 'valueOf', [type])
-    assert_equal(string, return_type)
+    type = @types.type(nil, 'java.lang.Object')
+    return_type = method_type(string_meta, 'valueOf', [type])
+    assert_equal(string, return_type.resolve)
   end
 
   def test_non_overtyped_method
-    string = AST.type(nil, 'java.lang.String')
+    string = @types.type(nil, 'java.lang.String')
 
-    int = AST.type(nil, 'int')
-    return_type = @java_typer.method_type(@typer, string, 'length', [])
-    assert_equal(int, return_type)
+    int = @types.type(nil, 'int')
+    return_type = method_type(string, 'length', [])
+    assert_equal(int, return_type.resolve)
 
-    byte_array = AST.type(nil, 'byte', true)
-    return_type = @java_typer.method_type(@typer, string, 'getBytes', [])
-    assert_equal(byte_array, return_type)
+    byte_array = @types.type(nil, 'byte', true)
+    return_type = method_type(string, 'getBytes', [])
+    assert_equal(byte_array, return_type.resolve)
   end
 
   def test_simple_overtyped_method
-    string_meta = AST.type(nil, 'java.lang.String', false, true)
-    string = AST.type(nil, 'java.lang.String')
+    string_meta = @types.type(nil, 'java.lang.String', false, true)
+    string = @types.type(nil, 'java.lang.String')
 
-    return_type = @java_typer.method_type(@typer, string_meta, 'valueOf', [string])
-    assert_equal(string, return_type)
+    return_type = method_type(string_meta, 'valueOf', [string])
+    assert_equal(string, return_type.resolve)
   end
 
   def test_primitive_conversion_method
-    string = AST.type(nil, 'java.lang.String')
-    byte = AST.type(nil, 'byte')
-    char = AST.type(nil, 'char')
-    long = AST.type(nil, 'long')
+    string = @types.type(nil, 'java.lang.String')
+    byte = @types.type(nil, 'byte')
+    char = @types.type(nil, 'char')
+    long = @types.type(nil, 'long')
 
-    return_type = @java_typer.method_type(@typer, string, 'charAt', [byte])
-    assert_equal(char, return_type)
+    return_type = method_type(string, 'charAt', [byte])
+    assert_kind_of(TypeFuture, return_type)
+    assert_equal(char, return_type.resolve)
 
-    assert_raise NoMethodError do
-      @java_typer.method_type(@typer, string, 'charAt', [long])
-    end
+    return_type = method_type(string, 'charAt', [long]).resolve
+    assert(return_type.isError)
   end
 
   include Mirah::JVM::MethodLookup
 
   def test_is_more_specific
-    object = java.lang.Object.java_class
-    charseq = java.lang.CharSequence.java_class
-    string = java.lang.String.java_class
+    object = @types.type(nil, 'java.lang.Object')
+    charseq = @types.type(nil, 'java.lang.CharSequence')
+    string = @types.type(nil, 'java.lang.String')
 
-    assert @java_typer.is_more_specific?([string], [object])
-    assert @java_typer.is_more_specific?([charseq], [object])
-    assert @java_typer.is_more_specific?([string], [charseq])
+    assert object.is_more_specific?([string], [object])
+    assert object.is_more_specific?([charseq], [object])
+    assert object.is_more_specific?([string], [charseq])
   end
 
   def test_primitive_convertible
-    boolean = Mirah::JVM::Types::Boolean
-    byte = Mirah::JVM::Types::Byte
-    short = Mirah::JVM::Types::Short
-    char = Mirah::JVM::Types::Char
-    int = Mirah::JVM::Types::Int
-    long = Mirah::JVM::Types::Long
-    float = Mirah::JVM::Types::Float
-    double = Mirah::JVM::Types::Double
+    boolean = @types.type(nil, 'boolean')
+    byte = @types.type(nil, 'byte')
+    short = @types.type(nil, 'short')
+    char = @types.type(nil, 'char')
+    int = @types.type(nil, 'int')
+    long = @types.type(nil, 'long')
+    float = @types.type(nil, 'float')
+    double = @types.type(nil, 'double')
 
     assert !primitive_convertible?(boolean, byte)
     assert !primitive_convertible?(boolean, short)
@@ -183,29 +205,33 @@ class JavaTyperTest < Test::Unit::TestCase
   end
 
   def test_primitive_array
-    ary = AST.type(nil, 'byte', true)
-    int = AST.type(nil, 'int')
+    ary = @types.type(nil, 'byte', true)
+    int = @types.type(nil, 'int')
+
+    # TODO fix intrinsics
+    assert_equal(@types.type(nil, 'byte'), method_type(ary, "[]", [int]).resolve)
+  end
 
-    java_typer = Typer::JavaTyper.new
 
-    assert_equal(AST.type(nil, 'byte'), java_typer.method_type(nil, ary, "[]", [int]))
+  def test_primitive_not_convertible_to_array_with_same_component_type
+    ary = @types.type(nil, 'byte', true)
+    byte = @types.type(nil, 'byte')
+
+    assert !primitive_convertible?(byte, ary)
   end
 
   def test_int
-    ast = AST.parse("#{1 << 16}")
-    assert_equal(AST.type(nil, 'int'), ast.infer(@typer, true))
+    ast = parse("#{1 << 16}")
+    assert_equal(@types.type(nil, 'int'), inferred_type(ast))
   end
 
   def test_long
-    ast = AST.parse("#{1 << 33}")
-    assert_equal(AST.type(nil, 'long'), ast.infer(@typer, true))
+    ast = parse("#{1 << 33}")
+    assert_equal(@types.type(nil, 'long'), inferred_type(ast))
   end
-  
-  def test_dynamic_assignability
-    ast = AST.parse("a = 1; a = dynamic('foo')")
-    assert_equal :error, ast.infer(@typer, true).name
-    
-    ast = AST.parse("a = Object.new; a = dynamic('foo')")
-    assert_equal 'java.lang.Object', ast.infer(@typer, true).name
+
+  def test_static_method
+    ast = parse("class Foo;def self.bar; 1; end; end; Foo.bar")
+    assert_equal(@types.type(nil, 'int'), inferred_type(ast))
   end
 end