mirah 0.0.7-java → 0.0.8-java

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

@@ -0,0 +1,62 @@
+module Mirah
+  module JVM
+    module Types
+      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
+          if component_type.primitive?
+            Object
+          elsif component_type.array?
+            # fix covariance here for arrays of arrays
+            # see #55
+            Object
+          else
+            if component_type == Object
+              Object
+            else
+              component_type.superclass.array_type
+            end
+          end
+        end
+
+        def interfaces
+          []
+        end
+
+        def meta
+          @meta ||= ArrayMetaType.new(self)
+        end
+      end
+
+      class ArrayMetaType < MetaType; end
+    end
+  end
+end

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

@@ -33,6 +33,7 @@ module Mirah::JVM::Types
           BiteScript::ASM::ClassMirror.load('java.lang.Iterable'))
 
   Void = VoidType.new
+  Unreachable = UnreachableType.new
   Null = NullType.new
 
   WIDENING_CONVERSIONS = {

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

@@ -0,0 +1,46 @@
+module Mirah
+  module JVM
+    module Types
+      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
+    end
+  end
+end

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

@@ -14,6 +14,7 @@
 # limitations under the License.
 
 require 'jruby'
+require 'mirah/jvm/types/source_mirror'
 module Mirah::JVM::Types
   class TypeFactory
     BASIC_TYPES = {
@@ -136,7 +137,7 @@ module Mirah::JVM::Types
       packages.each do |package|
         begin
           return get_type("#{package}.#{name}")
-        rescue
+        rescue NameError
         end
       end
       raise NameError, "Cannot find class #{name}"
@@ -213,12 +214,29 @@ module Mirah::JVM::Types
       Void
     end
 
+    def unreachable_type
+      Unreachable
+    end
+
     def get_mirror(name)
       @mirrors[name] ||= begin
-        classname = name.tr('.', '/') + ".class"
-        stream = JRuby.runtime.jruby_class_loader.getResourceAsStream(classname)
-        raise NameError, "Class '#{name}' not found." unless stream
-        BiteScript::ASM::ClassMirror.load(stream)
+        classname = name.tr('.', '/')
+        stream = JRuby.runtime.jruby_class_loader.getResourceAsStream(classname + ".class")
+        if stream
+          BiteScript::ASM::ClassMirror.load(stream) if stream
+        else
+          url = JRuby.runtime.jruby_class_loader.getResource(classname + ".java")
+          if url
+            file = java.io.File.new(url.toURI)
+            mirrors = JavaSourceMirror.load(file, self)
+            mirrors.each do |mirror|
+              @mirrors[mirror.type.class_name] = mirror
+            end if mirrors
+            @mirrors[name]
+          else
+            raise NameError, "Class '#{name}' not found."
+          end
+        end
       end
     end
   end

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

@@ -0,0 +1,20 @@
+module Mirah
+  module JVM
+    module Types
+      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
+    end
+  end
+end

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

@@ -78,11 +78,15 @@ module Mirah::JVM::Types
         # However the only way to do that is to wrap them in a ScopedBody.
         # It'd be better if we didn't have to expose this wrapper node to
         # the user code.
+        #
+        if call.block && call.name != 'quote'
+          call.block.body = wrap_with_scoped_body call, call.block.body
+        end
+        
         call.parameters = call.parameters.map do |arg|
-          wrapper = Mirah::AST::ScopedBody.new(call.parent, call.position)
-          wrapper.static_scope = call.scope.static_scope
-          wrapper << arg
+          wrap_with_scoped_body call, arg
         end
+        
         expander = klass.constructors[0].newInstance(duby, call)
         ast = expander.expand
         if ast
@@ -98,6 +102,12 @@ module Mirah::JVM::Types
         end
       end
     end
+    
+    def wrap_with_scoped_body call, node
+      wrapper = Mirah::AST::ScopedBody.new(call.parent, call.position)
+      wrapper.static_scope = call.scope.static_scope
+      wrapper << node
+    end
 
     def declared_intrinsics(name=nil)
       methods = []
@@ -377,6 +387,8 @@ module Mirah::JVM::Types
           if var
             forloop.pre << transformer.eval(
                 "#{var.name} = #{it}.next", '', forloop, it)
+          else
+            forloop.pre << transformer.eval("#{it}.next", '', forloop, it)
           end
           call.block.body.parent = forloop if call.block.body
           [

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

@@ -0,0 +1,45 @@
+module Mirah
+  module JVM
+    module Types
+      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 TypeDefMeta < MetaType
+      end
+    end
+  end
+end

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

@@ -280,16 +280,21 @@ module Mirah::JVM::Types
       ast.parameters.each do |param|
         param.compile(compiler, true)
       end
+      handle = compiler.method.mh_invokestatic(
+        org.dynalang.dynalink.DefaultBootstrapper,
+        "bootstrap",
+        java.lang.invoke.CallSite,
+        java.lang.invoke.MethodHandles::Lookup,
+        java.lang.String,
+        java.lang.invoke.MethodType)
       compiler.method.invokedynamic(
-        target,
         "dyn:callPropWithThis:#{name}",
-        [return_type, target, *@types])
+        [return_type, target, *@types],
+        handle)
 
       unless expression
         return_type.pop(compiler.method)
       end
-
-      compiler.bootstrap_dynamic
     end
   end
 
@@ -568,7 +573,9 @@ module Mirah::JVM::Types
       member = MirahMember.new(self, name, arguments, type, false, exceptions)
       if name == 'initialize'
         if @default_constructor_added
-          unless arguments.empty?
+          if arguments.empty?
+            @default_constructor_added = false
+          else
             raise "Can't add constructor #{member} after using the default."
           end
         else

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

@@ -0,0 +1,27 @@
+module Mirah
+  module JVM
+    module Types
+      class NullType < Type
+        def initialize
+          super(BiteScript::ASM::ClassMirror.load('java.lang.Object'))
+        end
+
+        def to_s
+          "Type(null)"
+        end
+
+        def null?
+          true
+        end
+
+        def compatible?(other)
+          !other.primitive?
+        end
+
+        def assignable_from?(other)
+          !other.primitive?
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+module Mirah
+  module JVM
+    module Types
+      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
+    end
+  end
+end

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

@@ -0,0 +1,266 @@
+# Copyright (c) 2010 The Mirah project authors. All Rights Reserved.
+# All contributing project authors may be found in the NOTICE file.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require 'jruby'
+require 'set'
+require 'bitescript'
+module Mirah::JVM::Types
+  class JavaSourceMirror
+    begin
+      java_import 'javax.tools.ToolProvider'
+      java_import 'java.util.Arrays'
+      java_import 'javax.tools.SimpleJavaFileObject'
+      java_import 'javax.tools.JavaFileObject'
+      java_import 'java.net.URI'
+      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'
+    rescue
+    end
+
+    if defined?(JavacElements)
+      class FakeJavaFile < SimpleJavaFileObject
+        def initialize(package, name, kind='class')
+          package ||= ''
+          super(URI.create(FakeJavaFile.build_uri(package, name)), JavaFileObject::Kind::SOURCE)
+          @code = ''
+          if package != ""
+            @code << "package #{package};\n"
+          end
+          @code << "@org.mirah.infer.FakeClass\n"
+          @code << "public #{kind} #{name} { }"
+        end
+
+        def self.build_uri(package, name)
+          name = name.tr('.', '$')
+          package = package.tr('.', '/')
+          package << '/' unless "" == package
+          "string:///#{package}#{name}#{JavaFileObject::Kind::SOURCE.extension}"
+        end
+
+        def getCharContent(ignoreEncodingErrors)
+          java.lang.String.new(@code)
+        end
+      end
+
+      class JavaSourceParser < ElementScanner6
+        include AnnotationValueVisitor
+
+        # TODO support generics
+        def initialize(file, type_factory)
+          super()
+          @file = file
+          @type_factory = type_factory
+          @mirrors = []
+        end
+
+        def parse
+          tools = ToolProvider.system_java_compiler
+          units = [get_java_file(tools)] + get_fake_files
+          @javac = tools.get_task(nil, nil, nil, classpath, nil, units)
+          @element_utils = JavacElements.instance(@javac.context)
+          elements = @javac.enter
+          elements.each {|elem| scan(elem)}
+          @mirrors
+        end
+
+        def classpath
+          [
+            '-classpath',
+            $CLASSPATH.to_a.join(java.io.File.pathSeparator)
+          ]
+        end
+
+        def get_java_file(tools)
+          fm = tools.get_standard_file_manager(nil, nil, nil)
+          fm.get_java_file_objects(@file).to_a[0]
+        end
+
+        def get_fake_files
+          mirah_typedefs = Set.new(@type_factory.known_types.values.reject {|t| !t.kind_of?(TypeDefinition)})
+          files = [FakeJavaFile.new('org.mirah.infer', 'FakeClass', '@interface')]
+          mirah_typedefs.each do |typedef|
+            typedef.name =~ /^(?:(.+)\.)?([^.]+)$/
+            package, name = $1, $2
+            kind = if typedef.interface?
+              'interface'
+            else
+              'class'
+            end
+            files << FakeJavaFile.new(package, name, kind)
+          end
+          files
+        end
+
+        def visitType(elem, arg)
+          return anno_visitType(elem, arg) if elem.kind_of?(TypeMirror)
+          if elem.annotation_mirrors.any? {|a| a.toString == '@org.mirah.infer.FakeClass'}
+            return
+          end
+          superclass = internal_type_name(elem.superclass) || 'java/lang/Object'
+          interfaces = elem.interfaces.map {|i| internal_type_name(i)}
+          flags = flags_from_modifiers(elem)
+          builder = BiteScript::ASM::ClassMirror::Builder.new
+          builder.visit(0, flags, internal_name(elem), nil, superclass, interfaces)
+          with(builder) do
+            elem.annotation_mirrors.each {|anno| visitAnnotation(anno)}
+            super(elem, arg)
+          end
+          @mirrors << builder.mirror
+          builder.mirror
+        end
+
+        def visitVariable(field, arg)
+          flags = flags_from_modifiers(field)
+          type = type_desc(field.as_type)
+          fbuilder = @current.visitField(
+            flags, field.simple_name, type, nil, field.constant_value)
+          with fbuilder do
+            field.annotation_mirrors.each {|anno| visitAnnotation(anno)}
+          end
+        end
+
+        def visitExecutable(method, arg)
+          # TODO varags
+          flags = flags_from_modifiers(method)
+          exceptions = method.thrown_types.map {|t| internal_type_name(t)}
+          desc = type_desc(method.as_type)
+          mbuilder = @current.visitMethod(flags, method.simple_name, desc, nil, exceptions)
+          with mbuilder do
+            method.annotation_mirrors.each {|anno| visitAnnotation(anno)}
+          end
+        end
+
+        def visitAnnotation(elem, arg=nil)
+          desc = type_desc(elem.annotation_type)
+          if arg.nil?
+            anno = @current.visitAnnotation(desc, 0)
+          else
+            builder, name = arg
+            anno = builder.visitAnnotation(name, desc)
+          end
+          elem.element_values.each do |method, value|
+            name = method.simple_name
+            visit(value, [anno, name])
+          end
+        end
+
+        # AnnotationValueVisitor
+        def visitArray(values, arg)
+          anno, name = arg
+          array = anno.visitArray(name)
+          values.each do |value|
+            visit(value, [array, name])
+          end
+        end
+
+        def visitBoolean(val, arg)
+          anno, name = arg
+          anno.visit(name, val)
+        end
+        alias visitByte visitBoolean
+        alias visitChar visitBoolean
+        alias visitDouble visitBoolean
+        alias visitFloat visitBoolean
+        alias visitInt visitBoolean
+        alias visitLong visitBoolean
+        alias visitShort visitBoolean
+        alias visitString visitBoolean
+        alias visitUnknown visitBoolean
+
+        def visitEnumConstant(c, arg)
+          anno, name = arg
+          anno.visitEnum(name, type_desc(c.as_type), c.simple_name)
+        end
+
+        def anno_visitType(t, arg)
+          anno, name = arg
+          anno.visit(name, BiteScript::ASM::Type.getType(type_desc(t)))
+        end
+
+        def with(elem)
+          saved, @current = @current, elem
+          begin
+            yield
+          ensure
+            @current = saved
+          end
+        end
+
+        def flags_from_modifiers(elem)
+          flags = 0
+          elem.modifiers.each do |modifier|
+            flags |= BiteScript::ASM::Opcodes.const_get("ACC_#{modifier.name}")
+          end
+          flags
+        end
+
+        def internal_name(element)
+          @element_utils.get_binary_name(element).to_s.tr('.', '/')
+        end
+
+        def internal_type_name(type)
+          return nil if type.kind == TypeKind::NONE
+          return @element_utils.get_binary_name(type.as_element).to_s.tr('.', '/')
+        end
+
+        def type_desc(type)
+          case type.kind.name
+          when 'ARRAY'
+            "[#{type_desc(type.component_type)}"
+          when 'BOOLEAN'
+            'Z'
+          when 'BYTE'
+            'B'
+          when 'CHAR'
+            'C'
+          when 'DECLARED'
+            name = internal_type_name(type)
+            "L#{name};"
+          when 'DOUBLE'
+            'D'
+          when 'FLOAT'
+            'F'
+          when 'INT'
+            'I'
+          when 'LONG'
+            'J'
+          when 'SHORT'
+            'S'
+          when 'VOID'
+            'V'
+          when 'EXECUTABLE'
+            desc = '('
+            type.parameter_types.each do |param|
+              desc << type_desc(param)
+            end
+            desc << ')'
+            desc << type_desc(type.return_type)
+          else
+            raise ArgumentError, "Unsupported type #{type.kind.name}"
+          end
+        end
+      end
+    end
+
+    def self.load(file, factory)
+      parser = JavaSourceParser.new(file, factory)
+      parser.parse
+    end
+  end
+end