mirah 0.0.4-java

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

@@ -0,0 +1,33 @@
+module Duby::JVM::Types
+  Boolean = BooleanType.new('boolean', java.lang.Boolean)
+  Byte = IntegerType.new('byte', java.lang.Byte)
+  Char = IntegerType.new('char', java.lang.Character)
+  Short = IntegerType.new('short', java.lang.Short)
+  Int = IntegerType.new('int', java.lang.Integer)
+  Long = LongType.new('long', java.lang.Long)
+  Float = FloatType.new('float', java.lang.Float)
+  Double = DoubleType.new('double', java.lang.Double)
+
+  # TODO these shouldn't be constants. They should be loaded from
+  # the compilation class path.
+  Object = Type.new(BiteScript::ASM::ClassMirror.load('java.lang.Object'))
+  ClassType = Type.new(BiteScript::ASM::ClassMirror.load('java.lang.Class'))
+  String = StringType.new(
+      BiteScript::ASM::ClassMirror.load('java.lang.String'))
+  Iterable = IterableType.new(
+          BiteScript::ASM::ClassMirror.load('java.lang.Iterable'))
+
+  Void = VoidType.new
+  Null = NullType.new
+
+  WIDENING_CONVERSIONS = {
+    Byte => [Byte, Short, Int, Long, Float, Double],
+    Short => [Short, Int, Long, Float, Double],
+    Char => [Char, Int, Long, Float, Double],
+    Int => [Int, Long, Float, Double],
+    Long => [Long, Float, Double],
+    Float => [Float, Double],
+    Double => [Double]
+  }
+  TYPE_ORDERING = [Byte, Short, Int, Long, Float, Double]
+end

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

@@ -0,0 +1,17 @@
+module Duby::JVM::Types
+  class BooleanType < PrimitiveType
+    def init_value(builder)
+      builder.iconst_0
+    end
+
+    def prefix
+      'i'
+    end
+
+    def box(builder)
+      box_type = Duby::AST::type(nil, 'java.lang.Boolean')
+      builder.invokestatic box_type, "valueOf", [box_type, self]
+    end
+
+  end
+end

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

@@ -0,0 +1,65 @@
+module Duby::JVM::Types
+  class Type
+    def expand_each(transformer, call)
+      arg_types = [Duby::AST.block_type]
+      code = intrinsics['each'][arg_types].return_type
+      code.inline(transformer, call)
+    end
+    
+    def add_enumerable_macros
+      all_proc = proc do |transformer, call|
+        if !call.block
+          # We need to create a block that just returns the item passed to it
+          # First get a new temp for the block argument
+          var = transformer.tmp
+          # Parse a fake function call to create a block. Then pull of the
+          # block and attach it to the real call.
+          call.block = transformer.eval("foo {|#{var}| #{var}}").block
+        end
+        
+        # Now that we've got a block we can transform it into a Loop.
+        forloop = expand_each(transformer, call)
+        
+        # Start adding stuff to the loop.
+        # At the beginning of the loop we create a temp initialized to true
+        all = transformer.tmp
+        forloop.init << transformer.eval("#{all} = true")
+        
+        # Now we want to wrap the body of the loop. Start off by using
+        # foo as a placeholder.
+        body = transformer.eval(
+            "unless foo;#{all} = false;break;end", '', forloop)
+        # Then replace foo with the real body.
+        body.condition.predicate = call.block.body
+        # And finally patch the new body back into the forloop.
+        forloop.body = call.block.body.parent = body
+        
+        # Loops don't have a return value, so we need somewhere to
+        # put the result.
+        result = Duby::AST::Body.new(call.parent, call.position)
+        result << forloop << transformer.eval("#{all}", '', nil, all)
+      end
+      add_macro('all?', &all_proc)
+      add_macro('all?', Duby::AST.block_type, &all_proc)
+
+      any_proc = proc do |transformer, call|
+        if !call.block
+          var = transformer.tmp
+          call.block = transformer.eval("foo {|#{var}| #{var}}").block
+        end
+        forloop = expand_each(transformer, call)
+        any = transformer.tmp
+        forloop.init << transformer.eval("#{any} = false")
+        body = transformer.eval(
+            "if foo;#{any} = true;break;end", '', forloop)
+        body.condition.predicate = call.block.body
+        forloop.body = call.block.body.parent = body
+        
+        result = Duby::AST::Body.new(call.parent, call.position)
+        result << forloop << transformer.eval("#{any}", '', nil, any)
+      end
+      add_macro('any?', &any_proc)
+      add_macro('any?', Duby::AST.block_type, &any_proc)
+    end
+  end
+end

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

@@ -0,0 +1,86 @@
+require 'delegate'
+
+module Duby::JVM::Types
+  class ExtendedType < DelegateClass(Type)
+    def initialize(*args)
+      super
+      @static_includes = []
+    end
+
+    def include(type)
+      @static_includes << type
+      self
+    end
+
+    def meta
+      if meta?
+        self
+      else
+        __getobj__.meta
+      end
+    end
+
+    def unmeta
+      if meta?
+        __getobj__.unmeta
+      else
+        self
+      end
+    end
+
+    def get_method(name, args)
+      method = __getobj__.get_method(name, args)
+      return method if method
+      @static_includes.each do |type|
+        method = type.meta.get_method(name, args)
+        return method if method
+      end
+      nil
+    end
+
+    def java_method(name, *types)
+      __getobj__.java_method(name, *types) || __included_method(name, types)
+    end
+
+    def java_static_method(name, *types)
+      __getobj__.java_static_method(name, *types) || __included_method(name, types)
+    end
+
+    def declared_instance_methods(name=nil)
+      __combine_methods(__getobj__.declared_instance_methods)
+    end
+
+    def declared_class_methods(name=nil)
+      __combine_methods(__getobj__.declared_class_methods)
+    end
+
+    def __combine_methods(basic_methods)
+      methods = {}
+      basic_methods.each do |method|
+        key = [method.name, method.parameter_types, method.return_type]
+        methods[key] = method
+      end
+      @static_includes.each do |type|
+        type.declared_class_methods.each do |method|
+          key = [method.name, method.parameter_types, method.return_type]
+          methods[key] ||= method
+        end
+      end
+      methods.values
+    end
+
+    def __included_method(name, types)
+      @static_includes.each do |type|
+        method = type.meta.java_method(name, *types)
+        return method if method
+      end
+      nil
+    end
+  end
+
+  class Type
+    def include(type)
+      ExtendedType.new(self).include(type)
+    end
+  end
+end

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

@@ -0,0 +1,186 @@
+require 'jruby'
+module Duby::JVM::Types
+  class TypeFactory
+    BASIC_TYPES = {
+      "boolean" => Boolean,
+      "byte" => Byte,
+      "char" => Char,
+      "short" => Short,
+      "int" => Int,
+      "long" => Long,
+      "float" => Float,
+      "double" => Double,
+      "fixnum" => Int,
+      "string" => String,
+      "java.lang.String" => String,
+      "String" => String,
+      "java.lang.Object" => Object,
+      "Object" => Object,
+      "java.lang.Class" => ClassType,
+      "java.lang.Iterable" => Iterable,
+      "Iterable" => Iterable,
+      "void" => Void,
+      "notype" => Void,
+      "null" => Null,
+      "dynamic" => DynamicType.new
+    }.freeze
+
+    attr_accessor :package
+    attr_reader :known_types
+
+    class ParanoidHash < Hash
+      def []=(k, v)
+        raise ArgumentError, "Can't store nil for key #{k.inspect}" if v.nil?
+        super(k, v)
+      end
+    end
+
+    def initialize
+      @known_types = ParanoidHash.new
+      @known_types.update(BASIC_TYPES)
+      @declarations = []
+      @mirrors = {}
+    end
+
+    def initialize_copy(other)
+      @known_types = other.known_types.dup
+      @known_types.delete_if do |key, value|
+        value.basic_type.kind_of?(Duby::JVM::Types::TypeDefinition)
+      end
+      @declarations = []
+    end
+
+    def define_types(builder)
+      @declarations.each do |declaration|
+        declaration.define(builder)
+      end
+    end
+
+    def type(scope, name, array=false, meta=false)
+      if name.kind_of?(BiteScript::ASM::Type)
+        if name.getDescriptor[0] == ?[
+          return type(scope, name.getElementType, true, meta)
+        else
+          name = name.getClassName
+        end
+      end
+      type = basic_type(scope, name)
+      type = type.array_type if array
+      type = type.meta if meta
+      return type
+    end
+
+    def basic_type(scope, name)
+      if name.kind_of?(Type) || name.kind_of?(NarrowingType)
+        return name.basic_type
+      end
+      orig = name
+      if name.kind_of? Java::JavaClass
+        if name.array?
+          return type(name.component_type, true)
+        else
+          name = name.name
+        end
+      elsif name.respond_to? :java_class
+        name = name.java_class.name
+      end
+      name = name.to_s unless name.kind_of?(::String)
+      raise ArgumentError, "Bad Type #{orig}" if name =~ /Java::/
+      raise ArgumentError, "Bad Type #{orig.inspect}" if name == '' || name.nil?
+      find_type(scope, name)
+    end
+
+    def find_type(scope, name)
+      begin
+        return get_type(name)
+      rescue NameError => ex
+        raise ex if scope.nil?
+      end
+
+      imports = scope.static_scope.imports
+      if imports.include?(name)
+        name = imports[name] while imports.include?(name)
+        return get_type(name)
+      end
+
+      # TODO support inner class names
+      if name !~ /\./
+        return package_search(name, scope)
+      end
+    end
+
+    def package_search(name, scope)
+      packages = []
+      packages << scope.static_scope.package unless scope.static_scope.package.empty?
+      packages.concat(scope.static_scope.search_packages)
+      packages << 'java.lang'
+      packages.each do |package|
+        begin
+          return get_type("#{package}.#{name}")
+        rescue
+        end
+      end
+      raise NameError, "Cannot find class #{name}"
+    end
+
+    def get_type(full_name)
+      type = @known_types[full_name]
+      return type.basic_type if type
+      type = Type.new(get_mirror(full_name)).load_extensions
+      @known_types[full_name] = type
+    end
+
+    def known_type(scope, name)
+      basic_type(scope, name) rescue nil
+    end
+
+    def declare_type(scope, name)
+      full_name = name
+      package = scope.static_scope.package
+      if !name.include?('.') && !package.empty?
+        full_name = "#{package}.#{name}"
+      end
+      if @known_types.include? full_name
+        @known_types[full_name]
+      else
+        scope.static_scope.import(full_name, name)
+        @known_types[full_name] = TypeDefinition.new(full_name, nil)
+      end
+    end
+
+    def define_type(node)
+      name = node.name
+      full_name = name
+      package = node.static_scope.package
+      if !name.include?('.') && !package.empty?
+        full_name = "#{package}.#{name}"
+      end
+      if @known_types.include? full_name
+        existing = @known_types[full_name]
+        existing.node ||= node
+        existing
+      else
+        if Duby::AST::InterfaceDeclaration === node
+          klass = InterfaceDefinition
+        else
+          klass = TypeDefinition
+        end
+        node.scope.static_scope.import(full_name, name)
+        @known_types[full_name] = klass.new(full_name, node)
+      end
+    end
+
+    def no_type
+      Void
+    end
+
+    def get_mirror(name)
+      @mirrors[name] ||= begin
+        classname = name.tr('.', '/') + ".class"
+        stream = JRuby.runtime.jruby_class_loader.getResourceAsStream(classname)
+        raise NameError, "Class '#{name}' not found." unless stream
+        BiteScript::ASM::ClassMirror.load(stream)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,86 @@
+module Duby::JVM::Types
+  class FloatType < Number
+    def prefix
+      'f'
+    end
+
+    def math_type
+      Float
+    end
+
+    def box_type
+      java.lang.Float
+    end
+    
+    def suffix
+      'g'
+    end
+
+    def init_value(builder)
+      builder.fconst_0
+    end
+
+    def literal(builder, value)
+      case value
+      when 0.0
+        builder.fconst_0
+      when 1.0
+        builder.fconst_1
+      when 2.0
+        builder.fconst_2
+      else
+        builder.ldc_float(value)
+      end
+    end
+    
+    def widen(builder, type)
+      case type
+      when Float
+        # Do nothing
+      when Double
+        builder.f2d
+      else
+        raise ArgumentError, "Invalid widening conversion from float to #{type}"
+      end
+    end
+  end
+  
+  class DoubleType < FloatType
+    def prefix
+      'd'
+    end
+
+    def math_type
+      Double
+    end
+
+    def box_type
+      java.lang.Double
+    end
+
+    def wide?
+      true
+    end
+
+    def init_value(builder)
+      builder.dconst_0
+    end
+
+    def literal(builder, value)
+      case value
+      when 0.0
+        builder.dconst_0
+      when 1.0
+        builder.dconst_1
+      else
+        builder.ldc_double(value)
+      end
+    end
+    
+    def widen(builder, type)
+      if type != Double
+        raise ArgumentError, "Invalid widening conversion from double to #{type}"
+      end
+    end
+  end
+end