mirah 0.0.7-java → 0.0.8-java

data/lib/mirah/jvm/method_lookup.rb

@@ -53,6 +53,7 @@ module Mirah
       end
 
       def find_jls(mapped_type, name, mapped_params, meta, constructor)
+        interfaces = []
         if constructor
           by_name = mapped_type.unmeta.declared_constructors
         elsif meta
@@ -61,9 +62,22 @@ module Mirah
           by_name = []
           cls = mapped_type
           while cls
-            by_name += cls.declared_instance_methods(name)
+            if cls.full_name != 'error'
+              by_name += cls.declared_instance_methods(name) 
+              interfaces.concat(cls.interfaces)
+            end
             cls = cls.superclass
           end
+          if mapped_type.interface?  # TODO or abstract
+            seen = {}
+            until interfaces.empty?
+              interface = interfaces.pop
+              next if seen[interface]
+              seen[interface] = true
+              interfaces.concat(interface.interfaces)
+              by_name += interface.declared_instance_methods(name)
+            end
+          end
         end
         # filter by arity
         by_name_and_arity = by_name.select {|m| m.argument_types.size == mapped_params.size}
@@ -205,7 +219,12 @@ module Mirah
           end
 
           # object type is assignable
-          return false unless target_type.assignable_from? in_type
+          compatible = if target_type.respond_to?(:compatible?)
+            target_type.compatible? in_type
+          else
+            target_type.assignable_from? in_type
+          end
+          return false unless compatible
         end
         return true
       end

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

@@ -151,27 +151,23 @@ module Mirah
 
       def annotate(annotations)
         annotations.each do |annotation|
-          print "@#{annotation.name.gsub("$", ".")}("
-          first = true
-          annotation.values.each do |name, value|
-            print ", " unless first
-            first = false
-            print "#{name}="
-            print annotation_value(value)
-          end
-          puts ")"
+          puts annotation_value(annotation)
         end
       end
 
       def annotation_value(value)
         case value
-        when Java::JavaLang::String
+        when Java::JavaLang::String, String
           value.to_s.inspect
         when Array
           values = value.map{|x|annotation_value(x)}.join(", ")
           "{#{values}}"
         when BiteScript::ASM::Type
           value.getClassName.gsub("$", ".")
+        when Mirah::AST::Annotation
+          name = value.name.gsub("$", ".")
+          values = value.values.map {|n, v| "#{n}=#{annotation_value(v)}"}
+          "@#{name}(#{values.join ', '})"
         else
           raise "Unsupported annotation value #{value.inspect}"
         end
@@ -180,7 +176,7 @@ module Mirah
 
     class ClassBuilder
       include Helper
-      include Mirah::Compiler::JVM::JVMLogger
+      include Mirah::JVM::Compiler::JVMBytecode::JVMLogger
       attr_reader :package, :name, :superclass, :filename, :class_name, :out
       attr_reader :interfaces, :abstract
       def initialize(builder, name, superclass, interfaces, abstract)
@@ -231,8 +227,8 @@ module Mirah
       end
 
       def finish_declaration
-        raise if @stopped
         return if @declaration_finished
+        raise "Already stopped class #{class_name}" if @stopped
 
         @declaration_finished = true
         modifiers = "public#{' static' if @static}#{' abstract' if @abstract}"
@@ -345,10 +341,11 @@ module Mirah
     class MethodBuilder
       include Helper
 
-      attr_accessor :name, :type, :out
+      attr_accessor :name, :type, :out, :klass
 
       def initialize(cls, options)
         @class = cls
+        @klass = cls
         @compiler = cls.compiler
         @out = Output.new
         @visibility = options[:visibility]

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

@@ -13,111 +13,117 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-class Mirah::Compiler::JavaSource < Mirah::Compiler::JVMCompilerBase
-  class SimpleWhileLoop
-    attr_reader :compiler, :loop
-    def initialize(loop, compiler)
-      @loop = loop
-      @compiler = compiler
-    end
+module Mirah
+  module JVM
+    module Compiler
+      class JavaSource < Base
+        class SimpleWhileLoop
+          attr_reader :compiler, :loop
+          def initialize(loop, compiler)
+            @loop = loop
+            @compiler = compiler
+          end
 
-    def break
-      compiler.method.puts "break;"
-    end
+          def break
+            compiler.method.puts "break;"
+          end
 
-    def next
-      compiler.method.puts "continue;"
-    end
+          def next
+            compiler.method.puts "continue;"
+          end
 
-    def redo
-      raise "#{self.class.name} doesn't support redo"
-    end
+          def redo
+            raise "#{self.class.name} doesn't support redo"
+          end
 
-    def compile(expression)
-      prepare
-      @loop.init.compile(compiler, false) if @loop.init?
-      @start.call
-      compiler.method.block do
-        @loop.pre.compile(compiler, false) if @loop.pre?
-        compile_body
-        @loop.post.compile(compiler, false) if @loop.post?
-      end
-      if @end_check
-        @end_check.call
-        compiler.method.puts ';'
-      end
-      if expression
-        compiler.method.puts "#{compiler.lvalue}null;"
-      end
-    end
+          def compile(expression)
+            prepare
+            @loop.init.compile(compiler, false) if @loop.init?
+            @start.call
+            compiler.method.block do
+              @loop.pre.compile(compiler, false) if @loop.pre?
+              compile_body
+              @loop.post.compile(compiler, false) if @loop.post?
+            end
+            if @end_check
+              @end_check.call
+              compiler.method.puts ';'
+            end
+            if expression
+              compiler.method.puts "#{compiler.lvalue}null;"
+            end
+          end
 
-    def compile_body
-      loop.body.compile(compiler, false) if loop.body
-    end
+          def compile_body
+            loop.body.compile(compiler, false) if loop.body
+          end
 
-    def prepare
-      predicate = loop.condition.predicate.precompile(compiler)
-      negative = loop.negative ? '!' : ''
-      check = lambda do
-        compiler.method.print "while (#{negative}"
-        predicate.compile(compiler, true)
-        compiler.method.print ')'
-      end
-      if loop.check_first
-        @start = check
-      else
-        @start = lambda {compiler.method.print 'do'}
-        @end_check = check
-      end
-    end
-  end
+          def prepare
+            predicate = loop.condition.predicate.precompile(compiler)
+            negative = loop.negative ? '!' : ''
+            check = lambda do
+              compiler.method.print "while (#{negative}"
+              predicate.compile(compiler, true)
+              compiler.method.print ')'
+            end
+            if loop.check_first
+              @start = check
+            else
+              @start = lambda {compiler.method.print 'do'}
+              @end_check = check
+            end
+          end
+        end
 
-  module Redoable
-    def compile_with_redo(block)
-      @redo = compiler.method.tmp(JVMTypes::Boolean)
-      compiler.method.puts "#{@inner}:"
-      compiler.method.block "do" do
-        compiler.method.puts "#{@redo} = false;"
-        block.compile(compiler, false) if block
-      end
-      compiler.method.puts "while (#{@redo});"
-    end
+        module Redoable
+          def compile_with_redo(block)
+            @redo = compiler.method.tmp(JVMTypes::Boolean)
+            compiler.method.puts "#{@inner}:"
+            compiler.method.block "do" do
+              compiler.method.puts "#{@redo} = false;"
+              block.compile(compiler, false) if block
+            end
+            compiler.method.puts "while (#{@redo});"
+          end
 
-    def break
-      compiler.method.puts "break #{@outer};"
-    end
+          def break
+            compiler.method.puts "break #{@outer};"
+          end
 
-    def next
-      compiler.method.puts "break #{@inner};"
-    end
+          def next
+            compiler.method.puts "break #{@inner};"
+          end
 
-    def redo
-      compiler.method.puts "#{@redo} = true;"
-      compiler.method.puts "continue #{@inner};"
-    end
-  end
+          def redo
+            compiler.method.puts "#{@redo} = true;"
+            compiler.method.puts "continue #{@inner};"
+          end
+        end
 
-  class ComplexWhileLoop < SimpleWhileLoop
-    include Redoable
-    def prepare
-      super
-      @outer = compiler.method.label
-      @inner = compiler.method.label
-      @complex_predicate = !loop.condition.predicate.expr?(compiler)
-      super_start = @start
-      @start = lambda do
-        compiler.method.puts "#{@outer}:"
-        super_start.call
-      end
-    end
+        class ComplexWhileLoop < SimpleWhileLoop
+          include Redoable
+          def prepare
+            super
+            @outer = compiler.method.label
+            @inner = compiler.method.label
+            @complex_predicate = !loop.condition.predicate.expr?(compiler)
+            super_start = @start
+            @start = lambda do
+              compiler.method.puts "#{@outer}:"
+              super_start.call
+            end
+          end
 
-    def compile_body
-      if @loop.redo?
-        compile_with_redo(@loop.body)
-      else
-        compiler.method.puts "#{@inner}:"
-        compiler.method.block do
-          loop.body.compile(compiler, false) if loop.body
+          def compile_body
+            if @loop.redo?
+              compile_with_redo(@loop.body)
+            else
+              compiler.method.puts "#{@inner}:"
+              compiler.method.block do
+                loop.body.compile(compiler, false) if loop.body
+              end
+            end
+          end
         end
       end
     end

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

@@ -92,8 +92,9 @@ module Mirah::AST
     def expr?(compiler)
       target.expr?(compiler) &&
           parameters.all? {|p| p.expr?(compiler)} &&
-          !method.return_type.kind_of?(Mirah::AST::InlineCode) &&
-          !method.return_type.void?
+          cast || (
+            !method.return_type.kind_of?(Mirah::AST::InlineCode) &&
+            !method.return_type.void?)
     end
 
     def precompile_target(compiler)

data/lib/mirah/jvm/typer.rb

@@ -18,8 +18,8 @@ require 'mirah/jvm/types'
 require 'mirah/jvm/types/factory'
 
 module Mirah
-  module Typer
-    class JVM < Simple
+  module JVM
+    class Typer < Mirah::Typer::Simple
       include Mirah::JVM::Types
 
       attr_reader :transformer
@@ -36,7 +36,7 @@ module Mirah
       end
 
       def set_filename(scope, filename)
-        classname = Mirah::Compiler::JVM.classname_from_filename(filename)
+        classname = Mirah::JVM::Compiler::JVMBytecode.classname_from_filename(filename)
         main_class = @factory.declare_type(scope, classname)
         @known_types['self'] = main_class.meta
       end

data/lib/mirah/jvm/types.rb

@@ -18,432 +18,16 @@ require 'mirah/ast'
 require 'mirah/jvm/method_lookup'
 require 'mirah/jvm/compiler'
 require 'set'
-
-module Mirah
-  module JVM
-    module Types
-      class Type < AST::TypeReference
-        include Java::DubyLangCompiler::Class
-        include Mirah::JVM::MethodLookup
-
-        attr_writer :inner_class
-
-        def log(message)
-          puts "* [JVM::Types] #{message}" if Mirah::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 ||= Mirah::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 pop(method)
-          if wide?
-            method.pop2
-          else
-            method.pop
-          end
-        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
-        
-        def assignable_from?(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(BiteScript::ASM::ClassMirror.for_name('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 full_name
-          "dynamic"
-        end
-
-        def dynamic?
-          true
-        end
-        
-        def superclass
-          ObjectType.superclass
-        end
-        
-        def interfaces
-          ObjectType.interfaces
-        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/type'
+require 'mirah/jvm/types/primitive_type'
+require 'mirah/jvm/types/meta_type'
+require 'mirah/jvm/types/null_type'
+require 'mirah/jvm/types/unreachable_type'
+require 'mirah/jvm/types/void_type'
+require 'mirah/jvm/types/array_type'
+require 'mirah/jvm/types/dynamic_type'
+require 'mirah/jvm/types/type_definition'
+require 'mirah/jvm/types/interface_definition'
 require 'mirah/jvm/types/intrinsics'
 require 'mirah/jvm/types/methods'
 require 'mirah/jvm/types/number'