duby 0.0.1

data/lib/duby/ast/call.rb

@@ -0,0 +1,73 @@
+module Duby::AST
+  class FunctionalCall < Node
+    include Named
+    attr_accessor :parameters, :block, :cast
+    alias cast? cast
+        
+    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
+        
+        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)
+          end
+        end
+        
+        @inferred_type ? resolved! : typer.defer(self)
+      end
+        
+      @inferred_type
+    end
+  end
+  
+  class Call < Node
+    include Named
+    attr_accessor :target, :parameters, :block
+
+    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 = false
+        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,145 @@
+module Duby::AST
+  class ClassDefinition < Node
+    include Named
+    include Scope
+    attr_accessor :superclass, :body, :interfaces
+        
+    def initialize(parent, line_number, name, &block)
+      @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)
+      super(parent, line_number, name) {|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) 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 Named
+    include ClassScoped
+    include Typed
+
+    def initialize(parent, line_number, name, &block)
+      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 Named
+    include Valued
+    include ClassScoped
+        
+    def initialize(parent, line_number, name, &block)
+      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 Named
+    include ClassScoped
+    
+    def initialize(parent, line_number, name, &block)
+      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,328 @@
+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 :redo
+
+      def infer(typer)
+        unless resolved?
+          child_types = children.map {|c| typer.infer(c)}
+          if child_types.any? {|t| t.nil?}
+            typer.defer(self)
+          else
+            resolved!
+            @inferred_type = typer.null_type
+          end
+        end
+
+        @inferred_type
+      end
+    end
+
+    class WhileLoop < Loop
+      attr_accessor :condition, :body, :check_first, :negative
+
+      def initialize(parent, line_number, check_first, negative, &block)
+        super(parent, line_number, &block)
+        @condition, @body = children
+        @check_first = check_first
+        @negative = negative
+      end
+
+      def check_first?; @check_first; end
+      def negative?; @negative; end
+      def has_redo?; @redo; end
+
+      def to_s
+        "WhileLoop(check_first = #{check_first?}, negative = #{negative?})"
+      end
+    end
+    
+    class ForLoop < Loop
+      attr_reader :name, :body, :iter
+
+      def initialize(parent, position, &block)
+        super(parent, position, &block)
+        var = children.shift
+        @body, @iter = children
+        @scope = var.scope
+        @name = var.name
+      end
+
+      def infer(typer)
+        super
+        iter_type = @iter.inferred_type
+        if iter_type
+          if !iter_type.iterable?
+            raise "#{iter_type} is not iterable."
+          end
+          typer.learn_local_type(@scope, name, iter_type.component_type)
+        end
+        @inferred_type
+      end
+    end
+
+    class Not < Node
+      def initialize(parent, line_number, &block)
+        super(parent, line_number, &block)
+      end
+    end
+
+    class JumpNode < Node
+      attr_accessor :ensures
+      
+      def initialize(parent, line_number, ensures, &block)
+        super(parent, line_number, &block)
+        @ensures = ensures
+      end
+    end
+
+    class Return < JumpNode
+      include Valued
+
+      def initialize(parent, line_number, ensures, &block)
+        super(parent, line_number, ensures, &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 < JumpNode;
+      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
+      
+      def ensures
+        [self]
+      end
+    end
+  end
+end