duby 0.0.2-java → 0.0.3-java

data/lib/duby/ast/class.rb

@@ -3,19 +3,84 @@ module Duby::AST
     include Annotated
     include Named
     include Scope
-    attr_accessor :superclass, :body, :interfaces
-        
-    def initialize(parent, line_number, name, annotations=[], &block)
+    attr_accessor :interfaces
+
+    child :superclass
+    child :body
+
+    def initialize(parent, position, name, annotations=[], &block)
       @annotations = annotations
       @interfaces = []
       @name = name
       if Duby::AST.type_factory.respond_to? :declare_type
         Duby::AST.type_factory.declare_type(self)
       end
-      super(parent, line_number, &block)
-      @superclass, @body = children
+      # We need somewhere to collect nodes that get appended during
+      # the transform phase.
+      @extra_body = Body.new(self, position)
+      super(parent, position, &block)
+      if body
+        @extra_body.insert(0, body)
+      end
+      self.body = @extra_body
+    end
+
+    def append_node(node)
+      @extra_body << node
+      node
+    end
+
+    def define_inner_class(position, name, &block)
+      name = "#{self.name}$#{name}"
+      append_node ClassDefinition.new(nil, position, name, &block)
+    end
+
+    def define_method(position, name, type, *args)
+      append_node(_define_method(MethodDefinition, position, name, type, args))
+    end
+
+    def define_static_method(position, name, type, *args)
+      append_node(
+          _define_method(StaticMethodDefinition, position, name, type, args))
+    end
+
+    def define_constructor(position, *args, &block)
+      append_node(_define_method(
+          ConstructorDefinition, position, 'initialize', nil, args, &block))
+    end
+
+    def _define_method(klass, position, name, type, args)
+      klass.new(nil, position, name) do |method|
+        signature = {:return => type}
+        if Arguments === args[0]
+          args_node = args[0]
+          args_node.parent = method
+        else
+          args_node = Arguments.new(method, position) do |args_node|
+            arg_list = args.map do |arg_name, arg_type, arg_position|
+              signature[arg_name.intern] = arg_type
+              arg_position ||= position
+              RequiredArgument.new(args_node, arg_position, arg_name)
+            end
+            [arg_list, nil, nil, nil]
+          end
+        end
+        [
+          signature,
+          args_node,
+          if block_given?
+            yield(method)
+          end
+        ]
+      end
+    end
+
+    def declare_field(position, name, type)
+      field = FieldDeclaration.new(nil, position || self.position, name)
+      field.type = type.dup
+      append_node(field)
     end
-    
+
     def infer(typer)
       unless resolved?
         @inferred_type ||= typer.define_type(name, superclass, @interfaces) do
@@ -25,35 +90,52 @@ module Duby::AST
             typer.no_type
           end
         end
-        @inferred_type ? resolved! : typer.defer(self)
+        if @inferred_type
+          resolved!
+        else
+          typer.defer(self)
+        end
       end
 
       @inferred_type
     end
-    
+
     def implements(*types)
       raise ArgumentError if types.any? {|x| x.nil?}
       @interfaces.concat types
     end
   end
-  
+
   defmacro('implements') do |transformer, fcall, parent|
     interfaces = fcall.args_node.child_nodes.map do |interface|
       interface.type_reference(parent)
     end
-    parent.parent.implements(*interfaces)
+    klass = parent
+    klass = klass.parent unless ClassDefinition === klass
+    klass.implements(*interfaces)
     Noop.new(parent, fcall.position)
   end
 
   class InterfaceDeclaration < ClassDefinition
-    attr_accessor :superclass, :body, :interfaces
-        
-    def initialize(parent, line_number, name, annotations)
-      super(parent, line_number, name, annotations) {|p| }
-      @interfaces = []
+    attr_accessor :superclass
+    child :interfaces
+    child :body
+
+    def initialize(parent, position, name, annotations)
+      super(parent, position, name, annotations) {|p| }
       @name = name
+      @children = [[], nil]
       @children = yield(self)
-      @interfaces, @body = children
+    end
+  end
+
+  class ClosureDefinition < ClassDefinition
+    attr_accessor :enclosing_type
+    def initialize(parent, position, name, enclosing_type)
+      super(parent, position, name, []) do
+        [nil, nil]
+      end
+      @enclosing_type = enclosing_type
     end
   end
 
@@ -84,11 +166,12 @@ module Duby::AST
     include ClassScoped
     include Typed
 
-    def initialize(parent, line_number, name, annotations=[], &block)
+    child :type
+
+    def initialize(parent, position, name, annotations=[], &block)
       @annotations = annotations
-      super(parent, line_number, &block)
+      super(parent, position, &block)
       @name = name
-      @type = children[0]
     end
 
     def infer(typer)
@@ -105,17 +188,18 @@ module Duby::AST
       @inferred_type
     end
   end
-      
+
   class FieldAssignment < Node
     include Annotated
     include Named
     include Valued
     include ClassScoped
-        
-    def initialize(parent, line_number, name, annotations=[], &block)
+
+    child :value
+
+    def initialize(parent, position, name, annotations=[], &block)
       @annotations = annotations
-      super(parent, line_number, &block)
-      @value = children[0]
+      super(parent, position, &block)
       @name = name
     end
 
@@ -129,15 +213,15 @@ module Duby::AST
       @inferred_type
     end
   end
-      
+
   class Field < Node
     include Annotated
     include Named
     include ClassScoped
-    
-    def initialize(parent, line_number, name, annotations=[], &block)
+
+    def initialize(parent, position, name, annotations=[], &block)
       @annotations = annotations
-      super(parent, line_number, &block)
+      super(parent, position, &block)
       @name = name
     end
 

data/lib/duby/ast/flow.rb

@@ -1,11 +1,10 @@
 module Duby
   module AST
     class Condition < Node
-      attr_accessor :predicate
+      child :predicate
 
       def initialize(parent, line_number, &block)
         super(parent, line_number, &block)
-        @predicate = children[0]
       end
 
       def infer(typer)
@@ -13,10 +12,10 @@ module Duby
           @inferred_type = typer.infer(predicate)
           if @inferred_type && !@inferred_type.primitive?
             call = Call.new(parent, position, '!=') do |call|
-              @predicate.parent = call
-              [@predicate, [Null.new(call, position)]]
+              predicate.parent = call
+              [predicate, [Null.new(call, position)]]
             end
-            @predicate = children[0] = call
+            self.predicate = call
             @inferred_type = typer.infer(predicate)
           end
 
@@ -28,11 +27,12 @@ module Duby
     end
 
     class If < Node
-      attr_accessor :condition, :body, :else
+      child :condition
+      child :body
+      child :else
 
       def initialize(parent, line_number, &block)
         super(parent, line_number, &block)
-        @condition, @body, @else = children
       end
 
       def infer(typer)
@@ -56,7 +56,11 @@ module Duby
               else
                 # we have else but not then, defer only then and use else type for now
                 @inferred_type = else_type
-                typer.defer(self)
+                if body
+                  typer.defer(self)
+                else
+                  resolved! if condition_type
+                end
               end
             else
               # no then type could be inferred and no else body, defer for now
@@ -93,17 +97,28 @@ module Duby
     end
 
     class Loop < Node
-      attr_accessor :init, :condition, :pre, :post, :body
+      child :init
+      child :condition
+      child :pre
+      child :body
+      child :post
       attr_accessor :check_first, :negative, :redo
 
       def initialize(parent, position, check_first, negative, &block)
         @check_first = check_first
         @negative = negative
-        @init = Body.new(self, position)
-        @pre = Body.new(self, position)
-        @post = Body.new(self, position)
-        super(parent, position, &block)
-        @condition, @body = @children
+
+        @children = [
+            Body.new(self, position),
+            nil,
+            Body.new(self, position),
+            nil,
+            Body.new(self, position),
+        ]
+        super(parent, position) do |l|
+          condition, body = yield(l)
+          [self.init, condition, self.pre, body, self.post]
+        end
       end
 
       def infer(typer)
@@ -125,10 +140,6 @@ module Duby
 
         @inferred_type
       end
-      
-      def children
-        [init, condition, pre, post, body]
-      end
 
       def check_first?; @check_first; end
       def negative?; @negative; end
@@ -154,15 +165,15 @@ module Duby
       end
 
       def init?
-        @init && !(@init.kind_of?(Body) && @init.empty?)
+        init && !(init.kind_of?(Body) && init.empty?)
       end
 
       def pre?
-        @pre && !(@pre.kind_of?(Body) && @pre.empty?)
+        pre && !(pre.kind_of?(Body) && pre.empty?)
       end
-      
+
       def post?
-        @post && !(@post.kind_of?(Body) && @post.empty?)
+        post && !(post.kind_of?(Body) && post.empty?)
       end
 
       def to_s
@@ -179,9 +190,10 @@ module Duby
     class Return < Node
       include Valued
 
+      child :value
+
       def initialize(parent, line_number, &block)
         super(parent, line_number, &block)
-        @value = children[0]
       end
 
       def infer(typer)
@@ -201,16 +213,19 @@ module Duby
           resolved!
           @inferred_type = typer.null_type
         end
+        @inferred_type
       end
     end
-    
+
     class Next < Break; end
-    
+
     class Redo < Break; end
 
     class Raise < Node
       include Valued
 
+      child :exception
+
       def initialize(parent, line_number, &block)
         super(parent, line_number, &block)
       end
@@ -220,13 +235,12 @@ module Duby
           @inferred_type = AST.unreachable_type
           throwable = AST.type('java.lang.Throwable')
           if children.size == 1
-            arg_type = typer.infer(children[0])
+            arg_type = typer.infer(self.exception)
             unless arg_type
               typer.defer(self)
               return
             end
             if throwable.assignable_from?(arg_type) && !arg_type.meta?
-              @exception = children[0]
               resolved!
               return @inferred_type
             end
@@ -241,12 +255,12 @@ module Duby
             else
               klass = Constant.new(self, position, 'RuntimeException')
             end
-            @exception = Call.new(self, position, 'new') do
+            exception = Call.new(self, position, 'new') do
               [klass, children, nil]
             end
             resolved!
-            @children = [@exception]
-            typer.infer(@exception)
+            @children = [exception]
+            typer.infer(exception)
           end
         end
         @inferred_type
@@ -265,38 +279,45 @@ module Duby
 
     class RescueClause < Node
       include Scoped
-      attr_accessor :types, :body, :name, :type
-      
+      attr_accessor :name, :type
+      child :types
+      child :body
+
       def initialize(parent, position, &block)
         super(parent, position, &block)
-        @types, @body = children
       end
 
       def infer(typer)
         unless resolved?
           if name
-            orig_type = typer.local_type(scope, name)
+            scope.static_scope << name
+            orig_type = typer.local_type(containing_scope, name)
             # TODO find the common parent Throwable
             @type = types.size == 1 ? types[0] : AST.type('java.lang.Throwable')
-            typer.learn_local_type(scope, name, @type)
+            typer.learn_local_type(containing_scope, name, @type)
           end
           @inferred_type = typer.infer(body)
 
+          if (@inferred_type && !body.resolved?)
+            puts "#{body} not resolved"
+          end
+
           (@inferred_type && body.resolved?) ? resolved! : typer.defer(self)
-          typer.local_type_hash(scope)[name] = orig_type if name
+          typer.local_type_hash(containing_scope)[name] = orig_type if name
         end
 
         @inferred_type
       end
     end
-    
+
     class Rescue < Node
-      attr_accessor :body, :clauses
+      child :body
+      child :clauses
       def initialize(parent, position, &block)
         super(parent, position, &block)
         @body, @clauses = children
       end
-      
+
       def infer(typer)
         unless resolved?
           types = [typer.infer(body)] + clauses.map {|c| typer.infer(c)}
@@ -311,16 +332,16 @@ module Duby
         @inferred_type
       end
     end
-    
+
     class Ensure < Node
-      attr_reader :body, :clause
+      child :body
+      child :clause
       attr_accessor :state  # Used by the some compilers.
-      
+
       def initialize(parent, position, &block)
         super(parent, position, &block)
-        @body, @clause = children
       end
-      
+
       def infer(typer)
         resolve_if(typer) do
           typer.infer(clause)