mirah 0.0.5-java → 0.0.6-java

data/lib/mirah/transform2.rb

@@ -213,7 +213,7 @@ module Mirah::AST
       name = transform(name, nil) unless name.kind_of?(::String)
       position = position(node)
       actual_name = name
-      if name =~ /=$/
+      if name =~ /=$/ && name != '[]='
         actual_name = name[0..-2] + '_set'
       end
       if name == 'initialize'
@@ -337,6 +337,15 @@ module Mirah::AST
       Constant.new(parent, position(node), node[1])
     end
 
+    def transform_colon2const(node, parent)
+      name = node[2]
+      name = transform(name, nil) unless name.kind_of?(::String)
+      target = node[1]
+      Colon2.new(parent, position(node), name) do |colon2|
+        [ transform(target, colon2) ]
+      end
+    end
+
     def transform_identifier(node, parent)
       name = node[1]
       position = position(node)

data/lib/mirah/typer.rb

@@ -15,6 +15,7 @@
 
 require 'mirah/ast'
 require 'mirah/transform'
+require 'mirah/errors'
 
 module Mirah
   module Typer
@@ -26,13 +27,7 @@ module Mirah
       end
     end
 
-    class InferenceError < Exception
-      attr_accessor :node
-      def initialize(msg, node = nil)
-        super(msg)
-        @node = node
-      end
-    end
+    InferenceError = Mirah::InferenceError
 
     class BaseTyper
       include Mirah
@@ -295,14 +290,14 @@ module Mirah
         @deferred_nodes ||= {}
       end
 
-      def infer(node)
+      def infer(node, expression=true)
         begin
-          node.infer(self)
+          node.infer(self, expression)
         rescue InferenceError => ex
           ex.node ||= node
           error(node, ex)
         rescue Exception => ex
-          error(node, ex.message, ex.backtrace)
+          raise Mirah::InternalCompilerError.wrap(ex, node)
         end
       end
 

data/lib/mirah/version.rb

@@ -14,5 +14,5 @@
 # limitations under the License.
 
 module Mirah
-  VERSION = "0.0.5"
+  VERSION = "0.0.6"
 end

data/test/test_compilation.rb

@@ -102,7 +102,7 @@ class TestAst < Test::Unit::TestCase
   def test_local_typed
     new_ast = AST.parse("a = 1").body[0]
     typer = Typer::Simple.new(:bar)
-    new_ast.infer(typer)
+    new_ast.infer(typer, true)
     new_ast.compile(@compiler, true)
 
     assert_equal([[:local_assign, a(Mirah::AST::StaticScope), "a", AST.type(nil, :fixnum), true, AST.fixnum(nil, nil, 1)]], @compiler.calls)

data/test/test_java_typer.rb

@@ -195,4 +195,14 @@ class TestJavaTyper < Test::Unit::TestCase
 
     assert_equal(AST.type(nil, 'byte'), java_typer.method_type(nil, ary, "[]", [int]))
   end
+
+  def test_int
+    ast = AST.parse("#{1 << 16}")
+    assert_equal(AST.type(nil, 'int'), ast.infer(@typer, true))
+  end
+
+  def test_long
+    ast = AST.parse("#{1 << 33}")
+    assert_equal(AST.type(nil, 'long'), ast.infer(@typer, true))
+  end
 end

data/test/test_javac_compiler.rb

@@ -55,12 +55,14 @@ class TestJavacCompiler < TestJVMCompiler
     File.unlink(*@tmp_classes)
     @tmp_classes.clear
     AST.type_factory = Mirah::JVM::Types::TypeFactory.new
-    transformer = Mirah::Transform::Transformer.new(Mirah::CompilationState.new)
+    state = Mirah::CompilationState.new
+    state.save_extensions = false
+    transformer = Mirah::Transform::Transformer.new(state)
     Java::MirahImpl::Builtin.initialize_builtins(transformer)
     name = "script" + System.nano_time.to_s
     ast  = AST.parse(code, name, true, transformer)
     typer = Typer::JVM.new(transformer)
-    ast.infer(typer)
+    ast.infer(typer, true)
     typer.resolve(true)
     compiler = Compiler::JavaSource.new
     ast.compile(compiler, false)

data/test/test_jvm_compiler.rb

@@ -71,11 +71,13 @@ class TestJVMCompiler < Test::Unit::TestCase
     @tmp_classes.clear
     AST.type_factory = Mirah::JVM::Types::TypeFactory.new
     name = "script" + System.nano_time.to_s
-    transformer = Mirah::Transform::Transformer.new(Mirah::CompilationState.new)
+    state = Mirah::CompilationState.new
+    state.save_extensions = false
+    transformer = Mirah::Transform::Transformer.new(state)
     Java::MirahImpl::Builtin.initialize_builtins(transformer)
     ast  = AST.parse(code, name, true, transformer)
     typer = Typer::JVM.new(transformer)
-    ast.infer(typer)
+    ast.infer(typer, true)
     typer.resolve(true)
     compiler = Compiler::JVM.new
     compiler.compile(ast)
@@ -2391,14 +2393,11 @@ class TestJVMCompiler < Test::Unit::TestCase
   def test_unquote
     # TODO fix annotation output and create a duby.anno.Extensions annotation.
     return if self.class.name == 'TestJavacCompiler'
-    # TODO figure out why this fails to compile in the unittests but works
-    # otherwise.
-    return
-    script, cls = compile(<<-EOF)
-      import duby.lang.compiler.StringNode
+
+    script, cls = compile(<<-'EOF')
       class UnquoteMacros
         macro def make_attr(name_node, type)
-          name = StringNode(name_node).literal()
+          name = name_node.string_value
           quote do
             def `name`
               @`name`
@@ -2417,7 +2416,7 @@ class TestJVMCompiler < Test::Unit::TestCase
       x.foo = 3
       puts x.foo
     EOF
-    assert_output("1\n3\n") {script.main(nil)}
+    assert_output("0\n3\n") {script.main(nil)}
   end
 
   def test_static_import
@@ -2499,6 +2498,16 @@ class TestJVMCompiler < Test::Unit::TestCase
     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_loop_in_ensure
@@ -2634,4 +2643,118 @@ class TestJVMCompiler < Test::Unit::TestCase
     assert_output("1\nFoo\n2\n") { cls.foo }
   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
+
+  def test_macro_hygene
+    cls, = compile(<<-EOF)
+      macro def doubleIt(arg)
+        quote do
+          x = `arg`
+          x = x + x
+          x
+        end
+      end
+
+      def foo
+        x = "1"
+        puts doubleIt(x)
+        puts x
+      end
+    EOF
+
+    assert_output("11\n1\n") {cls.foo}
+  end
+
+  def test_wide_nonexpressions
+    script, cls1, cls2 = compile(<<-EOF)
+      class WideA
+        def a
+          2.5
+        end
+      end
+      
+      class WideB < WideA
+        def a
+          super
+          3.5
+        end
+      end
+      
+      def self.b
+        1.5
+      end
+      
+      1.5
+      WideA.new.a
+      WideB.new.a
+      b
+    EOF
+
+    script.main(nil)
+  end
+
+  def test_parameter_used_in_block
+    cls, = compile(<<-EOF)
+      def foo(x:String):void
+        thread = Thread.new do
+          puts "Hello \#{x}"
+        end
+        begin
+          thread.run
+          thread.join
+        rescue
+          puts "Uh Oh!"
+        end
+      end
+      
+      foo('there')
+    EOF
+    assert_output("Hello there\n") do
+      cls.main(nil)
+    end
+  end
+
+  def test_colon2
+    cls, = compile(<<-EOF)
+      def foo
+        java.util::HashSet.new
+      end
+    EOF
+
+    assert_kind_of(java.util.HashSet, cls.foo)
+  end
 end

data/test/test_macros.rb

@@ -0,0 +1,51 @@
+# TODO refactor this and test_jvm_compiler to use mirah.rb
+
+$:.unshift File.join(File.dirname(__FILE__),'..','lib')
+
+require 'test/unit'
+require 'mirah'
+
+class TestMacros < Test::Unit::TestCase
+  java_import 'java.lang.System'
+
+  def parse(code)
+    Mirah::AST.type_factory = Mirah::JVM::Types::TypeFactory.new
+    name = "script" + System.nano_time.to_s
+    state = Mirah::CompilationState.new
+    state.save_extensions = false
+    transformer = Mirah::Transform::Transformer.new(state)
+    Java::MirahImpl::Builtin.initialize_builtins(transformer)
+    ast  = Mirah::AST.parse(code, name, true, transformer)
+    typer = Mirah::Typer::JVM.new(transformer)
+    ast.infer(typer, true)
+    typer.resolve(true)
+    ast
+  end
+
+  def test_macro_helper
+    script = parse(<<-EOF)
+      import duby.lang.compiler.Compiler
+
+      def helper(mirah:Compiler)
+        name = "foobar"
+        mirah.quote { `name` }
+      end
+    EOF
+  end
+
+  def test_self_call_in_unquote
+    script = parse(<<-EOF)
+      import duby.lang.compiler.Compiler
+
+      def foobar(name:String)
+        name
+      end
+
+      def helper(mirah:Compiler)
+        name = "foobar"
+        mirah.quote { `foobar(name)` }
+      end
+    EOF
+  end
+
+end

data/test/test_typer.rb

@@ -14,6 +14,9 @@
 # limitations under the License.
 
 require 'test/unit'
+
+$:.unshift File.join(File.dirname(__FILE__),'..','lib')
+
 require 'mirah'
 
 class TestTyper < Test::Unit::TestCase
@@ -22,49 +25,49 @@ class TestTyper < Test::Unit::TestCase
   def test_fixnum
     ast = AST.parse("1")
 
-    assert_equal(AST::TypeReference.new("fixnum"), ast.infer(Typer::Simple.new(:bar)))
+    assert_equal(AST::TypeReference.new("fixnum"), ast.infer(Typer::Simple.new(:bar), true))
   end
 
   def test_float
     ast = AST.parse("1.0")
 
-    assert_equal(AST::TypeReference.new("float"), ast.infer(Typer::Simple.new(:bar)))
+    assert_equal(AST::TypeReference.new("float"), ast.infer(Typer::Simple.new(:bar), true))
   end
 
   def test_string
     ast = AST.parse("'foo'")
 
-    assert_equal(AST::TypeReference.new("string"), ast.infer(Typer::Simple.new(:bar)))
+    assert_equal(AST::TypeReference.new("string"), ast.infer(Typer::Simple.new(:bar), true))
   end
 
   def test_boolean
     ast1 = AST.parse("true")
     ast2 = AST.parse("false")
 
-    assert_equal(AST::TypeReference.new("boolean"), ast1.infer(Typer::Simple.new(:bar)))
-    assert_equal(AST::TypeReference.new("boolean"), ast2.infer(Typer::Simple.new(:bar)))
+    assert_equal(AST::TypeReference.new("boolean"), ast1.infer(Typer::Simple.new(:bar), true))
+    assert_equal(AST::TypeReference.new("boolean"), ast2.infer(Typer::Simple.new(:bar), true))
   end
 
   def test_body
     ast1 = AST.parse("'foo'; 1.0; 1")
     ast2 = AST.parse("begin; end")
 
-    assert_equal(AST::TypeReference.new("fixnum"), ast1.infer(Typer::Simple.new(:bar)))
-    assert_equal(AST::TypeReference::NullType, ast2.infer(Typer::Simple.new(:bar)))
+    assert_equal(AST::TypeReference.new("fixnum"), ast1.infer(Typer::Simple.new(:bar), true))
+    assert_equal(AST::TypeReference::NullType, ast2.infer(Typer::Simple.new(:bar), true))
   end
 
   def test_local
     ast1 = AST.parse("a = 1; a")
     typer = Typer::Simple.new :bar
 
-    ast1.infer(typer)
+    ast1.infer(typer, true)
 
     assert_equal(AST::TypeReference.new("fixnum"), typer.local_type(ast1.static_scope, 'a'))
     assert_equal(AST::TypeReference.new("fixnum"), ast1.body.children[0].inferred_type)
     assert_equal(AST::TypeReference.new("fixnum"), ast1.body.children[1].inferred_type)
 
     ast2 = AST.parse("b = a = 1")
-    ast2.infer(typer)
+    ast2.infer(typer, true)
 
     assert_equal(AST::TypeReference.new("fixnum"), typer.local_type(ast2.static_scope, 'a'))
     assert_equal(AST::TypeReference.new("fixnum"), ast2.body.children[0].inferred_type)
@@ -75,7 +78,7 @@ class TestTyper < Test::Unit::TestCase
       ast1 = AST.parse("#{def_foo}(a:string); end")
       typer = Typer::Simple.new :bar
 
-      ast1.infer(typer)
+      ast1.infer(typer, true)
 
       assert_nothing_raised {typer.resolve(true)}
       assert_nothing_raised {typer.resolve}
@@ -95,7 +98,7 @@ class TestTyper < Test::Unit::TestCase
       ast1 = AST.parse("#{def_foo}(a:string); a; end")
       typer = Typer::Simple.new :bar
 
-      ast1.infer(typer)
+      ast1.infer(typer, true)
 
       assert_equal(typer.string_type, typer.method_type(type, 'foo', [typer.string_type]))
       assert_equal(typer.string_type, typer.local_type(ast1.body[0].static_scope, 'a'))
@@ -106,7 +109,7 @@ class TestTyper < Test::Unit::TestCase
       typer = Typer::Simple.new :bar
 
       assert_raise(Typer::InferenceError) do
-        ast1.infer(typer)
+        ast1.infer(typer, true)
         typer.resolve(true)
       end
     end
@@ -119,13 +122,13 @@ class TestTyper < Test::Unit::TestCase
     typer.learn_method_type(typer.fixnum_type, "foo", [typer.fixnum_type], typer.string_type, [])
     assert_equal(typer.string_type, typer.method_type(typer.fixnum_type, "foo", [typer.fixnum_type]))
 
-    ast.infer(typer)
+    ast.infer(typer, true)
 
     assert_equal(typer.string_type, ast.inferred_type)
 
     ast = AST.parse("def bar(a:fixnum, b:string); 1.0; end; def baz; bar(1, 'x'); end")
 
-    ast.infer(typer)
+    ast.infer(typer, true)
     ast = ast.body
 
     assert_equal(typer.float_type, typer.method_type(typer.self_type, "bar", [typer.fixnum_type, typer.string_type]))
@@ -137,7 +140,7 @@ class TestTyper < Test::Unit::TestCase
     ast = AST.parse("def baz; bar(1, 'x'); end; def bar(a:fixnum, b:string); 1.0; end")
     typer = Typer::Simple.new("bar")
 
-    ast.infer(typer)
+    ast.infer(typer, true)
     ast = ast.body
 
     assert_equal(typer.default_type, typer.method_type(typer.self_type, "baz", []))
@@ -157,7 +160,7 @@ class TestTyper < Test::Unit::TestCase
     ast = AST.parse("def baz; bar(1, 1); end; def bar(a:fixnum, b:string); 1.0; end")
     typer = Typer::Simple.new("bar")
 
-    ast.infer(typer)
+    ast.infer(typer, true)
     ast = ast.body
 
     assert_equal(typer.default_type, typer.method_type(typer.self_type, "baz", []))
@@ -177,11 +180,12 @@ class TestTyper < Test::Unit::TestCase
     typer = Typer::Simple.new("bar")
 
     # incompatible body types
-    assert_raise(Typer::InferenceError) {ast.infer(typer)}
+    assert_raise(Typer::InferenceError) {ast.infer(typer, true)}
+    assert_nothing_raised {ast.infer(typer, false)}
 
     ast = AST.parse("if true; 1.0; else; 2.0; end").body[0]
 
-    assert_nothing_raised {ast.infer(typer); typer.resolve(true)}
+    assert_nothing_raised {ast.infer(typer, true); typer.resolve(true)}
 
     assert_equal(typer.boolean_type, ast.condition.inferred_type)
     assert_equal(typer.float_type, ast.body.inferred_type)
@@ -189,7 +193,7 @@ class TestTyper < Test::Unit::TestCase
 
     ast = AST.parse("if foo; bar; else; baz; end").body[0]
 
-    assert_nothing_raised {ast.infer(typer)}
+    assert_nothing_raised {ast.infer(typer, true)}
 
     assert_equal(typer.default_type, ast.condition.inferred_type)
     assert_equal(typer.default_type, ast.body.inferred_type)
@@ -198,10 +202,10 @@ class TestTyper < Test::Unit::TestCase
     # unresolved types for the foo, bar, and baz calls
     assert_raise(Typer::InferenceError) {typer.resolve(true)}
 
-    ast2 = AST.parse("def foo; 1; end; def bar; 1.0; end")[0]
+    ast2 = AST.parse("def foo; 1; end; def bar; 1.0; end")
 
-    ast2.infer(typer)
-    ast.infer(typer)
+    ast2.infer(typer, true)
+    ast.infer(typer, true)
 
     # unresolved types for the baz call
     assert_raise(Typer::InferenceError) {typer.resolve(true)}
@@ -214,8 +218,8 @@ class TestTyper < Test::Unit::TestCase
 
     ast2 = AST.parse("def baz; 2.0; end")
 
-    ast2.infer(typer)
-    ast.infer(typer)
+    ast2.infer(typer, true)
+    ast.infer(typer, true)
 
     assert_nothing_raised {typer.resolve(true)}
 
@@ -229,7 +233,7 @@ class TestTyper < Test::Unit::TestCase
     baz = cls.body[1]
 
     typer = Typer::Simple.new("script")
-    ast.infer(typer)
+    ast.infer(typer, true)
 
     assert_nothing_raised {typer.resolve(true)}
   end