mirah 0.0.12-java → 0.1.0-java

data/test/core/env_test.rb

@@ -25,7 +25,7 @@ class EnvTest < Test::Unit::TestCase
     abc = %w[a b c]
     assert_equal(abc.join(Mirah::Env.path_separator), Mirah::Env.encode_paths(abc))
   end
-  
+
   def test_encode_paths_with_single_element
     assert_equal('a', Mirah::Env.encode_paths(['a']))
   end
@@ -38,17 +38,17 @@ class EnvTest < Test::Unit::TestCase
     paths_to_append = %w[a b c d]
     encoded_paths = paths_to_append.join Mirah::Env.path_separator
     path_array = ['1','2']
-    
+
     assert_equal(['1','2','a','b','c','d'], Mirah::Env.decode_paths(encoded_paths, path_array))
     assert_equal(['1','2','a','b','c','d'], path_array)
   end
-  
+
   def test_decode_paths_with_empty_list
     assert_equal([], Mirah::Env.decode_paths(''))
   end
-  
+
   def test_decode_paths_with_single_element
     assert_equal(['a'], Mirah::Env.decode_paths('a'))
   end
-  
+
 end

data/{lib/mirah/jvm/source_generator/typer.rb → test/core/generator_test.rb}

@@ -12,15 +12,15 @@
 # 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 'mirah/jvm/typer'
-require 'mirah/jvm/source_generator/builder'
 
-module Mirah
-  module Typer
-    class JavaSource < JVM
-      include Mirah::JVM::Types
-      
-    end
+class GeneratorTest < Test::Unit::TestCase
+  def test_generator_sets_classpath_bootclasspath_on_type_system
+
+    state =  Mirah::Util::CompilationState.new
+    state.bootclasspath = "a:b"
+    generator = Mirah::Generator.new(state, Mirah::JVM::Compiler::JVMBytecode, false, false)
+    assert state.bootclasspath == generator.typer.type_system.bootclasspath
   end
-end
+end

data/test/core/typer_test.rb

@@ -16,240 +16,278 @@ require 'test_helper'
 
 class TyperTest < Test::Unit::TestCase
   include Mirah
+  include Mirah::Util::ProcessErrors
+  java_import 'org.mirah.typer.TypeFuture'
+  java_import 'org.mirah.typer.simple.SimpleScoper'
+  java_import 'org.mirah.typer.simple.SimpleTypes'
+  java_import 'mirah.lang.ast.VCall'
+  java_import 'mirah.lang.ast.FunctionalCall'
+  java_import 'mirah.lang.ast.LocalAccess'
+
+  module TypeFuture
+    def inspect
+      toString
+    end
+  end
 
-  def test_fixnum
-    ast = AST.parse("1")
+  def setup
+    @scopes = SimpleScoper.new
+    new_typer('Bar')
+  end
 
-    assert_equal(AST::TypeReference.new("fixnum"), ast.infer(Typer::Simple.new(:bar), true))
+  def parse(text)
+    AST.parse(text, '-', false, @mirah)
   end
 
-  def test_float
-    ast = AST.parse("1.0")
+  def new_typer(n)
+    @types = SimpleTypes.new(n.to_s)
+    @typer = Mirah::Typer::Typer.new(@types, @scopes, nil)
+    @mirah = Transform::Transformer.new(Mirah::Util::CompilationState.new, @typer)
+    @typer
+  end
 
-    assert_equal(AST::TypeReference.new("float"), ast.infer(Typer::Simple.new(:bar), true))
+  def inferred_type(node)
+    type = @typer.infer(node, false).resolve
+    if type.name == ':error'
+      catch(:exit) do
+        process_errors([type])
+      end
+    end
+    type
+  end
+
+  def assert_no_errors(typer, ast)
+    process_inference_errors(typer, [ast]) do |errors|
+      errors.each {|e| add_failure(e.message)}
+    end
+  end
+
+  def assert_errors_including(message, typer, ast)
+    actual_errors = []
+    process_inference_errors(typer, [ast]) do |errors|
+      actual_errors += errors
+    end
+    fail("no errors") if actual_errors.empty?
+    assert actual_errors.any?{|error| error.message.join("\n").include? message },
+           "no errors with message \"#{message}\" in [#{actual_errors}"
+  end
+
+  def infer(ast, expression=true)
+    new_typer(:bar).infer(ast, expression)
+    inferred_type(ast)
+  end
+
+  def test_fixnum
+    ast = parse("1")
+    assert_equal(@types.getFixnumType(1), infer(ast))
+  end
+
+  def test_float
+    ast = parse("1.0")
+    new_typer(:bar).infer(ast, true)
+    assert_equal(@types.getFloatType(1.0), infer(ast))
   end
 
   def test_string
-    ast = AST.parse("'foo'")
+    ast = parse("'foo'")
 
-    assert_equal(AST::TypeReference.new("string"), ast.infer(Typer::Simple.new(:bar), true))
+    assert_equal(@types.getStringType, infer(ast))
   end
 
   def test_boolean
-    ast1 = AST.parse("true")
-    ast2 = AST.parse("false")
+    ast1 = parse("true")
+    ast2 = parse("false")
 
-    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))
+    assert_equal(@types.getBooleanType, infer(ast1))
+    assert_equal(@types.getBooleanType, infer(ast2))
   end
 
   def test_body
-    ast1 = AST.parse("'foo'; 1.0; 1")
-    ast2 = AST.parse("begin; end")
+    ast1 = parse("'foo'; 1.0; 1")
+    ast2 = parse("begin; end")
 
-    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))
+    assert_equal(@types.getFixnumType(1), infer(ast1))
+    assert_equal(@types.getNullType, infer(ast2))
   end
 
   def test_local
-    ast1 = AST.parse("a = 1; a")
-    typer = Typer::Simple.new :bar
+    ast1 = parse("a = 1; a")
+    infer(ast1)
 
-    ast1.infer(typer, true)
+    assert_equal(@types.getFixnumType(1), @types.getLocalType(@scopes.getScope(ast1), 'a', nil).resolve)
+    assert_equal(@types.getFixnumType(1), inferred_type(ast1.body.get(0)))
+    assert_equal(@types.getFixnumType(1), inferred_type(ast1.body.get(1)))
 
-    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 = parse("b = a = 1")
+    infer(ast2)
 
-    ast2 = AST.parse("b = a = 1")
-    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)
+    assert_equal(@types.getFixnumType(1), @types.getLocalType(@scopes.getScope(ast2), 'a', nil).resolve)
+    assert_equal(@types.getFixnumType(1), inferred_type(ast2.body.get(0)))
   end
 
   def test_signature
-    ["def foo", "def self.foo"].each do |def_foo|
-      ast1 = AST.parse("#{def_foo}(a:string); end")
-      typer = Typer::Simple.new :bar
-
-      ast1.infer(typer, true)
+    signature_test(false)
+  end
 
-      assert_nothing_raised {typer.resolve(true)}
-      assert_nothing_raised {typer.resolve}
+  def test_static_signature
+    signature_test(true)
+  end
 
+  def signature_test(is_static)
+    if is_static
+      def_foo = "def self.foo"
+    else
+      def_foo = "def foo"
+    end
+    ast1 = parse("#{def_foo}(a:String); end")
+    typer = new_typer(:bar)
+    typer.infer(ast1, true)
 
-      if def_foo =~ /self/
-        type = typer.self_type.meta
-      else
-        type = typer.self_type
-      end
+    assert_no_errors(typer, ast1)
 
-      assert_equal(typer.null_type, typer.method_type(type, 'foo', [typer.string_type]))
-      assert_equal(typer.string_type, typer.local_type(ast1.body[0].static_scope, 'a'))
-      assert_equal(typer.null_type, ast1.body.inferred_type)
-      assert_equal(typer.string_type, ast1.body[0].arguments.args[0].inferred_type)
 
-      ast1 = AST.parse("#{def_foo}(a:string); a; end")
-      typer = Typer::Simple.new :bar
+    type = @types.getMainType(@scopes.getScope(ast1), ast1)
+    type = @types.getMetaType(type) if is_static
 
-      ast1.infer(typer, true)
+    mdef = ast1.body.get(0)
+    inner_scope = @scopes.getScope(mdef.body)
 
-      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'))
-      assert_equal(typer.string_type, ast1.body[0].inferred_type)
-      assert_equal(typer.string_type, ast1.body[0].arguments.args[0].inferred_type)
+#    assert_equal(@types.getNullType, @types.getMethodType(type, 'foo', [@types.getStringType.resolve]).resolve)
+    assert_equal(@types.getStringType, @types.getLocalType(inner_scope, 'a', nil).resolve)
+    assert_equal(@types.getNullType, inferred_type(mdef).returnType)
+    assert_equal(@types.getStringType, inferred_type(mdef.arguments.required.get(0)))
 
-      ast1 = AST.parse("#{def_foo}(a) returns :string; end")
-      typer = Typer::Simple.new :bar
+    ast1 = parse("#{def_foo}(a:String); a; end")
+    typer = new_typer :bar
+    typer.infer(ast1, true)
+    mdef = ast1.body.get(0)
+    inner_scope = @scopes.getScope(mdef.body)
 
-      assert_raise(Typer::InferenceError) do
-        ast1.infer(typer, true)
-        typer.resolve(true)
-      end
-    end
+    # assert_equal(@types.getStringType, @types.getMethodType(type, 'foo', [@types.getStringType.resolve]).resolve)
+    assert_equal(@types.getStringType, @types.getLocalType(inner_scope, 'a', nil).resolve)
+    assert_equal(@types.getStringType, inferred_type(mdef).returnType)
+    assert_equal(@types.getStringType, inferred_type(mdef.arguments.required.get(0)))
   end
 
   def test_call
-    ast = AST.parse("1.foo(2)").body
-    typer = Typer::Simple.new "bar"
-
-    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, true)
+    ast = parse("class Int;def foo(a:Int):String; end; end; 1.foo(2)")
 
-    assert_equal(typer.string_type, ast.inferred_type)
+    assert_equal(@types.getStringType, infer(ast))
 
-    ast = AST.parse("def bar(a:fixnum, b:string); 1.0; end; def baz; bar(1, 'x'); end")
+    ast = parse("def bar(a:Int, b:String); 1.0; end; def baz; bar(1, 'x'); end")
 
-    ast.infer(typer, true)
+    infer(ast)
     ast = ast.body
-
-    assert_equal(typer.float_type, typer.method_type(typer.self_type, "bar", [typer.fixnum_type, typer.string_type]))
-    assert_equal(typer.float_type, typer.method_type(typer.self_type, "baz", []))
-    assert_equal(typer.float_type, ast.children[0].inferred_type)
-    assert_equal(typer.float_type, ast.children[1].inferred_type)
+    self_type = @scopes.getScope(ast.get(0)).selfType
+    assert_equal(@types.getFloatType(1.0), inferred_type(ast.get(0)).returnType)
+    assert_equal(@types.getFloatType(1.0), inferred_type(ast.get(1)).returnType)
 
     # Reverse the order, ensure deferred inference succeeds
-    ast = AST.parse("def baz; bar(1, 'x'); end; def bar(a:fixnum, b:string); 1.0; end")
-    typer = Typer::Simple.new("bar")
+    ast = parse("def baz; bar(1, 'x'); end; def bar(a:Int, b:String); 1.0; end")
+    typer = new_typer("bar")
 
-    ast.infer(typer, true)
+    typer.infer(ast, true)
     ast = ast.body
 
-    assert_equal(typer.default_type, typer.method_type(typer.self_type, "baz", []))
-    assert_equal(typer.float_type, typer.method_type(typer.self_type, "bar", [typer.fixnum_type, typer.string_type]))
-    assert_equal(typer.default_type, ast.children[0].inferred_type)
-    assert_equal(typer.float_type, ast.children[1].inferred_type)
-
-    # allow resolution to run
-    assert_nothing_raised {typer.resolve}
+    assert_no_errors(typer, ast)
 
-    assert_equal(typer.float_type, typer.method_type(typer.self_type, "baz", []))
-    assert_equal(typer.float_type, typer.method_type(typer.self_type, "bar", [typer.fixnum_type, typer.string_type]))
-    assert_equal(typer.float_type, ast.children[0].inferred_type)
-    assert_equal(typer.float_type, ast.children[1].inferred_type)
+    assert_equal(@types.getFloatType(1.0), inferred_type(ast.get(0)).returnType)
+    assert_equal(@types.getFloatType(1.0), inferred_type(ast.get(1)).returnType)
 
     # modify bar call to have bogus types, ensure resolution fails
-    ast = AST.parse("def baz; bar(1, 1); end; def bar(a:fixnum, b:string); 1.0; end")
-    typer = Typer::Simple.new("bar")
+    ast = parse("def baz; bar(1, 1); end; def bar(a:Int, b:String); 1.0; end")
+    typer = new_typer("bar")
 
-    ast.infer(typer, true)
+    typer.infer(ast, true)
     ast = ast.body
 
-    assert_equal(typer.default_type, typer.method_type(typer.self_type, "baz", []))
-    assert_equal(typer.float_type, typer.method_type(typer.self_type, "bar", [typer.fixnum_type, typer.string_type]))
-    assert_equal(typer.default_type, ast.children[0].inferred_type)
-    assert_equal(typer.float_type, ast.children[1].inferred_type)
-
-    # allow resolution to run and produce error
-    assert_raise(Typer::InferenceError) {typer.resolve(true)}
-    error_nodes = typer.errors.map {|e| e.node}
-    inspected = "[FunctionalCall(bar)\n Fixnum(1)\n Fixnum(1)]"
-    assert_equal(inspected, error_nodes.inspect)
+    assert_equal(":error", inferred_type(ast.get(0)).name)
+    assert_equal(@types.getFloatType(1.0), inferred_type(ast.get(1)).returnType)
   end
 
   def test_if
-    ast = AST.parse("if true; 1.0; else; ''; end").body[0]
-    typer = Typer::Simple.new("bar")
+    ast = parse("if true; 1.0; else; ''; end").body
 
     # incompatible body types
-    assert_raise(Typer::InferenceError) {ast.infer(typer, true)}
-    assert_nothing_raised {ast.infer(typer, false)}
+    assert_equal(':error', infer(ast).name)
 
-    ast = AST.parse("if true; 1.0; else; 2.0; end").body[0]
+    ast = parse("if true; 1.0; else; 2.0; end").body.get(0)
 
-    assert_nothing_raised {ast.infer(typer, true); typer.resolve(true)}
+    assert_not_equal(':error', infer(ast).name)
 
-    assert_equal(typer.boolean_type, ast.condition.inferred_type)
-    assert_equal(typer.float_type, ast.body.inferred_type)
-    assert_equal(typer.float_type, ast.else.inferred_type)
+    assert_equal(@types.getBooleanType, inferred_type(ast.condition))
+    assert_equal(@types.getFloatType(1.0), inferred_type(ast.body))
+    assert_equal(@types.getFloatType(1.0), inferred_type(ast.elseBody))
 
-    ast = AST.parse("if foo; bar; else; baz; end").body[0]
+    typer = new_typer(:Bar)
 
-    assert_nothing_raised {ast.infer(typer, true)}
+    ast = parse("if foo; bar; else; baz; end").body.get(0)
+    typer.infer(ast.parent.parent, true)
+    assert_equal(':error', inferred_type(ast).name)
 
-    assert_equal(typer.default_type, ast.condition.inferred_type)
-    assert_equal(typer.default_type, ast.body.inferred_type)
-    assert_equal(typer.default_type, ast.else.inferred_type)
+    ast2 = parse("def foo; 1; end; def bar; 1.0; end")
 
-    # unresolved types for the foo, bar, and baz calls
-    assert_raise(Typer::InferenceError) {typer.resolve(true)}
+    typer.infer(ast2, true)
 
-    ast2 = AST.parse("def foo; 1; end; def bar; 1.0; end")
+    # unresolved types for the baz call
+    assert_equal(':error', inferred_type(ast.elseBody).name)
 
-    ast2.infer(typer, true)
-    ast.infer(typer, true)
+    assert_equal(@types.getFixnumType(1), inferred_type(ast.condition))
+    assert_equal(@types.getFloatType(1.0), inferred_type(ast.body))
 
-    # unresolved types for the baz call
-    assert_raise(Typer::InferenceError) {typer.resolve(true)}
-
-    # the condition isn't a boolean
-    assert_equal(AST.error_type, ast.condition.inferred_type)
-
-    # TODO this portion of the test no longer works
-    #
-    ## the body types are errors because the types don't match
-    #assert_equal(AST.error_type, ast.body.inferred_type)
-    #assert_equal(AST.error_type, ast.else.inferred_type)
-
-    #typer.errors.clear
-    ## replacing baz w/ one that has a compatible type
-    #ast2 = AST.parse("def baz; 2.0; end")
-    #
-    #ast2.infer(typer, true)
-    #ast.infer(typer, true)
-    #
-    #assert_nothing_raised {typer.resolve(true)}
-    #
-    #assert_equal(typer.float_type, ast2.body[0].inferred_type)
-  end
-  
-  def test_rescue_w_different_type_raises_inference_error_when_expression
-    ast = AST.parse("begin true; 1.0; rescue; ''; end").body[0]
-    typer = Typer::Simple.new("bar")
+    ast2 = parse("def baz; 2.0; end")
+    typer.infer(ast2, true)
 
-    assert_raise(Mirah::InferenceError) {ast.infer(typer, true)}
+    assert_equal(@types.getFloatType(1.0), inferred_type(ast2.body).returnType)
+
+    assert_equal(@types.getFloatType(1.0), inferred_type(ast))
+    assert_equal(@types.getFloatType(1.0), inferred_type(ast.elseBody))
   end
 
-  def test_rescue_w_different_type_doesnt_raise_inference_error_when_statement
-    ast = AST.parse("begin true; 1.0; rescue; ''; end").body[0]
-    typer = Typer::Simple.new("bar")
+  def test_class
+    ast = parse("class Foo; def foo; 1; end; def baz; foo; end; end")
+    cls = ast.body.get(0)
+    foo = cls.body.get(0)
+    baz = cls.body.get(1)
+
+    typer = new_typer("script")
+    typer.infer(ast, true)
+
+    assert_no_errors(typer, ast)
+  end
 
-    assert_nothing_raised {ast.infer(typer, false)}
+  def test_rescue_w_different_type_raises_inference_error_when_expression
+    ast = parse("1 + begin true; 1.0; rescue; ''; end")
+    infer(ast, true)
+    assert_errors_including "Incompatible types", @typer, ast
   end
 
+  def test_rescue_w_different_type_doesnt_raise_inference_error_when_statement
+    ast = parse("begin true; 1.0; rescue; ''; end")
+    infer(ast, false)
+    assert_no_errors @typer, ast
+  end
 
-  def test_class
-    ast = AST.parse("class Foo; def foo; 1; end; def baz; foo; end; end")
-    cls = ast.body[0]
-    foo = cls.body[0]
-    baz = cls.body[1]
+  def test_colon2
+    ast = parse("java::lang::System.out")
+    infer(ast)
+    target_type = inferred_type(ast.body(0).target)
+    assert_equal('java.lang.System', target_type.name)
+  end
 
-    typer = Typer::Simple.new("script")
-    ast.infer(typer, true)
+  def test_static_method
+    ast = parse("class Foo; def self.bar;1; end; end; Foo.bar")
+    assert_equal(@types.getFixnumType(1), infer(ast))
+  end
 
-    assert_nothing_raised {typer.resolve(true)}
+  def test_vcall
+    ast = parse("foo = 1; def squeak; nil; end; foo; squeak")
+    assert_kind_of(VCall, ast.body(2))
+    assert_kind_of(VCall, ast.body(3))
+    infer(ast)
+    assert_equal(@types.getFixnumType(1), inferred_type(ast.body(2)))
+    assert_equal(@types.getNullType, inferred_type(ast.body(3)))
+    assert_kind_of(LocalAccess, ast.body(2))
+    assert_kind_of(FunctionalCall, ast.body(3))
   end
 end