mirah 0.1.2-java → 0.1.3-java

data/test/core/commands_test.rb

@@ -1,89 +0,0 @@
-# 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.
-require 'test_helper'
-
-
-class CommandsTest < Test::Unit::TestCase
-  class RaisesMirahErrorCommand < Mirah::Commands::Base
-    def execute
-      execute_base { raise Mirah::MirahError, "just an error" }
-    end
-    def command_name; :foo; end
-  end
-
-  class MirahProcessesErrorCommand < Mirah::Commands::Base
-    include  Mirah::Util::ProcessErrors
-    def execute
-      execute_base { process_errors [Mirah::NodeError.new("just an error")] }
-    end
-    def command_name; :foo; end
-  end
-
-  class SuccessfulCommand < Mirah::Commands::Base
-    def execute
-      execute_base { "something" }
-    end
-    def command_name; :foo; end
-  end
-
-  def test_on_Mirah_error_has_non_zero_exit_code
-    assert_non_zero_exit do
-      RaisesMirahErrorCommand.new([]).execute
-    end
-  end
-
-  def test_on_bad_argument_has_non_zero_exit_code
-    assert_non_zero_exit do
-      RaisesMirahErrorCommand.new(['-bad-argument']).execute
-    end
-  end
-
-  def test_on_v_with_no_args_exits_without_running_command
-    assert_zero_exit do
-      RaisesMirahErrorCommand.new(['-v']).execute
-    end
-  end
-
-  def test_on_j_option_when_command_is_not_compile_has_non_zero_exit_code
-    assert_non_zero_exit do
-      RaisesMirahErrorCommand.new(['-j']).execute
-    end
-  end
-
-  def test_success_is_truthy
-    assert SuccessfulCommand.new([]).execute, "expected it to be truthy"
-  end
-
-  def test_process_errors_causes_a_non_zero_exit
-    assert_non_zero_exit do
-      MirahProcessesErrorCommand.new([]).execute
-    end
-  end
-
-  def assert_non_zero_exit
-    ex = assert_raise SystemExit do
-      yield
-    end
-    assert_not_equal 0, ex.status
-  end
-
-  def assert_zero_exit
-    ex = assert_raise SystemExit do
-      yield
-    end
-    assert_equal 0, ex.status
-  end
-
-end

data/test/core/generator_test.rb

@@ -1,26 +0,0 @@
-# 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.
-require 'test_helper'
-
-
-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

data/test/jvm/bytecode_test_helper.rb

@@ -1,193 +0,0 @@
-# Copyright (c) 2010-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'
-require 'set'
-
-module JVMCompiler
-  $CLASSPATH << TEST_DEST
-
-  java_import 'java.lang.System'
-  java_import 'java.io.PrintStream'
-  java_import 'java.net.URLClassLoader'
-  java_import 'org.jruby.javasupport.JavaClass'
-
-  include Mirah
-
-  def new_state
-    state = Mirah::Util::CompilationState.new
-    state.save_extensions = true
-    state.destination = TEST_DEST
-    state.classpath =  Env.encode_paths [TEST_DEST, FIXTURE_TEST_DEST]
-    state.type_system = type_system if type_system
-    state
-  end
-
-  def type_system
-    nil
-  end
-
-  def clean_tmp_files
-    return unless @tmp_classes
-    File.unlink(*@tmp_classes)
-  end
-
-  def compiler_type
-    JVM::Compiler::JVMBytecode
-  end
-
-  def compiler_name
-    "original"
-  end
-
-  def parse name, code, transformer
-    AST.parse(code, name, true, transformer)
-  end
-
-  def infer_and_resolve_types ast, generator
-    scoper, typer = generator.infer_asts(ast, true)
-    ast
-  end
-
-  def parse_and_resolve_types name, code
-    state = new_state
-
-    generator = Mirah::Generator.new(state, compiler_type, false, false)
-    transformer = Mirah::Transform::Transformer.new(state, generator.typer)
-
-    ast = [AST.parse(code, name, true, transformer)]
-
-    infer_and_resolve_types ast, generator
-
-    ast
-  end
-
-  def generate_classes compiler_results, state
-    classes = {}
-
-    compiler_results.each do |result|
-      bytes = result.bytes
-      filename = "#{TEST_DEST}#{result.filename}"
-      FileUtils.mkdir_p(File.dirname(filename))
-      File.open(filename, 'wb') { |f| f.write(bytes) }
-      @tmp_classes << filename
-      classes[result.filename[0..-7]] = Mirah::Util::ClassLoader.binary_string bytes
-    end
-
-    loader = Mirah::Util::ClassLoader.new(
-       URLClassLoader.new(
-                          Mirah::Env.make_urls(state.classpath),
-                          JRuby.runtime.jruby_class_loader),
-      classes)
-
-    classes.keys.map do |name|
-      cls = loader.load_class(name.tr('/', '.'))
-      JavaUtilities.get_proxy_class(JavaClass.get(JRuby.runtime, cls))
-    end
-  end
-
-  def compile(code, options = {})
-    name = options.delete :name
-    name ||= tmp_script_name
-
-    state = new_state
-    java_version = options.delete :java_version
-    if java_version
-      state.set_jvm_version java_version
-    end
-
-    generator = Mirah::Generator.new(state, compiler_type, false, false)
-    transformer = Mirah::Transform::Transformer.new(state, generator.typer)
-
-    ast = [AST.parse_ruby(nil, code, name)]
-
-    scoper, typer = generator.infer_asts(ast, true)
-    generator.do_transforms ast
-    compiler_results = generator.compiler.compile_asts(ast, scoper, typer)
-
-    generate_classes compiler_results, state
-  end
-
-  def tmp_script_name
-    "script#{name.gsub(/\)|\(/,'_').capitalize}#{System.nano_time}"
-  end
-end
-
-
-module CommonAssertions
-  java_import 'java.lang.System'
-  java_import 'java.io.PrintStream'
-
-  def assert_include(value, array, message=nil)
-    message = build_message message, '<?> does not include <?>', array, value
-    assert_block message do
-      array.include? value
-    end
-  end
-
-  def capture_output
-    saved_output = System.out
-    output = StringIO.new
-    System.setOut(PrintStream.new(output.to_outputstream))
-    begin
-      yield
-      output.rewind
-      output.read
-    ensure
-      System.setOut(saved_output)
-    end
-  end
-
-  def assert_output(expected, &block)
-    assert_equal(expected, capture_output(&block))
-  end
-
-  def assert_raise_java(type, message=nil)
-    begin
-      yield
-    rescue Exception => e
-      ex = e
-    end
-    ex = ex.cause if ex.is_a? NativeException
-    assert_equal type, ex.class
-    if message
-      assert_equal message,
-                   ex.message.to_s,
-                  "expected error message to be '#{message}' but was '#{ex.message}'"
-    end
-    ex
-  end
-end
-
-module DebuggingHelp
-  def with_finest_logging
-    Mirah::Logging::MirahLogger.level = Mirah::Logging::Level::FINEST
-    yield
-  ensure
-    Mirah::Logging::MirahLogger.level = Mirah::Logging::Level::INFO
-  end
-end
-
-class Test::Unit::TestCase
-  include JVMCompiler
-  include DebuggingHelp
-
-  def setup
-    @tmp_classes = Set.new
-  end
-
-  def cleanup
-    clean_tmp_files
-  end
-end

data/test/jvm/factory_test.rb

@@ -1,28 +0,0 @@
-# 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 FactoryTest < Test::Unit::TestCase
-  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/java_typer_test.rb

@@ -1,283 +0,0 @@
-# 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.
-
-require 'test/unit'
-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
-    @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, nil)
-    @mirah = Mirah::Transform::Transformer.new(Mirah::Util::CompilationState.new, @typer)
-  end
-
-  def inferred_type(node, expression=false)
-    if node.kind_of? Java::MirahLangAst::Script
-      node = node.body
-    end
-    type = @typer.infer(node, expression).resolve
-    if type.name == ':error'
-      catch(:exit) do
-        process_errors([type])
-      end
-    end
-    type
-  end
-
-  def assert_errors_including(message, ast)
-    @typer.infer(ast, false)
-    actual_errors = []
-    process_inference_errors(@typer, [ast]) do |errors|
-      actual_errors += errors.map {|e| e.message.map{|m| m[0]}.join("\n")}
-    end
-    fail("no errors") if actual_errors.empty?
-    assert actual_errors.any?{|error| error =~ message },
-           "no errors with message \"#{message}\" in #{actual_errors}"
-  end
-
-  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, true, name, args, nil, nil)
-    @types.getMethodType(call).return_type
-  end
-
-  def parse(text)
-    AST.parse(text, '-', false, @mirah)
-  end
-
-  def test_simple_overtyped_meta_method
-    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 = @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 = @types.type(nil, 'char', true)
-    return_type = method_type(string_meta, 'valueOf', [type])
-    assert_equal(string, return_type.resolve)
-
-    # Object
-    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 = @types.type(nil, 'java.lang.String')
-
-    int = @types.type(nil, 'int')
-    return_type = method_type(string, 'length', [])
-    assert_equal(int, return_type.resolve)
-
-    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 = @types.type(nil, 'java.lang.String', false, true)
-    string = @types.type(nil, 'java.lang.String')
-
-    return_type = method_type(string_meta, 'valueOf', [string])
-    assert_equal(string, return_type.resolve)
-  end
-
-  def test_primitive_conversion_method
-    string = @types.type(nil, 'java.lang.String')
-    byte = @types.type(nil, 'byte')
-    char = @types.type(nil, 'char')
-    long = @types.type(nil, 'long')
-
-    return_type = method_type(string, 'charAt', [byte])
-    assert_kind_of(TypeFuture, return_type)
-    assert_equal(char, return_type.resolve)
-
-    return_type = method_type(string, 'charAt', [long]).resolve
-    assert(return_type.isError)
-  end
-
-  include Mirah::JVM::MethodLookup
-
-  def test_is_more_specific
-    object = @types.type(nil, 'java.lang.Object')
-    charseq = @types.type(nil, 'java.lang.CharSequence')
-    string = @types.type(nil, 'java.lang.String')
-
-    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 = @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)
-    assert !primitive_convertible?(boolean, char)
-    assert !primitive_convertible?(boolean, int)
-    assert !primitive_convertible?(boolean, long)
-    assert !primitive_convertible?(boolean, float)
-    assert !primitive_convertible?(boolean, double)
-    assert primitive_convertible?(boolean, boolean)
-
-    assert !primitive_convertible?(byte, boolean)
-    assert primitive_convertible?(byte, byte)
-    assert primitive_convertible?(byte, short)
-    assert !primitive_convertible?(byte, char)
-    assert primitive_convertible?(byte, int)
-    assert primitive_convertible?(byte, long)
-    assert primitive_convertible?(byte, float)
-    assert primitive_convertible?(byte, double)
-
-    assert !primitive_convertible?(short, boolean)
-    assert !primitive_convertible?(short, byte)
-    assert !primitive_convertible?(short, char)
-    assert primitive_convertible?(short, short)
-    assert primitive_convertible?(short, int)
-    assert primitive_convertible?(short, long)
-    assert primitive_convertible?(short, float)
-    assert primitive_convertible?(short, double)
-
-    assert !primitive_convertible?(char, boolean)
-    assert !primitive_convertible?(char, byte)
-    assert !primitive_convertible?(char, short)
-    assert primitive_convertible?(char, char)
-    assert primitive_convertible?(char, int)
-    assert primitive_convertible?(char, long)
-    assert primitive_convertible?(char, float)
-    assert primitive_convertible?(char, double)
-
-    assert !primitive_convertible?(int, boolean)
-    assert !primitive_convertible?(int, byte)
-    assert !primitive_convertible?(int, short)
-    assert !primitive_convertible?(int, char)
-    assert primitive_convertible?(int, int)
-    assert primitive_convertible?(int, long)
-    assert primitive_convertible?(int, float)
-    assert primitive_convertible?(int, double)
-
-    assert !primitive_convertible?(long, boolean)
-    assert !primitive_convertible?(long, byte)
-    assert !primitive_convertible?(long, short)
-    assert !primitive_convertible?(long, char)
-    assert !primitive_convertible?(long, int)
-    assert primitive_convertible?(long, long)
-    assert primitive_convertible?(long, float)
-    assert primitive_convertible?(long, double)
-
-    assert !primitive_convertible?(float, boolean)
-    assert !primitive_convertible?(float, byte)
-    assert !primitive_convertible?(float, short)
-    assert !primitive_convertible?(float, char)
-    assert !primitive_convertible?(float, int)
-    assert !primitive_convertible?(float, long)
-    assert primitive_convertible?(float, float)
-    assert primitive_convertible?(float, double)
-
-    assert !primitive_convertible?(double, boolean)
-    assert !primitive_convertible?(double, byte)
-    assert !primitive_convertible?(double, short)
-    assert !primitive_convertible?(double, char)
-    assert !primitive_convertible?(double, int)
-    assert !primitive_convertible?(double, long)
-    assert !primitive_convertible?(double, float)
-    assert primitive_convertible?(double, double)
-  end
-
-  def test_primitive_array
-    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
-
-
-  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 = parse("#{1 << 16}")
-    assert_equal(@types.type(nil, 'int'), inferred_type(ast))
-  end
-
-  def test_long
-    ast = parse("#{1 << 33}")
-    assert_equal(@types.type(nil, 'long'), inferred_type(ast))
-  end
-  
-  def test_char
-    ast = parse("?a")
-    assert_equal(@types.type(nil, 'char'), inferred_type(ast))
-  end
-
-  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
-
-  def test_if_with_raise_has_non_raise_type
-    ast = parse("if true; 1; else; raise 'error'; end")
-    assert_equal(@types.type(nil, 'int'), inferred_type(ast))
-  end
-
-  def test_rescue_with_raise_in_rescue_has_body_type
-    ast = parse("1 + begin; 1; rescue; raise 'error'; end")
-    assert_equal(@types.type(nil, 'int'), inferred_type(ast))
-  end
-
-  def test_rescue_with_else_and_raise_in_rescue_has_else_type
-    ast = parse("1 + begin; ''; rescue; raise 'error'; else 1 end")
-    assert_equal(@types.type(nil, 'int'), inferred_type(ast))
-  end
-
-  def test_type_cycle
-    ast = parse(<<-EOF)
-      def foo(a:String):Object
-        nil
-      end
-
-      a = "x"
-      a = foo(a)
-    EOF
-    assert_errors_including(/Cannot assign .*Object.* to .*String/, ast)
-  end
-end