mirah 0.0.12-java → 0.1.0-java

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

@@ -24,7 +24,7 @@ module Mirah::JVM::Types
       super(default_type)
       @narrowed = default_type != narrowed_type && narrowed_type
     end
-    
+
     def hash
       __getobj__.hash
     end
@@ -38,12 +38,12 @@ module Mirah::JVM::Types
       end
     end
   end
-  
+
   class FixnumLiteral < NarrowingType
     def self.range(type)
       type::MIN_VALUE .. type::MAX_VALUE
     end
-    
+
     BYTE_RANGE = range(java.lang.Byte)
     SHORT_RANGE = range(java.lang.Short)
     INT_RANGE = range(java.lang.Integer)
@@ -56,7 +56,7 @@ module Mirah::JVM::Types
       else
         Long
       end
-      
+
       # TODO chars?
       # There's not really any way to tell if we should narrow to a char
       # or a byte/short.  I suppose we could try both, but that seems ugly.
@@ -71,7 +71,7 @@ module Mirah::JVM::Types
       else
         Long
       end
-      
+
       super(default_type, narrowed_type)
     end
   end
@@ -86,4 +86,4 @@ module Mirah::JVM::Types
       super(Double, Double)
     end
   end
-end
+end

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

@@ -5,7 +5,7 @@ module Mirah
         attr_reader :unmeta
 
         def initialize(unmeta)
-          @name = unmeta.name
+          super(unmeta.type_system, unmeta.name)
           @unmeta = unmeta
         end
 
@@ -13,6 +13,11 @@ module Mirah
           @unmeta.basic_type
         end
 
+        def name
+          return @unmeta.name if @unmeta
+          super
+        end
+
         def meta?
           true
         end
@@ -22,10 +27,14 @@ module Mirah
         end
 
         def superclass
-          @unmeta.superclass.meta if @unmeta.superclass
+          if @unmeta.superclass
+            @unmeta.superclass.meta
+          else
+            nil
+          end
         end
 
-        def interfaces
+        def interfaces(include_parent=true)
           []
         end
 
@@ -42,4 +51,4 @@ module Mirah
       end
     end
   end
-end
+end

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

@@ -31,14 +31,36 @@ module Mirah::JVM::Types
   module ArgumentConversion
     def convert_args(compiler, values, types=nil)
       # TODO boxing/unboxing
-      # TODO varargs
       types ||= argument_types
-      values.zip(types).each do |value, type|
-        compiler.compile(value, true)
-        if type.primitive? && type != value.inferred_type
-            value.inferred_type.widen(compiler.method, type)
+      needs_to_build_varargs_array = false
+      
+      if respond_to?(:varargs?) && varargs?
+        non_varargs_types = types[0..-2]
+        non_varargs_values = values.first non_varargs_types.size
+
+        varargs_values = values.to_a.last(values.size - non_varargs_values.size)
+        varargs_type = types.last
+
+        unless varargs_values.length == 1 &&
+          varargs_type.compatible?(compiler.inferred_type(varargs_values.first))
+          needs_to_build_varargs_array = true
+          values = non_varargs_values
         end
       end
+
+      values_and_types = values.zip(types)
+      
+      values_and_types.each do |value, type|
+        compiler.visit(value, true)
+        in_type = compiler.inferred_type(value)
+        if in_type.primitive? && type != in_type
+          in_type.compile_widen(compiler.method, type)
+        end
+      end
+
+      if needs_to_build_varargs_array
+        compiler.visitVarargsArray(varargs_type, varargs_values)
+      end
     end
   end
 
@@ -57,8 +79,8 @@ module Mirah::JVM::Types
       @block = block
     end
 
-    def call(builder, ast, expression)
-      @block.call(builder, ast, expression)
+    def call(builder, ast, expression, *args)
+      @block.call(builder, ast, expression, *args)
     end
 
     def declaring_class
@@ -80,14 +102,41 @@ module Mirah::JVM::Types
     def exceptions
       []
     end
+
+    def varargs?
+      false
+    end
+  end
+
+  class Macro
+    java_import 'org.mirah.typer.InlineCode'
+    java_import 'org.mirah.typer.NodeBuilder'
+    attr_reader :name, :argument_types, :return_type
+
+    def initialize(klass, name, args, &block)
+      raise ArgumentError, "Block required" unless block_given?
+      @class = klass
+      @name = name
+      @argument_types = args
+      raise ArgumentError unless args.all?
+      @return_type = InlineCode.new(block.to_java(NodeBuilder))
+    end
+
+    def declaring_class
+      @class
+    end
   end
 
   class JavaCallable
     include ArgumentConversion
+    java_import 'org.mirah.typer.ResolvedType'
+    java_import 'org.mirah.typer.TypeSystem'
 
     attr_accessor :member
 
-    def initialize(member)
+    def initialize(types, member)
+      raise ArgumentError unless types.kind_of?(TypeSystem)
+      @types = types
       @member = member
     end
 
@@ -107,10 +156,10 @@ module Mirah::JVM::Types
   class JavaConstructor < JavaCallable
     def argument_types
       @argument_types ||= @member.argument_types.map do |arg|
-        if arg.kind_of?(AST::TypeReference) || arg.nil?
+        if arg.kind_of?(Type) || arg.nil?
           arg
         else
-          AST.type(nil, arg)
+          @types.type(nil, arg)
         end
       end
     end
@@ -121,23 +170,30 @@ module Mirah::JVM::Types
 
     def exceptions
       @member.exception_types.map do |exception|
-        if exception.kind_of?(Mirah::JVM::Types::Type)
+        if exception.kind_of?(ResolvedType)
           exception
         else
-          Mirah::AST.type(nil, exception.class_name)
+          @types.type(nil, exception.class_name)
         end
       end
     end
 
     def declaring_class
-      AST.type(nil, @member.declaring_class)
+      @types.type(nil, @member.declaring_class)
+    end
+
+    def type_parameters
+      @declaring_class and @declaring_class.jvm_type.type_parameters
     end
 
-    def call(compiler, ast, expression)
-      target = ast.target.inferred_type
-      compiler.method.new target
-      compiler.method.dup if expression
-      convert_args(compiler, ast.parameters)
+    def call(compiler, ast, expression, parameters=nil, delegate=false)
+      target = compiler.inferred_type(ast.target)
+      unless delegate
+        compiler.method.new target
+        compiler.method.dup if expression
+      end
+      parameters ||= ast.parameters
+      convert_args(compiler, parameters)
       compiler.method.invokespecial(
         target,
         "<init>",
@@ -147,15 +203,20 @@ module Mirah::JVM::Types
     def constructor?
       true
     end
+
+    def varargs?
+      @member.varargs?
+    end
+
   end
 
   class JavaMethod < JavaConstructor
     def return_type
       @return_type ||= begin
         if void?
-          Void
+          @types.type(nil, 'void')
         else
-          AST.type(nil, @member.return_type)
+          @types.type(nil, @member.return_type)
         end
       end
     end
@@ -168,6 +229,10 @@ module Mirah::JVM::Types
       @member.abstract?
     end
 
+    def type_parameters
+      @member.type_parameters
+    end
+
     def void?
       return_type = @member.return_type
       return true if return_type.nil?
@@ -181,9 +246,9 @@ module Mirah::JVM::Types
       false
     end
 
-    def call(compiler, ast, expression)
-      target = ast.target.inferred_type
-      ast.target.compile(compiler, true)
+    def call(compiler, ast, expression, parameters=nil)
+      target = compiler.inferred_type(ast.target)
+      compiler.visit(ast.target, true)
 
       # if expression, void methods return the called object,
       # for consistency and chaining
@@ -193,7 +258,8 @@ module Mirah::JVM::Types
         compiler.method.dup
       end
 
-      convert_args(compiler, ast.parameters)
+      parameters ||= ast.parameters
+      convert_args(compiler, parameters)
       if target.interface?
         compiler.method.invokeinterface(
           target,
@@ -206,14 +272,22 @@ module Mirah::JVM::Types
           [@member.return_type, *@member.argument_types])
       end
 
+      if expression && !void?
+        # Insert a cast if the inferred type and actual type differ. This is part of generics support.
+        inferred_return_type = compiler.inferred_type(ast)
+        if !inferred_return_type.assignableFrom(return_type)
+          compiler.method.checkcast(inferred_return_type)
+        end
+      end
+
       unless expression || void?
         return_type.pop(compiler.method)
       end
     end
 
-    def call_special(compiler, ast, expression)
-      target = ast.target.inferred_type
-      ast.target.compile(compiler, true)
+    def call_special(compiler, target, target_type, parameters, expression)
+      target_type ||= compiler.inferred_type(target)
+      compiler.visit(target, true)
 
       # if expression, void methods return the called object,
       # for consistency and chaining
@@ -223,12 +297,12 @@ module Mirah::JVM::Types
         compiler.method.dup
       end
 
-      convert_args(compiler, ast.parameters)
-      if target.interface?
+      convert_args(compiler, parameters)
+      if target_type.interface?
         raise "interfaces should not receive call_special"
       else
         compiler.method.invokespecial(
-          target,
+          target_type,
           name,
           [@member.return_type, *@member.argument_types])
       end
@@ -240,9 +314,10 @@ module Mirah::JVM::Types
   end
 
   class JavaStaticMethod < JavaMethod
-    def call(compiler, ast, expression)
+    def call(compiler, ast, expression, parameters=nil)
       target = declaring_class
-      convert_args(compiler, ast.parameters)
+      parameters ||= ast.parameters
+      convert_args(compiler, parameters)
       compiler.method.invokestatic(
         target,
         name,
@@ -256,13 +331,14 @@ module Mirah::JVM::Types
   end
 
   class JavaDynamicMethod < JavaMethod
-    def initialize(name, *types)
+    def initialize(type_system, name, *argument_types)
+      super(type_system, nil)
       @name = name
-      @types = types
+      @argument_types = argument_types
     end
 
     def return_type
-      AST.type(nil, 'dynamic')
+      @types.type(nil, 'dynamic')
     end
 
     def declaring_class
@@ -270,17 +346,21 @@ module Mirah::JVM::Types
     end
 
     def argument_types
-      @types
+      @argument_types
     end
 
-    def call(compiler, ast, expression)
-      target = ast.target.inferred_type
-      ast.target.compile(compiler, true)
+    def call(compiler, ast, expression, parameters=nil)
+      unless compiler.respond_to?(:supports_invokedynamic?) && compiler.supports_invokedynamic?
+        raise Mirah::MirahError, "Target JVM version: #{compiler.target_jvm_version} doesn't support invoke dynamic"
+      end
+      target = compiler.inferred_type(ast.target)
+      compiler.visit(ast.target, true)
 
-      ast.parameters.each do |param|
-        param.compile(compiler, true)
+      parameters ||= ast.parameters
+      parameters.each do |param|
+        compiler.visit(param, true)
       end
-      handle = compiler.method.mh_invokestatic(
+      handle = compiler.method.h_invokestatic(
         org.dynalang.dynalink.DefaultBootstrapper,
         "bootstrap",
         java.lang.invoke.CallSite,
@@ -289,7 +369,7 @@ module Mirah::JVM::Types
         java.lang.invoke.MethodType)
       compiler.method.invokedynamic(
         "dyn:callPropWithThis:#{name}",
-        [return_type, target, *@types],
+        [return_type, target, *@argument_types],
         handle)
 
       unless expression
@@ -304,7 +384,7 @@ module Mirah::JVM::Types
     end
 
     def return_type
-      AST.type(nil, @member.type)
+      @types.type(nil, @member.type)
     end
 
     def public?
@@ -321,8 +401,8 @@ module Mirah::JVM::Types
       []
     end
 
-    def call(compiler, ast, expression)
-      target = ast.target.inferred_type
+    def call(compiler, ast, expression, parameters=nil)
+      target = compiler.inferred_type(ast.target)
 
       # TODO: assert that no args are being passed, though that should have failed lookup
 
@@ -330,7 +410,7 @@ module Mirah::JVM::Types
         if @member.static?
           compiler.method.getstatic(target, name, @member.type)
         else
-          ast.target.compile(compiler, true)
+          compiler.visit(ast.target, true)
           compiler.method.getfield(target, name, @member.type)
         end
       end
@@ -339,25 +419,26 @@ module Mirah::JVM::Types
 
   class JavaFieldSetter < JavaFieldAccessor
     def return_type
-      AST.type(nil, @member.type)
+      @types.type(nil, @member.type)
     end
 
     def argument_types
-      [AST.type(nil, @member.type)]
+      [@types.type(nil, @member.type)]
     end
 
-    def call(compiler, ast, expression)
-      target = ast.target.inferred_type
+    def call(compiler, ast, expression, parameters=nil)
+      target = compiler.inferred_type(ast.target)
 
       # TODO: assert that no args are being passed, though that should have failed lookup
 
+      parameters ||= ast.parameters
       if @member.static?
-        convert_args(compiler, ast.parameters)
+        convert_args(compiler, parameters)
         compiler.method.dup if expression
         compiler.method.putstatic(target, name, @member.type)
       else
-        ast.target.compile(compiler, true)
-        convert_args(compiler, ast.parameters)
+        compiler.visit(ast.target, true)
+        convert_args(compiler, parameters)
         compiler.method.dup_x2 if expression
         compiler.method.putfield(target, name, @member.type)
       end
@@ -369,7 +450,7 @@ module Mirah::JVM::Types
     attr_reader :exception_types
 
     def initialize(klass, name, args, return_type, static, exceptions)
-      if return_type == Void
+      if return_type.name == 'void' || return_type.name == ':unreachable'
         return_type = nil
       end
       @declaring_class = klass
@@ -387,11 +468,111 @@ module Mirah::JVM::Types
     def abstract?
       @declaring_class.interface?
     end
+
+    def varargs?
+      false
+    end
   end
 
   class Type
+    def method_listeners
+      if meta?
+        unmeta.method_listeners
+      else
+        @method_listeners ||= {}
+      end
+    end
+
+    def method_updated(name)
+      listeners = method_listeners[name]
+      listeners.values.each do |l|
+        if l.kind_of?(Proc)
+          l.call(name)
+        else
+          l.method_updated(name)
+        end
+      end if listeners
+    end
+
+    def add_method_listener(name, listener=nil, &block)
+      listeners = method_listeners[name] ||= {}
+      if listener
+        unless listener.respond_to?(:method_updated) || listener.kind_of?(Proc)
+          raise "Invalid listener"
+        end
+        listeners[listener] = listener
+      else
+        listeners[block] = block
+      end
+      if !self.meta? && jvm_type && superclass && !superclass.isError
+        superclass.add_method_listener(name, self)
+      end
+      interfaces.each {|i| i.add_method_listener(name, self) unless i.isError}
+    end
+
+    # TODO take a scope and check visibility
+    def find_callable_macros(name)
+      interfaces = []
+      macros = find_callable_macros2(name, interfaces)
+      seen = {}
+      until interfaces.empty?
+        interface = interfaces.pop
+        next if seen[interface] || interface.isError
+        seen[interface] = true
+        interfaces.concat(interface.interfaces)
+        macros.concat(interface.declared_macros(name))
+      end
+      macros
+    end
+
+    def find_callable_macros2(name, interfaces)
+      macros = []
+      interfaces.concat(self.interfaces)
+      macros.concat(declared_macros(name))
+      if superclass && !superclass.error?
+        macros.concat(superclass.find_callable_macros2(name, interfaces))
+      end
+      macros
+    end
+
+    # TODO take a scope and check visibility
+    def find_callable_methods(name, include_interfaces=false, &proc)
+      if block_given?
+        add_method_listener(name) {proc.call(find_callable_methods(name))}
+        proc.call(find_callable_methods(name))
+        return
+      end
+      interfaces = if self.interface? || include_interfaces # TODO || self.abstract?
+        []
+      else
+        nil
+      end
+      methods = find_callable_methods2(name, interfaces)
+      if interfaces
+        seen = {}
+        until interfaces.empty?
+          interface = interfaces.pop
+          next if seen[interface]
+          seen[interface] = true
+          interfaces.concat(interface.interfaces)
+          methods.concat(interface.declared_instance_methods(name))
+        end
+      end
+      methods
+    end
+
+    def find_callable_methods2(name, interfaces)
+      methods = []
+      interfaces.concat(self.interfaces) if interfaces
+      methods.concat(declared_instance_methods(name))
+      if superclass && !superclass.error?
+        methods.concat(superclass.find_callable_methods2(name, interfaces))
+      end
+      methods
+    end
+
     def get_method(name, args)
-      method = find_method(self, name, args, meta?)
+      method = find_method(self, name, args, nil, meta?)
       unless method
         # Allow constant narrowing for assignment methods
         if name =~ /=$/ && args[-1].respond_to?(:narrow!)
@@ -407,9 +588,9 @@ module Mirah::JVM::Types
       begin
         descriptors = types.map {|type| BiteScript::Signature.class_id(type)}
         constructor = jvm_type.getConstructor(*descriptors)
-        return JavaConstructor.new(constructor) if constructor
+        return JavaConstructor.new(@type_system, constructor) if constructor
       rescue => ex
-        log(ex.message)
+        log("#{ex.message}\n#{ex.backtrace.join("\n")}")
       end
       raise NameError, "No constructor #{name}(#{types.join ', '})"
     end
@@ -419,7 +600,7 @@ module Mirah::JVM::Types
       return intrinsic if intrinsic
       jvm_types = types.map {|type| type.jvm_type}
 
-      return JavaDynamicMethod.new(name, *jvm_types) if dynamic?
+      return JavaDynamicMethod.new(@type_system, name, *jvm_types) if dynamic?
 
       begin
         descriptors = types.map {|type| BiteScript::Signature.class_id(type)}
@@ -429,7 +610,7 @@ module Mirah::JVM::Types
           method = superclass.java_method(name, *types) rescue nil
         end
 
-        if method.nil? && jvm_type.abstract?
+        if method.nil? && jvm_type && jvm_type.abstract?
           interfaces.each do |interface|
             method = interface.java_method(name, *types) rescue nil
             break if method
@@ -438,11 +619,11 @@ module Mirah::JVM::Types
 
         return method if method.kind_of?(JavaCallable)
         if method && method.static? == meta?
-          return JavaStaticMethod.new(method) if method.static?
-          return JavaMethod.new(method)
+          return JavaStaticMethod.new(@type_system, method) if method.static?
+          return JavaMethod.new(@type_system, method)
         end
       rescue   => ex
-        log(ex.message)
+        log("#{ex.message}\n#{ex.backtrace.join("\n")}")
       end
       raise NameError, "No method #{self.name}.#{name}(#{types.join ', '})"
     end
@@ -451,7 +632,7 @@ module Mirah::JVM::Types
       methods = []
       if jvm_type && !array?
         jvm_type.getDeclaredMethods(name).each do |method|
-          methods << JavaMethod.new(method) unless method.static?
+          methods << JavaMethod.new(@type_system, method) unless method.static?
         end
       end
       methods.concat((meta? ? unmeta : self).declared_intrinsics(name))
@@ -461,7 +642,7 @@ module Mirah::JVM::Types
       methods = []
       if jvm_type && !unmeta.array?
         jvm_type.getDeclaredMethods(name).each do |method|
-          methods << JavaStaticMethod.new(method) if method.static?
+          methods << JavaStaticMethod.new(@type_system, method) if method.static?
         end
       end
       methods.concat(meta.declared_intrinsics(name))
@@ -469,14 +650,14 @@ module Mirah::JVM::Types
 
     def declared_constructors
       jvm_type.getConstructors.map do |method|
-        JavaConstructor.new(method)
+        JavaConstructor.new(@type_system, method)
       end
     end
 
     def field_getter(name)
       if jvm_type
         field = jvm_type.getField(name)
-        JavaFieldGetter.new(field) if field
+        JavaFieldGetter.new(@type_system, field) if field
       else
         nil
       end
@@ -485,7 +666,7 @@ module Mirah::JVM::Types
     def field_setter(name)
       if jvm_type
         field = jvm_type.getField(name)
-        JavaFieldSetter.new(field) if field
+        JavaFieldSetter.new(@type_system, field) if field
       else
         nil
       end
@@ -493,13 +674,14 @@ module Mirah::JVM::Types
 
     def inner_class_getter(name)
       full_name = "#{self.name}$#{name}"
-      inner_class = Mirah::AST.type(nil, full_name) rescue nil
+      inner_class = @type_system.type(nil, full_name) rescue nil
       return unless inner_class
+
       inner_class.inner_class = true
-      add_macro(name) do |transformer, call|
-        Mirah::AST::Constant.new(call.parent, call.position, full_name)
+      macro = Macro.new(self, name, []) do |call, typer|
+        Mirah::AST::Constant.new(call.position, Mirah::AST::SimpleString.new(call.position, full_name))
       end
-      intrinsics[name][[]]
+      intrinsics[name][[]] = macro
     end
   end
 
@@ -547,17 +729,12 @@ module Mirah::JVM::Types
     end
 
     def constructors
-      @constructors ||= []
-    end
-
-    def default_constructor
-      if constructors.empty?
+      if @constructors.nil?
+        @constructors = []
         declare_method('initialize', [], self, [])
-        @default_constructor_added = true
-        constructors[0]
-      else
-        constructor
+        @have_default_constructor = true
       end
+      @constructors
     end
 
     def instance_methods
@@ -570,25 +747,36 @@ module Mirah::JVM::Types
 
     def declare_method(name, arguments, type, exceptions)
       raise "Bad args" unless arguments.all?
+      if type.isError
+        instance_methods.delete(name)
+        method_updated(name)
+        return
+      end
       member = MirahMember.new(self, name, arguments, type, false, exceptions)
       if name == 'initialize'
-        if @default_constructor_added
-          if arguments.empty?
-            @default_constructor_added = false
-          else
-            raise "Can't add constructor #{member} after using the default."
-          end
-        else
-          constructors << JavaConstructor.new(member)
+        # The ordering is important here:
+        # The first call to constructors initializes @have_default_constructor.
+        if constructors.size == 1 && @have_default_constructor
+          constructors.clear
+          @have_default_constructor = false
+        elsif constructors.size > 1 && @have_default_constructor
+          raise "Invalid state: default constructor but #{constructors.size} constructors"
         end
+        constructors << JavaConstructor.new(@type_system, member)
       else
-        instance_methods[name] << JavaMethod.new(member)
+        instance_methods[name] << JavaMethod.new(@type_system, member)
       end
+      method_updated(name)
     end
 
     def declare_static_method(name, arguments, type, exceptions)
-      member = MirahMember.new(self, name, arguments, type, true, exceptions)
-      static_methods[name] << JavaStaticMethod.new(member)
+      if type.isError
+        static_methods.delete(name)
+      else
+        member = MirahMember.new(self, name, arguments, type, true, exceptions)
+        static_methods[name] << JavaStaticMethod.new(@type_system, member)
+      end
+      method_updated(name)
     end
 
     def interface?
@@ -629,4 +817,4 @@ module Mirah::JVM::Types
       nil
     end
   end
-end
+end