mirah 0.1.1-java → 0.1.2-java

data/lib/mirah/env.rb

@@ -42,5 +42,11 @@ module Mirah
       end
       result
     end
+
+    def self.make_urls classpath
+      decode_paths(classpath).map do |filename|
+        java.io.File.new(filename).to_uri.to_url
+      end.to_java(java.net.URL)
+    end
   end
 end

data/lib/mirah/errors.rb

@@ -22,6 +22,10 @@ module Mirah
       super(message)
       @position = position
     end
+
+    def inspect
+      "MirahError: #{message} #{position}"
+    end
   end
 
   class NodeError < MirahError

data/lib/mirah/generator.rb

@@ -62,7 +62,7 @@ module Mirah
       # enter all ASTs into inference engine
       puts "Inferring types..." if logging
       scoper, typer = infer_asts(top_nodes)
-
+      do_transforms top_nodes
       # compile each AST in turn
       compiler_results = compiler.compile_asts(top_nodes, scoper, typer)
 
@@ -71,8 +71,25 @@ module Mirah
       compiler_results
     end
 
+    def do_transforms nodes
+      log("Starting Transform")
+
+      java_import 'org.mirah.jvm.compiler.ClosureTransformer' rescue puts $!
+      java_import 'org.mirah.util.Context' rescue puts $!
+      #java_import 'org.mirah.typer.Typer'
+      #java_import 'org.mirah.macros.Compiler'
+      transformer = ClosureTransformer.new(Context.new.tap{|c|c.add(Java::org.mirah.typer::Typer, @typer) }) rescue nil
+      if transformer
+        nodes.each{|n| n.accept transformer, nil } # rescue log("transformer exception", $!.cause)
+        log("POST Transform")
+        log_types nodes
+      else
+        log "No transformer, skipping"
+      end
+    end
+
     def infer_asts(nodes, should_raise=false)
-      begin
+      log_and_reraise "Caught exception during type inference" do
         nodes.each {|ast| @typer.infer(ast, false) }
         if should_raise
           error_handler = lambda do |errors|
@@ -81,13 +98,17 @@ module Mirah
           end
         end
         process_inference_errors(@typer, nodes, &error_handler)
-      rescue NativeException => ex
-        log("Caught exception during type inference", ex.cause)
-        raise ex
-      ensure
-        log_types(nodes)
       end
       [@scoper, @typer]
+    ensure
+      log_types(nodes)
+    end
+
+    def log_and_reraise message
+      yield
+    rescue NativeException => ex
+      log(message, ex.cause)
+      raise ex
     end
 
     def log_types(nodes)

data/lib/mirah/jvm/compiler/jvm_bytecode.rb

@@ -127,7 +127,7 @@ module Mirah
                 param_type = inferred_type(param)
                 if scope.captured?(param.name.identifier)
                   @method.dup
-                  type.load(@method, @method.local(name, param_type))
+                  param_type.load(@method, @method.local(name, param_type))
                   @method.putfield(type, name, param_type)
                 end
               end

data/lib/mirah/jvm/types/factory.rb

@@ -712,15 +712,9 @@ module Mirah::JVM::Types
       end
     end
 
-    def make_urls(classpath)
-      Mirah::Env.decode_paths(classpath).map do |filename|
-        java.io.File.new(filename).to_uri.to_url
-      end.to_java(java.net.URL)
-    end
-
     def base_classpath
       if __FILE__.include? '.jar'
-        Mirah::Env.encode_paths([__FILE__.split('!').first.split(':').last])
+        Mirah::Env.encode_paths([__FILE__.split('!').first.split(Mirah::Env.path_separator).last])
       else
         Mirah::Env.encode_paths(['.',
                                  File.dirname(__FILE__) + '/../../../../javalib/mirah-builtins.jar',
@@ -735,19 +729,19 @@ module Mirah::JVM::Types
 
     def classpath=(classpath)
       if classpath
-        @classpath = classpath + ":" + base_classpath
+        @classpath = Mirah::Env.encode_paths [classpath, base_classpath]
       end
       @resource_loader = nil
     end
 
     def resource_loader
-      @resource_loader ||= URLClassLoader.new(make_urls(classpath), bootstrap_loader)
+      @resource_loader ||= URLClassLoader.new(Mirah::Env.make_urls(classpath), bootstrap_loader)
     end
 
     def bootstrap_loader
       @bootstrap_loader ||= begin
         parent = if bootclasspath
-                   Mirah::Util::IsolatedResourceLoader.new(make_urls(bootclasspath))
+                   Mirah::Util::IsolatedResourceLoader.new(Mirah::Env.make_urls(bootclasspath))
                  end
         if __FILE__ =~ /^(file:.+jar)!/
           bootstrap_urls = [java.net.URL.new($1)].to_java(java.net.URL)

data/lib/mirah/util/argument_processor.rb

@@ -131,6 +131,10 @@ module Mirah
         -I DIR\t\tAdd DIR to the Ruby load path before running
         --jvm VERSION\t\tEmit JVM bytecode targeting specified JVM
         \t\t\t  version (1.4, 1.5, 1.6, 1.7)
+        --no-save-extensions\tDon't write macro classes to files
+        --no-color\t\tDon't use color when writing logs
+        -N, --new-backend\tUse the new backend
+        -T, --new-types\tUse the new type system
         -p, --plugin PLUGIN\trequire 'mirah/plugin/PLUGIN' before running
         -v, --version\t\tPrint the version of Mirah to the console
         -V, --verbose\t\tVerbose logging

data/lib/mirah/version.rb

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

data/test/core/typer/assignable_type_future_test.rb

@@ -0,0 +1,73 @@
+# 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.
+require 'test_helper'
+
+class TypeFutureTest < Test::Unit::TestCase
+  include Mirah
+  include Mirah::Util::ProcessErrors
+  java_import 'org.mirah.typer.TypeFuture'
+  java_import 'org.mirah.typer.AssignableTypeFuture'
+  java_import 'org.mirah.typer.SimpleFuture'
+  java_import 'org.mirah.typer.simple.SimpleScoper'
+  java_import 'org.mirah.typer.simple.SimpleTypes'
+  java_import 'org.mirah.typer.simple.SimpleType'
+  java_import 'org.mirah.typer.ErrorType'
+  java_import 'mirah.lang.ast.VCall'
+  java_import 'mirah.lang.ast.FunctionalCall'
+  java_import 'mirah.lang.ast.PositionImpl'
+  java_import 'mirah.lang.ast.LocalAccess'
+
+  module TypeFuture
+    def inspect
+      toString
+    end
+  end
+  
+  POS = PositionImpl.new(nil, 0, 0, 0, 0, 0, 0)
+
+# error type test
+
+# END error type test
+
+  def test_assignable_future_when_declared_resolves_to_declared_type
+    future = AssignableTypeFuture.new POS
+    type = SimpleType.new("Object",false,false)
+    future.declare SimpleFuture.new(type), POS
+
+    assert_equal type, future.resolve, "Expected #{future.resolve} to be a #{type}"
+  end
+
+
+  def test_assignable_future_doesnt_allow_multiple_declarations_of_different_types
+    future = AssignableTypeFuture.new POS
+    future.declare SimpleFuture.new(SimpleType.new("Object",false,false)), POS
+    future.declare SimpleFuture.new(SimpleType.new("NotObject",false,false)), POS
+
+    assign_future = future.assign SimpleFuture.new(SimpleType.new("Object",false,false)), POS
+
+    assert_kind_of ErrorType, assign_future.resolve
+  end
+
+  def test_assignable_future_doesnt_allow_invalid_assignment_to_declared_type
+    future = AssignableTypeFuture.new POS
+    f = SimpleFuture.new(SimpleType.new("Object",false,false))
+
+    future.declare f, POS
+    
+    assignment_future = future.assign SimpleFuture.new(SimpleType.new("NotObject",false,false)), POS
+    
+    assert_kind_of ErrorType, assignment_future.resolve
+  end
+end

data/test/core/typer/error_type_test.rb

@@ -0,0 +1,61 @@
+# 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.
+require 'test_helper'
+
+class ErrorTypeTest < Test::Unit::TestCase
+    include Mirah
+  include Mirah::Util::ProcessErrors
+  java_import 'org.mirah.typer.TypeFuture'
+  java_import 'org.mirah.typer.AssignableTypeFuture'
+  java_import 'org.mirah.typer.SimpleFuture'
+  java_import 'org.mirah.typer.simple.SimpleScoper'
+  java_import 'org.mirah.typer.simple.SimpleTypes'
+  java_import 'org.mirah.typer.simple.SimpleType'
+  java_import 'org.mirah.typer.ErrorType'
+  java_import 'mirah.lang.ast.VCall'
+  java_import 'mirah.lang.ast.FunctionalCall'
+  java_import 'mirah.lang.ast.PositionImpl'
+  java_import 'mirah.lang.ast.LocalAccess'
+
+  module TypeFuture
+    def inspect
+      toString
+    end
+  end
+  
+  POS = PositionImpl.new(nil, 0, 0, 0, 0, 0, 0)
+  
+  def test_error_type_matches_anything
+    type = ErrorType.new [["",POS]]
+    assert type.matchesAnything, "errors match any type"
+  end
+
+  def test_error_type_is_not_assignable_from
+    type = ErrorType.new [["",POS]]
+    assert !type.assignableFrom(SimpleType.new("Object",false,false))
+  end
+
+  def test_error_type_equal_to_another_error_type_when_message_same
+    type = ErrorType.new [["message one",POS]]
+    type2 = ErrorType.new [["message one",POS]]
+    assert_equal type, type2
+  end
+
+  def test_error_type_not_equal_to_another_error_type_when_message_differs
+    type = ErrorType.new [["message one",POS]]
+    type2 = ErrorType.new [["message two",POS]]
+    assert_not_equal type, type2
+  end
+end

data/test/core/typer/simple_type_test.rb

@@ -0,0 +1,69 @@
+# 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.
+require 'test_helper'
+
+class SimpleTypeTest < Test::Unit::TestCase
+  include Mirah
+  include Mirah::Util::ProcessErrors
+  java_import 'org.mirah.typer.TypeFuture'
+  java_import 'org.mirah.typer.AssignableTypeFuture'
+  java_import 'org.mirah.typer.SimpleFuture'
+  java_import 'org.mirah.typer.simple.SimpleScoper'
+  java_import 'org.mirah.typer.simple.SimpleTypes'
+  java_import 'org.mirah.typer.simple.SimpleType'
+  java_import 'org.mirah.typer.ErrorType'
+  java_import 'mirah.lang.ast.VCall'
+  java_import 'mirah.lang.ast.FunctionalCall'
+  java_import 'mirah.lang.ast.PositionImpl'
+  java_import 'mirah.lang.ast.LocalAccess'
+
+  module TypeFuture
+    def inspect
+      toString
+    end
+  end
+  
+  POS = PositionImpl.new(nil, 0, 0, 0, 0, 0, 0)
+  
+  def test_simple_type_widens_to_simple_type_of_same_name
+    type = SimpleType.new("Object",false,false)
+    assert_equal type, type.widen(SimpleType.new("Object",false,false))
+  end
+
+  def test_simple_type_equals_simple_type_of_same_name
+    type = SimpleType.new("Object",false,false)
+    assert_equal type, SimpleType.new("Object",false,false)
+  end
+
+  def test_simple_type_assignable_from_type_of_same_name
+    type = SimpleType.new("Object",false,false)
+    assert type.assignableFrom SimpleType.new("Object",false,false)
+  end
+
+  def test_simple_type_widens_to_error_type_when_other_has_different_name
+    type = SimpleType.new("Object",false,false)
+    assert_kind_of ErrorType, type.widen(SimpleType.new("NotObject",false,false))
+  end
+
+  def test_simple_type_does_not_equal_simple_type_of_different_name
+    type = SimpleType.new("Object",false,false)
+    assert_not_equal type, SimpleType.new("NotObject",false,false)
+  end
+
+  def test_simple_type_not_assignable_from_type_of_different_name
+    type = SimpleType.new("Object",false,false)
+    assert !type.assignableFrom(SimpleType.new("NotObject",false,false))
+  end
+end

data/test/jvm/blocks_test.rb

@@ -58,7 +58,6 @@ class BlocksTest < Test::Unit::TestCase
     end
   end
 
-
   def test_simple_block
     cls, = compile(<<-EOF)
       thread = Thread.new do
@@ -130,6 +129,20 @@ class BlocksTest < Test::Unit::TestCase
     assert_equal(2, cls.foo)
   end
 
+
+  def test_int_closure_with_int_as_method_param
+    cls, = compile(<<-EOF)
+      def run(x:Runnable)
+        x.run
+      end
+      def foo a: int
+        run {a += 1}
+        a
+      end
+    EOF
+    assert_equal(2, cls.foo(1))
+  end
+
   def test_block_with_method_def
     cls, = compile(<<-EOF)
       import java.util.ArrayList
@@ -333,7 +346,7 @@ class BlocksTest < Test::Unit::TestCase
     end
   end
 
-  def test_block_with_interface_method_with_2_arguments
+  def test_block_with_interface_method_with_2_arguments_with_types
     cls, = compile(<<-EOF)
       interface DoubleArgMethod do
         def run(a: String, b: int):void;end
@@ -344,7 +357,7 @@ class BlocksTest < Test::Unit::TestCase
           a.run "hello", 1243
         end
       end
-      ExpectsDoubleArgMethod.new.foo do |a, b|
+      ExpectsDoubleArgMethod.new.foo do |a: String, b: int|
         puts a
         puts b
       end
@@ -353,4 +366,251 @@ class BlocksTest < Test::Unit::TestCase
       cls.main(nil)
     end
   end
+
+  def test_block_with_interface_method_with_2_arguments_without_types
+    cls, = compile(<<-EOF)
+      interface DoubleArgMethod2 do
+        def run(a: String, b: int):void;end
+      end
+
+      class ExpectsDoubleArgMethod2
+        def foo(a:DoubleArgMethod2)
+          a.run "hello", 1243
+        end
+      end
+      ExpectsDoubleArgMethod2.new.foo do |a, b|
+        puts a
+        puts b
+      end
+    EOF
+    assert_output "hello\n1243\n" do
+      cls.main(nil)
+    end
+  end
+
+
+  def test_closures_support_non_local_return
+    pend "nlr doesnt work right now" do
+    cls, = compile(<<-EOF)
+      class NonLocalMe
+        def foo(a: Runnable)
+          a.run
+          puts "doesn't get here"
+        end
+      end
+      def nlr: String
+        NonLocalMe.new.foo { return "NLR!"}
+        "nor here either"
+      end
+      puts nlr
+    EOF
+    assert_output "NLR!\n" do
+      cls.main(nil)
+    end
+    end
+  end
+
+  def test_closures_support_non_local_return_with_primitives
+    pend "nlr doesnt work right now" do
+    cls, = compile(<<-EOF)
+      class NonLocalMe
+        def foo(a: Runnable)
+          a.run
+          puts "doesn't get here"
+        end
+      end
+      def nlr: int
+        NonLocalMe.new.foo { return 1234}
+        5678
+      end
+      puts nlr
+    EOF
+    assert_output "1234\n" do
+      cls.main(nil)
+    end
+    end
+  end
+
+  def test_when_non_local_return_types_incompatible_has_error
+    pend "nlr doesnt work right now" do
+    error = assert_raises Mirah::MirahError do
+      parse_and_type(<<-CODE)
+      class NonLocalMe
+        def foo(a: Runnable)
+          a.run
+          puts "doesn't get here"
+        end
+      end
+      def nlr: int
+        NonLocalMe.new.foo { return "not an int"}
+        5678
+      end
+
+      CODE
+    end
+    assert error.message.include? 'int'
+    end
+  end
+
+  def test_closures_non_local_return_to_a_script
+    pend "nlr doesnt work right now" do
+    cls, = compile(<<-EOF)
+      def foo(a: Runnable)
+        a.run
+        puts "doesn't get here"
+      end
+      puts "before"
+      foo { return }
+      puts "or here"
+    EOF
+    assert_output "before\n" do
+      cls.main(nil)
+    end
+    end
+  end
+
+  def test_closures_non_local_return_defined_in_a_class
+    pend "nlr doesnt work right now" do
+    cls, = compile(<<-EOF)
+      class ClosureInMethodInClass
+        def foo(a: Runnable)
+          a.run
+          puts "doesn't get here"
+        end
+        def nlr
+          puts "before"
+          foo { return 1234 }
+          puts "or here"
+          5678
+        end
+      end
+      puts ClosureInMethodInClass.new.nlr
+    EOF
+    assert_output "before\n1234\n" do
+      cls.main(nil)
+    end
+    end
+  end
+
+  def test_closures_non_local_return_defined_in_a_void_method
+    pend "nlr doesnt work right now" do
+    cls, = compile(<<-EOF)
+      class ClosureInVoidMethodInClass
+        def foo(a: Runnable)
+          a.run
+          puts "doesn't get here"
+        end
+        def nlr: void
+          puts "before"
+          foo { return }
+          puts "or here"
+        end
+      end
+      ClosureInVoidMethodInClass.new.nlr
+    EOF
+    puts "before running"
+    assert_output "before\n" do
+      cls.main(nil)
+    end
+    end
+  end
+
+  def test_closure_non_local_return_with_multiple_returns
+    pend "nlr doesnt work right now" do
+    cls, = compile(<<-EOF)
+      class NLRMultipleReturnRunner
+        def foo(a: Runnable)
+          a.run
+          puts "doesn't get here"
+        end
+      end
+      def nlr(flag: boolean): String
+        NLRMultipleReturnRunner.new.foo { if flag; return "NLR!"; else; return "NLArrrr"; end}
+        "nor here either"
+      end
+      puts nlr true
+      puts nlr false
+    EOF
+    assert_output "NLR!\nNLArrrr\n" do
+      cls.main(nil)
+    end
+    end
+  end
+
+  def test_two_nlr_closures_in_the_same_method_in_if
+    pend "nlr doesnt work right now" do
+    cls, = compile(<<-EOF)
+      class NLRTwoClosure
+        def foo(a: Runnable)
+          a.run
+          puts "doesn't get here"
+        end
+      end
+      def nlr(flag: boolean): String
+        if flag
+          NLRTwoClosure.new.foo { return "NLR!" }
+        else
+          NLRTwoClosure.new.foo { return "NLArrrr" }
+        end
+        "nor here either"
+      end
+      puts nlr true
+      puts nlr false
+    EOF
+    assert_output "NLR!\nNLArrrr\n" do
+      cls.main(nil)
+    end
+    end
+  end
+
+  def test_two_nlr_closures_in_the_same_method
+    pend "nlr doesnt work right now" do
+    # this has a binding generation problem
+    cls, = compile(<<-EOF)
+      class NonLocalMe2
+        def foo(a: Runnable)
+          a.run
+          puts "may get here"
+        end
+      end
+      def nlr(flag: boolean): String
+        NonLocalMe2.new.foo { return "NLR!" if flag }
+        NonLocalMe2.new.foo { return "NLArrrr" unless flag }
+        "but not here"
+      end
+      puts nlr true
+      puts nlr false
+    EOF
+    assert_output "NLR!\nmay get here\nNLArrrr\n" do
+      cls.main(nil)
+    end
+    end
+  end
+
+
+  def test_two_closures_in_the_same_method
+    cls, = compile(<<-EOF)
+      def foo(a: Runnable)
+        a.run
+      end
+      def regular: String
+        foo { puts "Closure!" }
+        foo { puts "We Want it" }
+        "finish"
+      end
+      regular
+    EOF
+    assert_output "Closure!\nWe Want it\n" do
+      cls.main(nil)
+    end
+  end
+
+  # nested nlr scopes
+
+# works with script as end
+  # non-local-return when return type incompat, has sensible error
+  # non-local-return when multiple non-local-return blocks in same method
+  # non-local-return when multiple non-local-return blocks in same method, in if statment
+  # non-local-return when multiple non-local-return block with multiple returns
+  #    
 end