mirah 0.0.4-java

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

@@ -0,0 +1,188 @@
+require 'mirah/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.return_type.void?
+    end
+
+    def precompile_target(compiler)
+      if method.return_type.void? && target.expr?(compiler)
+        TempValue.new(target, compiler)
+      else
+        target.precompile(compiler)
+      end
+    end
+  end
+
+  class FunctionalCall
+    def method(compiler)
+      @method ||= begin
+        arg_types = parameters.map {|p| p.inferred_type}
+        @self_type.get_method(name, arg_types)
+      end
+    end
+
+    def expr?(compiler)
+      parameters.all? {|p| p.expr?(compiler)} &&
+          (cast? || !method(compiler).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).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 ToString
+    def expr?(compiler)
+      body.expr?(compiler)
+    end
+
+    def temp(compiler, value=nil)
+      TempValue.new(body, compiler, value)
+    end
+  end
+
+  class StringConcat
+    def expr?(compiler)
+      children.all? {|x| x.expr?(compiler)}
+    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
+end

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

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

data/lib/mirah/jvm/typer.rb

@@ -0,0 +1,151 @@
+require 'mirah/typer'
+require 'mirah/jvm/types'
+require 'mirah/jvm/types/factory'
+
+module Duby
+  module Typer
+    class JVM < Simple
+      include Duby::JVM::Types
+
+      attr_reader :transformer
+
+      def initialize(transformer)
+        @factory = AST.type_factory
+        @transformer = transformer
+        unless @factory.kind_of? TypeFactory
+          raise "TypeFactory not installed"
+        end
+        @known_types = @factory.known_types
+        @known_types['dynamic'] = DynamicType.new
+        @errors = []
+      end
+
+      def set_filename(scope, filename)
+        classname = Duby::Compiler::JVM.classname_from_filename(filename)
+        main_class = @factory.declare_type(scope, classname)
+        @known_types['self'] = main_class.meta
+      end
+
+      def type_reference(scope, name, array=false, meta=false)
+        @factory.type(scope, name, array, meta)
+      end
+
+      def name
+        "JVM"
+      end
+
+      def type_definition(scope, name, superclass, interfaces)
+        imports = scope.static_scope.imports
+        name = imports[name] while imports.include?(name)
+        package = scope.static_scope.package
+        unless name =~ /\./ || package.empty?
+          name = "#{package}.#{name}"
+        end
+
+        @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(nil, "java.util.List")
+      end
+
+      def hash_type
+        # TODO: allow other types for pre-1.2 profiles
+        type_reference(nil, "java.util.Map")
+      end
+
+      def regexp_type
+        type_reference(nil, "java.util.regex.Pattern")
+      end
+
+      def known_type(scope, name)
+        @factory.known_type(scope, name)
+      end
+
+      def fixnum_type(value)
+        FixnumLiteral.new(value)
+      end
+
+      def float_type(value)
+        FloatLiteral.new(value)
+      end
+
+      def learn_method_type(target_type, name, parameter_types, type, exceptions)
+        static = target_type.meta?
+        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.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.return_type
+            signature[:throws] = method.exceptions
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mirah/jvm/types.rb

@@ -0,0 +1,416 @@
+require 'bitescript'
+require 'mirah/ast'
+require 'mirah/jvm/method_lookup'
+require 'mirah/jvm/compiler'
+require 'set'
+
+module Duby
+  module JVM
+    module Types
+      class Type < AST::TypeReference
+        include Java::DubyLangCompiler::Class
+        include Duby::JVM::MethodLookup
+
+        attr_writer :inner_class
+
+        def log(message)
+          puts "* [JVM::Types] #{message}" if Duby::Compiler::JVM.verbose
+        end
+
+        def initialize(mirror_or_name)
+          if mirror_or_name.kind_of?(BiteScript::ASM::ClassMirror)
+            @type = mirror_or_name
+            name = mirror_or_name.type.class_name
+          else
+            name = mirror_or_name.to_s
+          end
+          super(name, false, false)
+          raise ArgumentError, "Bad type #{mirror_or_name}" if name =~ /Java::/
+        end
+
+        def full_name
+          desc = BiteScript::Signature.class_id(self)
+          BiteScript::ASM::Type.get_type(desc).class_name
+        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 dynamic?
+          false
+        end
+
+        def inner_class?
+          @inner_class
+        end
+
+        def is_parent(other)
+          assignable_from?(other)
+        end
+
+        def compatible?(other)
+          assignable_from?(other)
+        end
+
+        def assignable_from?(other)
+          return false if other.nil?
+          return true if !primitive? && other == Null
+          return true if other == self
+          return true if other.error? || other.unreachable?
+
+          # TODO should we allow more here?
+          return interface? if other.block?
+
+          return true if jvm_type && (jvm_type == other.jvm_type)
+
+          assignable_from?(other.superclass) ||
+              other.interfaces.any? {|i| assignable_from?(i)}
+        end
+
+        def iterable?
+          ['java.lang.Iterable',
+           'java.util.Iterator',
+           'java.util.Enumeration'].any? {|n| AST.type(nil, n).assignable_from(self)}
+        end
+
+        def component_type
+          AST.type(nil, '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 ||= Duby::JVM::Types::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(nil, jvm_type.superclass) if jvm_type.superclass
+        end
+
+        def interfaces
+          raise "Incomplete type #{self} (#{self.class})" unless jvm_type
+          @interfaces ||= begin
+            interfaces = jvm_type.interfaces.map {|i| AST.type(nil, i)}.to_set
+            if superclass
+              interfaces |= superclass.interfaces
+            end
+            interfaces.to_a
+          end
+          @interfaces
+        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
+          widening_conversions = WIDENING_CONVERSIONS[self]
+          widening_conversions && widening_conversions.include?(type)
+        end
+
+        def superclass
+          nil
+        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
+
+        def inner_class?
+          basic_type.inner_class?
+        end
+      end
+
+      class NullType < Type
+        def initialize
+          super('java.lang.Object')
+        end
+
+        def to_s
+          "Type(null)"
+        end
+
+        def compatible?(other)
+          !other.primitive?
+        end
+      end
+
+      class VoidType < PrimitiveType
+        def initialize
+          super('void', Java::JavaLang::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
+          if @component_type.jvm_type
+            #@type = java.lang.reflect.Array.newInstance(@component_type.jvm_type, 0).class
+          else
+            # FIXME: THIS IS WRONG, but I don't know how to fix it
+            #@type = @component_type
+          end
+          @name = component_type.name
+        end
+
+        def array?
+          true
+        end
+
+        def iterable?
+          true
+        end
+
+        def inner_class?
+          basic_type.inner_class?
+        end
+
+        def basic_type
+          component_type.basic_type
+        end
+
+        def superclass
+          Object
+        end
+
+        def interfaces
+          []
+        end
+
+        def meta
+          @meta ||= ArrayMetaType.new(self)
+        end
+      end
+
+      class ArrayMetaType < MetaType; end
+
+      class DynamicType < Type
+        ObjectType = Type.new('java.lang.Object')
+
+        def initialize
+          # For naming, bytecode purposes, we are an Object
+          @name = "java.lang.Object"
+        end
+
+        def basic_type
+          self
+        end
+
+        def is_parent(other)
+          ObjectType.assignable_from?(other)
+        end
+
+        def assignable_from?(other)
+          ObjectType.assignable_from?(other)
+        end
+
+        def jvm_type
+          java.lang.Object
+        end
+
+        def dynamic?
+          true
+        end
+      end
+
+      class TypeDefinition < Type
+        attr_accessor :node
+
+        def initialize(name, node)
+          raise ArgumentError, "Bad name #{name}" if name[0,1] == '.'
+          raise ArgumentError, "Bad name #{name}" if name.include? ?/
+          @name = name
+          @node = node
+          raise ArgumentError, "Bad type #{name}" if self.name =~ /Java::/
+        end
+
+        def name
+          if @type
+            @type.name.tr('/', '.')
+          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('.', '/')
+          abstract = node && node.abstract
+          @type ||= builder.define_class(
+              class_name,
+              :visibility => :public,
+              :abstract => abstract,
+              :superclass => superclass,
+              :interfaces => interfaces)
+        end
+
+        def meta
+          @meta ||= TypeDefMeta.new(self)
+        end
+      end
+
+      class InterfaceDefinition < TypeDefinition
+        def initialize(name, node)
+          super(name, node)
+        end
+
+        def define(builder)
+          class_name = @name.tr('.', '/')
+          @type ||= builder.public_interface(class_name, *interfaces)
+        end
+
+        def interface?
+          true
+        end
+      end
+
+      class TypeDefMeta < MetaType
+      end
+    end
+  end
+end
+
+require 'mirah/jvm/types/intrinsics'
+require 'mirah/jvm/types/methods'
+require 'mirah/jvm/types/number'
+require 'mirah/jvm/types/integers'
+require 'mirah/jvm/types/boolean'
+require 'mirah/jvm/types/floats'
+require 'mirah/jvm/types/basic_types'
+require 'mirah/jvm/types/literals'
+require 'mirah/jvm/types/extensions'