duby 0.0.2-java

data/lib/duby/jvm/source_generator/precompile.rb

@@ -0,0 +1,170 @@
+require 'duby/ast'
+
+module Duby::AST
+  class TempValue
+    def initialize(node, compiler=nil, value=nil)
+      if compiler.nil?
+        @tempname = node
+      else
+        @tempname = compiler.temp(node, value)
+        @tempvalue = value || node
+      end
+    end
+    
+    def compile(compiler, expression)
+      if expression
+        compiler.method.print @tempname
+      end
+    end
+    
+    def reload(compiler)
+      compiler.assign(@tempname, @tempvalue)
+    end
+  end
+  
+  class Node
+    def expr?(compiler)
+      true
+    end
+
+    def precompile(compiler)
+      if expr?(compiler)
+        self
+      else
+        temp(compiler)
+      end
+    end
+    
+    def temp(compiler, value=nil)
+      TempValue.new(self, compiler, value)
+    end
+  end
+  
+  class Body
+    def expr?(compiler)
+      false
+    end
+  end
+  
+  class If
+    def expr?(compiler)
+      return false unless condition.predicate.expr?(compiler)
+      return false unless body.nil? || body.expr?(compiler)
+      return false unless self.else.nil? || self.else.expr?(compiler)
+      true
+    end
+  end
+  
+  class Loop
+    def expr?(compiler)
+      false
+    end
+    
+    def precompile(compiler)
+      compile(compiler, false)
+      temp(compiler, 'null')
+    end
+  end
+  
+  class Call
+    def method(compiler=nil)
+      @method ||= begin
+        arg_types = parameters.map {|p| p.inferred_type}
+        target.inferred_type.get_method(name, arg_types)
+      end
+    end
+    
+    def expr?(compiler)
+      target.expr?(compiler) &&
+          parameters.all? {|p| p.expr?(compiler)} &&
+          !method.return_type.kind_of?(Duby::AST::InlineCode) &&
+          !method.actual_return_type.void?
+    end
+  end
+  
+  class FunctionalCall
+    def method(compiler)
+      @method ||= begin
+        arg_types = parameters.map {|p| p.inferred_type}
+        compiler.self_type.get_method(name, arg_types)
+      end
+    end
+    
+    def expr?(compiler)
+      parameters.all? {|p| p.expr?(compiler)} &&
+          (cast? || !method(compiler).actual_return_type.void?)
+    end
+  end
+
+  # TODO merge with FunctionalCall logic (almost identical)
+  class Super
+    def method(compiler)
+      @method ||= begin
+        arg_types = parameters.map {|p| p.inferred_type}
+        compiler.self_type.superclass.get_method(name, arg_types)
+      end
+    end
+
+    def expr?(compiler)
+      parameters.all? {|p| p.expr?(compiler)} &&
+          !method(compiler).actual_return_type.void?
+    end
+  end
+  
+  class EmtpyArray
+    def expr?(compiler)
+      size.expr?(compiler)
+    end
+  end
+  
+  class LocalAssignment
+    def expr?(compiler)
+      compiler.method.local?(name) && value.expr?(compiler)
+    end
+
+    def precompile(compiler)
+      if expr?(compiler)
+        self
+      else
+        compile(compiler, false)
+        TempValue.new(name)
+      end
+    end
+  end
+  
+  class Return
+    def expr?(compiler)
+      false
+    end
+  end
+  
+  class Raise
+    def expr?(compiler)
+      false
+    end
+  end
+  
+  class Rescue
+    def expr?(compiler)
+      false
+    end
+  end
+  
+  class Ensure
+    def expr?(compiler)
+      false
+    end
+  end
+  
+  class FieldAssignment
+    def expr?(compiler)
+      false
+    end
+  end
+  
+  class LocalAssignment
+    def expr?(compiler)
+      false
+    end
+  end
+end

data/lib/duby/jvm/source_generator/typer.rb

@@ -0,0 +1,11 @@
+require 'duby/jvm/typer'
+require 'duby/jvm/source_generator/builder'
+
+module Duby
+  module Typer
+    class JavaSource < JVM
+      include Duby::JVM::Types
+      
+    end
+  end
+end

data/lib/duby/jvm/typer.rb

@@ -0,0 +1,131 @@
+require 'duby/typer'
+require 'duby/jvm/types'
+require 'duby/jvm/types/factory'
+
+module Duby
+  module Typer
+    class JVM < Simple
+      include Duby::JVM::Types
+      
+      attr_reader :transformer
+
+      def initialize(filename, transformer)
+        @factory = AST.type_factory
+        @transformer = transformer
+        unless @factory.kind_of? TypeFactory
+          raise "TypeFactory not installed"
+        end
+        @known_types = @factory.known_types
+        classname = File.basename(filename, '.duby')
+        main_class = @factory.declare_type(classname)
+        @known_types['self'] = main_class.meta
+        @errors = []
+      end
+      
+      def type_reference(name, array=false, meta=false)
+        @factory.type(name, array, meta)
+      end
+      
+      def alias_types(short, long)
+        @known_types[short] = type_reference(long)
+      end
+      
+      def name
+        "JVM"
+      end
+      
+      def type_definition(name, superclass, interfaces)
+        @known_types[name]
+      end
+
+      def null_type
+        Null
+      end
+      
+      def no_type
+        Void
+      end
+
+      def array_type
+        # TODO: allow other types for pre-1.2 profiles
+        type_reference("java.util.List")
+      end
+
+      def hash_type
+        # TODO: allow other types for pre-1.2 profiles
+        type_reference("java.util.Map")
+      end
+      
+      def learn_method_type(target_type, name, parameter_types, type, exceptions)
+        static = target_type.meta?
+        unless target_type.unmeta.kind_of?(TypeDefinition)
+          raise "Method defined on #{target_type}"
+        end
+        if static
+          target_type.unmeta.declare_static_method(name, parameter_types, type, exceptions)
+        else
+          target_type.declare_method(name, parameter_types, type, exceptions)
+        end
+        super
+      end
+      
+      def infer_signature(method_def)
+        signature = method_def.signature
+        sig_args = signature.dup
+        return_type = sig_args.delete(:return)
+        exceptions = sig_args.delete(:throws)
+        args = method_def.arguments.args || []
+        static = method_def.kind_of? Duby::AST::StaticMethodDefinition
+        if sig_args.size != args.size
+          # If the superclass declares one method with the same name and
+          # same number of arguments, assume we're overriding it.
+          found = nil
+          ambiguous = false
+          classes = [self_type.superclass] + self_type.interfaces
+          while classes.size > 0
+            cls = classes.pop
+            if static
+              methods = cls.declared_class_methods
+            else
+              methods = cls.declared_instance_methods
+            end
+            methods.each do |method|
+              if method.name == method_def.name &&
+                 method.argument_types.size == args.size
+                if found && found.argument_types != method.argument_types
+                  ambiguous = true
+                else
+                  found ||= method
+                end
+              end
+            end
+            classes << cls.superclass if cls.superclass
+          end
+          if found && !ambiguous
+            signature[:return] = found.actual_return_type
+            signature[:throws] = found.exceptions
+            args.zip(found.argument_types) do |arg, type|
+              signature[arg.name.intern] = type
+            end
+          end
+        elsif signature[:return].nil? && !static
+          arg_types = args.map do |arg|
+            signature[arg.name.intern]
+          end
+          method = self_type.find_method(
+              self_type, method_def.name, arg_types, false)
+          interfaces = self_type.interfaces.dup
+          until method || interfaces.empty?
+            interface = interfaces.pop
+            method = interface.find_method(
+                interface, method_def.name, arg_types, false)
+          end
+          if method
+            signature[:return] = method.actual_return_type
+            signature[:throws] = method.exceptions
+          end
+        end
+      end
+    end
+  end
+end

data/lib/duby/jvm/types.rb

@@ -0,0 +1,331 @@
+require 'bitescript'
+require 'duby/ast'
+require 'duby/jvm/method_lookup'
+require 'duby/jvm/compiler'
+
+class Object
+  def class_builder?
+    self.class.name =~ /::ClassBuilder$/
+  end
+end
+
+module Duby
+  module JVM
+    module Types
+      class Type < AST::TypeReference
+        include Duby::JVM::MethodLookup
+
+        def log(message)
+          puts "* [JVM::Types] #{message}" if Duby::Compiler::JVM.verbose
+        end
+
+        def initialize(java_type)
+          orig_type = java_type
+          if !(java_type.kind_of?(Java::JavaClass) ||
+               java_type.class_builder?)
+            java_type = java_type.java_class
+          end
+          super(java_type.name, false, false)
+          raise ArgumentError, "Bad type #{orig_type}" if name =~ /Java::/
+          @type = java_type
+        end
+
+        def jvm_type
+          @type
+        end
+
+        def void?
+          false
+        end
+
+        def meta?
+          false
+        end
+
+        def array?
+          false
+        end
+
+        def primitive?
+          false
+        end
+
+        def interface?
+          @type.interface?
+        end
+        
+        def is_parent(other)
+          assignable_from?(other)
+        end
+        
+        def compatible?(other)
+          assignable_from?(other)
+        end
+        
+        def assignable_from?(other)
+          return true if !primitive? && other == Null
+          return true if other == self
+          return true if other.error? || other.unreachable?
+          begin
+            jvm_type.assignable_from?(other.jvm_type)
+          rescue
+            assignable_from?(other.superclass) ||
+                other.interfaces.any? {|i| assignable_from?(i)}
+          end
+        end
+
+        def iterable?
+          ['java.lang.Iterable',
+           'java.util.Iterator',
+           'java.util.Enumeration'].any? {|n| AST.type(n).assignable_from(self)}
+        end
+        
+        def component_type
+          AST.type('java.lang.Object') if iterable?
+        end
+
+        def meta
+          @meta ||= MetaType.new(self)
+        end
+        
+        def unmeta
+          self
+        end
+
+        def basic_type
+          self
+        end
+
+        def array_type
+          @array_type ||= ArrayType.new(self)
+        end
+
+        def prefix
+          'a'
+        end
+        
+        # is this a 64 bit type?
+        def wide?
+          false
+        end
+
+        def inspect(indent=0)
+          "#{' ' * indent}#<#{self.class.name} #{name}>"
+        end
+
+        def newarray(method)
+          method.anewarray(self)
+        end
+
+        def superclass
+          raise "Incomplete type #{self}" unless jvm_type
+          AST.type(jvm_type.superclass) if jvm_type.superclass
+        end
+        
+        def interfaces
+          @interfaces ||= jvm_type.interfaces.map do |interface|
+            AST.type(interface)
+          end
+        end
+        
+        def astore(builder)
+          if primitive?
+            builder.send "#{name[0,1]}astore"
+          else
+            builder.aastore
+          end
+        end
+        
+        def aload(builder)
+          if primitive?
+            builder.send "#{name[0,1]}aload"
+          else
+            builder.aaload
+          end
+        end
+      end
+
+      class PrimitiveType < Type
+        def initialize(type, wrapper)
+          @wrapper = wrapper
+          super(type)
+        end
+
+        def primitive?
+          true
+        end
+
+        def primitive_type
+          @wrapper::TYPE
+        end
+
+        def newarray(method)
+          method.send "new#{name}array"
+        end
+        
+        def interfaces
+          []
+        end
+        
+        def convertible_to?(type)
+          return true if type == self
+          a, b = TYPE_ORDERING.index(self), TYPE_ORDERING.index(type)
+          a && b && b > a
+        end
+      end
+      
+      class MetaType < Type
+        attr_reader :unmeta
+
+        def initialize(unmeta)
+          @name = unmeta.name
+          @unmeta = unmeta
+        end
+
+        def basic_type
+          @unmeta.basic_type
+        end
+
+        def meta?
+          true
+        end
+
+        def meta
+          self
+        end
+        
+        def superclass
+          @unmeta.superclass.meta if @unmeta.superclass
+        end
+        
+        def interfaces
+          []
+        end
+        
+        def jvm_type
+          unmeta.jvm_type
+        end
+      end
+      
+      class NullType < Type
+        def initialize
+          super(java.lang.Object)
+        end
+        
+        def compatible?(other)
+          !other.primitive?
+        end
+      end
+
+      class VoidType < PrimitiveType
+        def initialize
+          super(Java::JavaLang::Void, Java::JavaLang::Void)
+          @name = "void"
+        end
+
+        def void?
+          true
+        end
+        
+        def return(builder)
+          builder.returnvoid
+        end
+      end
+
+      class ArrayType < Type
+        attr_reader :component_type
+
+        def initialize(component_type)
+          @component_type = component_type
+          @name = component_type.name
+        end
+
+        def jvm_type
+          @component_type.jvm_type
+        end
+
+        def array?
+          true
+        end
+        
+        def iterable?
+          true
+        end
+        
+        def basic_type
+          component_type.basic_type
+        end
+        
+        def superclass
+          Object
+        end
+      end
+      
+      class TypeDefinition < Type
+        attr_accessor :node
+        
+        def initialize(name, node)
+          if name.class_builder?
+            super(name)
+          else
+            raise ArgumentError, "Bad name #{name}" if name[0,1] == '.'
+            @name = name
+          end
+          @node = node
+          raise ArgumentError, "Bad type #{name}" if self.name =~ /Java::/
+        end
+        
+        def name
+          if @type
+            @type.name
+          else
+            @name
+          end
+        end
+        
+        def superclass
+          (node && node.superclass) || Object
+        end
+        
+        def interfaces
+          if node
+            node.interfaces
+          else
+            []
+          end
+        end
+        
+        def define(builder)
+          class_name = @name.tr('.', '/')
+          @type ||= builder.public_class(class_name, superclass, *interfaces)
+        end
+        
+        def meta
+          @meta ||= TypeDefMeta.new(self)
+        end
+      end
+      
+      class InterfaceDefinition < TypeDefinition
+        def initialize(name, node)
+          super(name, node)
+        end
+        
+        def define(builder)
+          @type ||= builder.public_interface(@name, *interfaces)
+        end
+      end
+      
+      class TypeDefMeta < MetaType
+      end
+    end
+  end
+end
+
+require 'duby/jvm/types/intrinsics'
+require 'duby/jvm/types/methods'
+require 'duby/jvm/types/number'
+require 'duby/jvm/types/integers'
+require 'duby/jvm/types/boolean'
+require 'duby/jvm/types/floats'
+require 'duby/jvm/types/basic_types'
+require 'duby/jvm/types/literals'