duby 0.0.2-java

data/lib/duby/ast/call.rb

@@ -0,0 +1,145 @@
+require 'delegate'
+
+module Duby::AST
+  class NodeProxy < DelegateClass(Node)
+    def __inline__(node)
+      node.parent = parent
+      __setobj__(node)
+    end
+  end
+
+  class FunctionalCall < Node
+    include Named
+    attr_accessor :parameters, :block, :cast, :inlined, :proxy
+    alias cast? cast
+
+    def self.new(*args, &block)
+      real_node = super
+      real_node.proxy = NodeProxy.new(real_node)
+    end
+
+    def initialize(parent, line_number, name, &kids)
+      super(parent, line_number, &kids)
+      @parameters, @block = children
+      @name = name
+      @cast = false
+    end
+        
+    def infer(typer)
+      @self_type ||= typer.self_type
+
+      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
+      
+        unless should_defer
+          if parameters.size == 1 && typer.known_types[name]
+            # cast operation
+            resolved!
+            self.cast = true
+            @inferred_type = typer.known_types[name]
+          else
+            @inferred_type = typer.method_type(receiver_type, name,
+                                               parameter_types)
+            if @inferred_type.kind_of? InlineCode
+              @inlined = @inferred_type.inline(typer.transformer, self)
+              proxy.__inline__(@inlined)
+              return proxy.infer(typer)
+            end
+          end
+        end
+        
+        @inferred_type ? resolved! : typer.defer(proxy)
+      end
+        
+      @inferred_type
+    end
+  end
+  
+  class Call < Node
+    include Named
+    attr_accessor :target, :parameters, :block, :inlined, :proxy
+
+    def self.new(*args, &block)
+      real_node = super
+      real_node.proxy = NodeProxy.new(real_node)
+    end
+
+    def initialize(parent, line_number, name, &kids)
+      super(parent, line_number, children, &kids)
+      @target, @parameters, @block = children
+      @name = name
+    end
+
+    def infer(typer)
+      unless @inferred_type
+        receiver_type = typer.infer(target)
+        should_defer = receiver_type.nil?
+        parameter_types = parameters.map do |param|
+          typer.infer(param) || should_defer = true
+        end
+
+        parameter_types << Duby::AST.block_type if @block
+
+        unless should_defer
+          @inferred_type = typer.method_type(receiver_type, name,
+                                             parameter_types)
+          if @inferred_type.kind_of? InlineCode
+            @inlined = @inferred_type.inline(typer.transformer, self)
+            proxy.__inline__(@inlined)
+            return proxy.infer(typer)
+          end
+        end
+        
+        @inferred_type ? resolved! : typer.defer(proxy)
+      end
+        
+      @inferred_type
+    end
+  end
+
+  class Super < Node
+    include Named
+    attr_accessor :parameters, :method, :cast
+    alias :cast? :cast
+
+    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
+    end
+
+    def name
+      @call_parent.name
+    end
+
+    def infer(typer)
+      @self_type ||= typer.self_type.superclass
+      
+      unless @inferred_type
+        receiver_type = @call_parent.defining_class
+        should_defer = receiver_type.nil?
+        parameter_types = parameters.map do |param|
+          typer.infer(param) || should_defer = true
+        end
+
+        unless should_defer
+          @inferred_type = typer.method_type(receiver_type, name,
+                                             parameter_types)
+        end
+
+        @inferred_type ? resolved! : typer.defer(self)
+      end
+
+      @inferred_type
+    end
+  end
+end

data/lib/duby/ast/class.rb

@@ -0,0 +1,154 @@
+module Duby::AST
+  class ClassDefinition < Node
+    include Annotated
+    include Named
+    include Scope
+    attr_accessor :superclass, :body, :interfaces
+        
+    def initialize(parent, line_number, 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
+    end
+    
+    def infer(typer)
+      unless resolved?
+        @inferred_type ||= typer.define_type(name, superclass, @interfaces) do
+          if body
+            typer.infer(body)
+          else
+            typer.no_type
+          end
+        end
+        @inferred_type ? resolved! : typer.defer(self)
+      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)
+    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 = []
+      @name = name
+      @children = yield(self)
+      @interfaces, @body = children
+    end
+  end
+
+  defmacro('interface') do |transformer, fcall, parent|
+    raise "Interface name required" unless fcall.args_node
+    interfaces = fcall.args_node.child_nodes.to_a
+    interface_name = interfaces.shift
+    if (JRubyAst::CallNode === interface_name &&
+        interface_name.args_node.size == 1)
+      interfaces.unshift(interface_name.args_node.get(0))
+      interface_name = interface_name.receiver_node
+    end
+    raise 'Interface body required' unless fcall.iter_node
+    InterfaceDeclaration.new(parent, fcall.position,
+                             interface_name.name,
+                             transformer.annotations) do |interface|
+      [interfaces.map {|p| p.type_reference(interface)},
+       if fcall.iter_node.body_node
+         transformer.transform(fcall.iter_node.body_node, interface)
+       end
+      ]
+    end
+  end
+
+  class FieldDeclaration < Node
+    include Annotated
+    include Named
+    include ClassScoped
+    include Typed
+
+    def initialize(parent, line_number, name, annotations=[], &block)
+      @annotations = annotations
+      super(parent, line_number, &block)
+      @name = name
+      @type = children[0]
+    end
+
+    def infer(typer)
+      unless resolved?
+        resolved!
+        @inferred_type = typer.known_types[type]
+        if @inferred_type
+          resolved!
+          typer.learn_field_type(scope, name, @inferred_type)
+        else
+          typer.defer(self)
+        end
+      end
+      @inferred_type
+    end
+  end
+      
+  class FieldAssignment < Node
+    include Annotated
+    include Named
+    include Valued
+    include ClassScoped
+        
+    def initialize(parent, line_number, name, annotations=[], &block)
+      @annotations = annotations
+      super(parent, line_number, &block)
+      @value = children[0]
+      @name = name
+    end
+
+    def infer(typer)
+      unless resolved?
+        @inferred_type = typer.learn_field_type(scope, name, typer.infer(value))
+
+        @inferred_type ? resolved! : typer.defer(self)
+      end
+
+      @inferred_type
+    end
+  end
+      
+  class Field < Node
+    include Annotated
+    include Named
+    include ClassScoped
+    
+    def initialize(parent, line_number, name, annotations=[], &block)
+      @annotations = annotations
+      super(parent, line_number, &block)
+      @name = name
+    end
+
+    def infer(typer)
+      unless resolved?
+        @inferred_type = typer.field_type(scope, name)
+
+        @inferred_type ? resolved! : typer.defer(self)
+      end
+
+      @inferred_type
+    end
+  end
+end

data/lib/duby/ast/flow.rb

@@ -0,0 +1,332 @@
+module Duby
+  module AST
+    class Condition < Node
+      attr_accessor :predicate
+
+      def initialize(parent, line_number, &block)
+        super(parent, line_number, &block)
+        @predicate = children[0]
+      end
+
+      def infer(typer)
+        unless resolved?
+          @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)]]
+            end
+            @predicate = children[0] = call
+            @inferred_type = typer.infer(predicate)
+          end
+
+          @inferred_type ? resolved! : typer.defer(self)
+        end
+
+        @inferred_type
+      end
+    end
+
+    class If < Node
+      attr_accessor :condition, :body, :else
+
+      def initialize(parent, line_number, &block)
+        super(parent, line_number, &block)
+        @condition, @body, @else = children
+      end
+
+      def infer(typer)
+        unless resolved?
+          condition_type = typer.infer(condition)
+          unless condition_type
+            typer.defer(condition)
+          end
+
+          # condition type is unrelated to body types, so we proceed with bodies
+          then_type = typer.infer(body) if body
+
+          if !then_type
+            # attempt to determine else branch
+            if self.else
+              else_type = typer.infer(self.else)
+
+              if !else_type
+                # we have neither type, defer until later
+                typer.defer(self)
+              else
+                # we have else but not then, defer only then and use else type for now
+                @inferred_type = else_type
+                typer.defer(self)
+              end
+            else
+              # no then type could be inferred and no else body, defer for now
+              typer.defer(self)
+            end
+          else
+            if self.else
+              else_type = typer.infer(self.else)
+
+              if !else_type
+                # we determined a then type, so we use that and defer the else body
+                @inferred_type = then_type
+                typer.defer(self)
+              else
+                # both then and else inferred, ensure they're compatible
+                if then_type.compatible?(else_type)
+                  # types are compatible...if condition is resolved, we're done
+                  @inferred_type = then_type.narrow(else_type)
+                  resolved! if condition_type
+                else
+                  raise Typer::InferenceError.new("if statement with incompatible result types")
+                end
+              end
+            else
+              # only then and type inferred, we're 100% resolved
+              @inferred_type = then_type
+              resolved! if condition_type
+            end
+          end
+        end
+
+        @inferred_type
+      end
+    end
+
+    class Loop < Node
+      attr_accessor :init, :condition, :pre, :post, :body
+      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
+      end
+
+      def infer(typer)
+        unless resolved?
+          child_types = children.map do |c|
+            if c.nil? || (Body === c && c.empty?)
+              typer.no_type
+            else
+              typer.infer(c)
+            end
+          end
+          if child_types.any? {|t| t.nil?}
+            typer.defer(self)
+          else
+            resolved!
+            @inferred_type = typer.null_type
+          end
+        end
+
+        @inferred_type
+      end
+      
+      def children
+        [init, condition, pre, post, body]
+      end
+
+      def check_first?; @check_first; end
+      def negative?; @negative; end
+
+      def redo?
+        if @redo.nil?
+          nodes = @children.dup
+          until nodes.empty?
+            node = nodes.shift
+            while node.respond_to?(:inlined) && node.inlined
+              node = node.inlined
+            end
+            next if node.nil? || Loop === node
+            if Redo === node
+              return @redo = true
+            end
+            nodes.insert(-1, *node.children.flatten)
+          end
+          return @redo = false
+        else
+          @redo
+        end
+      end
+
+      def init?
+        @init && !(@init.kind_of?(Body) && @init.empty?)
+      end
+
+      def pre?
+        @pre && !(@pre.kind_of?(Body) && @pre.empty?)
+      end
+      
+      def post?
+        @post && !(@post.kind_of?(Body) && @post.empty?)
+      end
+
+      def to_s
+        "Loop(check_first = #{check_first?}, negative = #{negative?})"
+      end
+    end
+
+    class Not < Node
+      def initialize(parent, line_number, &block)
+        super(parent, line_number, &block)
+      end
+    end
+
+    class Return < Node
+      include Valued
+
+      def initialize(parent, line_number, &block)
+        super(parent, line_number, &block)
+        @value = children[0]
+      end
+
+      def infer(typer)
+        unless resolved?
+          @inferred_type = typer.infer(value)
+
+          (@inferred_type && value.resolved?) ? resolved! : typer.defer(self)
+        end
+
+        @inferred_type
+      end
+    end
+
+    class Break < Node;
+      def infer(typer)
+        unless resolved?
+          resolved!
+          @inferred_type = typer.null_type
+        end
+      end
+    end
+    
+    class Next < Break; end
+    
+    class Redo < Break; end
+
+    class Raise < Node
+      include Valued
+
+      def initialize(parent, line_number, &block)
+        super(parent, line_number, &block)
+      end
+
+      def infer(typer)
+        unless resolved?
+          @inferred_type = AST.unreachable_type
+          throwable = AST.type('java.lang.Throwable')
+          if children.size == 1
+            arg_type = typer.infer(children[0])
+            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
+          end
+
+          arg_types = children.map {|c| typer.infer(c)}
+          if arg_types.any? {|c| c.nil?}
+            typer.defer(self)
+          else
+            if arg_types[0] && throwable.assignable_from?(arg_types[0])
+              klass = children.shift
+            else
+              klass = Constant.new(self, position, 'RuntimeException')
+            end
+            @exception = Call.new(self, position, 'new') do
+              [klass, children, nil]
+            end
+            resolved!
+            @children = [@exception]
+            typer.infer(@exception)
+          end
+        end
+        @inferred_type
+      end
+    end
+
+    defmacro('raise') do |transformer, fcall, parent|
+      Raise.new(parent, fcall.position) do |raise_node|
+        if fcall.args_node
+          fcall.args_node.child_nodes.map do |arg|
+            transformer.transform(arg, raise_node)
+          end
+        end
+      end
+    end
+
+    class RescueClause < Node
+      include Scoped
+      attr_accessor :types, :body, :name, :type
+      
+      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)
+            # TODO find the common parent Throwable
+            @type = types.size == 1 ? types[0] : AST.type('java.lang.Throwable')
+            typer.learn_local_type(scope, name, @type)
+          end
+          @inferred_type = typer.infer(body)
+
+          (@inferred_type && body.resolved?) ? resolved! : typer.defer(self)
+          typer.local_type_hash(scope)[name] = orig_type if name
+        end
+
+        @inferred_type
+      end
+    end
+    
+    class Rescue < Node
+      attr_accessor :body, :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)}
+          if types.any? {|t| t.nil?}
+            typer.defer(self)
+          else
+            # TODO check types for compatibility (maybe only if an expression)
+            resolved!
+            @inferred_type = types[0]
+          end
+        end
+        @inferred_type
+      end
+    end
+    
+    class Ensure < Node
+      attr_reader :body, :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)
+          typer.infer(body)
+        end
+      end
+    end
+  end
+end