mirah 0.1.1-java → 0.1.2-java

data/test/jvm/bytecode_test_helper.rb

@@ -16,18 +16,20 @@ require 'test_helper'
 require 'set'
 
 module JVMCompiler
-  TEST_DEST = File.expand_path(File.dirname(__FILE__)+'/../../tmp_test/') + "/"
   $CLASSPATH << TEST_DEST
 
-  import java.lang.System
-  import java.io.PrintStream
+  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 =  TEST_DEST
+    state.classpath =  Env.encode_paths [TEST_DEST, FIXTURE_TEST_DEST]
     state.type_system = type_system if type_system
     state
   end
@@ -71,7 +73,7 @@ module JVMCompiler
     ast
   end
 
-  def generate_classes compiler_results
+  def generate_classes compiler_results, state
     classes = {}
 
     compiler_results.each do |result|
@@ -83,11 +85,15 @@ module JVMCompiler
       classes[result.filename[0..-7]] = Mirah::Util::ClassLoader.binary_string bytes
     end
 
-    loader = Mirah::Util::ClassLoader.new(JRuby.runtime.jruby_class_loader, classes)
+    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(cls.name)
+      JavaUtilities.get_proxy_class(JavaClass.get(JRuby.runtime, cls))
     end
   end
 
@@ -107,9 +113,10 @@ module JVMCompiler
     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
+    generate_classes compiler_results, state
   end
 
   def tmp_script_name
@@ -119,8 +126,8 @@ end
 
 
 module CommonAssertions
-  import java.lang.System
-  import java.io.PrintStream
+  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

data/test/jvm/jvm_commands_test.rb

@@ -21,4 +21,14 @@ class JVMCommandsTest < Test::Unit::TestCase
       Mirah::Commands::Run.new(['-e','puts 1']).execute
     end
   end
+
+  def test_runtime_classpath_modifications
+    assert_output "1234\n" do
+      Mirah::Commands::Run.new(['-c', FIXTURE_TEST_DEST,
+                                '-e',
+                                  'import org.foo.LowerCaseInnerClass
+                                  puts LowerCaseInnerClass.inner.field']
+                              ).execute
+    end
+  end
 end

data/test/jvm/string_builder_extensions_test.rb

@@ -0,0 +1,49 @@
+# 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 StringBuilderExtensionsTest < Test::Unit::TestCase
+  def test_string_builder_greetings
+    result = '<p>Greetings are: hello hola ciao salut hallo</p>'
+    cls, = compile(<<-EOF)
+    def greetings
+      languages = ['hello ', 'hola ', 'ciao ', 'salut ', 'hallo']
+      greetings = StringBuilder.new
+      greetings << '<p>Greetings are: '
+      languages.each { |greet| greetings << greet }
+      greetings << '</p>'
+      greetings.toString
+    end
+    EOF
+    assert_equal result, cls.greetings
+  end
+
+  def test_string_builder_shovel_object
+    cls, = compile(<<-EOF)
+    class MyObject
+      def toString
+        "Hey, I am a shiny instance of \#{getClass.getName}"
+      end
+    end
+
+    def shovel_object
+      sb = StringBuilder.new
+      sb << MyObject.new
+      sb.toString
+    end
+    EOF
+    result = 'Hey, I am a shiny instance of MyObject'
+    assert_equal result, cls.shovel_object
+  end
+end

data/test/jvm/{string_test.rb → string_extensions_test.rb}

@@ -13,7 +13,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-class StringTest < Test::Unit::TestCase
+class StringExtensionsTest < Test::Unit::TestCase
 
   def test_string_concat
     cls, = compile("
@@ -38,4 +38,35 @@ class StringTest < Test::Unit::TestCase
     assert_equal("a1", cls.str_long)
   end
 
+  def test_string_included
+    cls, = compile("def included; 'abcdef'.include? 'd'; end")
+    assert cls.included, 'failed to find the contained string'
+  end
+
+  def test_string_dont_include
+    cls, = compile("def dont_include; 'abcdef'.include? 'g'; end")
+    refute cls.dont_include, 'mistakenly found contained string'
+  end
+
+  def test_string_include_wrong_type
+    assert_raises Mirah::MirahError do
+      compile("def include_wrong_type; 'abcdef'.include? 1; end")
+    end
+  end
+
+  def test_string_match
+    cls, = compile("def match; 'abcdef' =~ /d/; end")
+    assert cls.match, 'failed to match string'
+  end
+
+  def test_string_dont_match
+    cls, = compile("def dont_match; 'abcdef' =~ /g/; end")
+    refute cls.dont_match, 'mistakenly matched string'
+  end
+
+  def test_string_match_wrong_type
+    assert_raises Mirah::MirahError do
+      compile("def match_wrong_type; 'abcdef' =~ 'd'; end")
+    end
+  end
 end

data/test/mirrors/method_lookup_test.rb

@@ -358,7 +358,7 @@ class CompareSpecificityTest < BaseMethodLookupTest
   end
 
   def assert_specificity(a, b, value)
-    actual = MethodLookup.compareSpecificity(make_method(a), make_method(b))
+    actual = MethodLookup.compareSpecificity(make_method(a), make_method(b), [nil, nil])
     assert_block "Expected compareSpecificity(#{a.inspect}, #{b.inspect}) = #{value} but was #{actual}" do
       if value.nan?
         actual.nan?
@@ -423,7 +423,7 @@ class FindMaximallySpecificTest < BaseMethodLookupTest
       method = make_method(m)
       methods[method] = m
     end
-    result = MethodLookup.findMaximallySpecific(methods.keys)
+    result = MethodLookup.findMaximallySpecific(methods.keys, [nil, nil])
     result.map {|m| methods[m] || m}
   end
 

data/test/mirrors/mirrors_test.rb

@@ -21,6 +21,7 @@ class BaseMirrorsTest < Test::Unit::TestCase
   java_import 'org.mirah.jvm.mirrors.JVMScope'
   java_import 'org.mirah.jvm.types.JVMType'
   java_import 'org.mirah.jvm.types.JVMTypeUtils'
+  java_import 'org.mirah.typer.AssignableTypeFuture'
   java_import 'org.mirah.typer.BaseTypeFuture'
   java_import 'org.mirah.typer.CallFuture'
   java_import 'org.mirah.typer.TypeFuture'
@@ -45,7 +46,7 @@ class BaseMirrorsTest < Test::Unit::TestCase
   end
 
   def assert_descriptor(descriptor, type)
-    assert(type.isResolved)
+    assert(type.isResolved, type.resolve.toString)
     assert_resolved_to(descriptor, type.resolve)
     assert_not_error(type)
   end
@@ -62,7 +63,7 @@ class BaseMirrorsTest < Test::Unit::TestCase
   end
 
   def assert_not_error(type)
-    assert(!type.resolve.isError)
+    assert(!type.resolve.isError, type.resolve.toString)
   end
 
   def assert_subtype_of(supertype, subtype)
@@ -405,6 +406,26 @@ class MTS_MethodLookupTest < BaseMirrorsTest
     assert_resolved_to('I', type.resolve.returnType)
   end
 
+  def test_async_return_type_from_superclass
+    a = define_type('A')
+    b = define_type('B', a)
+    type = CallFuture.new(@types, @scope, b, true, 'foo', [], [], nil)
+    assert_error(type)
+    @types.getMethodDefType(a, 'foo', [], a, nil)
+    assert_not_error(type)
+    assert_descriptor('LA;', type)
+  end
+
+  def test_async_return_type_from_interface
+    a = define_type('A')
+    b = define_type('B', main_type, [a])
+    type = CallFuture.new(@types, @scope, b, true, 'foo', [], [], nil)
+    assert_error(type)
+    @types.getMethodDefType(a, 'foo', [], a, nil)
+    assert_not_error(type)
+    assert_descriptor('LA;', type)
+  end
+
   def test_infer_return_type_from_body
     future = @types.getMethodDefType(main_type, 'foo', [], nil, nil)
     type = @types.getMethodType(
@@ -420,9 +441,13 @@ class MTS_MethodLookupTest < BaseMirrorsTest
     @scope.selfType_set(type)
     int = @types.wrap(Type.getType("I"))
     short = @types.wrap(Type.getType("S"))
-    @types.getMethodDefType(type, 'foo', [int], int, nil)
+    decl = AssignableTypeFuture.new(nil)
+    decl.declare(int, nil)
+    @types.getMethodDefType(type, 'foo', [decl], int, nil)
     argument_future = BaseTypeFuture.new
-    @types.getMethodDefType(type, 'foo', [argument_future], short, nil)
+    decl = AssignableTypeFuture.new(nil)
+    decl.declare(argument_future, nil)
+    @types.getMethodDefType(type, 'foo', [decl], short, nil)
 
     call_future = CallFuture.new(@types, @scope, type, true, 'foo', [short], [], nil)
     assert_not_error(call_future)
@@ -436,9 +461,13 @@ class MTS_MethodLookupTest < BaseMirrorsTest
   def test_async_arguments_meta
     int = @types.wrap(Type.getType("I"))
     short = @types.wrap(Type.getType("S"))
-    @types.getMethodDefType(main_type, 'foo', [int], int, nil)
+    decl = AssignableTypeFuture.new(nil)
+    decl.declare(int, nil)
+    @types.getMethodDefType(main_type, 'foo', [decl], int, nil)
     argument_future = BaseTypeFuture.new
-    @types.getMethodDefType(main_type, 'foo', [argument_future], short, nil)
+    decl = AssignableTypeFuture.new(nil)
+    decl.declare(argument_future, nil)
+    @types.getMethodDefType(main_type, 'foo', [decl], short, nil)
 
     call_future = CallFuture.new(@types, @scope, main_type, true, 'foo', [short], [], nil)
     assert_not_error(call_future)
@@ -455,8 +484,10 @@ class MTS_MethodLookupTest < BaseMirrorsTest
     b = @types.defineType(@scope, ClassDefinition.new, "B", super_future, [])
     a = @types.defineType(@scope, ClassDefinition.new, "A", b, [])
     c = @types.defineType(@scope, ClassDefinition.new, "C", nil, [])
+    decl = AssignableTypeFuture.new(nil)
+    decl.declare(c, nil)
     
-    @types.getMethodDefType(main_type, 'foobar', [c],
+    @types.getMethodDefType(main_type, 'foobar', [decl],
                             @types.getFixnumType(0), nil)
     type1 = CallFuture.new(@types, @scope, main_type, true, 'foobar', [b], [], nil)
     assert_error(type1)
@@ -559,4 +590,10 @@ class MTS_MethodLookupTest < BaseMirrorsTest
         @types, @scope, collections, true, 'checkedSet', [set, klass], [], nil)
     assert_equal('java.util.Set<FooBar>', checked.resolve.toString)
   end
+
+  def test_nil_argument
+    sb = @types.get(@scope, typeref('java.lang.StringBuilder'))
+    result = CallFuture.new(@types, @scope, sb, true, 'append', [@types.getNullType], [], nil)
+    assert_descriptor('Ljava/lang/StringBuilder;', result)
+  end
 end

data/test/test_helper.rb

@@ -19,6 +19,12 @@ require 'jruby'
 require 'stringio'
 require 'fileutils'
 
+test_tmp_dir = File.expand_path(File.dirname(__FILE__)+'/../tmp_test/')
+TEST_DEST =  "#{test_tmp_dir}/test_classes/"
+FIXTURE_TEST_DEST =  "#{test_tmp_dir}/fixtures/"
+
+
+
 module CommonAssertions
   import java.lang.System
   import java.io.PrintStream

metadata

@@ -1,8 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mirah
 version: !ruby/object:Gem::Version
-  prerelease:
-  version: 0.1.1
+  version: 0.1.2
 platform: java
 authors:
 - Charles Oliver Nutter
@@ -10,7 +9,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2013-08-05 00:00:00.000000000 Z
+date: 2014-01-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bitescript
@@ -19,13 +18,11 @@ dependencies:
     - - '>='
       - !ruby/object:Gem::Version
         version: 0.1.4
-    none: false
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '>='
       - !ruby/object:Gem::Version
         version: 0.1.4
-    none: false
   prerelease: false
   type: :runtime
 description: |-
@@ -93,7 +90,6 @@ files:
 - lib/mirah/jvm/types/literals.rb
 - lib/mirah/jvm/types/meta_type.rb
 - lib/mirah/jvm/types/methods.rb
-- lib/mirah/jvm/types/methods.rb~
 - lib/mirah/jvm/types/null_type.rb
 - lib/mirah/jvm/types/number.rb
 - lib/mirah/jvm/types/primitive_type.rb
@@ -105,7 +101,6 @@ files:
 - lib/mirah/transform/ast_ext.rb
 - lib/mirah/transform/transformer.rb
 - lib/mirah/util/argument_processor.rb
-- lib/mirah/util/argument_processor.rb~
 - lib/mirah/util/class_loader.rb
 - lib/mirah/util/compilation_state.rb
 - lib/mirah/util/delegate.rb
@@ -116,6 +111,9 @@ files:
 - test/core/env_test.rb
 - test/core/generator_test.rb
 - test/core/typer_test.rb
+- test/core/typer/assignable_type_future_test.rb
+- test/core/typer/error_type_test.rb
+- test/core/typer/simple_type_test.rb
 - test/core/util/argument_processor_test.rb
 - test/core/util/class_loader_test.rb
 - test/core/util/compilation_state_test.rb
@@ -146,7 +144,8 @@ files:
 - test/jvm/new_backend_test_helper.rb
 - test/jvm/numeric_extensions_test.rb
 - test/jvm/rescue_test.rb
-- test/jvm/string_test.rb
+- test/jvm/string_builder_extensions_test.rb
+- test/jvm/string_extensions_test.rb
 - test/jvm/varargs_test.rb
 - test/mirrors/base_type_test.rb
 - test/mirrors/bytecode_mirror_test.rb
@@ -221,6 +220,7 @@ files:
 - javalib/mirah-bootstrap.jar
 - javalib/mirah-builtins.jar
 - javalib/mirah-compiler.jar
+- javalib/mirah-mirrors.jar
 - javalib/mirah-newast-transitional.jar
 - javalib/mirah-parser.jar
 - javalib/mirah-util.jar
@@ -228,7 +228,9 @@ files:
 - Rakefile
 - README.md
 homepage: http://www.mirah.org/
-licenses: []
+licenses:
+- Apache-2.0
+metadata: {}
 post_install_message:
 rdoc_options:
 - --main
@@ -239,25 +241,17 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - '>='
     - !ruby/object:Gem::Version
-      segments:
-      - 0
-      hash: 2
       version: '0'
-  none: false
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - '>='
     - !ruby/object:Gem::Version
-      segments:
-      - 0
-      hash: 2
       version: '0'
-  none: false
 requirements: []
 rubyforge_project: mirah
-rubygems_version: 1.8.24
+rubygems_version: 2.1.11
 signing_key:
-specification_version: 3
+specification_version: 4
 summary: Mirah is a customizable programming language featuring static types, local type inference and a heavily Ruby-inspired syntax
 test_files:
 - test/test_helper.rb

data/lib/mirah/jvm/types/methods.rb~

@@ -1,973 +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 'mirah/jvm/types'
-
-class Java::JavaMethod
-  def static?
-    java.lang.reflect.Modifier.static?(modifiers)
-  end
-
-  def abstract?
-    java.lang.reflect.Modifier.abstract?(modifiers)
-  end
-end
-
-class BiteScript::ASM::FieldMirror
-  def returnType
-    self.type
-  end
-end
-
-module Mirah::JVM::Types
-  AST ||= Mirah::AST
-
-  module ArgumentConversion
-    def convert_args(compiler, values, types=nil)
-      # TODO boxing/unboxing
-      types ||= argument_types
-      needs_to_build_varargs_array = false
-      
-      if respond_to?(:varargs?) && varargs?
-        non_varargs_types = types[0..-2]
-        non_varargs_values = values.first non_varargs_types.size
-
-        varargs_values = values.to_a.last(values.size - non_varargs_values.size)
-        varargs_type = types.last
-
-        unless varargs_values.length == 1 &&
-          varargs_type.compatible?(compiler.inferred_type(varargs_values.first))
-          needs_to_build_varargs_array = true
-          values = non_varargs_values
-        end
-      end
-
-      values_and_types = values.zip(types)
-      
-      values_and_types.each do |value, type|
-        compiler.visit(value, true)
-        in_type = compiler.inferred_type(value)
-        if in_type.primitive? && type != in_type
-          in_type.compile_widen(compiler.method, type)
-        end
-      end
-
-      if needs_to_build_varargs_array
-        compiler.visitVarargsArray(varargs_type, varargs_values)
-      end
-    end
-  end
-
-  Type.send :include, ArgumentConversion
-
-  class Intrinsic
-    include ArgumentConversion
-    attr_reader :name, :argument_types, :return_type
-
-    def initialize(klass, name, args, type, kind=nil, &block)
-      raise ArgumentError, "Block required" unless block_given?
-      @class = klass
-      @name = name
-      @argument_types = args
-      @return_type = type
-      @block = block
-      @kind = kind
-    end
-
-    def kind
-      Java::OrgMirahJvmTypes::MemberKind.const_get(@kind)
-    end
-    
-    def accept(visitor, expression)
-      name = "visit_#{@kind.downcase}".sub(/_op$/,"")
-      visitor.send(name, self, expression)
-    end
-
-    def call(builder, ast, expression, *args)
-      @block.call(builder, ast, expression, *args)
-    end
-
-    def declaring_class
-      @class
-    end
-
-    def constructor?
-      false
-    end
-
-    def field?
-      false
-    end
-
-    def abstract?
-      false
-    end
-
-    def exceptions
-      []
-    end
-
-    def varargs?
-      false
-    end
-    
-    def isVararg
-      varargs?
-    end
-  end
-
-  class Macro
-    java_import 'org.mirah.typer.InlineCode'
-    java_import 'org.mirah.typer.NodeBuilder'
-    attr_reader :name, :argument_types, :return_type
-
-    def initialize(klass, name, args, &block)
-      raise ArgumentError, "Block required" unless block_given?
-      @class = klass
-      @name = name
-      @argument_types = args
-      raise ArgumentError unless args.all?
-      @return_type = InlineCode.new(block.to_java(NodeBuilder))
-    end
-
-    def declaring_class
-      @class
-    end
-  end
-
-  class JavaCallable
-    include ArgumentConversion
-
-    attr_accessor :member
-
-    def initialize(types, member)
-      raise ArgumentError unless types.kind_of?(Mirah::Typer::TypeSystem)
-      @types = types
-      @member = member
-    end
-
-    def name
-      @name ||= @member.name
-    end
-
-    def field?
-      false
-    end
-
-    def parameter_types
-      @member.parameter_types
-    end
-    
-    def synthetic?
-      @member.synthetic?
-    end
-  end
-
-  class JavaConstructor < JavaCallable
-    def argument_types
-      @argument_types ||= @member.argument_types.map do |arg|
-        if arg.kind_of?(Type) || arg.nil?
-          arg
-        else
-          @types.type(nil, arg)
-        end
-      end
-    end
-
-    def return_type
-      declaring_class
-    end
-
-    def exceptions
-      @member.exception_types.map do |exception|
-        if exception.kind_of?(Mirah::Typer::ResolvedType)
-          exception
-        else
-          @types.type(nil, exception.class_name)
-        end
-      end
-    end
-
-    def declaring_class
-      @types.type(nil, @member.declaring_class)
-    end
-
-    def type_parameters
-      @declaring_class and @declaring_class.jvm_type.type_parameters
-    end
-
-    def call(compiler, ast, expression, parameters=nil, delegate=false)
-      target = compiler.inferred_type(ast.target)
-      unless delegate
-        compiler.method.new target
-        compiler.method.dup if expression
-      end
-      parameters ||= ast.parameters
-      convert_args(compiler, parameters)
-      compiler.method.invokespecial(
-        target,
-        "<init>",
-        [nil, *@member.argument_types])
-    end
-
-    def constructor?
-      true
-    end
-
-    def varargs?
-      @member.varargs?
-    end
-
-    def isVararg
-      varargs?
-    end
-
-    def accept(visitor, expression)
-      visitor.visitConstructor(self, expression)
-    end
-    
-    def kind
-      Java::OrgMirahJvmTypes::MemberKind::CONSTRUCTOR
-    end
-  end
-
-  class JavaMethod < JavaConstructor
-    def return_type
-      @return_type ||= begin
-        if void?
-          @types.type(nil, 'void')
-        else
-          @types.type(nil, @member.return_type)
-        end
-      end
-    end
-
-    def static?
-      @member.static?
-    end
-
-    def abstract?
-      @member.abstract?
-    end
-
-    def type_parameters
-      @member.type_parameters
-    end
-
-    def void?
-      return_type = @member.return_type
-      return true if return_type.nil?
-      if return_type.respond_to?(:descriptor) && return_type.descriptor == 'V'
-        return true
-      end
-      false
-    end
-
-    def constructor?
-      false
-    end
-
-    def accept(visitor, expression)
-      if self.static?
-        visitor.visitStaticMethodCall(self, expression)
-      else
-        visitor.visitMethodCall(self, expression)
-      end
-    end
-    
-    def kind
-      if self.static?
-        Java::OrgMirahJvmTypes::MemberKind::STATIC_METHOD
-      else
-        Java::OrgMirahJvmTypes::MemberKind::METHOD
-      end
-    end
-
-    def call(compiler, ast, expression, parameters=nil)
-      target = compiler.inferred_type(ast.target)
-      compiler.visit(ast.target, true)
-
-      # if expression, void methods return the called object,
-      # for consistency and chaining
-      # TODO: inference phase needs to track that signature is
-      # void but actual type is callee
-      if expression && void?
-        compiler.method.dup
-      end
-
-      parameters ||= ast.parameters
-      convert_args(compiler, parameters)
-      if target.interface?
-        compiler.method.invokeinterface(
-          target,
-          name,
-          [@member.return_type, *@member.argument_types])
-      else
-        compiler.method.invokevirtual(
-          target,
-          name,
-          [@member.return_type, *@member.argument_types])
-      end
-
-      if expression && !void?
-        # Insert a cast if the inferred type and actual type differ. This is part of generics support.
-        inferred_return_type = compiler.inferred_type(ast)
-        if !inferred_return_type.assignableFrom(return_type)
-          compiler.method.checkcast(inferred_return_type)
-        end
-      end
-
-      unless expression || void?
-        return_type.pop(compiler.method)
-      end
-    end
-
-    def call_special(compiler, target, target_type, parameters, expression)
-      target_type ||= compiler.inferred_type(target)
-      compiler.visit(target, true)
-
-      # if expression, void methods return the called object,
-      # for consistency and chaining
-      # TODO: inference phase needs to track that signature is
-      # void but actual type is callee
-      if expression && void?
-        compiler.method.dup
-      end
-
-      convert_args(compiler, parameters)
-      if target_type.interface?
-        raise "interfaces should not receive call_special"
-      else
-        compiler.method.invokespecial(
-          target_type,
-          name,
-          [@member.return_type, *@member.argument_types])
-      end
-
-      unless expression || void?
-        return_type.pop(compiler.method)
-      end
-    end
-  end
-
-  class JavaStaticMethod < JavaMethod
-    def call(compiler, ast, expression, parameters=nil)
-      target = declaring_class
-      parameters ||= ast.parameters
-      convert_args(compiler, parameters)
-      compiler.method.invokestatic(
-        target,
-        name,
-        [@member.return_type, *@member.argument_types])
-      # if expression, void static methods return null, for consistency
-      # TODO: inference phase needs to track that signature is void
-      # but actual type is null object
-      compiler.method.aconst_null if expression && void?
-      return_type.pop(compiler.method) unless expression || void?
-    end
-
-    def accept(visitor, expression)
-      visitor.visitStaticMethodCall(self, expression)
-    end
-    
-    def kind
-      Java::OrgMirahJvmTypes::MemberKind::STATIC_METHOD
-    end
-  end
-
-  class JavaDynamicMethod < JavaMethod
-    def initialize(type_system, name, *argument_types)
-      super(type_system, nil)
-      @name = name
-      @argument_types = argument_types
-    end
-
-    def return_type
-      @types.type(nil, 'dynamic')
-    end
-
-    def declaring_class
-      java.lang.Object
-    end
-
-    def argument_types
-      @argument_types
-    end
-
-    def call(compiler, ast, expression, parameters=nil)
-      unless compiler.respond_to?(:supports_invokedynamic?) && compiler.supports_invokedynamic?
-        raise Mirah::MirahError, "Target JVM version: #{compiler.target_jvm_version} doesn't support invoke dynamic"
-      end
-      target = compiler.inferred_type(ast.target)
-      compiler.visit(ast.target, true)
-
-      parameters ||= ast.parameters
-      parameters.each do |param|
-        compiler.visit(param, true)
-      end
-      handle = compiler.method.h_invokestatic(
-        org.dynalang.dynalink.DefaultBootstrapper,
-        "bootstrap",
-        java.lang.invoke.CallSite,
-        java.lang.invoke.MethodHandles::Lookup,
-        java.lang.String,
-        java.lang.invoke.MethodType)
-      compiler.method.invokedynamic(
-        "dyn:callPropWithThis:#{name}",
-        [return_type, target, *@argument_types],
-        handle)
-
-      unless expression
-        return_type.pop(compiler.method)
-      end
-    end
-  end
-
-  class JavaFieldAccessor < JavaMethod
-    def field?
-      true
-    end
-
-    def return_type
-      @types.type(nil, @member.type)
-    end
-
-    def public?
-      @member.public?
-    end
-
-    def final?
-      @member.final?
-    end
-  end
-
-  class JavaFieldGetter < JavaFieldAccessor
-    def argument_types
-      []
-    end
-
-    def call(compiler, ast, expression, parameters=nil)
-      target = compiler.inferred_type(ast.target)
-
-      # TODO: assert that no args are being passed, though that should have failed lookup
-
-      if expression
-        if @member.static?
-          compiler.method.getstatic(target, name, @member.type)
-        else
-          compiler.visit(ast.target, true)
-          compiler.method.getfield(target, name, @member.type)
-        end
-      end
-    end
-
-    def accept(visitor, expression)
-      if self.static?
-        visitor.visitStaticFieldAccess(self, expression)
-      else
-        visitor.visitFieldAccess(self, expression)
-      end
-    end
-    
-    def kind
-      if self.static?
-        Java::OrgMirahJvmTypes::MemberKind::STATIC_FIELD_ACCESS
-      else
-        Java::OrgMirahJvmTypes::MemberKind::FIELD_ACCESS
-      end
-    end
-  end
-
-  class JavaFieldSetter < JavaFieldAccessor
-    def return_type
-      @types.type(nil, @member.type)
-    end
-
-    def argument_types
-      [@types.type(nil, @member.type)]
-    end
-
-    def call(compiler, ast, expression, parameters=nil)
-      target = compiler.inferred_type(ast.target)
-
-      # TODO: assert that no args are being passed, though that should have failed lookup
-
-      parameters ||= ast.parameters
-      if @member.static?
-        convert_args(compiler, parameters)
-        compiler.method.dup if expression
-        compiler.method.putstatic(target, name, @member.type)
-      else
-        compiler.visit(ast.target, true)
-        convert_args(compiler, parameters)
-        compiler.method.dup_x2 if expression
-        compiler.method.putfield(target, name, @member.type)
-      end
-    end
-
-    def accept(visitor, expression)
-      if self.static?
-        visitor.visitStaticFieldAssign(self, expression)
-      else
-        visitor.visitFieldAssign(self, expression)
-      end
-    end
-    
-    def kind
-      if self.static?
-        Java::OrgMirahJvmTypes::MemberKind::STATIC_FIELD_ASSIGN
-      else
-        Java::OrgMirahJvmTypes::MemberKind::FIELD_ASSIGN
-      end
-    end
-  end
-
-  class MirahMember
-    attr_reader :name, :argument_types, :declaring_class, :return_type
-    attr_reader :exception_types
-
-    def initialize(klass, name, args, return_type, static, exceptions)
-      if return_type.name == 'void' || return_type.name == ':unreachable'
-        return_type = nil
-      end
-      @declaring_class = klass
-      @name = name
-      @argument_types = args
-      @return_type = return_type
-      @static = static
-      @exception_types = exceptions || []
-    end
-
-    def static?
-      @static
-    end
-
-    def abstract?
-      @declaring_class.interface?
-    end
-
-    def varargs?
-      false
-    end
-    
-    def isVararg
-      varargs?
-    end
-  end
-
-  class Type
-    java_import "org.mirah.jvm.types.JVMMethod" rescue nil
-
-    def method_listeners
-      if meta?
-        unmeta.method_listeners
-      else
-        @method_listeners ||= {}
-      end
-    end
-
-    def method_updated(name)
-      listeners = method_listeners[name]
-      listeners.values.each do |l|
-        if l.kind_of?(Proc)
-          l.call(name)
-        else
-          l.method_updated(name)
-        end
-      end if listeners
-    end
-
-    def add_method_listener(name, listener=nil, &block)
-      listeners = method_listeners[name] ||= {}
-      if listener
-        unless listener.respond_to?(:method_updated) || listener.kind_of?(Proc)
-          raise "Invalid listener"
-        end
-        listeners[listener] = listener
-      else
-        listeners[block] = block
-      end
-      if !self.meta? && jvm_type && super_class_valid?
-        superclass.add_method_listener(name, self)
-      end
-      interfaces.each {|i| i.add_method_listener(name, self) unless i.isError}
-    end
-
-    # TODO take a scope and check visibility
-    def find_callable_macros(name)
-      macros = find_callable_macros2 name
-      macros.concat collect_up_interface_tree {|interface| interface.declared_macros(name) }
-      macros
-    end
-
-    def find_callable_macros2(name)
-      collect_up_inheritance_tree {|type| type.declared_macros name }
-    end
-
-    def find_callable_static_methods(name)
-      collect_up_inheritance_tree { |type| type.declared_class_methods(name) }
-    end
-
-    # TODO take a scope and check visibility
-    def find_callable_methods(name, include_interfaces=false, &proc)
-      if block_given?
-        add_method_listener(name) {proc.call(find_callable_methods(name))}
-        proc.call(find_callable_methods(name))
-        return
-      end
-
-      methods = find_callable_methods2 name
-
-      if self.interface? || include_interfaces # TODO || self.abstract?
-        methods.concat collect_up_interface_tree { |interface| interface.declared_instance_methods(name) }
-      end
-      methods
-    end
-
-    def find_callable_methods2(name)
-      collect_up_inheritance_tree { |type| type.declared_instance_methods(name) }
-    end
-
-    def get_method(name, args)
-      method = find_method(self, name, args, nil, meta?)
-      unless method
-        # Allow constant narrowing for assignment methods
-        if name =~ /=$/ && args[-1].respond_to?(:narrow!)
-          if args[-1].narrow!
-            method = find_method(self, name, args, meta?)
-          end
-        end
-      end
-      method
-    end
-
-    def constructor(*types)
-      begin
-        constructor = jvm_type.getConstructor(*bitescript_signatures(types))
-        return JavaConstructor.new(@type_system, constructor) if constructor
-      rescue => ex
-        log("#{ex.message}\n#{ex.backtrace.join("\n")}")
-      end
-      raise NameError, "No constructor #{name}(#{types.join ', '})"
-    end
-
-    def java_method(name, *types)
-      intrinsic = intrinsics[name][types]
-      return intrinsic if intrinsic
-      jvm_types = types.map {|type| type.jvm_type}
-
-      return JavaDynamicMethod.new(@type_system, name, *jvm_types) if dynamic?
-
-      begin
-        method = jvm_type.getDeclaredMethod(name, *bitescript_signatures(types)) if jvm_type
-
-        if method.nil? && superclass
-          method = superclass.java_method(name, *types) rescue nil
-        end
-
-        if method.nil? && jvm_type && jvm_type.abstract?
-          interfaces.each do |interface|
-            method = interface.java_method(name, *types) rescue nil
-            break if method
-          end
-        end
-
-        return method if method.kind_of?(JavaCallable)
-        if method && method.static? == meta?
-          return wrap_jvm_method method
-        end
-      rescue   => ex
-        log("#{ex.message}\n#{ex.backtrace.join("\n")}")
-      end
-      raise NameError, "No method #{self.name}.#{name}(#{types.join ', '})"
-    end
-
-    def declared_instance_methods(name=nil)
-      all_declared_jvm_methods(name).reject{ |method| method.static? && !method.synthetic? } +
-      (meta? ? unmeta : self).declared_intrinsics(name)
-    end
-
-    def declared_class_methods(name=nil)
-      all_declared_jvm_methods(name).select{ |method| method.static? && !method.synthetic? } +
-      meta.declared_intrinsics(name)
-    end
-
-    def declared_constructors
-      jvm_type.getConstructors.map do |method|
-        JavaConstructor.new(@type_system, method)
-      end
-    end
-
-    def field_getter(name)
-      field = jvm_field(name)
-      return nil unless field
-
-      JavaFieldGetter.new(@type_system, field)
-    end
-
-    def field_setter(name)
-      field = jvm_field(name)
-      return nil unless field
-
-      JavaFieldSetter.new(@type_system, field)
-    end
-
-    def inner_class_getter(name)
-      full_name = "#{self.name}$#{name}"
-      inner_class = @type_system.type(nil, full_name) rescue nil
-      return unless inner_class
-
-      inner_class.inner_class = true
-      macro = Macro.new(self, name, []) do |call, typer|
-        Mirah::AST::Constant.new(call.position, Mirah::AST::SimpleString.new(call.position, full_name))
-      end
-      intrinsics[name][[]] = macro
-    end
-    
-    def getDeclaredFields
-      @member.getDeclaredFields.to_java(JVMMethod)
-    end
-    
-    def getDeclaredField(name)
-      @member.getDeclaredField(name)
-    end
-    
-    def hasStaticField(name)
-      f = getDeclaredField(name)
-      f && f.static?
-    end
-
-    protected
-
-    def find_interfaces
-      collect_up_inheritance_tree {|type| type.interfaces }
-    end
-
-    def collect_up_interface_tree &block
-      interfaces = find_interfaces
-      things = []
-      seen = {}
-      until interfaces.empty?
-        interface = interfaces.pop
-        next if seen[interface]
-        seen[interface] = true
-        interfaces.concat(interface.interfaces)
-        new_things = block.call interface
-        things.concat new_things if new_things
-      end
-      things
-    end
-
-    def collect_up_inheritance_tree(&block)
-      things = []
-      new_things = block.call(self)
-      things.concat new_things if new_things
-      if super_class_valid?
-        things.concat superclass.collect_up_inheritance_tree(&block)
-      end
-      things
-    end
-
-    private
-
-    def super_class_valid?
-      superclass && !superclass.error?
-    end
-
-    def all_declared_jvm_methods(name=nil)
-      return [] if !jvm_type || (meta? ? unmeta : self).array?
-
-      jvm_type.getDeclaredMethods(name).map { |method| wrap_jvm_method method }
-    end
-
-    def wrap_jvm_method method
-      if (method.static? && !method.synthetic?)
-        JavaStaticMethod.new(@type_system, method)
-      else
-        JavaMethod.new(@type_system, method)
-      end
-    end
-
-    def jvm_field(name)
-      return nil unless jvm_type
-      jvm_type.getField(name)
-    end
-
-    def bitescript_signatures types
-      types.map {|type| BiteScript::Signature.class_id(type)}
-    end
-  end
-
-  class TypeDefinition
-    java_import "org.mirah.jvm.types.JVMMethod" rescue nil
-
-    def java_method(name, *types)
-      method = first_matching instance_methods[name], types
-      return method if method
-      intrinsic = intrinsics[name][types]
-      return intrinsic if intrinsic
-      raise NameError, "No method #{self.name}.#{name}(#{types.join ', '})"
-    end
-
-    def java_static_method(name, *types)
-      method = first_matching static_methods[name], types
-      return method if method
-      intrinsic = meta.intrinsics[name][types]
-      return intrinsic if intrinsic
-      raise NameError, "No method #{self.name}.#{name}(#{types.join ', '})"
-    end
-
-    def constructor(*types)
-      constructor = first_matching constructors, types
-      return constructor if constructor
-      raise NameError, "No constructor #{name}(#{types.join ', '})"
-    end
-
-    def declared_instance_methods(name=nil)
-      declared_methods self, instance_methods, name
-    end
-
-    def declared_class_methods(name=nil)
-      declared_methods meta, static_methods, name
-    end
-
-    def constructors
-      if @constructors.nil?
-        @constructors = []
-        declare_method('initialize', [], self, [])
-        @have_default_constructor = true
-      end
-      @constructors
-    end
-    alias :declared_constructors :constructors
-
-    def instance_methods
-      @instance_methods ||= Hash.new {|h, k| h[k] = []}
-    end
-
-    def static_methods
-      @static_methods ||= Hash.new {|h, k| h[k] = []}
-    end
-    
-    def getDeclaredFields
-      @fields.values.to_java(JVMMethod)
-    end
-    
-    def getDeclaredField(name)
-      @fields[name]
-    end
-    
-    def hasStaticField(name)
-      f = getDeclaredField(name)
-      f && f.static?
-    end
-    
-    def declared_fields
-      @fields ||= {}
-    end
-
-    def declare_field(name, type, static)
-      declared_fields[name] ||= MirahMember.new(self, name, [], type, static, [])
-    end
-
-    def declare_method(name, arguments, type, exceptions)
-      raise "Bad args" unless arguments.all?
-      if type.isError
-        instance_methods.delete(name)
-        method_updated(name)
-        return
-      end
-      member = MirahMember.new(self, name, arguments, type, false, exceptions)
-      if name == 'initialize'
-        # The ordering is important here:
-        # The first call to constructors initializes @have_default_constructor.
-        if constructors.size == 1 && @have_default_constructor
-          constructors.clear
-          @have_default_constructor = false
-        elsif constructors.size > 1 && @have_default_constructor
-          raise "Invalid state: default constructor but #{constructors.size} constructors"
-        end
-        constructors << JavaConstructor.new(@type_system, member)
-      else
-        instance_methods[name] << JavaMethod.new(@type_system, member)
-      end
-      method_updated(name)
-    end
-
-    def declare_static_method(name, arguments, type, exceptions)
-      if type.isError
-        static_methods.delete(name)
-      else
-        member = MirahMember.new(self, name, arguments, type, true, exceptions)
-        static_methods[name] << JavaStaticMethod.new(@type_system, member)
-      end
-      method_updated(name)
-    end
-
-    def interface?
-      false
-    end
-
-    def field_getter(name)
-      nil
-    end
-
-    def field_setter(name)
-      nil
-    end
-
-    private
-
-    def declared_methods target, method_hash, name
-      # should the declared intrinsics be first here? nh
-      target.declared_intrinsics(name) +
-        if name.nil?
-          method_hash.values.flatten
-        else
-          method_hash[name]
-        end
-    end
-
-    def first_matching method_list, types
-      method_list.find {|m| m.argument_types == types}
-    end
-  end
-
-  class TypeDefMeta
-    def constructor(*args)
-      unmeta.constructor(*args)
-    end
-
-    def java_method(*args)
-      unmeta.java_static_method(*args)
-    end
-
-    def declared_class_methods(name=nil)
-      unmeta.declared_class_methods(name)
-    end
-
-    def declared_instance_methods(name=nil)
-      unmeta.declared_instance_methods(name)
-    end
-
-    def field_getter(name)
-      nil
-    end
-
-    def field_setter(name)
-      nil
-    end
-  end
-end