mirah 0.0.7-java → 0.0.8-java

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

@@ -0,0 +1,173 @@
+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::JVM::Compiler::JVMBytecode.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?
+          # FIXME: Don't do rescue nil. Figure out a cleaner way to handle
+          # 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 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
+    end
+  end
+end

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

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

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

@@ -0,0 +1,27 @@
+module Mirah
+  module JVM
+    module Types
+      class UnreachableType < Type
+        def initialize
+          super('java.lang.Object')
+        end
+
+        def to_s
+          "Type(null)"
+        end
+
+        def unreachable?
+          true
+        end
+
+        def compatible?(other)
+          true
+        end
+
+        def assignable_from?(other)
+          true
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+module Mirah
+  module JVM
+    module Types
+      class VoidType < PrimitiveType
+        def initialize
+          super('void', Java::JavaLang::Void)
+        end
+
+        def void?
+          true
+        end
+
+        def return(builder)
+          builder.returnvoid
+        end
+      end
+    end
+  end
+end

data/lib/mirah/parser.rb

@@ -0,0 +1,90 @@
+# 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 'mirah/util/process_errors'
+require 'mirah/transform'
+require 'java'
+
+module Mirah
+  class Parser
+    include Mirah::Util::ProcessErrors
+    
+    def initialize(state, logging)
+      @transformer = Mirah::Transform::Transformer.new(state)
+      Java::MirahImpl::Builtin.initialize_builtins(@transformer)
+      @logging = logging
+      @verbose = state.verbose
+    end
+    
+    attr_accessor :transformer, :logging
+    
+    def parse_from_args(files_or_scripts)
+      nodes = []
+      inline = false
+      puts "Parsing..." if logging
+      expand_files(files_or_scripts).each do |script|
+        if script == '-e'
+          inline = true
+          next
+        elsif inline
+          nodes << parse_inline(script)
+          break
+        else
+          nodes << parse_file(script)
+        end
+      end
+      raise 'nothing to parse? ' + files_or_scripts.inspect unless nodes.length > 0
+      nodes
+    end
+    
+    def parse_inline(source)
+      puts "  <inline script>" if logging
+      parse_and_transform('DashE', source)
+    end
+    
+    def parse_file(filename)
+      puts "  #{filename}" if logging
+      parse_and_transform(filename, File.read(filename))
+    end
+    
+    def parse_and_transform(filename, src)
+      parser_ast = Mirah::AST.parse_ruby(src, filename)
+      
+      transformer.filename = filename
+      mirah_ast = transformer.transform(parser_ast, nil)
+      process_errors(transformer.errors)
+      
+      mirah_ast
+    end
+      
+    def expand_files(files_or_scripts)
+      expanded = []
+      files_or_scripts.each do |filename|
+        if File.directory?(filename)
+          Dir[File.join(filename, '*')].each do |child|
+            if File.directory?(child)
+              files_or_scripts << child
+            elsif child =~ /\.(duby|mirah)$/
+              expanded << child
+            end
+          end
+        else
+          expanded << filename
+        end
+      end
+      expanded
+    end
+  end
+end

data/lib/mirah/plugin/gwt.rb

@@ -65,13 +65,13 @@ module Mirah::JavaSource
   end
 end
 
-module Mirah::Compiler
-  class JVMCompilerBase
+module Mirah::JVM::Compiler
+  class Base
+    alias :original_create_method_builder :create_method_builder
     # arg_types must be an Array
     def create_method_builder(name, node, static, exceptions, return_type, arg_types)
       unless node.class == Mirah::AST::JsniMethodDefinition
-        @class.build_method(name.to_s, node.visibility, static,
-          exceptions, return_type, *arg_types)
+        original_create_method_builder(name, node, static, exceptions, return_type, arg_types)
       else
         @class.build_jsni_method(name.to_s, node.visibility, static,
           exceptions, return_type, *arg_types)
@@ -79,7 +79,7 @@ module Mirah::Compiler
     end
   end
 
-  class JavaSource < JVMCompilerBase
+  class JavaSource < Base
     def define_jsni_method(node)
       base_define_method(node, false) do |method, arg_types|
         with :method => method do

data/lib/mirah/plugin/java.rb

@@ -20,7 +20,7 @@ require 'java'
 
 module Mirah
   module Typer
-    class JavaTyper < BaseTyper
+    class JavaTyper < Base
       include Mirah::JVM::MethodLookup
       include Mirah::JVM::Types
       

data/lib/mirah/transform.rb

@@ -16,324 +16,7 @@
 require 'base64'
 require 'jruby'
 require 'mirah/errors'
-
-module Mirah
-  module Transform
-    class Error < Mirah::MirahError
-      attr_reader :position
-      def initialize(msg, position, cause=nil)
-        position = position.position if position.respond_to? :position
-        super(msg, position)
-        self.cause = cause
-      end
-    end
-
-    class Transformer
-      begin
-        include Java::DubyLangCompiler.Compiler
-      rescue NameError
-        $CLASSPATH << File.dirname(__FILE__) + '/../../javalib/mirah-bootstrap.jar'
-        include Java::DubyLangCompiler.Compiler
-      end
-
-      attr_reader :errors, :state
-      attr_accessor :filename
-      def initialize(state)
-        @errors = []
-        @tmp_count = 0
-        @annotations = []
-        @scopes = []
-        @extra_body = nil
-        @state = state
-        @helper = Mirah::AST::TransformHelper.new(self)
-      end
-
-      def destination
-        @state.destination
-      end
-
-      def verbose?
-        @state.verbose
-      end
-
-      def annotations
-        result, @annotations = @annotations, []
-        return result
-      end
-
-      def add_annotation(annotation)
-        @annotations << annotation
-        Mirah::AST::Noop.new(annotation.parent, annotation.position)
-      end
-
-      def tmp(format="__xform_tmp_%d")
-        format % [@tmp_count += 1]
-      end
-
-      class JMetaPosition
-        attr_accessor :start_line, :end_line, :start_offset, :end_offset, :file
-        attr_accessor :startpos, :endpos, :start_col, :end_col
-
-        def initialize(startpos, endpos)
-          @startpos = startpos
-          @endpos = endpos
-          @file = startpos.filename
-          @start_line = startpos.line
-          @start_offset = startpos.pos
-          @start_col = startpos.col
-          @end_line = endpos.line
-          @end_offset = endpos.pos
-          @end_col = endpos.col
-        end
-
-        def +(other)
-          JMetaPosition.new(@startpos, other.endpos)
-        end
-      end
-
-      def position(node)
-        JMetaPosition.new(node.start_position, node.end_position)
-      end
-
-      def camelize(name)
-        name.gsub(/([a-z])([A-Z])/, '\1_\2').downcase
-      end
-
-      def transform(node, parent)
-        begin
-          top = @extra_body.nil?
-          if top
-            @extra_body = Mirah::AST::Body.new(nil, position(node))
-          end
-          method = "transform_#{camelize(node[0])}"
-          result = @helper.send method, node, parent
-          if top
-            body = result.body
-            if body.kind_of?(Mirah::AST::Body) && @extra_body.empty?
-              @extra_body = body
-            else
-              result.body = @extra_body
-              body.parent = @extra_body
-              @extra_body.children.insert(0, body)
-            end
-          end
-          return result
-        rescue Error => ex
-          @errors << ex
-          Mirah::AST::ErrorNode.new(parent, ex)
-        rescue Exception => ex
-          error = Error.new(ex.message, position(node), ex)
-          @errors << error
-          Mirah::AST::ErrorNode.new(parent, error)
-        end
-      end
-
-      def captured?(node)
-        depth = node.depth
-        scope = @scopes[-1]
-        while depth > 0
-          depth -= 1
-          scope = scope.enclosing_scope
-        end
-        scope.isCaptured(node.index)
-      end
-
-      def eval(src, filename='-', parent=nil, *vars)
-        node = Mirah::AST.parse_ruby(src, filename)
-        duby_node = transform(node, nil).body
-        duby_node.parent = parent
-        duby_node
-      end
-
-      def dump_ast(node, call=nil)
-        encoded = nil
-        values = Mirah::AST::Unquote.extract_values do
-          encoded = Base64.encode64(Marshal.dump(node))
-        end
-        scope = call.scope.static_scope if call
-        result = Mirah::AST::Array.new(nil, node.position)
-        if encoded.size < 65535
-          result << Mirah::AST::String.new(result, node.position, encoded)
-        else
-          strings = Mirah::AST::StringConcat.new(result, node.position)
-          result << strings
-          while encoded.size >= 65535
-            chunk = encoded[0, 65535]
-            encoded[0, 65535] = ""
-            strings << Mirah::AST::String.new(strings, node.position, chunk)
-          end
-          strings << Mirah::AST::String.new(strings, node.position, encoded)
-        end
-        values.each do |value|
-          if call
-            scoped_value = Mirah::AST::ScopedBody.new(result, value.position)
-            scoped_value << value
-            scoped_value.static_scope = scope
-          else
-            scoped_value = value
-          end
-          result << scoped_value
-        end
-        return result
-      end
-
-      def load_ast(args)
-        nodes = args.to_a
-        encoded = nodes.shift
-        Mirah::AST::Unquote.inject_values(nodes) do
-          result = Marshal.load(Base64.decode64(encoded))
-          if Mirah::AST::UnquotedValue === result
-            result.node
-          else
-            result
-          end
-        end
-      end
-
-      def __ruby_eval(code, arg)
-        self.instance_eval(code)
-      end
-
-      def fixnum(value)
-        node = eval("1")
-        node.literal = value
-        node
-      end
-
-      def constant(name, array=false)
-        node = eval("Foo")
-        node.name = name
-        node.array = array
-        node
-      end
-
-      def cast(type, value)
-        if value.kind_of?(String)
-          value = Mirah::AST::Local.new(@extra_body, @extra_body.position, value)
-        end
-        fcall = eval("Foo()")
-        fcall.name = type
-        fcall.parameters = [value]
-        fcall
-      end
-
-      def string(value)
-        node = eval('"Foo"')
-        node.literal = value
-        node
-      end
-
-      def empty_array(type_node, size_node)
-        node = eval('int[0]')
-        node.type_node = type_node
-        node.size = size_node
-        node
-      end
-
-      def find_class(name)
-        AST.type(nil, name, false, false)
-      end
-
-      def expand(fvcall, parent)
-        result = yield self, fvcall, parent
-        unless AST::Node === result
-          raise Error.new('Invalid macro result', fvcall.position)
-        end
-        result
-      end
-
-      def append_node(node)
-        @extra_body << node
-        node
-      end
-
-      def define_class(position, name, &block)
-        append_node Mirah::AST::ClassDefinition.new(@extra_body, position, name, &block)
-      end
-
-      def defineClass(name, superclass=nil)
-        define_class(@extra_body.position, name) do |class_def|
-          superclass = constant(superclass)
-          superclass.parent = class_def
-          [superclass, body(class_def)]
-        end
-      end
-
-      def body(parent=nil)
-        parent ||= @extra_body
-        Mirah::AST::Body.new(parent, parent.position)
-      end
-
-      def define_closure(position, name, enclosing_type)
-        target = self
-        parent = @extra_body
-        enclosing_type = enclosing_type.unmeta
-        if enclosing_type.respond_to?(:node) && enclosing_type.node
-          parent = target = enclosing_type.node
-        end
-        target.append_node(Mirah::AST::ClosureDefinition.new(
-            parent, position, name, enclosing_type))
-      end
-    end
-  end
-  TransformError = Transform::Error
-
-  module AST
-    begin
-      java_import 'mirah.impl.MirahParser'
-    rescue NameError
-      $CLASSPATH << File.dirname(__FILE__) + '/../../javalib/mirah-parser.jar'
-      java_import 'mirah.impl.MirahParser'
-    end
-    java_import 'jmeta.ErrorHandler'
-
-    class MirahErrorHandler
-      include ErrorHandler
-      def warning(messages, positions)
-        print "Warning: "
-        messages.each_with_index do |message, i|
-          jpos = positions[i]
-          if jpos
-            dpos = Mirah::Transform::Transformer::JMetaPosition.new(jpos, jpos)
-            print "#{message} at "
-            Mirah.print_error("", dpos)
-          else
-            print message
-          end
-        end
-      end
-    end
-
-    def parse(src, filename='dash_e', raise_errors=false, transformer=nil)
-      ast = parse_ruby(src, filename)
-      transformer ||= Transform::Transformer.new(Mirah::CompilationState.new)
-      transformer.filename = filename
-      ast = transformer.transform(ast, nil)
-      if raise_errors
-        transformer.errors.each do |e|
-          raise e.cause || e
-        end
-      end
-      ast
-    end
-    module_function :parse
-
-    def parse_ruby(src, filename='-')
-      raise ArgumentError if src.nil?
-      parser = MirahParser.new
-      parser.filename = filename
-      parser.errorHandler = MirahErrorHandler.new
-      begin
-        parser.parse(src)
-      rescue => ex
-        if ex.cause.respond_to? :position
-          position = ex.cause.position
-          Mirah.print_error(ex.cause.message, position)
-        end
-        raise ex
-      end
-    end
-    module_function :parse_ruby
-  end
-end
-require 'mirah/transform2'
+require 'mirah/transform/error'
+require 'mirah/transform/transformer'
+require 'mirah/transform/ast_ext'
+require 'mirah/transform/helper'