duby 0.0.2-java

data/lib/duby/jvm/types/literals.rb

@@ -0,0 +1,82 @@
+require 'delegate'
+
+module Duby::JVM::Types
+
+  # Represents a literal number that can be represented
+  # in multiple types
+  class NarrowingType < DelegateClass(PrimitiveType)
+    def initialize(default_type, narrowed_type)
+      super(default_type)
+      @narrowed = default_type != narrowed_type && narrowed_type
+    end
+    
+    def hash
+      __getobj__.hash
+    end
+
+    # Changes this type to the smallest type that will hold
+    # its literal value.
+    def narrow!
+      if @narrowed
+        __setobj__(@narrowed)
+        true
+      end
+    end
+  end
+  
+  class FixnumLiteral < NarrowingType
+    def self.range(type)
+      type::MIN_VALUE .. type::MAX_VALUE
+    end
+    
+    BYTE_RANGE = range(java.lang.Byte)
+    SHORT_RANGE = range(java.lang.Short)
+    INT_RANGE = range(java.lang.Integer)
+    LONG_RANGE = range(java.lang.Long)
+
+    def initialize(literal)
+      default_type = case literal
+      when INT_RANGE
+        Int
+      else
+        Long
+      end
+      
+      # TODO chars?
+      # There's not really any way to tell if we should narrow to a char
+      # or a byte/short.  I suppose we could try both, but that seems ugly.
+      # Maybe it's the right thing to do though?
+      narrowed_type = case literal
+      when BYTE_RANGE
+        Byte
+      when SHORT_RANGE
+        Short
+      when INT_RANGE
+        Int
+      else
+        Long
+      end
+      
+      super(default_type, narrowed_type)
+    end
+  end
+
+  class FloatLiteral < NarrowingType
+    FLOAT_RANGE = java.lang.Float::MIN_VALUE .. java.lang.Float::MAX_VALUE
+    NaN = java.lang.Float::NaN
+    POSITIVE_INFINITY = java.lang.Float::POSITIVE_INFINITY
+    NEGATIVE_INFINITY = java.lang.Float::NEGATIVE_INFINITY
+
+    def initialize(literal)
+      narrowed_type = case literal
+      when FLOAT_RANGE, NaN, POSITIVE_INFINITY, NEGATIVE_INFINITY
+        Float
+      else
+        Double
+      end
+      
+      # TODO Double should be default once it supports operators
+      super(narrowed_type, narrowed_type)
+    end
+  end
+end

data/lib/duby/jvm/types/methods.rb

@@ -0,0 +1,381 @@
+require 'duby/jvm/types'
+
+class Java::JavaMethod
+  def static?
+    java.lang.reflect.Modifier.static?(modifiers)
+  end
+end
+
+module Duby::JVM::Types
+  AST ||= Duby::AST
+
+  module ArgumentConversion
+    def convert_args(compiler, values, types=nil)
+      # TODO boxing/unboxing
+      # TODO varargs
+      types ||= argument_types
+      values.zip(types).each do |value, type|
+        value.compile(compiler, true)
+        if type.primitive? && type != value.inferred_type
+            value.inferred_type.widen(compiler.method, type)
+        end
+      end
+    end
+  end
+  
+  Type.send :include, ArgumentConversion
+
+  class Intrinsic
+    include ArgumentConversion
+    attr_reader :name, :argument_types, :return_type
+
+    def initialize(klass, name, args, type, &block)
+      raise ArgumentError, "Block required" unless block_given?
+      @class = klass
+      @name = name
+      @argument_types = args
+      @return_type = type
+      @block = block
+    end
+
+    def call(builder, ast, expression)
+      @block.call(builder, ast, expression)
+    end
+    
+    def declaring_class
+      @class
+    end
+    
+    def constructor?
+      false
+    end
+    
+    def exceptions
+      []
+    end
+    
+    def actual_return_type
+      return_type
+    end
+  end
+  
+  class JavaConstructor
+    include ArgumentConversion
+    def initialize(member)
+      @member = member
+    end
+
+    def name
+      @name ||= @member.name
+    end
+    
+    def argument_types
+      @argument_types ||= @member.argument_types.map do |arg|
+        AST.type(arg) if arg
+      end
+    end
+    
+    def return_type
+      declaring_class
+    end
+    
+    def actual_return_type
+      return_type
+    end
+
+    def exceptions
+      @member.exception_types.map do |exception|
+        AST.type(exception.name)
+      end
+    end
+
+    def declaring_class
+      AST.type(@member.declaring_class)
+    end
+    
+    def call(compiler, ast, expression)
+      target = ast.target.inferred_type
+      compiler.method.new target
+      compiler.method.dup if expression
+      convert_args(compiler, ast.parameters)
+      compiler.method.invokespecial(
+        target,
+        "<init>",
+        [nil, *@member.argument_types])        
+    end
+    
+    def constructor?
+      true
+    end
+  end
+
+  class JavaMethod < JavaConstructor
+    def return_type
+      @return_type ||= begin
+        if @member.return_type
+          AST.type(@member.return_type)
+        else
+          declaring_class
+        end
+      end
+    end
+    
+    def actual_return_type
+      if @member.return_type
+        return_type
+      else
+        Void
+      end
+    end
+    
+    def static?
+      @member.static?
+    end
+    
+    def void?
+      @member.return_type.nil?
+    end
+    
+    def constructor?
+      false
+    end
+    
+    def call(compiler, ast, expression)
+      target = ast.target.inferred_type
+      ast.target.compile(compiler, 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, ast.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
+      
+      unless expression || void?
+        compiler.method.pop
+      end
+    end
+
+    def call_special(compiler, ast, expression)
+      target = ast.target.inferred_type
+      ast.target.compile(compiler, 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, ast.parameters)
+      if target.interface?
+        raise "interfaces should not receive call_special"
+      else
+        compiler.method.invokespecial(
+          target,
+          name,
+          [@member.return_type, *@member.argument_types])
+      end
+
+      unless expression || void?
+        compiler.method.pop
+      end
+    end
+  end
+  
+  class JavaStaticMethod < JavaMethod
+    def return_type
+      @return_type ||= begin
+        if @member.return_type
+          AST.type(@member.return_type)
+        else
+          Void
+        end
+      end
+    end
+
+    def call(compiler, ast, expression)
+      target = ast.target.inferred_type
+      convert_args(compiler, ast.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?
+      compiler.method.pop unless expression || void?
+    end
+  end
+  
+  class DubyMember
+    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 == Void
+        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
+  end
+  
+  class Type
+    def get_method(name, args)
+      method = find_method(self, name, args, 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)
+      types = types.map {|type| type.jvm_type}
+      constructor = (jvm_type.constructor(*types) rescue nil)
+      return JavaConstructor.new(constructor) if constructor
+      raise NameError, "No constructor #{name}(#{types.join ', '})"
+    end
+    
+    def java_method(name, *types)
+      intrinsic = intrinsics[name][types]
+      return intrinsic if intrinsic
+      types = types.map {|type| type.jvm_type}
+      method = (jvm_type.java_method(name, *types) rescue nil)
+      if method && method.static? == meta?
+        return JavaStaticMethod.new(method) if method.static?
+        return JavaMethod.new(method)
+      end
+      raise NameError, "No method #{self.name}.#{name}(#{types.join ', '})"
+    end
+
+    def declared_instance_methods
+      if jvm_type && !array?
+        methods = jvm_type.declared_instance_methods.map do |method|
+          JavaMethod.new(method)
+        end
+      else
+        methods = []
+      end
+      methods.concat((meta? ? unmeta : self).declared_intrinsics)
+    end
+
+    def declared_class_methods
+      methods = jvm_type.declared_class_methods.map do |method|
+        JavaStaticMethod.new(method)
+      end
+      methods.concat(meta.declared_intrinsics)
+    end
+
+    def declared_constructors
+      jvm_type.declared_constructors.map do |method|
+        JavaConstructor.new(method)
+      end
+    end
+  end
+
+  class TypeDefinition
+    def java_method(name, *types)
+      method = instance_methods[name].find {|m| m.argument_types == types}
+      return method if method
+      raise NameError, "No method #{self.name}.#{name}(#{types.join ', '})"
+    end
+    
+    def java_static_method(name, *types)
+      method = static_methods[name].find {|m| m.argument_types == types}
+      return method if method
+      raise NameError, "No method #{self.name}.#{name}(#{types.join ', '})"
+    end
+    
+    def constructor(*types)
+      constructor = constructors.find {|c| c.argument_types == types}
+      return constructor if constructor
+      raise NameError, "No constructor #{name}(#{types.join ', '})"
+    end
+
+    def declared_instance_methods
+      instance_methods.values.flatten
+    end
+
+    def declared_class_methods
+      static_methods.values.flatten
+    end
+    
+    def declared_constructors
+      constructors
+    end
+    
+    def constructors
+      @constructors ||= []
+    end
+    
+    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 declare_method(name, arguments, type, exceptions)
+      member = DubyMember.new(self, name, arguments, type, false, exceptions)
+      if name == 'initialize'
+        constructors << JavaConstructor.new(member)
+      else
+        instance_methods[name] << JavaMethod.new(member)
+      end
+    end
+    
+    def declare_static_method(name, arguments, type, exceptions)
+      member = DubyMember.new(self, name, arguments, type, true, exceptions)
+      static_methods[name] << JavaStaticMethod.new(member)
+    end
+  end
+
+  class TypeDefMeta
+    def constructor(*args)
+      unmeta.constructor(*args)
+    end
+
+    def java_method(*args)
+      unmeta.java_static_method(*args)
+    end
+    
+    def declared_instance_methods
+      unmeta.declared_instance_methods
+    end
+    
+    def declared_class_methods
+      unmeta.declared_class_methods
+    end
+  end
+end