duby 0.0.2-java → 0.0.3-java

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

@@ -4,6 +4,10 @@ class Java::JavaMethod
   def static?
     java.lang.reflect.Modifier.static?(modifiers)
   end
+
+  def abstract?
+    java.lang.reflect.Modifier.abstract?(modifiers)
+  end
 end
 
 module Duby::JVM::Types
@@ -22,7 +26,7 @@ module Duby::JVM::Types
       end
     end
   end
-  
+
   Type.send :include, ArgumentConversion
 
   class Intrinsic
@@ -41,26 +45,33 @@ module Duby::JVM::Types
     def call(builder, ast, expression)
       @block.call(builder, ast, expression)
     end
-    
+
     def declaring_class
       @class
     end
-    
+
     def constructor?
       false
     end
-    
+
+    def abstract?
+      false
+    end
+
     def exceptions
       []
     end
-    
+
     def actual_return_type
       return_type
     end
   end
-  
-  class JavaConstructor
+
+  class JavaCallable
     include ArgumentConversion
+
+    attr_accessor :member
+
     def initialize(member)
       @member = member
     end
@@ -68,31 +79,49 @@ module Duby::JVM::Types
     def name
       @name ||= @member.name
     end
-    
+
+    def field?
+      false
+    end
+
+    def parameter_types
+      @member.parameter_types
+    end
+  end
+
+  class JavaConstructor < JavaCallable
     def argument_types
       @argument_types ||= @member.argument_types.map do |arg|
-        AST.type(arg) if arg
+        if arg.kind_of?(AST::TypeReference) || arg.nil?
+          arg
+        else
+          AST.type(arg)
+        end
       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)
+        if exception.kind_of?(Duby::JVM::Types::Type)
+          exception
+        else
+          Duby::AST.type(exception.class_name)
+        end
       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
@@ -101,9 +130,9 @@ module Duby::JVM::Types
       compiler.method.invokespecial(
         target,
         "<init>",
-        [nil, *@member.argument_types])        
+        [nil, *@member.argument_types])
     end
-    
+
     def constructor?
       true
     end
@@ -112,38 +141,47 @@ module Duby::JVM::Types
   class JavaMethod < JavaConstructor
     def return_type
       @return_type ||= begin
-        if @member.return_type
-          AST.type(@member.return_type)
-        else
+        if void?
           declaring_class
+        else
+          AST.type(@member.return_type)
         end
       end
     end
-    
+
     def actual_return_type
-      if @member.return_type
-        return_type
-      else
+      if void?
         Void
+      else
+        return_type
       end
     end
-    
+
     def static?
       @member.static?
     end
-    
+
+    def abstract?
+      @member.abstract?
+    end
+
     def void?
-      @member.return_type.nil?
+      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 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
@@ -151,7 +189,7 @@ module Duby::JVM::Types
       if expression && void?
         compiler.method.dup
       end
-      
+
       convert_args(compiler, ast.parameters)
       if target.interface?
         compiler.method.invokeinterface(
@@ -164,7 +202,7 @@ module Duby::JVM::Types
           name,
           [@member.return_type, *@member.argument_types])
       end
-      
+
       unless expression || void?
         compiler.method.pop
       end
@@ -197,18 +235,8 @@ module Duby::JVM::Types
       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
 
+  class JavaStaticMethod < JavaMethod
     def call(compiler, ast, expression)
       target = ast.target.inferred_type
       convert_args(compiler, ast.parameters)
@@ -223,11 +251,117 @@ module Duby::JVM::Types
       compiler.method.pop unless expression || void?
     end
   end
-  
+
+  class JavaDynamicMethod < JavaMethod
+    def initialize(name, *types)
+      @name = name
+      @types = types
+    end
+
+    def return_type
+      AST.type('dynamic')
+    end
+
+    def declaring_class
+      java.lang.Object
+    end
+
+    def argument_types
+      @types
+    end
+
+    def call(compiler, ast, expression)
+      target = ast.target.inferred_type
+      ast.target.compile(compiler, true)
+
+      ast.parameters.each do |param|
+        param.compile(compiler, true)
+      end
+      compiler.method.invokedynamic(
+        target,
+        "dyn:callPropWithThis:#{name}",
+        [return_type, target, *@types])
+
+      unless expression
+        compiler.method.pop
+      end
+
+      compiler.bootstrap_dynamic
+    end
+  end
+
+  class JavaFieldAccessor < JavaMethod
+    def field?
+      true
+    end
+    
+    def return_type
+      AST.type(@member.type)
+    end
+
+    alias actual_return_type return_type
+    
+    def public?
+      @member.public?
+    end
+
+    def final?
+      @member.final?
+    end
+  end
+
+  class JavaFieldGetter < JavaFieldAccessor
+    def argument_types
+      []
+    end
+
+    def call(compiler, ast, expression)
+      target = ast.target.inferred_type
+      
+      # 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
+          ast.target.compile(compiler, true)
+          compiler.method.getfield(target, name, @member.type)
+        end
+      end
+    end
+  end
+
+  class JavaFieldSetter < JavaFieldAccessor
+    def return_type
+      AST.type(@member.type)
+    end
+
+    def argument_types
+      [AST.type(@member.type)]
+    end
+
+    def call(compiler, ast, expression)
+      target = ast.target.inferred_type
+
+      # TODO: assert that no args are being passed, though that should have failed lookup
+
+      convert_args(compiler, ast.parameters)
+      if @member.static?
+        compiler.method.dup if expression
+        compiler.method.putstatic(target, name, @member.type)
+      else
+        ast.target.compile(compiler, true)
+        convert_args(compiler, ast.parameters)
+        compiler.method.dup_x2 if expression
+        compiler.method.putfield(target, name, @member.type)
+      end
+    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
@@ -239,12 +373,16 @@ module Duby::JVM::Types
       @static = static
       @exception_types = exceptions || []
     end
-    
+
     def static?
       @static
     end
+
+    def abstract?
+      @declaring_class.interface?
+    end
   end
-  
+
   class Type
     def get_method(name, args)
       method = find_method(self, name, args, meta?)
@@ -254,111 +392,205 @@ module Duby::JVM::Types
           if args[-1].narrow!
             method = find_method(self, name, args, meta?)
           end
-        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
+      begin
+        descriptors = types.map {|type| BiteScript::Signature.class_id(type)}
+        constructor = jvm_type.getConstructor(*descriptors)
+        return JavaConstructor.new(constructor) if constructor
+      rescue => ex
+        log(ex.message)
+      end
       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)
+      jvm_types = types.map {|type| type.jvm_type}
+
+      return JavaDynamicMethod.new(name, *jvm_types) if dynamic?
+
+      begin
+        descriptors = types.map {|type| BiteScript::Signature.class_id(type)}
+        method = jvm_type.getDeclaredMethod(name, *descriptors)
+
+        if method.nil? && superclass
+          method = superclass.java_method(name, *types) rescue nil
+        end
+
+        if method.nil? && jvm_type.abstract?
+          interfaces.each do |interface|
+            method = interface.java_method(name, *types) rescue nil
+            break if method
+          end
+        end
+
+        if method && method.static? == meta?
+          return JavaStaticMethod.new(method) if method.static?
+          return JavaMethod.new(method)
+        end
+      rescue   => ex
+        log(ex.message)
       end
       raise NameError, "No method #{self.name}.#{name}(#{types.join ', '})"
     end
 
-    def declared_instance_methods
+    def declared_instance_methods(name=nil)
+      methods = []
       if jvm_type && !array?
-        methods = jvm_type.declared_instance_methods.map do |method|
-          JavaMethod.new(method)
+        jvm_type.getDeclaredMethods(name).each do |method|
+          methods << JavaMethod.new(method) unless method.static?
         end
-      else
-        methods = []
       end
-      methods.concat((meta? ? unmeta : self).declared_intrinsics)
+      methods.concat((meta? ? unmeta : self).declared_intrinsics(name))
     end
 
-    def declared_class_methods
-      methods = jvm_type.declared_class_methods.map do |method|
-        JavaStaticMethod.new(method)
+    def declared_class_methods(name=nil)
+      methods = []
+      jvm_type.getDeclaredMethods(name).each do |method|
+        methods << JavaStaticMethod.new(method) if method.static?
       end
-      methods.concat(meta.declared_intrinsics)
+      methods.concat(meta.declared_intrinsics(name))
     end
 
     def declared_constructors
-      jvm_type.declared_constructors.map do |method|
+      jvm_type.getConstructors.map do |method|
         JavaConstructor.new(method)
       end
     end
+
+    def field_getter(name)
+      if jvm_type
+        field = jvm_type.getField(name)
+        JavaFieldGetter.new(field) if field
+      else
+        nil
+      end
+    end
+
+    def field_setter(name)
+      if jvm_type
+        field = jvm_type.getField(name)
+        JavaFieldSetter.new(field) if field
+      else
+        nil
+      end
+    end
+
+    def inner_class_getter(name)
+      full_name = "#{self.name}$#{name}"
+      inner_class = Duby::AST.type(full_name) rescue nil
+      return unless inner_class
+      inner_class.inner_class = true
+      add_macro(name) do |transformer, call|
+        Duby::AST::Constant.new(call.parent, call.position, full_name)
+      end
+      intrinsics[name][[]]
+    end
   end
 
   class TypeDefinition
     def java_method(name, *types)
       method = instance_methods[name].find {|m| m.argument_types == 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 = static_methods[name].find {|m| m.argument_types == 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 = 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
+    def declared_instance_methods(name=nil)
+      declared_intrinsics(name) + if name.nil?
+        instance_methods.values.flatten
+      else
+        instance_methods[name]
+      end
     end
 
-    def declared_class_methods
-      static_methods.values.flatten
+    def declared_class_methods(name=nil)
+      meta.declared_intrinsics(name) + if name.nil?
+        static_methods.values.flatten
+      else
+        static_methods[name]
+      end
     end
-    
+
     def declared_constructors
       constructors
     end
-    
+
     def constructors
       @constructors ||= []
     end
-    
+
+    def default_constructor
+      if constructors.empty?
+        declare_method('initialize', [], self, [])
+        @default_constructor_added = true
+        constructors[0]
+      else
+        constructor
+      end
+    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)
+      raise "Bad args" unless arguments.all?
       member = DubyMember.new(self, name, arguments, type, false, exceptions)
       if name == 'initialize'
-        constructors << JavaConstructor.new(member)
+        if @default_constructor_added
+          unless arguments.empty?
+            raise "Can't add constructor #{member} after using the default."
+          end
+        else
+          constructors << JavaConstructor.new(member)
+        end
       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
+
+    def interface?
+      false
+    end
+
+    def field_getter(name)
+      nil
+    end
+
+    def field_setter(name)
+      nil
+    end
   end
 
   class TypeDefMeta
@@ -369,13 +601,21 @@ module Duby::JVM::Types
     def java_method(*args)
       unmeta.java_static_method(*args)
     end
-    
-    def declared_instance_methods
-      unmeta.declared_instance_methods
+
+    def declared_class_methods(name=nil)
+      unmeta.declared_class_methods(name)
     end
-    
-    def declared_class_methods
-      unmeta.declared_class_methods
+
+    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