duby 0.0.2-java → 0.0.3-java

data/lib/duby/ast/method.rb

@@ -1,132 +1,147 @@
 module Duby::AST
   class Arguments < Node
-    attr_accessor :args, :opt_args, :rest_arg, :block_arg
-    
+    child :args
+    child :opt_args
+    child :rest_arg
+    child :block_arg
+
     def initialize(parent, line_number, &block)
       super(parent, line_number, &block)
-      @args, @opt_args, @rest_arg, @block_arg = children
     end
-    
+
     def infer(typer)
-      unless @inferred_type
+      unless resolved?
         @inferred_type = args ? args.map {|arg| typer.infer(arg)} : []
+        if @inferred_type.all?
+          resolved!
+        else
+          typer.defer(self)
+        end
       end
+      @inferred_type
     end
   end
-      
+
   class Argument < Node
     include Typed
+
+    def resolved!(typer)
+      typer.learn_local_type(containing_scope, name, @inferred_type)
+      super
+    end
   end
-      
+
   class RequiredArgument < Argument
     include Named
     include Scoped
-    
+
     def initialize(parent, line_number, name)
       super(parent, line_number)
 
       @name = name
     end
-    
+
     def infer(typer)
-      unless @inferred_type
-        # if not already typed, check parent of parent (MethodDefinition) for signature info
+      resolve_if(typer) do
+        scope.static_scope << name
+        # if not already typed, check parent of parent (MethodDefinition)
+        # for signature info
         method_def = parent.parent
         signature = method_def.signature
 
         # if signature, search for this argument
-        if signature[name.intern]
-          @inferred_type = typer.learn_local_type(scope, name, signature[name.intern])
-        else
-          @inferred_type = typer.local_type(scope, name)
-        end
-          
-        unless @inferred_type
-          typer.defer(self)
-        end
+        signature[name.intern] || typer.local_type(scope, name)
       end
-        
-      @inferred_type
     end
   end
-      
+
   class OptionalArgument < Argument
     include Named
     include Scoped
-    attr_accessor :child
-    
+    child :child
+
     def initialize(parent, line_number, name, &block)
       super(parent, line_number, &block)
-      @child = children[0]
       @name = name
     end
 
     def infer(typer)
-      unless @inferred_type
-        # if not already typed, check parent of parent (MethodDefinition) for signature info
+      resolve_if(typer) do
+        scope.static_scope << name
+        # if not already typed, check parent of parent (MethodDefinition)
+        # for signature info
         method_def = parent.parent
         signature = method_def.signature
 
-        # if signature, search for this argument
-        @inferred_type = child.infer(typer)
-        if @inferred_type
-          typer.learn_local_type(scope, name, @inferred_type)
-          signature[name.intern] = @inferred_type
-        else
-          typer.defer(self)
-        end
+        signature[name.intern] = child.infer(typer)
       end
-
-      @inferred_type
     end
   end
-      
+
   class RestArgument < Argument
     include Named
     include Scoped
-    
+
     def initialize(parent, line_number, name)
       super(parent, line_number)
 
       @name = name
     end
+
+    def infer(typer)
+      scope.static_scope << name
+      super
+    end
   end
-      
+
   class BlockArgument < Argument
     include Named
-    
+    include Scoped
+    attr_accessor :optional
+    alias optional? optional
+
     def initialize(parent, line_number, name)
       super(parent, line_number)
 
       @name = name
     end
+
+    def infer(typer)
+      scope.static_scope << name
+      super
+    end
   end
-      
+
   class MethodDefinition < Node
     include Annotated
     include Named
     include Scope
-    attr_accessor :signature, :arguments, :body, :defining_class
-        
+    include Binding
+
+    child :signature
+    child :arguments
+    child :body
+
+    attr_accessor :defining_class
+
     def initialize(parent, line_number, name, annotations=[], &block)
       @annotations = annotations
       super(parent, line_number, &block)
-      @signature, @arguments, @body = children
       @name = name
     end
 
     def name
       super
     end
-    
+
     def infer(typer)
       @defining_class ||= typer.self_type
       typer.infer(arguments)
       typer.infer_signature(self)
       forced_type = signature[:return]
       inferred_type = body ? typer.infer(body) : typer.no_type
-        
-      if !inferred_type
+
+      if !(inferred_type && arguments.inferred_type.all?)
         typer.defer(self)
       else
         actual_type = if forced_type.nil?
@@ -137,7 +152,7 @@ module Duby::AST
         if actual_type.unreachable?
           actual_type = typer.no_type
         end
-        
+
         if !abstract? &&
             forced_type != typer.no_type &&
             !actual_type.is_parent(inferred_type)
@@ -164,10 +179,10 @@ module Duby::AST
 
         signature[:return] = @inferred_type
       end
-        
+
       @inferred_type
     end
-    
+
     def abstract?
       node = parent
       while node && !node.kind_of?(Scope)
@@ -175,46 +190,47 @@ module Duby::AST
       end
       InterfaceDeclaration === node
     end
-    
+
     def static?
       false
     end
   end
-      
+
   class StaticMethodDefinition < MethodDefinition
     def defining_class
       @defining_class.meta
     end
-    
+
     def static?
       true
     end
   end
-  
+
   class ConstructorDefinition < MethodDefinition
     attr_accessor :delegate_args, :calls_super
-    
+
     def initialize(*args)
       super
       extract_delegate_constructor
     end
-    
+
     def first_node
-      if @body.kind_of? Body
-        @body.children[0]
+      if body.kind_of? Body
+        body.children[0]
       else
-        @body
+        body
       end
     end
-    
+
     def first_node=(new_node)
-      if @body.kind_of? Body
-        @body.children[0] = new_node
+      if body.kind_of? Body
+        new_node.parent = body
+        body.children[0] = new_node
       else
-        @body = children[2] = new_node
+        self.body = new_node
       end
     end
-    
+
     def extract_delegate_constructor
       # TODO verify that this constructor exists during type inference.
       possible_delegate = first_node
@@ -233,7 +249,7 @@ module Duby::AST
       end
       self.first_node = Noop.new(self, position) if @delegate_args
     end
-    
+
     def infer(typer)
       unless @inferred_type
         delegate_args.each {|a| typer.infer(a)} if delegate_args

data/lib/duby/ast/structure.rb

@@ -3,59 +3,141 @@ module Duby::AST
     def initialize(parent, line_number, &block)
       super(parent, line_number, &block)
     end
-        
+
     # Type of a block is the type of its final element
     def infer(typer)
       unless @inferred_type
         if children.size == 0
-          @inferred_type = typer.default_type
+          @inferred_type = typer.no_type
         else
           children.each {|child| @inferred_type = typer.infer(child)}
         end
-          
-        unless @inferred_type
+
+        if @inferred_type
+          resolved!
+        else
           typer.defer(self)
         end
       end
 
       @inferred_type
     end
-    
-    def <<(node)
-      @children << node
-      node.parent = self
-    end
-    
-    def empty?
-      @children.empty?
-    end
   end
-  
+
+  class ScopedBody < Body
+    include Scope
+  end
+
   class Block < Node
-    attr_accessor :args, :body
+    include Scoped
+    include Scope
+    child :args
+    child :body
 
     def initialize(parent, position, &block)
-      super(parent, position, &block)
-      @args, @body = children
+      super(parent, position) do
+        static_scope.parent = scope.static_scope
+        yield(self) if block_given?
+      end
+    end
+
+    def prepare(typer, method)
+      duby = typer.transformer
+      interface = method.argument_types[-1]
+      outer_class = scope.defining_class
+      binding = scope.binding_type(duby)
+      name = "#{outer_class.name}$#{duby.tmp}"
+      klass = duby.define_closure(position, name, outer_class)
+      klass.interfaces = [interface]
+      klass.define_constructor(position,
+                               ['binding', binding]) do |c|
+          duby.eval("@binding = binding", '-', c, 'binding')
+      end
+      
+      # find all methods which would not otherwise be on java.lang.Object
+      impl_methods = find_methods(interface).select do |m|
+        begin
+          obj_m = java.lang.Object.java_class.java_method m.name, *m.parameter_types
+        rescue NameError
+          # not found on Object
+          next true
+        end
+        # found on Object
+        next false
+      end
+
+      # TODO: find a nice way to closure-impl multiple methods
+      # perhaps something like
+      # Collections.sort(list) do
+      #   def equals(other); self == other; end
+      #   def compareTo(x,y); Comparable(x).compareTo(y); end
+      # end
+      raise "Multiple abstract methods found; cannot use block" if impl_methods.size > 1
+      impl_methods.each do |method|
+        mdef = klass.define_method(position,
+                                   method.name,
+                                   method.actual_return_type,
+                                   args.dup)
+        mdef.static_scope = static_scope
+        mdef.body = body.dup
+        mdef.binding_type = binding
+      end
+      call = parent
+      instance = Call.new(call, position, 'new')
+      instance.target = Constant.new(call, position, name)
+      instance.parameters = [
+        BindingReference.new(instance, position, binding)
+      ]
+      call.parameters << instance
+      call.block = nil
+      typer.infer(klass)
+      typer.infer(instance)
+    end
+
+    def find_methods(interface)
+      methods = []
+      interfaces = [interface]
+      until interfaces.empty?
+        interface = interfaces.pop
+        methods += interface.declared_instance_methods.select {|m| m.abstract?}
+        interfaces.concat(interface.interfaces)
+      end
+      methods
+    end
+  end
+
+  class BindingReference < Node
+    def initialize(parent, position, type)
+      super(parent, position)
+      @inferred_type = type
+    end
+
+    def infer(typer)
+      resolved! unless resolved?
+      @inferred_type
     end
   end
-  
+
   class Noop < Node
     def infer(typer)
+      resolved!
       @inferred_type ||= typer.no_type
     end
   end
-  
+
   class Script < Node
     include Scope
-    attr_accessor :body
-    
+    include Binding
+    child :body
+
+    attr_accessor :defining_class
+
     def initialize(parent, line_number, &block)
       super(parent, line_number, children, &block)
-      @body = children[0]
     end
-    
+
     def infer(typer)
+      @defining_class ||= typer.self_type
       @inferred_type ||= typer.infer(body) || (typer.defer(self); nil)
     end
   end