mirah 0.0.12-java → 0.1.0-java

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

@@ -20,13 +20,13 @@ module Mirah::JVM::Types
     end
 
     def math_type
-      Float
+      @type_system.type(nil, 'float')
     end
 
     def box_type
-      java.lang.Float
+      @type_system.type(nil, 'java.lang.Float')
     end
-    
+
     def suffix
       'g'
     end
@@ -47,30 +47,32 @@ module Mirah::JVM::Types
         builder.ldc_float(value)
       end
     end
-    
-    def widen(builder, type)
-      case type
-      when Float
+
+    def compile_widen(builder, type)
+      case type.name
+      when 'float'
         # Do nothing
-      when Double
+      when 'double'
         builder.f2d
+      when @wrapper.java_class.name, 'java.lang.Object'
+        builder.invokestatic @wrapper, "valueOf", [@wrapper, builder.send(name)]
       else
         raise ArgumentError, "Invalid widening conversion from float to #{type}"
       end
     end
   end
-  
+
   class DoubleType < FloatType
     def prefix
       'd'
     end
 
     def math_type
-      Double
+      @type_system.type(nil, 'double')
     end
 
     def box_type
-      java.lang.Double
+      @type_system.type(nil, 'java.lang.Double')
     end
 
     def wide?
@@ -91,11 +93,15 @@ module Mirah::JVM::Types
         builder.ldc_double(value)
       end
     end
-    
-    def widen(builder, type)
-      if type != Double
+
+    def compile_widen(builder, type)
+      case type.name
+      when 'double'
+      when @wrapper.java_class.name, 'java.lang.Object'
+        builder.invokestatic @wrapper, "valueOf", [@wrapper, builder.send(name)]
+      else
         raise ArgumentError, "Invalid widening conversion from double to #{type}"
       end
     end
   end
-end
+end

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

@@ -0,0 +1,72 @@
+module Mirah
+  module JVM
+    module Types
+      class GenericType < Type
+        java_import 'java.util.HashMap'
+        java_import 'org.mirah.typer.GenericType'
+        include GenericType
+
+        attr_reader :ungeneric
+
+        def initialize(ungeneric)
+          super(ungeneric.type_system, ungeneric.name)
+          @ungeneric = ungeneric
+        end
+
+        def basic_type
+          @ungeneric.basic_type
+        end
+
+        def generic?
+          true
+        end
+
+        def generic
+          self
+        end
+
+        def ungeneric
+          @ungeneric
+        end
+
+        def superclass
+          @ungeneric.superclass.generic if @ungeneric.superclass
+        end
+
+        def declared_macros(name=nil)
+          @ungeneric.declared_macros(name)
+        end
+
+        def interfaces(include_parent=true)
+          ungeneric.interfaces
+        end
+
+        def jvm_type
+          @ungeneric.jvm_type
+        end
+
+        def inner_class?
+          basic_type.inner_class?
+        end
+
+        def type_parameter_map
+          unless @type_parameter_map
+            @type_parameter_map = HashMap.new
+          end
+          @type_parameter_map
+        end
+
+        def assignable_from?(other)
+          @ungeneric.assignable_from?(other)
+        end
+
+        def inspect(indent=0)
+          "#{' ' * indent}#<#{self.class.name.split(/::/)[-1]} #{name} #{type_parameter_map}>"
+        end
+      end
+
+      class TypeDefGeneric < GenericType
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+module Mirah
+  module JVM
+    module Types
+      class ImplicitNilType < Type
+        def initialize(types)
+          super(types, types.get_mirror('java.lang.Object'))
+        end
+
+        def to_s
+          "Type(implicit_nil)"
+        end
+
+        def widen(other)
+          other
+        end
+
+        def compatible?(other)
+          true
+        end
+
+        def assignable_from?(other)
+          true
+        end
+
+        def matchesAnything; true; end
+      end
+    end
+  end
+end

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

@@ -20,81 +20,48 @@ module Mirah::JVM::Types
     def literal(builder, value)
       builder.push_int(value)
     end
-    
+
     def init_value(builder)
       builder.iconst_0
     end
-    
+
     def load(builder, index)
       builder.iload(index)
     end
-    
-    def widen(builder, type)
-      case type
-      when Byte, Short, Int
+
+    def compile_widen(builder, type)
+      case type.name
+      when 'byte', 'short', 'int'
         # do nothing
-      when Long
+      when 'long'
         builder.i2l
-      when Float
+      when 'float'
         builder.i2f
-      when Double
+      when 'double'
         builder.i2d
+      when @wrapper.java_class.name, 'java.lang.Object'
+        builder.invokestatic @wrapper, "valueOf", [@wrapper, builder.send(name)]
       else
         raise ArgumentError, "Invalid widening conversion from #{name} to #{type}"
       end
     end
-    
+
     def prefix
       'i'
     end
-    
+
     def math_type
-      Int
+      @type_system.type(nil, 'int')
     end
 
     def box_type
-      java.lang.Integer
+      @type_system.type(nil, 'java.lang.Integer')
     end
 
     def jump_if(builder, op, label)
       builder.send "if_icmp#{op}", label
     end
 
-    def build_loop(parent, position, duby, block, first_value,
-                   last_value, ascending, inclusive)
-      if ascending
-        comparison = "<"
-        op = "+="
-      else
-        comparison = ">"
-        op = "-="
-      end
-      comparison << "=" if inclusive
-      forloop = Mirah::AST::Loop.new(parent, position, true, false) do |forloop|
-        first, last = duby.tmp, duby.tmp
-        init = duby.eval("#{first} = 0; #{last} = 0;")
-        init.children[-2].value = first_value
-        init.children[-1].value = last_value
-        forloop.init << init
-
-        var = (block.args.args || [])[0]
-        if var
-          forloop.pre << duby.eval(
-              "#{var.name} = #{first}", '', forloop, first, last)
-        end
-        forloop.post << duby.eval("#{first} #{op} 1")
-        [
-          Mirah::AST::Condition.new(forloop, position) do |c|
-            [duby.eval("#{first} #{comparison} #{last}",
-                       '', forloop, first, last)]
-          end,
-          nil
-        ]
-      end
-      forloop.body = block.body
-      forloop
-    end
-
     def add_intrinsics
       super
       math_operator('<<', 'shl')
@@ -104,20 +71,6 @@ module Mirah::JVM::Types
       math_operator('&', 'and')
       math_operator('^', 'xor')
       unary_operator('~', 'not')
-
-      add_macro('downto', Int, Mirah::AST.block_type) do |transformer, call|
-        build_loop(call.parent, call.position, transformer,
-                   call.block, call.target, call.parameters[0], false, true)
-      end
-      add_macro('upto', Int, Mirah::AST.block_type) do |transformer, call|
-        build_loop(call.parent, call.position, transformer,
-                   call.block, call.target, call.parameters[0], true, true)
-      end
-      add_macro('times', Mirah::AST.block_type) do |transformer, call|
-        build_loop(call.parent, call.position, transformer,
-                   call.block, Mirah::AST::fixnum(nil, call.position, 0),
-                   call.target, true, false)
-      end
     end
   end
 
@@ -127,11 +80,11 @@ module Mirah::JVM::Types
     end
 
     def math_type
-      Long
+      @type_system.type(nil, 'long')
     end
 
     def box_type
-      java.lang.Long
+      @type_system.type(nil, 'java.lang.Long')
     end
 
     def literal(builder, value)
@@ -141,24 +94,26 @@ module Mirah::JVM::Types
     def init_value(builder)
       builder.lconst_0
     end
-    
+
     def wide?
       true
     end
 
-    def widen(builder, type)
-      case type
-      when Long
+    def compile_widen(builder, type)
+      case type.name
+      when 'long'
         # do nothing
-      when Float
+      when 'float'
         builder.l2f
-      when Double
+      when 'double'
         builder.l2d
+      when @wrapper.java_class.name, 'java.lang.Object'
+        builder.invokestatic @wrapper, "valueOf", [@wrapper, builder.send(name)]
       else
         raise ArgumentError, "Invalid widening conversion from Int to #{type}"
       end
     end
-    
+
     def add_intrinsics
       super
       math_operator('<<', 'shl')

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

@@ -2,8 +2,8 @@ module Mirah
   module JVM
     module Types
       class InterfaceDefinition < TypeDefinition
-        def initialize(name, node)
-          super(name, node)
+        def initialize(types, scope, name, node)
+          super(types, scope, name, node)
         end
 
         def define(builder)
@@ -17,4 +17,4 @@ module Mirah
       end
     end
   end
-end
+end

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

@@ -14,11 +14,11 @@
 # limitations under the License.
 
 require 'bitescript'
-require 'mirah/jvm/types/enumerable'
 require 'mirah/jvm/types/bitescript_ext'
 
 module Mirah::JVM::Types
   class Type
+    java_import 'org.mirah.macros.anno.MacroDef'
 
     def load(builder, index)
       builder.send "#{prefix}load", index
@@ -44,6 +44,10 @@ module Mirah::JVM::Types
       end
     end
 
+    def macros
+      @macros ||= Hash.new {|h, k| h[k] = {}}
+    end
+
     def add_method(name, args, method_or_type=nil, &block)
       if block_given?
         method_or_type = Intrinsic.new(self, name, args,
@@ -52,53 +56,79 @@ module Mirah::JVM::Types
       intrinsics[name][args] = method_or_type
     end
 
-    def add_macro(name, *args, &block)
-      type = Mirah::AST::InlineCode.new(&block)
-      intrinsics[name][args] = Intrinsic.new(self, name, args, type) do
-        raise "Macro should be expanded, no called!"
+    def add_compiled_macro(klass)
+      name, arg_types, is_static = read_macrodef_annotation(klass)
+      if arg_types.nil?
+        return
+      elsif is_static && !self.meta?
+        self.meta.add_compiled_macro(klass)
+        return
       end
-    end
 
-    def add_compiled_macro(klass, name, arg_types)
-      add_macro(name, *arg_types) do |mirah, call|
-        # Ick. We need to preserve the scope of the arguments to the macro.
-        # However the only way to do that is to wrap them in a ScopedBody.
-        # It'd be better if we didn't have to expose this wrapper node to
-        # the user code.
-        #
-        if call.block && call.name != 'quote'
-          call.block.body = wrap_with_scoped_body call, call.block.body
-        end
-        
-        call.parameters = call.parameters.map do |arg|
-          wrap_with_scoped_body call, arg
+      log "Adding macro #{self.name}.#{name}(#{arg_types.map{|t| t.full_name}.join(', ')})"
+      # TODO separate static and instance macros
+      macro = Macro.new(self, name, arg_types) do |call, typer|
+        #TODO scope
+        # We probably need to set the scope on all the parameters, plus the
+        # arguments and body of any block params. Also make sure scope is copied
+        # when cloned.
+        scope = typer.scoper.get_scope(call)
+        # call.parameters.each do |arg|
+        #   arg.scope = scope
+        # end
+
+        begin
+          expander = klass.constructors[0].newInstance(typer.macro_compiler, call)
+          ast = expander.expand
+        # rescue
+        #   puts "Unable to expand macro #{name.inspect} from #{klass} with #{call}"
         end
-        
-        expander = klass.constructors[0].newInstance(mirah, call)
-        ast = expander.expand
         if ast
-          body = Mirah::AST::ScopedBody.new(call.parent, call.position)
-          body << ast
-          
-          # if the macro was called on something, and that something
-          # was not a class only containing macros, reassign self for
-          # the body.
-          if call.target && !call.target.is_a?(Mirah::AST::Builtin)
-            body.static_scope.self_type = call.target.inferred_type!
-            body.static_scope.self_node = call.target
-          end
-          
+          body = Mirah::AST::NodeList.new(ast.position.to_java(Mirah::AST::Position))
+          # TODO scope
+          # static_scope = typer.scoper.add_scope(body)
+          # static_scope.parent = typer.scoper.get_scope(call)
+          body.add(ast)
+          # if call.target
+          #   static_scope.self_type = call.target.inferred_type!
+          #   static_scope.self_node = call.target
+          # else
+          #   static_scope.self_type = scope.self_type
+          # end
+
           body
         else
-          Mirah::AST::Noop.new(call.parent, call.position)
+          Mirah::AST::Noop.new
         end
       end
+      macros[name][arg_types] = macro
+    end
+
+    def declared_macros(name=nil)
+      result = []
+      each_name = lambda do |name, hash|
+        hash.each do |args, macro|
+          result << macro
+        end
+      end
+      if name
+        each_name.call(name, self.macros[name])
+      else
+        self.macros.each &each_name
+      end
+      result
     end
-    
-    def wrap_with_scoped_body call, node
-      wrapper = Mirah::AST::ScopedBody.new(call.parent, call.position)
-      wrapper.static_scope = call.scope.static_scope
-      wrapper << node
+
+    def macro(name, types)
+      macro = macros[name][types]
+      return macro if macro
+      macro = superclass.macro(name, types) if (superclass && !superclass.isError)
+      return macro if macro
+      interfaces.each do |interface|
+        macro = interface.macro(name, types) unless interface.isError
+        return macro if macro
+      end
+      nil
     end
 
     def declared_intrinsics(name=nil)
@@ -114,8 +144,7 @@ module Mirah::JVM::Types
         end
       end
       interfaces.each do |interface|
-        next if interface.error?
-        methods.concat(interface.declared_intrinsics(name))
+        methods.concat(interface.declared_intrinsics(name)) unless interface.isError
       end
       methods
     end
@@ -123,240 +152,245 @@ module Mirah::JVM::Types
     def load_extensions(klass=nil)
       mirror = nil
       if klass
-        factory = Mirah::AST.type_factory
-        mirror = factory.get_mirror(klass.getName)
+        mirror = @type_system.mirror_class(klass)
       elsif jvm_type
         mirror = jvm_type
       end
       if mirror
-        extensions = mirror.getDeclaredAnnotation('duby.anno.Extensions')
+        extensions = mirror.getDeclaredAnnotation('org.mirah.macros.anno.Extensions')
         return self if extensions.nil?
         macros = extensions['macros']
         return self if macros.nil?
-        macros.each do |macro|
-          macro_name = macro['name']
-          class_name = macro['class']
-          types = BiteScript::ASM::Type.get_argument_types(macro['signature'])
-          args = types.map do |type|
-            if type.class_name == 'duby.lang.compiler.Block'
-              Mirah::AST::TypeReference::BlockType
-            else
-              Mirah::AST.type(nil, type)
-            end
-          end
-          klass = JRuby.runtime.jruby_class_loader.loadClass(class_name)
-          add_compiled_macro(klass, macro_name, args)
+        macros.each do |macro_class|
+          klass = begin
+                    JRuby.runtime.jruby_class_loader.loadClass(macro_class)
+                  rescue java.lang.NoClassDefFoundError => ex
+                    raise ex
+                  end
+          add_compiled_macro(klass)
         end
       end
       self
     end
 
+    def read_macrodef_annotation(klass)
+      macro = klass.getAnnotation(MacroDef.java_class)
+      if macro.nil?
+        error("Unable to load macro #{klass.name}: no MacroDef annotation")
+        return
+      end
+      macro_name = macro.name
+      # TODO optional, rest args
+      args = macro.arguments.required.map do |typename|
+        type = @type_system.get_type(typename)
+        raise "Unable to find class #{typename}" unless type
+        type
+      end
+      [macro_name, args, macro.is_static]
+    end
+
     def add_intrinsics
-      add_method('nil?', [], Boolean) do |compiler, call, expression|
+      boolean = @type_system.type(nil, 'boolean')
+      object_type = @type_system.type(nil, 'java.lang.Object')
+      class_type = @type_system.type(nil, 'java.lang.Class')
+
+      add_method('nil?', [], boolean) do |compiler, call, expression|
         if expression
-          call.target.compile(compiler, true)
+          compiler.visit(call.target, true)
           compiler.method.op_to_bool do |target|
             compiler.method.ifnull(target)
           end
         end
       end
 
-      add_method('==', [Object], Boolean) do |compiler, call, expression|
+      add_method('==', [object_type], boolean) do |compiler, call, expression|
         # Should this call Object.equals for consistency with Ruby?
         if expression
-          call.target.compile(compiler, true)
-          call.parameters[0].compile(compiler, true)
+          compiler.visit(call.target, true)
+          compiler.visit(call.parameters(0), true)
           compiler.method.op_to_bool do |target|
             compiler.method.if_acmpeq(target)
           end
         end
       end
 
-      add_method('!=', [Object], Boolean) do |compiler, call, expression|
+      add_method('!=', [object_type], boolean) do |compiler, call, expression|
         # Should this call Object.equals for consistency with Ruby?
         if expression
-          call.target.compile(compiler, true)
-          call.parameters[0].compile(compiler, true)
+          compiler.visit(call.target, true)
+          compiler.visit(call.parameters(0), true)
           compiler.method.op_to_bool do |target|
             compiler.method.if_acmpne(target)
           end
         end
       end
 
-      add_macro('kind_of?', ClassType) do |transformer, call|
-        klass, object = call.parameters[0], call.target
-        Mirah::AST::Call.new(call.parent, call.position, 'isInstance') do |call2|
-          klass.parent = object.parent = call2
-          [
-            klass,
-            [object]
-          ]
-        end
-      end
-
-      add_method('kind_of?', [Object.meta], Boolean) do |compiler, call, expression|
-        call.target.compile(compiler, expression)
+      add_method('kind_of?', [object_type.meta], boolean) do |compiler, call, expression|
+        compiler.visit(call.target, expression)
         if expression
-          klass = call.parameters[0].inferred_type!
+          klass = compiler.inferred_type(call.parameters(0))
           compiler.method.instanceof(klass.unmeta)
         end
       end
+
+      # add_macro('kind_of?', class_type) do |transformer, call|
+      #   klass, object = call.parameters(0), call.target
+      #   Mirah::AST::Call.new(call.parent, call.position, 'isInstance') do |call2|
+      #     klass.parent = object.parent = call2
+      #     [
+      #       klass,
+      #       [object]
+      #     ]
+      #   end
+      # end
+      #
     end
   end
 
   class ArrayType
+    begin
+      java_import 'org.mirah.builtins.ArrayExtensions'
+      java_import 'org.mirah.builtins.EnumerableExtensions'
+    rescue NameError
+      ArrayExtensions = nil
+      EnumerableExtensions = nil
+    end
+
     def add_intrinsics
       super
-      add_enumerable_macros
-
+      load_extensions(EnumerableExtensions.java_class) if EnumerableExtensions
+      load_extensions(ArrayExtensions.java_class) if ArrayExtensions
+      int_type = @type_system.type(nil, 'int')
       add_method(
-          '[]', [Int], component_type) do |compiler, call, expression|
+          '[]', [int_type], component_type) do |compiler, call, expression|
         if expression
-          call.target.compile(compiler, true)
-          call.parameters[0].compile(compiler, true)
+          compiler.visit(call.target, true)
+          compiler.visit(call.parameters(0), true)
           component_type.aload(compiler.method)
         end
       end
 
       add_method('[]=',
-                 [Int, component_type],
+                 [int_type, component_type],
                  component_type) do |compiler, call, expression|
-        call.target.compile(compiler, true)
-        convert_args(compiler, call.parameters, [Int, component_type])
+        compiler.visit(call.target, true)
+        convert_args(compiler, call.parameters, [@type_system.type(nil, 'int'), component_type])
         component_type.astore(compiler.method)
         if expression
-          call.parameters[1].compile(compiler, true)
+          compiler.visit(call.parameters(1), true)
         end
       end
 
-      add_method('length', [], Int) do |compiler, call, expression|
-        call.target.compile(compiler, true)
+      add_method('length', [], int_type) do |compiler, call, expression|
+        compiler.visit(call.target, true)
         compiler.method.arraylength
       end
-
-      add_macro('each', Mirah::AST.block_type) do |transformer, call|
-        Mirah::AST::Loop.new(call.parent,
-                            call.position, true, false) do |forloop|
-          index = transformer.tmp
-          array = transformer.tmp
-
-          init = transformer.eval("#{index} = 0;#{array} = nil")
-          array_assignment = init.children[-1]
-          array_assignment.value = call.target
-          call.target.parent = array_assignment
-          forloop.init << init
-
-          var = call.block.args.args[0]
-          if var
-            forloop.pre << transformer.eval(
-                "#{var.name} = #{array}[#{index}]", '', forloop, index, array)
-          end
-          forloop.post << transformer.eval("#{index} += 1")
-          call.block.body.parent = forloop if call.block.body
-          [
-            Mirah::AST::Condition.new(forloop, call.position) do |c|
-              [transformer.eval("#{index} < #{array}.length",
-                                '', forloop, index, array)]
-            end,
-            call.block.body
-          ]
-        end
-      end
     end
   end
 
   class MetaType
     def add_intrinsics
-      add_method('class', [], ClassType) do |compiler, call, expression|
+      add_method('class', [], @type_system.type(nil, 'java.lang.Class')) do |compiler, call, expression|
         if expression
           compiler.method.ldc_class(unmeta)
         end
       end
+      add_method('[]', [], unmeta.array_type.meta) do |compiler, call, expression|
+        compiler.method.ldc_class(unmeta.array_type.meta)
+      end
     end
   end
 
   class ArrayMetaType
     def add_intrinsics
       super
-      add_macro('cast', Object) do |transformer, call|
-        call.cast = true
-        call.resolve_if(nil) { unmeta }
-        call
-      end
+      load_extensions(@type_system.type(nil, 'org.mirah.builtins.ArrayMetaExtensions'))
+      # add_macro('cast', @type_system.type(nil, 'java.lang.Object')) do |transformer, call|
+      #   call.cast = true
+      #   call.resolve_if(nil) { unmeta }
+      #   call
+      # end
     end
   end
 
   class StringType < Type
     def add_intrinsics
       super
-      add_method('+', [String], String) do |compiler, call, expression|
+      string_type = @type_system.type(nil, 'java.lang.String')
+      bool_type = @type_system.type(nil, 'boolean')
+      int_type = @type_system.type(nil, 'int')
+      long_type = @type_system.type(nil, 'long')
+      char_type = @type_system.type(nil, 'char')
+      float_type = @type_system.type(nil, 'float')
+      double_type = @type_system.type(nil, 'double')
+      add_method('+', [string_type], string_type) do |compiler, call, expression|
         if expression
-          java_method('concat', String).call(compiler, call, expression)
+          java_method('concat', string_type).call(compiler, call, expression)
         end
       end
-      add_method('+', [Boolean], String) do |compiler, call, expression|
+      add_method('+', [bool_type], string_type) do |compiler, call, expression|
         if expression
-          call.target.compile(compiler, true)
-          call.parameters[0].compile(compiler, true)
-          compiler.method.invokestatic String, "valueOf", [String, Boolean]
-          compiler.method.invokevirtual String, "concat", [String, String]
+          compiler.visit(call.target, true)
+          compiler.visit(call.parameters(0), true)
+          compiler.method.invokestatic string_type, "valueOf", [string_type, bool_type]
+          compiler.method.invokevirtual string_type, "concat", [string_type, string_type]
         end
       end
-      add_method('+', [Char], String) do |compiler, call, expression|
+      add_method('+', [char_type], string_type) do |compiler, call, expression|
         if expression
-          call.target.compile(compiler, true)
-          call.parameters[0].compile(compiler, true)
-          compiler.method.invokestatic String, "valueOf", [String, Char]
-          compiler.method.invokevirtual String, "concat", [String, String]
+          compiler.visit(call.target, true)
+          compiler.visit(call.parameters(0), true)
+          compiler.method.invokestatic string_type, "valueOf", [string_type, char_type]
+          compiler.method.invokevirtual string_type, "concat", [string_type, string_type]
         end
       end
-      add_method('+', [Int], String) do |compiler, call, expression|
+      add_method('+', [int_type], string_type) do |compiler, call, expression|
         if expression
-          call.target.compile(compiler, true)
-          call.parameters[0].compile(compiler, true)
-          compiler.method.invokestatic String, "valueOf", [String, Int]
-          compiler.method.invokevirtual String, "concat", [String, String]
+          compiler.visit(call.target, true)
+          compiler.visit(call.parameters(0), true)
+          compiler.method.invokestatic string_type, "valueOf", [string_type, int_type]
+          compiler.method.invokevirtual string_type, "concat", [string_type, string_type]
         end
       end
-      add_method('+', [Long], String) do |compiler, call, expression|
+      add_method('+', [long_type], string_type) do |compiler, call, expression|
         if expression
-          call.target.compile(compiler, true)
-          call.parameters[0].compile(compiler, true)
-          compiler.method.invokestatic String, "valueOf", [String, Long]
-          compiler.method.invokevirtual String, "concat", [String, String]
+          compiler.visit(call.target, true)
+          compiler.visit(call.parameters(0), true)
+          compiler.method.invokestatic string_type, "valueOf", [string_type, long_type]
+          compiler.method.invokevirtual string_type, "concat", [string_type, string_type]
         end
       end
-      add_method('+', [Float], String) do |compiler, call, expression|
+      add_method('+', [float_type], string_type) do |compiler, call, expression|
         if expression
-          call.target.compile(compiler, true)
-          call.parameters[0].compile(compiler, true)
-          compiler.method.invokestatic String, "valueOf", [String, Float]
-          compiler.method.invokevirtual String, "concat", [String, String]
+          compiler.visit(call.target, true)
+          compiler.visit(call.parameters(0), true)
+          compiler.method.invokestatic string_type, "valueOf", [string_type, float_type]
+          compiler.method.invokevirtual string_type, "concat", [string_type, string_type]
         end
       end
-      add_method('+', [Double], String) do |compiler, call, expression|
+      add_method('+', [double_type], string_type) do |compiler, call, expression|
         if expression
-          call.target.compile(compiler, true)
-          call.parameters[0].compile(compiler, true)
-          compiler.method.invokestatic String, "valueOf", [String, Double]
-          compiler.method.invokevirtual String, "concat", [String, String]
+          compiler.visit(call.target, true)
+          compiler.visit(call.parameters(0), true)
+          compiler.method.invokestatic string_type, "valueOf", [string_type, double_type]
+          compiler.method.invokevirtual string_type, "concat", [string_type, string_type]
         end
       end
-      add_method('[]', [Int], Char) do |compiler, call, expression|
+      add_method('[]', [int_type], char_type) do |compiler, call, expression|
         if expression
-          call.target.compile(compiler, true)
-          call.parameters[0].compile(compiler, true)
-          compiler.method.invokevirtual String, "charAt", [Char, Int]
+          compiler.visit(call.target, true)
+          compiler.visit(call.parameters(0), true)
+          compiler.method.invokevirtual string_type, "charAt", [char_type, int_type]
         end
       end
-      add_method('[]', [Int, Int], String) do |compiler, call, expression|
+      add_method('[]', [int_type, int_type], string_type) do |compiler, call, expression|
         if expression
-          call.target.compile(compiler, true)
-          call.parameters[0].compile(compiler, true)
+          compiler.visit(call.target, true)
+          compiler.visit(call.parameters(0), true)
           compiler.method.dup
-          call.parameters[1].compile(compiler, true)
+          compiler.visit(call.parameters[1], true)
           compiler.method.iadd
-          compiler.method.invokevirtual String, "substring", [String, Int, Int]
+          compiler.method.invokevirtual string_type, "substring", [string_type, int_type, int_type]
         end
       end
     end
@@ -365,8 +399,9 @@ module Mirah::JVM::Types
   class IterableType < Type
     def add_intrinsics
       super
+      return
       add_enumerable_macros
-      add_macro('each', Mirah::AST.block_type) do |transformer, call|
+      add_macro('each', @type_system.block_type) do |transformer, call|
         Mirah::AST::Loop.new(call.parent,
                             call.position, true, false) do |forloop|
           it = transformer.tmp
@@ -400,4 +435,4 @@ module Mirah::JVM::Types
     def add_intrinsics
     end
   end
-end
+end