duby 0.0.2-java

data/lib/duby/ast/intrinsics.rb

@@ -0,0 +1,56 @@
+module Duby::AST
+  class Print < Node
+    attr_accessor :parameters
+    attr_accessor :println
+    
+    def initialize(parent, line_number, println, &block)
+      super(parent, line_number, &block)
+      @parameters = children
+      @println = println
+    end
+
+    def infer(typer)
+      if parameters.size > 0
+        resolved = parameters.select {|param| typer.infer(param); param.resolved?}
+        resolved! if resolved.size == parameters.size
+      else
+        resolved!
+      end
+      typer.no_type
+    end
+  end
+  
+  defmacro('puts') do |transformer, fcall, parent|
+    Print.new(parent, fcall.position, true) do |print|
+      if fcall.respond_to?(:args_node) && fcall.args_node
+        fcall.args_node.child_nodes.map do |arg|
+          transformer.transform(arg, print)
+        end
+      else
+        []
+      end
+    end
+  end
+
+  defmacro('print') do |transformer, fcall, parent|
+    Print.new(parent, fcall.position, false) do |print|
+      if fcall.respond_to?(:args_node) && fcall.args_node
+        fcall.args_node.child_nodes.map do |arg|
+          transformer.transform(arg, print)
+        end
+      else
+        []
+      end
+    end
+  end
+  
+  class InlineCode
+    def initialize(&block)
+      @block = block
+    end
+    
+    def inline(transformer, call)
+      @block.call(transformer, call)
+    end
+  end
+end

data/lib/duby/ast/literal.rb

@@ -0,0 +1,97 @@
+module Duby::AST
+  class Array < Node
+    def initialize(parent, line_number, &block)
+      super(parent, line_number, &block)
+    end
+
+    def infer(typer)
+      @inferred_type = typer.array_type
+    end
+  end
+  
+  class Fixnum < Node
+    include Literal
+    
+    def initialize(parent, line_number, literal)
+      super(parent, line_number)
+      @literal = literal
+    end
+    
+    def infer(typer)
+      return @inferred_type if resolved?
+      resolved!
+      @inferred_type = typer.fixnum_type
+    end
+    
+    def ==(other)
+      @literal == other.literal
+    end
+    
+    def eql?(other)
+      self.class == other.class && @literal.eql?(other.literal)
+    end
+  end
+  
+  class Float < Node
+    include Literal
+    
+    def initialize(parent, line_number, literal)
+      super(parent, line_number)
+      @literal = literal
+    end
+    
+    def infer(typer)
+      return @inferred_type if resolved?
+      resolved!
+      @inferred_type = typer.float_type
+    end
+  end
+  
+  class Hash < Node; end
+  
+  class String < Node
+    include Literal
+    
+    def initialize(parent, line_number, literal)
+      super(parent, line_number)
+      @literal = literal
+    end
+    
+    def infer(typer)
+      return @inferred_type if resolved?
+      resolved!
+      @inferred_type ||= typer.string_type
+    end
+  end
+  
+  class Symbol < Node; end
+  
+  class Boolean < Node
+    include Literal
+    
+    def initialize(parent, line_number, literal)
+      super(parent, line_number)
+      @literal = literal
+    end
+    
+    def infer(typer)
+      return @inferred_type if resolved?
+      resolved!
+      @inferred_type ||= typer.boolean_type
+    end
+  end
+
+  class Null < Node
+    include Literal
+
+    def initialize(parent, line_number)
+      super(parent, line_number)
+    end
+
+    def infer(typer)
+      return @inferred_type if resolved?
+      resolved!
+      @inferred_type ||= typer.null_type
+    end
+  end
+end

data/lib/duby/ast/local.rb

@@ -0,0 +1,92 @@
+module Duby::AST
+  class LocalDeclaration < Node
+    include Named
+    include Typed
+    include Scoped
+
+    def initialize(parent, line_number, name, captured=false, &block)
+      super(parent, line_number, &block)
+      @name = name
+      @captured = captured
+      @type = children[0]
+    end
+
+    def captured?
+      @captured
+    end
+
+    def infer(typer)
+      unless resolved?
+        resolved!
+        @inferred_type = typer.known_types[type] || type
+        if @inferred_type
+          resolved!
+          typer.learn_local_type(scope, name, @inferred_type)
+        else
+          typer.defer(self)
+        end
+      end
+      @inferred_type
+    end
+  end
+  
+  class LocalAssignment < Node
+    include Named
+    include Valued
+    include Scoped
+    
+    def initialize(parent, line_number, name, captured=false, &block)
+      super(parent, line_number, children, &block)
+      @captured = captured
+      @value = children[0]
+      @name = name
+    end
+
+    def captured?
+      @captured
+    end
+
+    def to_s
+      "LocalAssignment(name = #{name}, scope = #{scope}, captured = #{captured?})"
+    end
+    
+    def infer(typer)
+      unless @inferred_type
+        @inferred_type = typer.learn_local_type(scope, name, typer.infer(value))
+
+        @inferred_type ? resolved! : typer.defer(self)
+      end
+
+      @inferred_type
+    end
+  end
+
+  class Local < Node
+    include Named
+    include Scoped
+    
+    def initialize(parent, line_number, name, captured=false)
+      super(parent, line_number, [])
+      @name = name
+      @captured = captured
+    end
+
+    def captured?
+      @captured
+    end
+
+    def to_s
+      "Local(name = #{name}, scope = #{scope}, captured = #{captured?})"
+    end
+    
+    def infer(typer)
+      unless @inferred_type
+        @inferred_type = typer.local_type(scope, name)
+
+        @inferred_type ? resolved! : typer.defer(self)
+      end
+
+      @inferred_type
+    end
+  end
+end

data/lib/duby/ast/method.rb

@@ -0,0 +1,244 @@
+module Duby::AST
+  class Arguments < Node
+    attr_accessor :args, :opt_args, :rest_arg, :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
+        @inferred_type = args ? args.map {|arg| typer.infer(arg)} : []
+      end
+    end
+  end
+      
+  class Argument < Node
+    include Typed
+  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
+        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
+      end
+        
+      @inferred_type
+    end
+  end
+      
+  class OptionalArgument < Argument
+    include Named
+    include Scoped
+    attr_accessor :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
+        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
+      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
+  end
+      
+  class BlockArgument < Argument
+    include Named
+    
+    def initialize(parent, line_number, name)
+      super(parent, line_number)
+
+      @name = name
+    end
+  end
+      
+  class MethodDefinition < Node
+    include Annotated
+    include Named
+    include Scope
+    attr_accessor :signature, :arguments, :body, :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
+        typer.defer(self)
+      else
+        actual_type = if forced_type.nil?
+          inferred_type
+        else
+          forced_type
+        end
+        if actual_type.unreachable?
+          actual_type = typer.no_type
+        end
+        
+        if !abstract? &&
+            forced_type != typer.no_type &&
+            !actual_type.is_parent(inferred_type)
+          raise Duby::Typer::InferenceError.new(
+              "Inferred return type %s is incompatible with declared %s" %
+              [inferred_type, actual_type], self)
+        end
+
+        @inferred_type = typer.learn_method_type(defining_class, name, arguments.inferred_type, actual_type, signature[:throws])
+
+        # learn the other overloads as well
+        args_for_opt = []
+        if arguments.args
+          arguments.args.each do |arg|
+            if OptionalArgument === arg
+              arg_types_for_opt = args_for_opt.map do |arg_for_opt|
+                arg_for_opt.infer(typer)
+              end
+              typer.learn_method_type(defining_class, name, arg_types_for_opt, actual_type, signature[:throws])
+            end
+            args_for_opt << arg
+          end
+        end
+
+        signature[:return] = @inferred_type
+      end
+        
+      @inferred_type
+    end
+    
+    def abstract?
+      node = parent
+      while node && !node.kind_of?(Scope)
+        node = node.parent
+      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]
+      else
+        @body
+      end
+    end
+    
+    def first_node=(new_node)
+      if @body.kind_of? Body
+        @body.children[0] = new_node
+      else
+        @body = children[2] = new_node
+      end
+    end
+    
+    def extract_delegate_constructor
+      # TODO verify that this constructor exists during type inference.
+      possible_delegate = first_node
+      if FunctionalCall === possible_delegate &&
+          possible_delegate.name == 'initialize'
+        @delegate_args = possible_delegate.parameters
+      elsif Super === possible_delegate
+        @calls_super = true
+        @delegate_args = possible_delegate.parameters
+        unless @delegate_args
+          args = arguments.children.map {|x| x || []}
+          @delegate_args = args.flatten.map do |arg|
+            Local.new(self, possible_delegate.position, arg.name)
+          end
+        end
+      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
+      end
+      super
+    end
+  end
+end