mirah 0.0.12-java → 0.1.0-java

data/lib/mirah/jvm/types/null_type.rb

@@ -2,8 +2,8 @@ module Mirah
   module JVM
     module Types
       class NullType < Type
-        def initialize
-          super(BiteScript::ASM::ClassMirror.load('java.lang.Object'))
+        def initialize(types)
+          super(types, types.get_mirror('java.lang.Object'))
         end
 
         def to_s
@@ -15,13 +15,25 @@ module Mirah
         end
 
         def compatible?(other)
-          !other.primitive?
+          assignable_from(other)
         end
 
         def assignable_from?(other)
-          !other.primitive?
+          if other.respond_to?(:primitive?)
+            !other.primitive?
+          else
+            other.matchesAnything
+          end
+        end
+
+        def widen(other)
+          if other.matchesAnything
+            self
+          else
+            other
+          end
         end
       end
     end
   end
-end
+end

data/lib/mirah/jvm/types/number.rb

@@ -17,7 +17,7 @@ module Mirah::JVM::Types
   class ComparisonIntrinsic < Intrinsic
     attr_reader :name, :op
     def initialize(type, name, op, args)
-      super(type, name, args, Boolean) do; end
+      super(type, name, args, type.type_system.type(nil, 'boolean')) do; end
       @type = type
       @op = op
     end
@@ -38,15 +38,17 @@ module Mirah::JVM::Types
   end
 
   class Number < PrimitiveType
+    TYPE_ORDERING = ['byte', 'short', 'int', 'long', 'float', 'double']
+
     # The type returned by arithmetic operations with this type.
     def math_type
       self
     end
-    
+
     def suffix
       ''
     end
-    
+
     # Adds an intrinsic that delegates to an intrinsic in another primitive
     # type. That type must support promoting the "this" argument.
     def delegate_intrinsic(name, type, return_type)
@@ -62,11 +64,12 @@ module Mirah::JVM::Types
         end
       end
     end
-    
+
     def add_delegates(name, return_type = nil)
-      index = TYPE_ORDERING.index(math_type)
+      index = TYPE_ORDERING.index(math_type.name)
       larger_types = TYPE_ORDERING[index + 1, TYPE_ORDERING.size]
       larger_types.each do |type|
+        type = @type_system.type(nil, type)
         delegate_intrinsic(name, type, return_type || type)
       end
     end
@@ -80,7 +83,7 @@ module Mirah::JVM::Types
     def boolean_operator(name, op)
       args = [math_type]
       add_method(name, args, ComparisonIntrinsic.new(self, name, op, args))
-      add_delegates(name, Boolean)
+      add_delegates(name, @type_system.type(nil, 'boolean'))
     end
 
     def invert_op(op)
@@ -155,4 +158,4 @@ module Mirah::JVM::Types
       builder.invokestatic box_type, "valueOf", [box_type, math_type]
     end
   end
-end
+end

data/lib/mirah/jvm/types/primitive_type.rb

@@ -2,9 +2,19 @@ module Mirah
   module JVM
     module Types
       class PrimitiveType < Type
-        def initialize(type, wrapper)
+        WIDENING_CONVERSIONS = {
+          'byte' => ['byte', 'short', 'int', 'long', 'float', 'double', 'java.lang.Byte', 'java.lang.Object'],
+          'short' => ['short', 'int', 'long', 'float', 'double', 'java.lang.Short', 'java.lang.Object'],
+          'char' => ['char', 'int', 'long', 'float', 'double', 'java.lang.Character', 'java.lang.Object'],
+          'int' => ['int', 'long', 'float', 'double','java.lang.Integer', 'java.lang.Object'],
+          'long' => ['long', 'float', 'double', 'java.lang.Long', 'java.lang.Object'],
+          'float' => ['float', 'double', 'java.lang.Float', 'java.lang.Object'],
+          'double' => ['double', 'java.lang.Double', 'java.lang.Object']
+        }
+
+        def initialize(types, type, wrapper)
           @wrapper = wrapper
-          super(type)
+          super(types, type)
         end
 
         def primitive?
@@ -19,14 +29,15 @@ module Mirah
           method.send "new#{name}array"
         end
 
-        def interfaces
+        def interfaces(include_parent=true)
           []
         end
 
         def convertible_to?(type)
           return true if type == self
-          widening_conversions = WIDENING_CONVERSIONS[self]
-          widening_conversions && widening_conversions.include?(type)
+          return false if type.array?
+          widening_conversions = WIDENING_CONVERSIONS[self.name]
+          widening_conversions && widening_conversions.include?(type.name)
         end
 
         def superclass
@@ -35,4 +46,4 @@ module Mirah
       end
     end
   end
-end
+end

data/lib/mirah/jvm/types/source_mirror.rb

@@ -27,10 +27,11 @@ module Mirah::JVM::Types
       java_import 'javax.lang.model.element.Element'
       java_import 'javax.lang.model.type.TypeKind'
       java_import 'javax.lang.model.type.TypeMirror'
-      java_import 'com.sun.tools.javac.model.JavacElements'
       java_import 'javax.lang.model.util.ElementScanner6'
       java_import 'javax.lang.model.element.AnnotationValueVisitor'
+      java_import 'com.sun.tools.javac.model.JavacElements'
     rescue
+      # must be after Java 7-15
     end
 
     if defined?(JavacElements)
@@ -81,10 +82,10 @@ module Mirah::JVM::Types
 
         def classpath
           options = [
-            '-classpath', Mirah::AST.type_factory.classpath
+            '-classpath', @type_factory.classpath
           ]
-          if Mirah::AST.type_factory.bootclasspath
-            options << '-bootclasspath' << Mirah::AST.type_factory.bootclasspath
+          if @type_factory.bootclasspath
+            options << '-bootclasspath' << @type_factory.bootclasspath
           end
           options
         end
@@ -262,8 +263,12 @@ module Mirah::JVM::Types
     end
 
     def self.load(file, factory)
-      parser = JavaSourceParser.new(file, factory)
-      parser.parse
+      if defined? JavacElements
+        parser = JavaSourceParser.new(file, factory)
+        parser.parse
+      end
+    rescue TypeError
+      # 1.6.8 on Java 7, don't use source mirror
     end
   end
-end
+end

data/lib/mirah/jvm/types/type.rb

@@ -1,24 +1,34 @@
 module Mirah
   module JVM
     module Types
-      class Type < AST::TypeReference
-        include Java::DubyLangCompiler::Class
+      class Type
+        java_import 'org.mirah.typer.ErrorType'
+        java_import 'org.mirah.typer.SpecialType'
+        java_import 'org.mirah.typer.ResolvedType'
+
+        class SpecialType
+          def full_name
+            name
+          end
+        end
+
         include Mirah::JVM::MethodLookup
+        include Mirah::Logging::Logged
 
-        attr_writer :inner_class
+        include ResolvedType
 
-        def log(message)
-          puts "* [JVM::Types] #{message}" if Mirah::JVM::Compiler::JVMBytecode.verbose
-        end
+        attr_reader :name, :type_system
+        attr_writer :inner_class
 
-        def initialize(mirror_or_name)
+        def initialize(type_system, mirror_or_name)
+          @type_system = type_system
+          raise ArgumentError if type_system.nil?
           if mirror_or_name.kind_of?(BiteScript::ASM::ClassMirror)
             @type = mirror_or_name
-            name = mirror_or_name.type.class_name
+            @name = mirror_or_name.type.class_name
           else
-            name = mirror_or_name.to_s
+            @name = mirror_or_name.to_s
           end
-          super(name, false, false)
           raise ArgumentError, "Bad type #{mirror_or_name}" if name =~ /Java::/
         end
 
@@ -38,10 +48,28 @@ module Mirah
         def meta?
           false
         end
+        def isMeta
+          self.meta?
+        end
+
+
+        def generic?
+          false
+        end
+        def isGeneric
+          self.generic?
+        end
+
+        def isBlock
+          false
+        end
 
         def array?
           false
         end
+        def isArray
+          self.array?
+        end
 
         def primitive?
           false
@@ -52,7 +80,7 @@ module Mirah
           # mirrors for all incoming types without blowing up on e.g. 'boolean' or 'int'
           (@type || BiteScript::ASM::ClassMirror.for_name(@name)).interface? rescue nil
         end
-        
+
         def abstract?
           (@type || BiteScript::ASM::ClassMirror.for_name(@name)).abstract? rescue nil
         end
@@ -73,29 +101,50 @@ module Mirah
           assignable_from?(other)
         end
 
+        def error?
+          false
+        end
+        def isError
+          false
+        end
+
         def assignable_from?(other)
-          return false if other.nil?
-          return true if !primitive? && other == Null
+          return false unless other
+          return true if !primitive? && other.kind_of?(NullType)
           return true if other == self
-          return true if other.error? || other.unreachable?
+          return true if other.matchesAnything
 
-          # TODO should we allow more here?
-          return interface? || abstract? if other.block?
+          return interface? || abstract? if other.isBlock
 
           return true if jvm_type && (jvm_type == other.jvm_type)
 
+          return assignable_from?(other.ungeneric) if other.generic?
+
+          return other.convertible_to?(self) if other.primitive?
+
           assignable_from?(other.superclass) ||
               other.interfaces.any? {|i| assignable_from?(i)}
         end
+        def assignableFrom(other)
+          assignable_from?(other)
+        end
+
+        def widen(other)
+          return self if assignable_from?(other)
+          common_parent = (ancestors_and_interfaces & ([other] + other.ancestors_and_interfaces))[0]
+          common_parent || ErrorType.new([["Incompatible types #{self} and #{other}."]])
+        end
+
+        def matchesAnything; false; end
 
         def iterable?
           ['java.lang.Iterable',
            'java.util.Iterator',
-           'java.util.Enumeration'].any? {|n| AST.type(nil, n).assignable_from(self)}
+           'java.util.Enumeration'].any? {|n| @type_system.type(nil, n).assignable_from(self)}
         end
 
         def component_type
-          AST.type(nil, 'java.lang.Object') if iterable?
+          @type_system.type(nil, 'java.lang.Object') if iterable?
         end
 
         def meta
@@ -106,6 +155,19 @@ module Mirah
           self
         end
 
+        def generic
+          @generic ||= GenericType.new(self)
+        end
+
+        def ungeneric
+          self
+        end
+
+        def type_parameters
+          return nil unless jvm_type
+          jvm_type.type_parameters
+        end
+
         def basic_type
           self
         end
@@ -124,7 +186,11 @@ module Mirah
         end
 
         def inspect(indent=0)
-          "#{' ' * indent}#<#{self.class.name} #{name}>"
+          "#{' ' * indent}#<#{self.class.name.split(/::/)[-1]} #{name}>"
+        end
+
+        def to_s
+          inspect
         end
 
         def newarray(method)
@@ -141,14 +207,14 @@ module Mirah
 
         def superclass
           raise "Incomplete type #{self}" unless jvm_type
-          AST.type(nil, jvm_type.superclass) if jvm_type.superclass
+          @type_system.type(nil, jvm_type.superclass) if jvm_type.superclass
         end
 
-        def interfaces
+        def interfaces(include_parent=true)
           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 = jvm_type.interfaces.map {|i| @type_system.type(nil, i)}.to_set
+            if superclass && include_parent
               interfaces |= superclass.interfaces
             end
             interfaces.to_a
@@ -156,6 +222,24 @@ module Mirah
           @interfaces
         end
 
+        def ancestors_and_interfaces
+          if self.primitive?
+            []
+          else
+            ancestors = []
+            get_ancestors = lambda {|c| [c.superclass] + c.interfaces(false)}
+            new_ancestors = get_ancestors.call(self)
+            until new_ancestors.empty?
+              klass = new_ancestors.shift
+              next if klass.nil? || klass.name == 'java.lang.Object' || klass.isError
+              ancestors << klass
+              new_ancestors.concat(get_ancestors.call(klass))
+            end
+            ancestors << @type_system.type(nil, 'java.lang.Object')
+            ancestors
+          end
+        end
+
         def astore(builder)
           if primitive?
             builder.send "#{name[0,1]}astore"

data/lib/mirah/jvm/types/type_definition.rb

@@ -2,11 +2,14 @@ module Mirah
   module JVM
     module Types
       class TypeDefinition < Type
-        attr_accessor :node
+        java_import 'mirah.lang.ast.InterfaceDeclaration'
+        attr_accessor :node, :scope
 
-        def initialize(name, node)
+        def initialize(types, scope, name, node)
           raise ArgumentError, "Bad name #{name}" if name[0,1] == '.'
           raise ArgumentError, "Bad name #{name}" if name.include? ?/
+          @type_system = types
+          @scope = scope
           @name = name
           @node = node
           raise ArgumentError, "Bad type #{name}" if self.name =~ /Java::/
@@ -16,29 +19,41 @@ module Mirah
           if @type
             @type.name.tr('/', '.')
           else
-            @name
+            if !@name.include?(?.) && scope.package
+              "#{scope.package}.#{@name}"
+            else
+              @name
+            end
           end
         end
 
         def superclass
-          (node && node.superclass) || Object
+          if node && node.superclass
+            @type_system.get(scope, node.superclass.typeref).resolve
+          else
+            @type_system.type(nil, 'java.lang.Object')
+          end
         end
 
-        def interfaces
+        def interfaces(include_parent=true)
           if node
-            node.interfaces
+            node.interfaces.map {|n| @type_system.get(scope, n.typeref).resolve}
           else
             []
           end
         end
 
+        def abstract?
+          node && (node.kind_of?(InterfaceDeclaration) || node.annotated_abstract?)
+        end
+
         def define(builder)
-          class_name = @name.tr('.', '/')
-          abstract = node && node.abstract
+          class_name = name.tr('.', '/')
+          abstract = node && node.kind_of?(InterfaceDeclaration)  #node.abstract
           @type ||= builder.define_class(
               class_name,
               :visibility => :public,
-              :abstract => abstract,
+              :abstract => abstract?,
               :superclass => superclass,
               :interfaces => interfaces)
         end
@@ -52,4 +67,4 @@ module Mirah
       end
     end
   end
-end
+end