duby 0.0.2-java → 0.0.3-java

data/lib/duby/old/declaration.rb

@@ -1,72 +0,0 @@
-require 'compiler/builder'
-require 'jruby'
-
-module Compiler
-  module PrimitiveRuby
-    # reload 
-    module Java::OrgJrubyAst
-      class CallNode
-        def declared_type(builder)
-          if name == "[]"
-            # array type, top should be a constant; find the rest
-            array = true
-            elements = []
-          else
-            elements = [name]
-          end
-          
-          receiver = receiver_node
-          
-          loop do
-            case receiver
-            when ConstNode
-              elements << receiver_node.name
-              break
-            when CallNode
-              elements.unshift(receiver.name)
-              receiver = receiver.receiver_node
-            when SymbolNode
-              elements.unshift(receiver.name)
-              break
-            when VCallNode
-              elements.unshift(receiver.name)
-              break
-            end
-          end
-          
-          # join and load
-          class_name = elements.join(".")
-          type = builder.type(class_name)
-          
-          if array
-            type.array_class
-          else
-            type
-          end
-        end
-      end
-  
-      class Colon2Node
-        def declared_type(builder)
-          left_node.declared_type(builder).declared_field(name).static_value
-        end
-      end
-      
-      class HashNode
-        def declare_types(builder)
-          @declared = true
-          list = list_node.child_nodes.to_a
-          list.each_index do |index|
-            builder.local(list[index].name, list[index + 1].declared_type(builder)) if index % 2 == 0
-          end
-        end
-      end
-      
-      class SymbolNode
-        def declared_type(builder)
-          @type ||= builder.type(name.intern)
-        end
-      end
-    end
-  end
-end

data/lib/duby/old/mapper.rb

@@ -1,72 +0,0 @@
-require 'compiler/builder'
-require 'jruby'
-
-module Compiler
-  module PrimitiveRuby
-    # reload 
-    module Java::OrgJrubyAst
-      class CallNode
-        def mapped_name(builder)
-          # TODO move to a utility somewhere for smart name mappings
-          # TODO or at least make it a table...
-          mapped_name = name
-          case receiver_node.type(builder)
-          when JString
-            case name
-            when "+"
-              mapped_name = "concat"
-            # This doesn't work yet, because format is a static method on String
-#            when "%"
-#              mapped_name = "format"
-            end
-          else
-            case name
-            when "new"
-              mapped_name = "<init>"
-            end
-          end
-          
-          mapped_name
-        end
-      end
-      
-      class DefnNode
-        def mapped_name(builder)
-          case name
-          when "initialize"
-            "<init>"
-          else
-            name
-          end
-        end
-      end
-  
-      class FCallNode
-        def mapped_name(builder)
-          if name == "puts"
-            "println"
-          end
-        end
-      end
-      
-      class InstVarNode
-        def mapped_name(builder)
-          name[1..-1]
-        end
-      end
-      
-      class InstAsgnNode
-        def mapped_name(builder)
-          name[1..-1]
-        end
-      end
-  
-      class VCallNode
-        def mapped_name(builder)
-          # TODO map names for the local type?
-          name
-        end
-      end
-    end
-  end
-end

data/lib/duby/old/signature.rb

@@ -1,52 +0,0 @@
-require 'compiler/builder'
-require 'jruby'
-
-module Compiler
-  module PrimitiveRuby
-    # reload 
-    module Java::OrgJrubyAst
-      class CallNode
-        def signature(builder)
-          arg_types = []
-          args_node.child_nodes.each do |node|
-            arg_types << node.type(builder)
-          end if args_node
-          
-          recv_java_class = receiver_node.type(builder)
-          declared_method = recv_java_class.declared_method_smart(mapped_name(builder), *arg_types)
-          return_type = declared_method.return_type
-          
-          if (return_type)
-            return_class = builder.type(return_type.to_s)
-          else
-            return_type = Void
-          end
-          
-          return [
-            return_class,
-            *declared_method.parameter_types.map {|type| builder.type(type.to_s)}
-          ]
-        end
-      end
-      
-      class HashNode
-        def signature(builder)
-          @declared = true
-          arg_types = []
-          return_type = Void
-          list = list_node.child_nodes.to_a
-          list.each_index do |index|
-            if index % 2 == 0
-              if SymbolNode === list[index] && list[index].name == 'return'
-                return_type = list[index + 1].declared_type(builder)
-              else
-                arg_types << list[index + 1].declared_type(builder)
-              end
-            end
-          end
-          return [return_type, *arg_types]
-        end
-      end
-    end
-  end
-end

data/lib/duby/old/typer_old.rb

@@ -1,163 +0,0 @@
-require 'compiler/builder'
-require 'jruby'
-
-module Compiler
-  module PrimitiveRuby
-    # reload 
-    module Java::OrgJrubyAst
-      class BeginNode
-        def type(builder)
-          body_node.type(builder)
-        end
-      end
-  
-      class BlockNode
-        # Type of a block is the type of its final element
-        def type(builder)
-          if child_nodes.size == 0
-            JObject
-          else
-            @type ||= child_nodes.get(child_nodes.size - 1).type(builder)
-          end
-        end
-      end
-      
-      class CallNode
-        def type(builder)
-          @return_type ||= begin
-            recv_type = receiver_node.type(builder)
-            
-            # if we already have an exact class, use it
-            if recv_type.array?
-              if name == "length"
-                Jint
-              else
-                recv_type = recv_type.component_type
-              end
-            elsif JavaClass === recv_type
-              recv_type
-            else
-              # otherwise, find the target method and get its return type
-              recv_java_class = recv_type
-              arg_types = []
-              args_node.child_nodes.each do |node|
-                arg_types << node.type(builder)
-              end if args_node
-              declared_method = recv_java_class.declared_method_smart(mapped_name(builder), *arg_types)
-              return_type = declared_method.return_type
-
-              builder.type(return_type.to_s)
-            end
-          end
-        end
-      end
-      
-      class ConstNode
-        def type(builder)
-          @type ||= builder.type(name)
-        end
-      end
-  
-      class FCallNode
-        def special_signature(recv_type, builder)
-          arg_types = []
-          args_node.child_nodes.each do |node|
-            arg_types << node.type(builder)
-          end if args_node
-          recv_java_class = recv_type
-          declared_method = recv_java_class.declared_method_smart(mapped_name(builder), *arg_types)
-          return_type = declared_method.return_type
-          if (return_type)
-            return_class = return_type
-          else
-            return_class = Void
-          end
-          
-          return [
-            return_class,
-            *declared_method.parameter_types
-          ]
-        end
-        
-        def type(builder)
-          @type ||= begin
-            arg_types = []
-            args_node.child_nodes.each do |node|
-              arg_types << node.type(builder)
-            end if args_node
-            if builder.static
-              signature = builder.static_signature(name, arg_types)
-            else
-              signature = builder.instance_signature(name, arg_types)
-            end
-            raise CompileError.new(position, "Signature not found for call #{name}") unless signature
-
-            signature[0]
-          end
-        end
-      end
-      
-      class FixnumNode
-        def type(builder)
-          Jint
-        end
-      end
-      
-      class FloatNode
-        def type(builder)
-          Jfloat
-        end
-      end
-      
-      class InstVarNode
-        def type(builder)
-          @type ||= builder.field_type(mapped_name(builder))
-        end
-      end
-      
-      class InstAsgnNode
-        def type(builder)
-          builder.field(mapped_name(builder), value_node.type(builder))
-          @type ||= builder.field_type(mapped_name(builder))
-        end
-      end
-      
-      class LocalAsgnNode
-        def type(builder)
-          @type ||= builder.local_type(name)
-        end
-      end
-      
-      class LocalVarNode
-        def type(builder)
-          @type ||= builder.local_type(name)
-        end
-      end
-      
-      class ModuleNode
-      end
-  
-      class NewlineNode
-        def type(builder)
-          @type ||= next_node.type(builder)
-        end
-      end
-  
-      class StrNode
-        def type(builder)
-          JString
-        end
-      end
-  
-      class VCallNode
-        def type(builder)
-          @type ||= if builder.static
-            builder.static_signature(name, [])[0]
-          else
-            builder.instance_signature(name, [])[0]
-          end
-        end
-      end
-    end
-  end
-end

data/lib/duby/plugin/math.rb

@@ -1,84 +0,0 @@
-require 'duby/typer'
-
-module Duby
-  module Typer
-    class MathTyper < BaseTyper
-      def name
-        "Math"
-      end
-      
-      def method_type(typer, target_type, name, parameter_types)
-        return nil unless parameter_types.size == 1
-
-        result = case name
-        when '-', '+', '*', '/', '%'
-          case target_type
-          when typer.fixnum_type
-            case parameter_types[0]
-            when typer.fixnum_type
-              typer.fixnum_type
-            when typer.float_type
-              typer.float_type
-            else
-              nil
-            end
-          when typer.float_type
-            case parameter_types[0]
-            when typer.float_type
-              typer.float_type
-            when typer.fixnum_type
-              typer.float_type
-            else
-              nil
-            end
-          else
-            nil
-          end
-        when '<<', '>>', '>>>', '&', '|', '^'
-          case target_type
-          when typer.fixnum_type
-            case parameter_types[0]
-            when typer.fixnum_type
-              typer.fixnum_type
-            else
-              nil
-            end
-          else
-            nil
-          end
-        when '<', '>', '<=', '>=', '=='
-          case target_type
-          when typer.fixnum_type
-            case parameter_types[0]
-            when typer.fixnum_type
-              typer.boolean_type
-            else
-              nil
-            end
-          when typer.float_type
-            case parameter_types[0]
-            when typer.float_type
-              typer.boolean_type
-            else
-              nil
-            end
-          else
-            nil
-          end
-        else
-          nil
-        end
-        
-        if result
-          log "Method type for \"#{name}\" #{parameter_types} on #{target_type} = #{result}"
-        else
-          log "Method type for \"#{name}\" #{parameter_types} on #{target_type} not found"
-        end
-        
-        result
-      end
-    end
-  end
-
-  typer_plugins << Typer::MathTyper.new
-end

data/test/test_math_plugin.rb

@@ -1,87 +0,0 @@
-require 'test/unit'
-require 'duby'
-require 'duby/plugin/math'
-
-class TestMathPlugin < Test::Unit::TestCase
-  include Duby
-
-  def setup
-    @typer = Typer::Simple.new :bar
-  end
-
-  def assert_resolves_to(type, script)
-    ast = AST.parse("1 + 1")
-    ast.infer(@typer)
-    assert_nothing_raised {@typer.resolve(true)}
-    assert_equal(@typer.fixnum_type, ast.inferred_type)
-  end
-  
-  def test_plus
-    assert_resolves_to(@typer.fixnum_type, '1 + 1')
-    assert_resolves_to(@typer.float_type, '1.0 + 1.0')
-  end
-  
-  def test_minus
-    assert_resolves_to(@typer.fixnum_type, '1 - 1')
-    assert_resolves_to(@typer.float_type, '1.0 - 1.0')
-  end
-  
-  def test_times
-    assert_resolves_to(@typer.fixnum_type, '1 * 1')
-    assert_resolves_to(@typer.float_type, '1.0 * 1.0')
-  end
-  
-  def test_divide
-    assert_resolves_to(@typer.fixnum_type, '1 / 1')
-    assert_resolves_to(@typer.float_type, '1.0 / 1.0')
-  end
-
-  def test_remainder
-    assert_resolves_to(@typer.fixnum_type, '1 % 1')
-    assert_resolves_to(@typer.float_type, '1.0 % 1.0')
-  end
-
-  def test_shift_left
-    assert_resolves_to(@typer.fixnum_type, '1 << 1')
-  end
-
-  def test_shift_right
-    assert_resolves_to(@typer.fixnum_type, '1 >> 1')
-  end
-
-  def test_ushift_right
-    assert_resolves_to(@typer.fixnum_type, '1 >>> 1')
-  end
-
-  def test_bitwise_and
-    assert_resolves_to(@typer.fixnum_type, '1 & 1')
-  end
-
-  def test_bitwise_or
-    assert_resolves_to(@typer.fixnum_type, '1 | 1')
-  end
-
-  def test_bitwise_xor
-    assert_resolves_to(@typer.fixnum_type, '1 ^ 1')
-  end
-
-  def test_less_than
-    assert_resolves_to(@typer.boolean_type, '1 < 1')
-    assert_resolves_to(@typer.boolean_type, '1.0 < 1.0')
-  end
-
-  def test_greater_than
-    assert_resolves_to(@typer.boolean_type, '1 > 1')
-    assert_resolves_to(@typer.boolean_type, '1.0 > 1.0')
-  end
-
-  def test_less_than_or_equal
-    assert_resolves_to(@typer.boolean_type, '1 <= 1')
-    assert_resolves_to(@typer.boolean_type, '1.0 <= 1.0')
-  end
-
-  def test_greater_than_or_equal
-    assert_resolves_to(@typer.boolean_type, '1 >= 1')
-    assert_resolves_to(@typer.boolean_type, '1.0 >= 1.0')
-  end
-end