mirah 0.0.12-java → 0.1.0-java

data/lib/mirah/jvm/method_lookup.rb

@@ -16,95 +16,141 @@
 module Mirah
   module JVM
     module MethodLookup
-      # dummy log; it's expected the inclusion target will have it
-      def log(msg); end
+      java_import 'mirah.lang.ast.ConstructorDefinition'
+
+      def find_method2(mapped_type, name, mapped_params, macro_params, meta, scope=nil, &block)
+        find_method(mapped_type, name, mapped_params, macro_params, meta, scope, &block)
+      rescue NameError => ex
+        raise ex unless ex.message.include?(name)
+        if block_given?
+          block.call(ex)
+        end
+        ex
+      end
 
-      def find_method(mapped_type, name, mapped_params, meta)
-        raise ArgumentError if mapped_params.any? {|p| p.nil?}
+      def find_method(mapped_type, name, mapped_params, macro_params, meta, scope=nil, &block)
+        if mapped_type.error?
+          raise "WTF?!?"
+        end
 
-        if name == 'new'
-          if meta
-            name = "<init>"
+        if name == 'new' && meta # we're calling SomeClass.new
+          name = "<init>"
+          constructor = true
+          mapped_type = mapped_type.unmeta
+          meta = false
+        elsif name == 'new' && !meta # we're calling some_instance.new
+          constructor = false
+        elsif name == '<init>' && !meta # how do we get here?
+          constructor = true
+        elsif name == 'initialize' && !meta && scope
+          context = scope.context
+          if context.kind_of?(ConstructorDefinition) || context.findAncesor(ConstructorDefinition.class)
             constructor = true
-          else
-            constructor = false
+            name = '<init>'
           end
         end
 
-        begin
+        if block_given?
           if constructor
-            method = mapped_type.constructor(*mapped_params)
+            mapped_type.add_method_listener('initialize') {block.call(find_method2(mapped_type.meta, 'new', mapped_params, macro_params, true))}
           else
-            method = mapped_type.java_method(name, *mapped_params)
+            mapped_type.add_method_listener(name) {block.call(find_method2(mapped_type, name, mapped_params, macro_params, meta))}
+          end
+          block.call(find_method(mapped_type, name, mapped_params, macro_params, meta))
+          return
+        end
+
+        begin
+          unless mapped_params.any? {|p| p.nil? || p.isError}
+            if constructor
+              method = mapped_type.constructor(*mapped_params)
+            else
+              method = mapped_type.java_method(name, *mapped_params)
+            end
           end
-        rescue NameError
+        rescue NameError => ex
+          # TODO return nil instead of raising an exception if the method doesn't exist.
+          raise ex unless ex.message =~ /#{Regexp.quote(mapped_type.name)}\.#{Regexp.quote(name)}|No constructor #{Regexp.quote(mapped_type.name)}/
+        end
+
+        macro = mapped_type.macro(name, macro_params)
+        if method && macro
+          method = nil  # Need full lookup to determine precedence.
+        elsif method.nil? && macro
+          method = macro
+        elsif method.nil?
           # exact args failed, do a deeper search
-          log "No exact match for #{mapped_type.name}.#{name}(#{mapped_params.map(&:name).join ', '})"
+          log "No exact match for #{mapped_type.name}.#{name}(#{mapped_params.map(&:name).join ', '})" if mapped_params.all?
 
-          method = find_jls(mapped_type, name, mapped_params, meta, constructor)
+          method = find_jls(mapped_type, name, mapped_params, macro_params, meta, constructor, scope)
 
           unless method
-            log "Failed to locate method #{mapped_type.name}.#{name}(#{mapped_params.map(&:name).join ', '})"
+            log "Failed to locate method #{mapped_type.name}.#{name}(#{mapped_params.map(&:name).join ', '})" if mapped_params.all?
             return nil
           end
         end
 
-        log "Found method #{method.declaring_class.name}.#{name}(#{method.argument_types.map(&:name).join ', '}) from #{mapped_type.name}"
+        log "Found method #{method.declaring_class.name}.#{name}(#{method.argument_types.map(&:name).join ', '}) from #{mapped_type.name}" if method
         return method
       end
 
-      def find_jls(mapped_type, name, mapped_params, meta, constructor)
+      def find_jls(mapped_type, name, mapped_params, macro_params, meta, constructor, scope=nil)
         interfaces = []
-        if constructor
-          by_name = mapped_type.unmeta.declared_constructors
+        by_name = if constructor
+          mapped_type.unmeta.declared_constructors
         elsif meta
-          by_name = mapped_type.declared_class_methods(name)
+          mapped_type.declared_class_methods(name)
         else
-          by_name = []
-          cls = mapped_type
-          while cls && !cls.error?
-            by_name += cls.declared_instance_methods(name)
-            interfaces.concat(cls.interfaces)
-            cls = cls.superclass
-          end
-          if mapped_type.interface?  # TODO or abstract
-            seen = {}
-            until interfaces.empty?
-              interface = interfaces.pop
-              next if seen[interface] || interface.error?
-              seen[interface] = true
-              interfaces.concat(interface.interfaces)
-              by_name += interface.declared_instance_methods(name)
-            end
-          end
+          mapped_type.find_callable_methods(name)
         end
-        # filter by arity
-        by_name_and_arity = by_name.select {|m| m.argument_types.size == mapped_params.size}
+        method = find_jls2(mapped_type, name, mapped_params, meta, by_name, true, scope)
+        return method if (constructor || macro_params.nil?)
+        macros = mapped_type.find_callable_macros(name)
+        if macros.size != 0
+          log "Found potential macro match for #{mapped_type.name}.#{name}(#{macro_params.map(&:full_name).join ', '})"
+          macro = find_jls2(mapped_type, name, macro_params, meta, macros, false, scope)
+        end
+        if macro && method
+          raise "Ambiguous targets invoking #{mapped_type}.#{name}:\n#{macro} and #{method}"
+        end
+        macro || method
+      end
+
+      def find_jls2(mapped_type, name, mapped_params, meta, by_name, include_fields=true, scope=nil)
+        return nil if mapped_params.any? {|p| p.nil? || p.isError}
+
+        # filter by arity, varargs
+        by_name_and_arity = by_name.select {|m| m.argument_types.size == mapped_params.size }
 
         phase1_methods = phase1(mapped_params, by_name_and_arity)
 
         if phase1_methods.size > 1
           method_list = phase1_methods.map do |m|
-            
-            "#{m.name}(#{m.parameter_types.map(&:name).join(', ')})"
+            case m.member
+            when BiteScript::ASM::MethodMirror
+              m.member.inspect
+            else
+              "#{m.name}(#{m.parameter_types.map(&:name).join(', ')})"
+            end
           end.join("\n")
           raise "Ambiguous targets invoking #{mapped_type}.#{name}:\n#{method_list}"
         end
 
         phase1_methods[0] ||
           phase2(mapped_params, by_name) ||
-          phase3(mapped_params, by_name) ||
-          field_lookup(mapped_params, mapped_type, meta, name) ||
-          inner_class(mapped_params, mapped_type, meta, name)
+          phase3(mapped_params, by_name)[0] ||
+          (include_fields &&
+            (field_lookup(mapped_params, mapped_type, meta, name, scope) ||
+             inner_class(mapped_params, mapped_type, meta, name)))
       end
 
       def phase1(mapped_params, potentials)
-        log "Beginning JLS phase 1 search with params (#{mapped_params.map(&:name)})"
+        log "Beginning JLS phase 1 search with params (#{mapped_params.map(&:name).join ', '})"
 
         # cycle through methods looking for more specific matches; gather matches of equal specificity
         methods = potentials.inject([]) do |currents, potential|
           method_params = potential.argument_types
-          raise "Bad arguments for method #{potential.declaring_class}.#{potential.name}" unless method_params.all?
+          next currents unless method_params.all?
 
           # exact match always wins; duplicates not possible
           if each_is_exact(mapped_params, method_params)
@@ -114,7 +160,7 @@ module Mirah
           # otherwise, check for potential match and compare to current
           # TODO: missing ambiguity check; picks last method of equal specificity
           if each_is_exact_or_subtype_or_convertible(mapped_params, method_params)
-            if currents.size > 0
+            if !currents.empty?
               if is_more_specific?(potential.argument_types, currents[0].argument_types)
                 # potential is better, dump all currents
                 currents = [potential]
@@ -146,14 +192,33 @@ module Mirah
       end
 
       def phase3(mapped_params, potentials)
-        nil
+        potential_varargs = potentials.select{|m| m.varargs? }
+        methods = potential_varargs.inject([]) do |currents, potential|
+          method_params = potential.argument_types
+          # match n-1 params of potential
+          non_varargs_params, possible_varargs_params = mapped_params.partition.with_index{|param,i| i < method_params.size-1}
+          
+          vararg_types = possible_varargs_params.size.times.map{ method_params.last.component_type }
+          
+          if each_is_exact(non_varargs_params, method_params[0..-2]) &&
+              each_is_exact(possible_varargs_params, vararg_types)
+            return [potential]
+          end
+          
+          if each_is_exact_or_subtype_or_convertible(non_varargs_params, method_params[0..-2]) &&
+              each_is_exact_or_subtype_or_convertible(possible_varargs_params, vararg_types)
+            currents << potential
+          end
+
+          currents
+        end
       end
 
-      def field_lookup(mapped_params, mapped_type, meta, name)
+      def field_lookup(mapped_params, mapped_type, meta, name, scope)
         log("Attempting #{meta ? 'static' : 'instance'} field lookup for '#{name}' on class #{mapped_type}")
         # if we get to this point, the potentials do not match, so we ignore them
-        
-        
+
+
         # search for a field of the given name
         if name =~ /_set$/
           # setter
@@ -173,42 +238,46 @@ module Mirah
 
         if (meta && !field.static?) ||
             (!meta && field.static?)
-          field == nil
+          return nil
         end
 
         # check accessibility
         # TODO: protected field access check appropriate to current type
         if setter
-          raise "cannot set final field '#{name}' on class #{mapped_type}" if field.final?
+          if field.final?
+            log "cannot set final field '#{name}' on class #{mapped_type}"
+            return nil
+          end
+        end
+        unless field.public?
+          from = " from #{scope.selfType.resolve.name}" if scope
+          log "cannot access field '#{name}' on class #{mapped_type}#{from}"
+          return nil
         end
-        raise "cannot access field '#{name}' on class #{mapped_type}" unless field.public?
 
         field
       end
 
       def inner_class(params, type, meta, name)
-        return unless params.size == 0 && meta
+        return unless params.empty? && meta
         log("Attempting inner class lookup for '#{name}' on #{type}")
         type.inner_class_getter(name)
       end
 
       def each_is_exact(incoming, target)
-        incoming.each_with_index do |in_type, i|
-          target_type = target[i]
-
-          # exact match
-          return false unless target_type == in_type
-        end
-        return true
+        incoming.zip(target).all? { |in_type, target_type| target_type == in_type }
       end
 
       def each_is_exact_or_subtype_or_convertible(incoming, target)
-        incoming.each_with_index do |in_type, i|
-          target_type = target[i]
+        incoming.zip(target).each do |in_type, target_type|
 
           # exact match
           next if target_type == in_type
 
+          unless target_type.respond_to?(:primitive?) && in_type.respond_to?(:primitive?)
+            puts "Huh?"
+          end
+
           # primitive is safely convertible
           if target_type.primitive?
             if in_type.primitive?

data/lib/mirah/jvm/typer.rb

@@ -13,7 +13,6 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-require 'mirah/typer'
 require 'mirah/jvm/types'
 require 'mirah/jvm/types/factory'
 
@@ -33,6 +32,13 @@ module Mirah
         @known_types = @factory.known_types
         @known_types['dynamic'] = DynamicType.new
         @errors = []
+        self.scopes = transformer.scopes
+      end
+
+      def define_type(node, name, superclass, interfaces)
+        scope = get_scope(node)
+        @factory.define_type(scope, node)
+        super(scope, name, superclass, interfaces)
       end
 
       def set_filename(scope, filename)
@@ -55,9 +61,9 @@ module Mirah
       end
 
       def type_definition(scope, name, superclass, interfaces)
-        imports = scope.static_scope.imports
+        imports = scope.imports
         name = imports[name] while imports.include?(name)
-        package = scope.static_scope.package
+        package = scope.package
         unless name =~ /\./ || package.empty?
           name = "#{package}.#{name}"
         end
@@ -157,7 +163,6 @@ module Mirah
           interfaces = self_type.interfaces.dup
           until method || interfaces.empty?
             interface = interfaces.pop
-            next if interface.error?
             method = interface.find_method(
                 interface, method_def.name, arg_types, false)
           end
@@ -169,4 +174,4 @@ module Mirah
       end
     end
   end
-end
+end

data/lib/mirah/jvm/types.rb

@@ -16,14 +16,22 @@
 require 'bitescript'
 require 'mirah/ast'
 require 'mirah/jvm/method_lookup'
-require 'mirah/jvm/compiler'
+require 'mirah/util/logging'
+#require 'mirah/jvm/compiler'
 require 'set'
+module Mirah::JVM
+  module Types
+  end
+end
 require 'mirah/jvm/types/type'
 require 'mirah/jvm/types/primitive_type'
 require 'mirah/jvm/types/meta_type'
+require 'mirah/jvm/types/generic_type'
 require 'mirah/jvm/types/null_type'
+require 'mirah/jvm/types/implicit_nil_type'
 require 'mirah/jvm/types/unreachable_type'
 require 'mirah/jvm/types/void_type'
+require 'mirah/jvm/types/block_type'
 require 'mirah/jvm/types/array_type'
 require 'mirah/jvm/types/dynamic_type'
 require 'mirah/jvm/types/type_definition'
@@ -34,6 +42,6 @@ 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/factory'
 require 'mirah/jvm/types/extensions'

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

@@ -6,13 +6,10 @@ module Mirah
 
         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
+          @type_system = component_type.type_system
+          self.intrinsics
         end
 
         def array?
@@ -32,22 +29,23 @@ module Mirah
         end
 
         def superclass
+          object_type = @type_system.type(nil, 'java.lang.Object')
           if component_type.primitive?
-            Object
+            object_type
           elsif component_type.array?
             # fix covariance here for arrays of arrays
             # see #55
-            Object
+            object_type
           else
-            if component_type == Object
-              Object
+            if component_type == object_type
+              object_type
             else
               component_type.superclass.array_type
             end
           end
         end
 
-        def interfaces
+        def interfaces(include_parent=true)
           []
         end
 
@@ -59,4 +57,4 @@ module Mirah
       class ArrayMetaType < MetaType; end
     end
   end
-end
+end

data/lib/mirah/{compiler/type.rb → jvm/types/ast_ext.rb}

@@ -13,15 +13,19 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-module Mirah
-  module AST
-    class Import
-      def compile(compiler, expression)
-        # TODO: what does it mean for import to be an expression?
-        compiler.import(short, long)
-      rescue Exception => ex
-        raise Mirah::InternalCompilerError.wrap(ex, self)
+class Java::MirahLangAst::NodeImpl
+  def annotated_abstract?
+    annotations.each do |anno|
+      if anno.type.typeref.name == 'org.mirah.jvm.types.Modifiers'
+        anno.values.each do |entry|
+          if entry.key.identifier == 'flags'
+            entry.value.values.each do |value|
+              return true if value.identifier == 'ABSTRACT'
+            end
+          end
+        end
       end
     end
+    false
   end
 end