duby 0.0.1

data/lib/duby/old/declaration.rb

@@ -0,0 +1,72 @@
+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

@@ -0,0 +1,72 @@
+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

@@ -0,0 +1,52 @@
+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

@@ -0,0 +1,163 @@
+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/edb.rb

@@ -0,0 +1,25 @@
+require 'erb'
+
+Duby::AST.defmacro('def_edb') do |transformer, fcall, parent|
+  name = fcall.args_node.get(0).name
+  path = fcall.args_node.get(1).value
+  compiler = ERB::Compiler.new(nil)
+  compiler.put_cmd = "_edbout.append"
+  compiler.insert_cmd = "__edb_insert__ _edbout.append"
+  compiler.pre_cmd = ["def #{name}", "_edbout = StringBuilder.new"]
+  compiler.post_cmd = ["_edbout.toString", "end"]
+  src = compiler.compile(IO.read(path))
+  ast = Duby::AST.parse_ruby(src, "(edb)")
+  transformer.transform(ast.body_node, parent)
+end
+
+Duby::AST.defmacro('__edb_insert__') do |transformer, fcall, parent|
+  # ERB sticks in a .to_s that we don't want.
+  # the ast is __edb_insert__(_edbout.append(content.to_s))
+  append = fcall.args_node.get(0)
+  content = append.args_node.get(0).receiver_node
+  new_args = org.jrubyparser.ast.ListNode.new(content.position, content)
+  append.setArgsNode(new_args)
+  transformer.transform(append, parent)
+end
+

data/lib/duby/plugin/java.rb

@@ -0,0 +1,42 @@
+require 'duby/typer'
+require 'duby/jvm/method_lookup'
+require 'duby/jvm/types'
+require 'java'
+
+module Duby
+  module Typer
+    class JavaTyper < BaseTyper
+      include Duby::JVM::MethodLookup
+      include Duby::JVM::Types
+      
+      def initialize
+      end
+      
+      def name
+        "Java"
+      end
+      
+      def method_type(typer, target_type, name, parameter_types)
+        return if target_type.nil? or parameter_types.any? {|t| t.nil?}
+        if target_type.respond_to? :get_method
+          method = target_type.get_method(name, parameter_types)
+          unless method || target_type.basic_type.kind_of?(TypeDefinition)
+            raise NoMethodError, "Method %s(%s) on %s not found" %
+                [name, parameter_types.join(', '), target_type]
+          end
+          result = method.return_type if method
+        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::JavaTyper.new
+end

data/lib/duby/plugin/math.rb

@@ -0,0 +1,84 @@
+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