mirah 0.0.4-java

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

@@ -0,0 +1,143 @@
+module Duby::JVM::Types
+  class ComparisonIntrinsic < Intrinsic
+    attr_reader :name, :op
+    def initialize(type, name, op, args)
+      super(type, name, args, Boolean) do; end
+      @type = type
+      @op = op
+    end
+
+    def call(compiler, call, expression)
+      if expression
+        @type.compile_boolean_operator(compiler, op, false, call, nil)
+      end
+    end
+
+    def jump_if(compiler, call, label)
+      @type.compile_boolean_operator(compiler, @op, false, call, label)
+    end
+
+    def jump_if_not(compiler, call, label)
+      @type.compile_boolean_operator(compiler, @op, true, call, label)
+    end
+  end
+
+  class Number < PrimitiveType
+    # 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)
+      args = [type]
+      delegate = type.intrinsics[name][args]
+      if delegate.kind_of?(ComparisonIntrinsic)
+        add_method(name, args, ComparisonIntrinsic.new(type, name, delegate.op, args))
+      else
+        add_method(name, args, return_type) do |compiler, call, expression|
+          if expression
+            delegate.call(compiler, call, expression)
+          end
+        end
+      end
+    end
+    
+    def add_delegates(name, return_type = nil)
+      index = TYPE_ORDERING.index(math_type)
+      larger_types = TYPE_ORDERING[index + 1, TYPE_ORDERING.size]
+      larger_types.each do |type|
+        delegate_intrinsic(name, type, return_type || type)
+      end
+    end
+
+    # if_cmpxx for non-ints
+    def jump_if(builder, op, label)
+      builder.send "#{prefix}cmp#{suffix}"
+      builder.send "if#{op}", label
+    end
+
+    def boolean_operator(name, op)
+      args = [math_type]
+      add_method(name, args, ComparisonIntrinsic.new(self, name, op, args))
+      add_delegates(name, Boolean)
+    end
+
+    def invert_op(op)
+      inverted = {
+        :lt => :ge,
+        :le => :gt,
+        :eq => :ne,
+        :ne => :eq,
+        :gt => :le,
+        :ge => :lt
+      }[op]
+      raise "Can't invert #{op}." unless inverted
+      inverted
+    end
+
+    def compile_boolean_operator(compiler, op, negated, call, label)
+      # Promote the target or the argument if necessary
+      convert_args(compiler,
+                   [call.target, *call.parameters],
+                   [math_type, math_type])
+      if negated
+        op = invert_op(op)
+      end
+      if label
+        jump_if(compiler.method, op, label)
+      else
+        compiler.method.op_to_bool do |label|
+          jump_if(compiler.method, op, label)
+        end
+      end
+    end
+
+    def math_operator(name, op)
+      add_method(name, [math_type], math_type) do |compiler, call, expression|
+        if expression
+          # Promote the target or the argument if necessary
+          convert_args(compiler,
+                       [call.target, *call.parameters],
+                       [math_type, math_type])
+          compiler.method.send "#{prefix}#{op}"
+        end
+      end
+      add_delegates(name)
+    end
+
+    def unary_operator(name, op)
+      add_method(name, [], math_type) do |compiler, call, expression|
+        if expression
+          call.target.compile(compiler, true)
+          compiler.method.send("#{prefix}#{op}") if op
+        end
+      end
+    end
+
+    def add_intrinsics
+      boolean_operator('<', :lt)
+      boolean_operator('<=', :le)
+      boolean_operator('==', :eq)
+      boolean_operator('!=', :ne)
+      boolean_operator('>=', :ge)
+      boolean_operator('>', :gt)
+      math_operator('+', :add)
+      math_operator('-', :sub)
+      math_operator('*', :mul)
+      math_operator('/', :div)
+      math_operator('%', :rem)
+      unary_operator('-@', :neg)
+      unary_operator('+@', nil)
+    end
+
+    def box(builder)
+      builder.invokestatic box_type, "valueOf", [box_type, math_type]
+    end
+  end
+end

data/lib/mirah/nbcompiler.rb

@@ -0,0 +1,29 @@
+require 'mirah'
+module Duby
+  class NbCompiler
+    include org.mirah.DubyCompiler
+
+    class ParseResult
+      ParseError = org.mirah.ParseError
+
+      include org.mirah.ParseResult
+
+      attr_reader :ast, :errors
+      def initialize(ast, errors)
+        @ast = ast
+        parse_errors = errors.map do |error|
+          ParseError.new(error.message, error.position)
+        end
+        @errors = parse_errors.to_java(ParseError)
+      end
+    end
+
+    def parse(text)
+      Duby::AST.type_factory = Duby::JVM::Types::TypeFactory.new
+      ast = Duby::AST.parse_ruby(text)
+      transformer = Duby::Transform::Transformer.new(Duby::CompilationState.new)
+      return ParseResult.new(
+          transformer.transform(ast, nil), transformer.errors)
+    end
+  end
+end

data/lib/mirah/plugin/edb.rb

@@ -0,0 +1,29 @@
+require 'erb'
+
+Duby::AST.defmacro('def_edb') do |transformer, fcall, parent|
+  name = fcall.parameters[0].name
+  path = fcall.parameters[1].literal
+  compiler = ERB::Compiler.new(nil)
+  compiler.put_cmd = "_edbout.append"
+  compiler.insert_cmd = "__edb_insert__ _edbout.append"
+  compiler.pre_cmd = ["def #{name}", "_edbout = StringBuilder.new"]
+  compiler.post_cmd = ["_edbout.toString", "end"]
+  src = compiler.compile(IO.read(path))
+  ast = Duby::AST.parse_ruby(src, path)
+  transformer.filename = path
+  script = transformer.transform(ast, parent)
+  script.body.parent = parent
+  script.body
+end
+
+Duby::AST.defmacro('__edb_insert__') do |transformer, fcall, parent|
+  # ERB sticks in a .to_s that we don't want.
+  # the ast is __edb_insert__(_edbout.append(content.to_s))
+  append = fcall.parameters[0]
+  content = append.parameters[0].target
+  content.parent = append
+  append.parameters = [content]
+  append.parent = parent
+  append
+end
+

data/lib/mirah/plugin/gwt.rb

@@ -0,0 +1,173 @@
+require 'mirah/jvm/source_generator/builder'
+
+module Duby::JavaSource
+  class ClassBuilder
+    def build_jsni_method(name, visibility, static, exceptions, type, *args)
+      finish_declaration
+      type ||= Duby::AST.type(nil, :void)
+      @methods << JsniMethodBuilder.new(self,
+        :name => name,
+        :visibility => visibility,
+        :static => static,
+        :return => type,
+        :args => args,
+        :exceptions => exceptions)
+      @methods[-1]
+    end
+  end
+
+  class JsniMethodBuilder < MethodBuilder
+    include Helper
+
+    attr_accessor :name, :type, :out
+
+    def initialize(cls, options)
+      super(cls, options)
+    end
+
+    # Based on superclass's method.
+    def start
+      print "public#{@static} native #{@typename} #{@name}("
+      @args.each_with_index do |(type, name), i|
+        print ', ' unless i == 0
+        print "#{type.to_source} #{name}"
+      end
+      print ')'
+      unless @exceptions.empty?
+        print ' throws '
+        @exceptions.each_with_index do |exception, i|
+          print ', ' unless i == 0
+          print exception.name
+        end
+      end
+      puts ' /*-{'
+    end
+
+    # Based on superclass's method.
+    def stop
+      puts '}-*/;'
+    end
+  end
+end
+
+module Duby::Compiler
+  class JVMCompilerBase
+    # arg_types must be an Array
+    def create_method_builder(name, node, static, exceptions, return_type, arg_types)
+      unless node.class == Duby::AST::JsniMethodDefinition
+        @class.build_method(name.to_s, node.visibility, static,
+          exceptions, return_type, *arg_types)
+      else
+        @class.build_jsni_method(name.to_s, node.visibility, static,
+          exceptions, return_type, *arg_types)
+      end
+    end
+  end
+
+  class JavaSource < JVMCompilerBase
+    def define_jsni_method(node)
+      base_define_method(node, false) do |method, arg_types|
+        with :method => method do
+          log "Starting new JSNI method #{node.name}"
+          @method.start
+
+          @method.puts node.body.literal.chomp
+
+          log "JSNI method #{node.name} complete!"
+          @method.stop
+        end
+      end
+    end
+  end
+end
+
+module Duby::AST
+  class JsniMethodDefinition < MethodDefinition
+    def initialize(static, parent, line_number, name, annotations=[], &block)
+      super(parent, line_number, name, annotations, &block)
+      @static = static
+    end
+
+    def compile(compiler, expression)
+      compiler.define_jsni_method(self)
+    end
+
+    def infer(typer)
+      @static ||= scope.static_scope.self_type.meta? unless scope.nil?
+      @defining_class ||= begin
+        static_scope.self_type = if static?
+          scope.static_scope.self_type.meta
+        else
+          scope.static_scope.self_type
+        end
+      end
+      resolve_if(typer) do
+        argument_types = typer.infer(arguments)
+        if argument_types.all?
+          typer.learn_method_type(defining_class, name, argument_types,
+            signature[:return], signature[:throws])
+        end
+      end
+    end
+
+    # JSNI can't be abstract.
+    def abstract?
+      false
+    end
+
+    def static?
+      @static
+    end
+  end
+
+  defmacro 'def_jsni' do |transformer, fcall, parent|
+    args = fcall.parameters
+
+    unless args.size == 3
+      raise "def_jsni must have 3 arguments."
+    end
+
+    call_node = args[1]
+    if Self === call_node.target
+      is_static = true
+    end
+
+    JsniMethodDefinition.new(is_static,
+      parent,
+      fcall.position,
+      call_node.name,
+      transformer.annotations) do |defn|
+
+      signature = {:return => Duby::AST.type(nil, args[0].name)}
+      method = call_node.parameters[0]
+
+      unless method.nil?
+        hash_node = method.parameters[0]
+
+        args = Arguments.new(defn, defn.position) do |args_new|
+          arg_list = []
+          hash_node.child_nodes.each_slice(2) do |name, type|
+            position = name.position + type.position
+            name = name.literal
+            type = Duby::AST.type(nil, type.name)
+            signature[name.intern] = type
+            arg_list.push(RequiredArgument.new(args_new, position, name))
+          end
+          [arg_list, nil, nil, nil]
+        end
+      else
+        args = Arguments.new(defn, defn.position) do |args_new|
+          [nil, nil, nil, nil]
+        end
+      end
+
+      body_node = fcall.parameters[-1]
+
+      [
+        signature,
+        args,
+        body_node
+      ]
+    end
+  end
+end

data/lib/mirah/plugin/java.rb

@@ -0,0 +1,55 @@
+require 'mirah/typer'
+require 'mirah/jvm/method_lookup'
+require 'mirah/jvm/types'
+require 'java'
+
+module Duby
+  module Typer
+    class JavaTyper < BaseTyper
+      include Duby::JVM::MethodLookup
+      include Duby::JVM::Types
+      
+      def initialize
+      end
+      
+      def name
+        "Java"
+      end
+      
+      def method_type(typer, target_type, name, parameter_types)
+        return if target_type.nil? or parameter_types.any? {|t| t.nil?}
+        if target_type.respond_to? :get_method
+          method = target_type.get_method(name, parameter_types)
+          unless method || target_type.basic_type.kind_of?(TypeDefinition)
+            raise NoMethodError, "Cannot find %s method %s(%s) on %s" %
+                [ target_type.meta? ? "static" : "instance",
+                  name,
+                  parameter_types.map{|t| t.full_name}.join(', '),
+                  target_type.full_name
+                ]
+          end
+          if method
+            result = method.return_type
+          elsif typer.last_chance && target_type.meta? &&
+              name == 'new' && parameter_types == []
+            unmeta = target_type.unmeta
+            if unmeta.respond_to?(:default_constructor)
+              result = unmeta.default_constructor
+              typer.last_chance = false if result
+            end
+          end
+        end
+
+        if result
+          log "Method type for \"#{name}\" #{parameter_types} on #{target_type} = #{result}"
+        else
+          log "Method type for \"#{name}\" #{parameter_types} on #{target_type} not found"
+        end
+
+        result
+      end
+    end
+  end
+
+  typer_plugins << Typer::JavaTyper.new
+end

data/lib/mirah/transform.rb

@@ -0,0 +1,266 @@
+require 'base64'
+require 'jruby'
+
+module Duby
+  module Transform
+    class Error < StandardError
+      attr_reader :position, :cause
+      def initialize(msg, position, cause=nil)
+        super(msg)
+        @position = position
+        @position = position.position if position.respond_to? :position
+        @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 = Duby::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
+        Duby::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 = Duby::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?(Duby::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
+          Duby::AST::ErrorNode.new(parent, ex)
+        rescue Exception => ex
+          error = Error.new(ex.message, position(node), ex)
+          @errors << error
+          Duby::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 = Duby::AST.parse_ruby(src, filename)
+        duby_node = transform(node, nil).body
+        duby_node.parent = parent
+        duby_node
+      end
+
+      def dump_ast(node)
+        encoded = nil
+        values = Duby::AST::Unquote.extract_values do
+          encoded = Base64.encode64(Marshal.dump(node))
+        end
+        result = Duby::AST::Array.new(nil, node.position)
+        result << Duby::AST::String.new(result, node.position, encoded)
+        values.each {|value| result << value}
+        return result
+      end
+
+      def load_ast(args)
+        nodes = args.to_a
+        encoded = nodes.shift
+        Duby::AST::Unquote.inject_values(nodes) do
+          result = Marshal.load(Base64.decode64(encoded))
+          if Duby::AST::UnquotedValue === result
+            result.node
+          else
+            result
+          end
+        end
+      end
+
+      def __ruby_eval(code, arg)
+        Kernel.eval(code)
+      end
+
+      def fixnum(value)
+        node = eval("1")
+        node.literal = value
+        node
+      end
+
+      def constant(name)
+        node = eval("Foo")
+        node.name = name
+        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 Duby::AST::ClassDefinition.new(@extra_body, position, name, &block)
+      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(Duby::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 = Duby::Transform::Transformer::JMetaPosition.new(jpos, jpos)
+            print "#{message} at "
+            Duby.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(Duby::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
+          Duby.print_error(ex.cause.message, position)
+        end
+        raise ex
+      end
+    end
+    module_function :parse_ruby
+  end
+end
+require 'mirah/transform2'