duby 0.0.2-java → 0.0.3-java

data/lib/duby/ast.rb

@@ -5,18 +5,40 @@ module Duby
     class << self
       attr_accessor :verbose
     end
-    
+
     # The top of the AST class hierarchy, this represents an abstract AST node.
     # It provides accessors for _children_, an array of all child nodes,
     # _parent_, a reference to this node's parent (nil if none), and _newline_,
     # whether this node represents a new line.
     class Node
+      include Java::DubyLangCompiler.Node
+      include Enumerable
+
       attr_accessor :children
       attr_accessor :parent
       attr_accessor :position
       attr_accessor :newline
       attr_accessor :inferred_type
 
+      def self.child(name)
+        @children ||= []
+        index = @children.size
+        class_eval <<-EOF
+          def #{name}
+            @children[#{index}]
+          end
+
+          def #{name}=(node)
+            @children[#{index}] = _set_parent(node)
+          end
+        EOF
+        @children << name
+      end
+
+      def self.child_name(i)
+        @children[i] if @children
+      end
+
       def initialize(parent, position, children = [])
         @parent = parent
         @newline = false
@@ -45,16 +67,28 @@ module Duby
       def inspect(indent = 0)
         indent_str = ' ' * indent
         str = indent_str + to_s
-        children.each do |child|
+        children.each_with_index do |child, i|
+          extra_indent = 0
           if child
+            name = self.class.child_name(i)
+            if Duby::AST.verbose && name
+              str << "\n#{indent_str} #{name}:"
+              extra_indent = 1
+            end
             if ::Array === child
               child.each {|ary_child|
-                str << "\n#{ary_child.inspect(indent + 1)}"
+                if Duby::AST.verbose && Node === ary_child && ary_child.parent != self
+                   str << "\n#{indent_str} (wrong parent)"
+                 end
+                str << "\n#{ary_child.inspect(indent + extra_indent + 1)}"
               }
             elsif ::Hash === child
               str << "\n#{indent_str} #{child.inspect}"
             else
-              str << "\n#{child.inspect(indent + 1)}"
+              if Duby::AST.verbose && Node === child && child.parent != self
+                str << "\n#{indent_str} (wrong parent)"
+              end
+              str << "\n#{child.inspect(indent + extra_indent + 1)}"
             end
           end
         end
@@ -71,7 +105,21 @@ module Duby
 
       def each(&b) children.each(&b) end
 
-      def resolved!
+      def <<(node)
+        @children << _set_parent(node)
+        self
+      end
+
+      def insert(index, node)
+        node.parent = self
+        @children.insert(index, node)
+      end
+
+      def empty?
+        @children.empty?
+      end
+
+      def resolved!(typer=nil)
         log "#{to_s} resolved!"
         @resolved = true
       end
@@ -81,7 +129,7 @@ module Duby
       def resolve_if(typer)
         unless resolved?
           @inferred_type = yield
-          @inferred_type ? resolved! : typer.defer(self)
+          @inferred_type ? resolved!(typer) : typer.defer(self)
         end
         @inferred_type
       end
@@ -89,8 +137,33 @@ module Duby
       def self.===(other)
         super || (other.kind_of?(NodeProxy) && (self === other.__getobj__))
       end
+
+      def _set_parent(node)
+        case node
+        when Node
+          node.parent = self
+        when ::Array
+          node.each {|x| x.parent = self if x}
+        end
+        node
+      end
+
+      def initialize_copy(other)
+        @parent = nil
+        @children = []
+        other.children.each do |child|
+          case child
+          when ::Array
+            self << child.map {|x| x.dup}
+          when nil
+            self << nil
+          else
+            self << child.dup
+          end
+        end
+      end
     end
-    
+
     class ErrorNode < Node
       def initialize(parent, error)
         super(parent, error.position)
@@ -98,7 +171,7 @@ module Duby
         @inferred_type = TypeReference::ErrorType
         @resolved = true
       end
-      
+
       def infer(typer)
       end
     end
@@ -134,10 +207,20 @@ module Duby
         @scope ||= begin
           scope = parent
           raise "No parent for #{self.class.name} at #{line_number}" if scope.nil?
-          scope = scope.parent until scope.class.include?(Scope)
+          until scope.class.include?(Scope)
+            scope = scope.parent
+          end
           scope
         end
       end
+
+      def containing_scope
+        scope = self.scope.static_scope
+        while scope.parent && scope.parent.include?(name)
+          scope = scope.parent
+        end
+        scope
+      end
     end
 
     module ClassScoped
@@ -159,7 +242,109 @@ module Duby
       end
     end
 
-    module Scope; end
+    class StaticScope
+      attr_reader :parent
+      attr_writer :self_type
+
+      def initialize(parent=nil)
+        @vars = {}
+        @parent = parent
+        @children = {}
+      end
+
+      def <<(name)
+        @vars[name] = true
+      end
+
+      def include?(name, include_parent=true)
+        @vars.include?(name) ||
+            (include_parent && parent && parent.include?(name))
+      end
+
+      def captured?(name)
+        if !include?(name, false)
+          return false
+        elsif parent && parent.include?(name)
+          return true
+        else
+          return children.any? {|child| child.include?(name, false)}
+        end
+      end
+
+      def children
+        @children.keys
+      end
+
+      def add_child(scope)
+        @children[scope] = true
+      end
+
+      def remove_child(scope)
+        @children.delete(scope)
+      end
+
+      def parent=(parent)
+        @parent.remove_child(self) if @parent
+        parent.add_child(self)
+        @parent = parent
+      end
+
+      def self_type
+        if @self_type.nil? && parent
+          @self_type = parent.self_type
+        end
+        @self_type
+      end
+
+      def binding_type(defining_class=nil, duby=nil)
+        @binding_type ||= begin
+          if parent
+            parent.binding_type(defining_class, duby)
+          else
+            name = "#{defining_class.name}$#{duby.tmp}"
+            factory = Duby::AST.type_factory
+            if factory
+              factory.declare_type(name)
+            else
+              Duby::AST::TypeReference.new(name, false, false)
+            end
+          end
+        end
+      end
+
+      def binding_type=(type)
+        if parent
+          parent.binding_type = type
+        else
+          @binding_type = type
+        end
+      end
+
+      def has_binding?
+        @binding_type != nil || (parent && parent.has_binding?)
+      end
+    end
+
+    module Scope
+      attr_writer :static_scope
+      def static_scope
+        @static_scope ||= StaticScope.new
+      end
+    end
+
+    module Binding
+      def binding_type(duby=nil)
+        static_scope.binding_type(defining_class, duby)
+      end
+
+      def binding_type=(type)
+        static_scope.binding_type = type
+      end
+
+      def has_binding?
+        static_scope.has_binding?
+      end
+    end
 
     class Colon2 < Node; end
 
@@ -186,10 +371,14 @@ module Duby
     class VoidType < Node; end
 
     class Annotation < Node
+      attr_reader :values
+      attr_accessor :runtime
+      alias runtime? runtime
+
       def initialize(parent, position, klass)
         super(parent, position)
         @class = klass
-        @values = []
+        @values = {}
       end
 
       def name
@@ -201,7 +390,11 @@ module Duby
       end
 
       def []=(name, value)
-        # TODO support annotation arguments
+        @values[name] = value
+      end
+
+      def [](name)
+        @values[name]
       end
     end
 
@@ -211,7 +404,7 @@ module Duby
       alias array? array
       attr_accessor :meta
       alias meta? meta
-      
+
       def initialize(name, array = false, meta = false, position=nil)
         super(nil, position)
         @name = name
@@ -239,7 +432,7 @@ module Duby
         # default behavior now is to disallow any polymorphic types
         self == other
       end
-      
+
       def compatible?(other)
         # default behavior is only exact match right now
         self == other ||
@@ -250,7 +443,7 @@ module Duby
       def iterable?
         array?
       end
-      
+
       def component_type
         AST.type(name) if array?
       end
@@ -276,14 +469,18 @@ module Duby
         name == :error
       end
 
+      def null?
+        name == :null
+      end
+
       def unreachable?
         name == :unreachable
       end
-      
+
       def block?
         name == :block
       end
-      
+
       def primitive?
         true
       end
@@ -305,15 +502,15 @@ module Duby
         @interfaces = interfaces
       end
     end
-    
+
     def self.type_factory
       Thread.current[:ast_type_factory]
     end
-    
+
     def self.type_factory=(factory)
       Thread.current[:ast_type_factory] = factory
     end
-    
+
     # Shortcut method to construct type references
     def self.type(typesym, array = false, meta = false)
       factory = type_factory
@@ -323,7 +520,7 @@ module Duby
         TypeReference.new(typesym, array, meta)
       end
     end
-    
+
     def self.no_type
       factory = type_factory
       if factory
@@ -332,7 +529,7 @@ module Duby
         TypeReference::NoType
       end
     end
-    
+
     def self.error_type
       TypeReference::ErrorType
     end
@@ -340,7 +537,7 @@ module Duby
     def self.unreachable_type
       TypeReference::UnreachableType
     end
-    
+
     def self.block_type
       TypeReference::BlockType
     end
@@ -351,7 +548,7 @@ module Duby
         factory.fixnum(parent, position, literal)
       else
         Fixnum.new(parent, position, literal)
-      end      
+      end
     end
 
     def self.float(parent, position, literal)
@@ -360,15 +557,15 @@ module Duby
         factory.float(parent, position, literal)
       else
         Float.new(parent, position, literal)
-      end      
+      end
     end
-    
+
     def self.defmacro(name, &block)
       @macros ||= {}
       raise "Conflicting macros for #{name}" if @macros[name]
       @macros[name] = block
     end
-    
+
     def self.macro(name)
       @macros[name]
     end

data/lib/duby/ast/call.rb

@@ -6,13 +6,25 @@ module Duby::AST
       node.parent = parent
       __setobj__(node)
     end
+
+    def dup
+      new = super
+      new.__setobj__(__getobj__.dup)
+      new.proxy = new
+      new
+    end
   end
 
   class FunctionalCall < Node
+    include Java::DubyLangCompiler.Call
     include Named
-    attr_accessor :parameters, :block, :cast, :inlined, :proxy
+    include Scoped
+    attr_accessor :cast, :inlined, :proxy
     alias cast? cast
 
+    child :parameters
+    child :block
+
     def self.new(*args, &block)
       real_node = super
       real_node.proxy = NodeProxy.new(real_node)
@@ -20,30 +32,47 @@ module Duby::AST
 
     def initialize(parent, line_number, name, &kids)
       super(parent, line_number, &kids)
-      @parameters, @block = children
       @name = name
       @cast = false
     end
-        
+
+    def arguments
+      @arguments ||= begin
+        args = java.util.ArrayList.new(parameters.size)
+        parameters.each do |param|
+          args.add(param)
+        end
+        args
+      end
+    end
+
+    def target
+      nil
+    end
+
     def infer(typer)
-      @self_type ||= typer.self_type
+      @self_type ||= scope.defining_class
 
       unless @inferred_type
         receiver_type = @self_type
         should_defer = false
-      
+
         parameter_types = parameters.map do |param|
           typer.infer(param) || should_defer = true
         end
-        
-        parameter_types << Duby::AST.block_type if @block
-      
+
+        parameter_types << Duby::AST.block_type if block
+
         unless should_defer
-          if parameters.size == 1 && typer.known_types[name]
+          if parameters.size == 1 && typer.known_type(name)
             # cast operation
             resolved!
             self.cast = true
-            @inferred_type = typer.known_types[name]
+            @inferred_type = typer.known_type(name)
+          elsif parameters.size == 0 && scope.static_scope.include?(name)
+            @inlined = Local.new(parent, position, name)
+            proxy.__inline__(@inlined)
+            return proxy.infer(typer)
           else
             @inferred_type = typer.method_type(receiver_type, name,
                                                parameter_types)
@@ -54,17 +83,30 @@ module Duby::AST
             end
           end
         end
-        
-        @inferred_type ? resolved! : typer.defer(proxy)
+
+        if @inferred_type
+          if block
+            method = receiver_type.get_method(name, parameter_types)
+            block.prepare(typer, method)
+          end
+          resolved!
+        else
+          typer.defer(proxy)
+        end
       end
-        
+
       @inferred_type
     end
   end
-  
+
   class Call < Node
+    include Java::DubyLangCompiler.Call
     include Named
-    attr_accessor :target, :parameters, :block, :inlined, :proxy
+    attr_accessor :inlined, :proxy
+
+    child :target
+    child :parameters
+    child :block
 
     def self.new(*args, &block)
       real_node = super
@@ -72,11 +114,20 @@ module Duby::AST
     end
 
     def initialize(parent, line_number, name, &kids)
-      super(parent, line_number, children, &kids)
-      @target, @parameters, @block = children
+      super(parent, line_number, &kids)
       @name = name
     end
 
+    def arguments
+      @arguments ||= begin
+        args = java.util.ArrayList.new(parameters.size)
+        parameters.each do |param|
+          args.add(param)
+        end
+        args
+      end
+    end
+
     def infer(typer)
       unless @inferred_type
         receiver_type = typer.infer(target)
@@ -85,7 +136,7 @@ module Duby::AST
           typer.infer(param) || should_defer = true
         end
 
-        parameter_types << Duby::AST.block_type if @block
+        parameter_types << Duby::AST.block_type if block
 
         unless should_defer
           @inferred_type = typer.method_type(receiver_type, name,
@@ -96,22 +147,31 @@ module Duby::AST
             return proxy.infer(typer)
           end
         end
-        
-        @inferred_type ? resolved! : typer.defer(proxy)
+
+        if @inferred_type
+          if block && !receiver_type.error?
+            method = receiver_type.get_method(name, parameter_types)
+            block.prepare(typer, method)
+          end
+          resolved!
+        else
+          typer.defer(proxy)
+        end
       end
-        
+
       @inferred_type
     end
   end
 
   class Super < Node
     include Named
-    attr_accessor :parameters, :method, :cast
+    attr_accessor :method, :cast
     alias :cast? :cast
 
+    child :parameters
+
     def initialize(parent, line_number)
       super(parent, line_number)
-      @parameters = children[0]
       @call_parent = parent
       @call_parent = (@call_parent = @call_parent.parent) until MethodDefinition === @call_parent
       @cast = false
@@ -123,9 +183,9 @@ module Duby::AST
 
     def infer(typer)
       @self_type ||= typer.self_type.superclass
-      
+
       unless @inferred_type
-        receiver_type = @call_parent.defining_class
+        receiver_type = @call_parent.defining_class.superclass
         should_defer = receiver_type.nil?
         parameter_types = parameters.map do |param|
           typer.infer(param) || should_defer = true