mirah 0.0.7-java → 0.0.8-java

data/lib/mirah/jvm/base.rb

@@ -1,267 +0,0 @@
-# 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.
-
-module Mirah
-  module Compiler
-    class JVMCompilerBase
-      attr_accessor :filename, :method, :static, :class
-
-      class CompilationError < Mirah::NodeError
-      end
-
-      def initialize
-        @jump_scope = []
-        @bindings = Hash.new {|h, type| h[type] = type.define(@file)}
-        @captured_locals = Hash.new {|h, binding| h[binding] = {}}
-        @self_scope = nil
-      end
-
-      def error(message, node)
-        raise CompilationError.new(message, node)
-      end
-
-      def compile(ast, expression = false)
-        begin
-          ast.compile(self, expression)
-        rescue => ex
-          raise Mirah::InternalCompilerError.wrap(ex, ast)
-        end
-        log "Compilation successful!"
-      end
-
-      def log(message); JVM.log(message); end
-
-      def toplevel_class
-        @class = @type.define(@file)
-      end
-
-      def generate
-        log "Generating #{output_type}..."
-        @file.generate do |filename, builder|
-          log "  #{builder.class_name}"
-          if block_given?
-            yield filename, builder
-          else
-            File.open(filename, 'wb') {|f| f.write(builder.generate)}
-          end
-        end
-        log "...done!"
-      end
-
-      def define_main(script)
-        @static = true
-        @filename = File.basename(script.filename)
-        classname = JVM.classname_from_filename(@filename)
-        @type = AST.type(script, classname)
-        @file = file_builder(@filename)
-        body = script.body
-        body = body[0] if body.children.size == 1
-        if body.class != AST::ClassDefinition
-          @class = @type.define(@file)
-          with :method => @class.main do
-            log "Starting main method"
-
-            @method.start
-            @current_scope = script.static_scope
-            declare_locals(@current_scope)
-            begin_main
-
-            prepare_binding(script) do
-              body.compile(self, false)
-            end
-
-            finish_main
-            @method.stop
-          end
-          @class.stop
-        else
-          body.compile(self, false)
-        end
-
-        log "Main method complete!"
-      end
-
-      def begin_main; end
-      def finish_main; end
-
-      # arg_types must be an Array
-      def create_method_builder(name, node, static, exceptions, return_type, arg_types)
-        @class.build_method(name.to_s, node.visibility, static,
-          exceptions, return_type, *arg_types)
-      end
-
-      def base_define_method(node, args_are_types)
-        name, signature, args = node.name, node.signature, node.arguments.args
-        if name == "initialize" && node.static?
-          name = "<clinit>"
-        end
-        if args_are_types
-          arg_types = args.map { |arg| arg.inferred_type } if args
-        else
-          arg_types = args
-        end
-        arg_types ||= []
-        return_type = signature[:return]
-        exceptions = signature[:throws]
-
-        with :static => @static || node.static?, :current_scope => node.static_scope do
-          method = create_method_builder(name, node, @static, exceptions,
-                                         return_type, arg_types)
-          annotate(method, node.annotations)
-          yield method, arg_types
-        end
-
-        arg_types_for_opt = []
-        args_for_opt = []
-        if args
-          args.each do |arg|
-            if AST::OptionalArgument === arg
-              new_args = if args_are_types
-                arg_types_for_opt
-              else
-                args_for_opt
-              end
-              method = create_method_builder(name, node, @static, exceptions,
-                                             return_type, new_args)
-              with :method => method do
-                log "Starting new method #{name}(#{arg_types_for_opt})"
-
-                annotate(method, node.annotations)
-                @method.start
-
-                define_optarg_chain(name, arg,
-                                    return_type,
-                                    args_for_opt,
-                                    arg_types_for_opt)
-
-                @method.stop
-              end
-            end
-            arg_types_for_opt << arg.inferred_type
-            args_for_opt << arg
-          end
-        end
-      end
-
-      def constructor(node, args_are_types)
-        args = node.arguments.args || []
-        arg_types = if args_are_types
-          args.map { |arg| arg.inferred_type }
-        else
-          args
-        end
-        exceptions = node.signature[:throws]
-        method = @class.build_constructor(node.visibility, exceptions, *arg_types)
-        annotate(method, node.annotations)
-        with :current_scope => node.static_scope do
-          yield(method, args)
-        end
-      end
-
-      def define_class(class_def, expression)
-        with(:type => class_def.inferred_type,
-             :class => class_def.inferred_type.define(@file),
-             :static => false) do
-          annotate(@class, class_def.annotations)
-          class_def.body.compile(self, false) if class_def.body
-          @class.stop
-        end
-      end
-
-      def declare_argument(name, type)
-        # declare local vars for arguments here
-      end
-
-      def body(body, expression)
-        saved_self = @self_scope
-        if body.kind_of?(Mirah::AST::ScopedBody)
-          scope = body.static_scope
-          declare_locals(scope)
-          if scope != @self_scope
-            if scope.self_node && scope.self_node != :self
-              # FIXME This is a horrible hack!
-              # Instead we should eliminate unused self's.
-              unless scope.self_type.name == 'mirah.impl.Builtin'
-                local_assign(
-                    scope, 'self', scope.self_type, false, scope.self_node)
-              end
-            end
-            @self_scope = scope
-          end
-        end
-        # all except the last element in a body of code is treated as a statement
-        i, last = 0, body.children.size - 1
-        while i < last
-          body.children[i].compile(self, false)
-          i += 1
-        end
-        yield body.children[last] if last >= 0
-        @self_scope = saved_self
-      end
-
-      def scoped_body(scope, expression)
-        body(scope, expression)
-      end
-
-      def scoped_local_name(name, scope=nil)
-        if scope.nil? || scope == @current_scope
-          name
-        else
-          "#{name}$#{scope.object_id}"
-        end
-      end
-
-      def import(short, long)
-      end
-
-      def fixnum(type, value)
-        type.literal(method, value)
-      end
-      alias float fixnum
-
-      def compile_self
-        if @self_scope && @self_scope.self_node && @self_scope.self_node != :self
-          local(@self_scope, 'self', @self_scope.self_type)
-        else
-          real_self
-        end
-      end
-
-      def get_binding(type)
-        @bindings[type]
-      end
-
-      def declared_captures(binding=nil)
-        @captured_locals[binding || @binding]
-      end
-
-      def with(vars)
-        orig_values = {}
-        begin
-          vars.each do |name, new_value|
-            name = "@#{name}"
-            orig_values[name] = instance_variable_get name
-            instance_variable_set name, new_value
-          end
-          yield
-        ensure
-          orig_values.each do |name, value|
-            instance_variable_set name, value
-          end
-        end
-      end
-    end
-  end
-end

data/lib/mirah/jvm/source_compiler.rb

@@ -1,760 +0,0 @@
-# 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'
-require 'mirah/ast'
-require 'mirah/jvm/types'
-require 'mirah/jvm/compiler'
-require 'mirah/jvm/source_generator/builder'
-require 'mirah/jvm/source_generator/precompile'
-require 'mirah/jvm/source_generator/loops'
-
-class String
-  def compile(compiler, expression)
-    compiler.method.print self if expression
-  end
-end
-
-module Mirah
-  module Compiler
-    class JavaSource < JVMCompilerBase
-      JVMTypes = Mirah::JVM::Types
-      attr_accessor :lvalue
-
-      Operators = [
-        '+', '-', '+@', '-@', '/', '%', '*', '<',
-        '<=', '==', '!=', '>=', '>',
-        '<<', '>>', '>>>', '|', '&', '^', '~'
-      ]
-      ArrayOps = [
-        '[]', '[]=', 'length'
-      ]
-
-      ImplicitReturn = Struct.new(:value)
-
-      def initialize
-        super
-      end
-
-      def file_builder(filename)
-        Mirah::JavaSource::Builder.new(filename, self)
-      end
-
-      def output_type
-        "source files"
-      end
-
-      def define_method(node)
-        base_define_method(node, false) do |method, _|
-          with :method => method do
-            log "Starting new method #{node.name}"
-            @method.start
-
-            prepare_binding(node) do
-              declare_locals(node.static_scope)
-              unless @method.type.nil? || @method.type.void?
-                self.return(ImplicitReturn.new(node.body))
-              else
-                node.body.compile(self, false) if node.body
-              end
-            end
-
-            log "Method #{node.name} complete!"
-            @method.stop
-          end
-        end
-      end
-
-      def annotate(node, annotations)
-        node.annotate(annotations)
-      end
-
-      def define_optarg_chain(name, arg, return_type,
-                              args_for_opt, arg_types_for_opt)
-        # declare all args so they get their values
-        @method.print "return " unless @method.type.nil? || @method.type.void?
-        @method.print "this." unless @static
-        @method.print "#{name}("
-        @method.print args_for_opt.map(&:name).join(', ')
-        @method.print ', 'if args_for_opt.size > 0
-        arg.value.compile(self, true)
-
-        # invoke the next one in the chain
-        @method.print ");\n"
-      end
-
-      def constructor(node)
-        super(node, false) do |method, _|
-          with :method => method do
-            @method.start
-            if node.delegate_args
-              delegate = if node.calls_super
-                "super"
-              else
-                "this"
-              end
-              method.print "#{delegate}("
-              node.delegate_args.each_with_index do |arg, index|
-                method.print ', ' unless index == 0
-                raise "Invalid constructor argument #{arg}" unless arg.expr?(self)
-                arg.compile(self, true)
-              end
-              method.puts ");"
-            end
-
-            prepare_binding(node) do
-              declare_locals(node.static_scope)
-              node.body.compile(self, false) if node.body
-            end
-            method.stop
-          end
-        end
-      end
-
-      def prepare_binding(scope)
-        if scope.has_binding?
-          type = scope.binding_type
-          @binding = @bindings[type]
-          @method.puts "#{type.to_source} $binding = new #{type.to_source}();"
-          if scope.respond_to? :arguments
-            scope.arguments.args.each do |param|
-              if scope.static_scope.captured?(param.name)
-                captured_local_declare(scope, param.name, param.inferred_type)
-                @method.puts "$binding.#{param.name} = #{param.name};"
-              end
-            end
-          end
-        end
-        begin
-          yield
-        ensure
-          if scope.has_binding?
-            @binding.stop
-            @binding = nil
-          end
-        end
-      end
-
-      def define_closure(class_def, expression)
-        compiler = ClosureCompiler.new(@file, @type, self)
-        compiler.define_class(class_def, expression)
-      end
-
-      def return(node)
-        if @method.type.nil? || @method.type.void?
-          @method.puts 'return;'
-          return
-        end
-        if node.value.expr?(self)
-          @method.print 'return '
-          node.value.compile(self, true)
-          @method.puts ';'
-        else
-          store_value('return ', node.value)
-        end
-      end
-
-      def _raise(node)
-        if node.expr?(self)
-          @method.print 'throw '
-          node.compile(self, true)
-          @method.puts ';'
-        else
-          store_value('throw ', node)
-        end
-      end
-
-      def rescue(node, expression)
-        @method.block 'try' do
-          maybe_store(node.body, expression)
-        end
-        node.clauses.each do |clause|
-          clause.types.each do |type|
-            name = scoped_local_name(clause.name || 'tmp$ex', clause.static_scope)
-            @method.declare_local(type, name, false)
-            @method.block "catch (#{type.to_source} #{name})" do
-              declare_locals(clause.static_scope)
-              maybe_store(clause.body, expression)
-            end
-          end
-        end
-      end
-
-      def ensure(node, expression)
-        @method.block 'try' do
-          maybe_store(node.body, expression)
-        end
-        @method.block 'finally' do
-          node.clause.compile(self, false)
-        end
-      end
-
-      def line(num)
-      end
-
-      def declare_local(name, type)
-        @method.declare_local(type, name)
-      end
-
-      def declare_field(name, type, annotations, static_field)
-        @class.declare_field(name, type, @static || static_field, 'private', annotations)
-      end
-
-      def local(scope, name, type)
-        name = scoped_local_name(name, scope)
-        @method.print name
-      end
-
-      def field(name, type, annotations, static_field)
-        name = name[1..-1] if name =~ /^@/
-        declare_field(name, type, annotations, static_field)
-        @method.print "#{this}.#{name}"
-      end
-
-      def this(method=nil)
-        if method && method.static?
-          method.declaring_class.name
-        elsif @self_scope && @self_scope.self_node && @self_scope.self_node != :self
-          scoped_local_name('self', @self_scope)
-        else
-          @static ? @class.class_name : 'this'
-        end
-      end
-
-      def declare_locals(scope)
-        scope.locals.each do |name|
-          full_name = scoped_local_name(name, scope)
-          unless scope.captured?(name) || method.local?(full_name)
-            declare_local(full_name, scope.local_type(name))
-          end
-        end
-      end
-
-      def local_assign(scope, name, type, expression, value)
-        simple = value.expr?(self)
-        value = value.precompile(self)
-        name = scoped_local_name(name, scope)
-        if method.local?(name)
-          if expression
-            if simple
-              @method.print '('
-            else
-              @method.print @lvalue
-            end
-          end
-          @method.print "#{name} = "
-          value.compile(self, true)
-          if simple && expression
-            @method.print ')'
-          else
-            @method.puts ';'
-          end
-        else
-          @method.declare_local(type, name) do
-            value.compile(self, true)
-          end
-          if expression
-            @method.puts "#{@lvalue}#{name};"
-          end
-        end
-      end
-
-      def field_declare(name, type, annotations)
-        name = name[1..-1] if name =~ /^@/
-        declare_field(name, type, annotations)
-      end
-
-      def local_declare(scope, name, type)
-        name = scoped_local_name(name, scope)
-        declare_local(name, type)
-      end
-
-      def field_assign(name, type, expression, value, annotations, static_field)
-        name = name[1..-1] if name =~ /^@/
-        declare_field(name, type, annotations, static_field)
-        lvalue = "#{@lvalue if expression}#{this}.#{name} = "
-        store_value(lvalue, value)
-      end
-
-      def captured_local_declare(scope, name, type)
-        unless declared_captures[name]
-          declared_captures[name] = type
-          @binding.declare_field(name, type, false, '')
-        end
-      end
-
-      def captured_local(scope, name, type)
-        captured_local_declare(scope, name, type)
-        @method.print "$binding.#{name}"
-      end
-
-      def captured_local_assign(node, expression)
-        scope, name, type = node.containing_scope, node.name, node.inferred_type
-        captured_local_declare(scope, name, type)
-        lvalue = "#{@lvalue if expression}$binding.#{name} = "
-        store_value(lvalue, node.value)
-      end
-
-      def store_value(lvalue, value)
-        if value.is_a? String
-          @method.puts "#{lvalue}#{value};"
-        elsif value.expr?(self)
-          @method.print lvalue
-          value.compile(self, true)
-          @method.puts ';'
-        else
-          with :lvalue => lvalue do
-            value.compile(self, true)
-          end
-        end
-      end
-
-      def assign(name, value)
-        store_value("#{name} = ", value)
-        name
-      end
-
-      def maybe_store(value, expression)
-        if expression
-          store_value(@lvalue, value)
-        else
-          value.compile(self, false)
-        end
-      end
-
-      def body(body, expression)
-        super(body, expression) do |last|
-          maybe_store(last, expression)
-        end
-      end
-
-      def scoped_body(scope, expression)
-        @method.block do
-          super
-        end
-      end
-
-      def branch_expression(node)
-        node.condition.compile(self, true)
-        @method.print ' ? ('
-        if node.body
-          node.body.compile(self, true)
-        else
-          @method.print @method.init_value(node.inferred_type)
-        end
-        @method.print ') : ('
-        if node.else
-          node.else.compile(self, true)
-        else
-          @method.print @method.init_value(node.inferred_type)
-        end
-        @method.print ')'
-      end
-
-      def branch(node, expression)
-        if expression && node.expr?(self)
-          return branch_expression(node)
-        end
-        predicate = node.condition.predicate.precompile(self)
-        @method.print 'if ('
-        predicate.compile(self, true)
-        @method.block ")" do
-          if node.body
-            maybe_store(node.body, expression)
-          elsif expression
-            store_value(@lvalue, @method.init_value(node.inferred_type))
-          end
-        end
-        if node.else || expression
-          @method.block 'else' do
-            if node.else
-              maybe_store(node.else, expression)
-            else
-              store_value(@lvalue, @method.init_value(node.inferred_type))
-            end
-          end
-        end
-      end
-
-      def loop(loop, expression)
-        if loop.redo? || loop.post || !loop.condition.predicate.expr?(self)
-          loop = ComplexWhileLoop.new(loop, self)
-        else
-          loop = SimpleWhileLoop.new(loop, self)
-        end
-        with(:loop => loop) do
-          loop.compile(expression)
-        end
-      end
-
-      def expr?(target, params)
-        !([target] + params).any? {|x| x.kind_of? Mirah::AST::TempValue}
-      end
-
-      def operator(target, op, params, expression)
-        simple = expr?(target, params)
-        if expression && !simple
-          @method.print @lvalue
-        end
-        if params.size == 0
-          # unary operator
-          op = op[0,1]
-          @method.print op
-          target.compile(self, true)
-        else
-          @method.print '('
-          other = params[0]
-          target.compile(self, true)
-          @method.print " #{op} "
-          other.compile(self, true)
-          @method.print ')'
-        end
-        unless expression && simple
-          @method.puts ';'
-        end
-      end
-
-      def precompile_nodes(nodes)
-        if nodes.all? {|n| n.expr?(self)}
-          nodes
-        else
-          nodes.map do |node|
-            tempval = node.precompile(self)
-            if node == tempval && !node.kind_of?(Mirah::AST::Literal)
-              tempval = node.temp(self)
-            end
-            tempval
-          end
-        end
-      end
-
-      def compile_args(call)
-        precompile_nodes(call.parameters)
-      end
-
-      def self_type
-        type = AST.type(nil, @class.name.tr('/', '.'))
-        type = type.meta if @static
-        type
-      end
-
-      def super_call(call, expression)
-        super_method_call(this, call, compile_args(call), expression)
-      end
-
-      def cast(call, expression)
-        args = compile_args(call)
-        simple = call.expr?(self)
-        @method.print @lvalue if expression && !simple
-        @method.print "((#{call.inferred_type.to_source})("
-        args.each{|arg| arg.compile(self, true)}
-        @method.print "))"
-        @method.puts ';' unless simple && expression
-      end
-
-      def self_call(call, expression)
-        if call.cast?
-          cast(call, expression)
-        else
-          type = call.scope.static_scope.self_type
-          type = type.meta if (@static && type == @type)
-          params = call.parameters.map do |param|
-            param.inferred_type
-          end
-          method = type.get_method(call.name, params)
-          method_call(this(method), call, compile_args(call), expression)
-        end
-      end
-
-      def call(call, expression)
-        return cast(call, expression) if call.cast?
-        if Mirah::AST::Constant === call.target || Mirah::AST::Colon2 === call.target
-          target = call.target.inferred_type.to_source
-        else
-          target = call.precompile_target(self)
-        end
-        params = compile_args(call)
-
-        if Operators.include? call.name
-          operator(target, call.name, params, expression)
-        elsif call.target.inferred_type.array? && ArrayOps.include?(call.name)
-          array_op(target, call.name, params, expression)
-        elsif call.name == 'nil?'
-          operator(target, '==', ['null'], expression)
-        else
-          method_call(target, call, params, expression)
-        end
-      end
-
-      def array_op(target, name, args, expression)
-        simple = expr?(target, args)
-        index, value = args
-        if expression && !simple
-          @method.print @lvalue
-        end
-        target.compile(self, true)
-        if name == 'length'
-          @method.print '.length'
-        else
-          @method.print '['
-          index.compile(self, true)
-          @method.print ']'
-          if name == '[]='
-            @method.print " = "
-            value.compile(self, true)
-          end
-        end
-        unless simple && expression
-          @method.puts ';'
-        end
-      end
-
-      def break(node)
-        error("break outside of loop", node) unless @loop
-        @loop.break
-      end
-
-      def next(node)
-        error("next outside of loop", node) unless @loop
-        @loop.next
-      end
-
-      def redo(node)
-        error("redo outside of loop", node) unless @loop
-        @loop.redo
-      end
-
-      # TODO: merge cleanly with method_call logic
-      def super_method_call(target, call, params, expression)
-        simple = call.expr?(self)
-        method = call.method(self)
-        unless simple || method.return_type.void?
-          @method.print @lvalue if expression
-        end
-        if method.constructor?
-          @method.print "super("
-        else
-          @method.print "super.#{method.name}("
-        end
-        params.each_with_index do |param, index|
-          @method.print ', ' unless index == 0
-          param.compile(self, true)
-        end
-        if simple && expression
-          @method.print ')'
-        else
-          @method.puts ');'
-        end
-        if method.return_type.void? && expression
-          @method.print @lvalue
-          if method.static?
-            @method.puts 'null;'
-          else
-            target.compile(self, true)
-            @method.puts ';'
-          end
-        end
-
-      end
-
-      def method_call(target, call, params, expression)
-        simple = call.expr?(self)
-        method = call.method(self)
-        unless simple || method.return_type.void?
-          @method.print @lvalue if expression
-        end
-
-        # preamble
-        if method.constructor?
-          @method.print "new "
-          target.compile(self, true)
-          @method.print '('
-        elsif method.field?
-          target.compile(self, true)
-          @method.print ".#{method.name}"
-          if method.argument_types.size == 1
-            @method.print " = ("
-          end
-        elsif Mirah::JVM::Types::Intrinsic === method
-          method.call(self, call, expression)
-          return
-        else
-          target.compile(self, true)
-          @method.print ".#{method.name}("
-        end
-
-        # args
-        params.each_with_index do |param, index|
-          @method.print ', ' unless index == 0
-          param.compile(self, true)
-        end
-
-        # postamble
-        if !method.field? || (method.field? && method.argument_types.size == 1)
-          if simple && expression
-            @method.print ')'
-          else
-            @method.puts ');'
-          end
-        end
-
-        # cleanup
-        if method.return_type.void? && expression
-          @method.print @lvalue
-          if method.static?
-            @method.puts 'null;'
-          else
-            target.compile(self, true)
-            @method.puts ';'
-          end
-        end
-      end
-
-      def temp(expression, value=nil)
-        value ||= expression
-        type = value.inferred_type
-        if value.expr?(self)
-          @method.tmp(type) do
-            value.compile(self, true)
-          end
-        else
-          assign(@method.tmp(type), value)
-        end
-      end
-
-      def empty_array(type, size)
-        sizevar = size.precompile(self)
-        @method.print "#{@lvalue unless size.expr?(self)}new #{type.name}["
-        sizevar.compile(self, true)
-        @method.print ']'
-      end
-
-      def string(value)
-        @method.print value.inspect
-      end
-
-      def boolean(value)
-        @method.print value ? 'true' : 'false'
-      end
-
-      def regexp(value, flags = 0)
-        @method.print "java.util.regex.Pattern.compile("
-        @method.print value.inspect
-        @method.print ")"
-      end
-
-      def array(node, expression)
-        if expression
-          # create unmodifiable list from array (simplest way to do this in Java source)
-          @method.print "java.util.Collections.unmodifiableList(java.util.Arrays.asList("
-
-          # elements, as expressions
-          comma = false
-          node.children.each do |n|
-            @method.print ", " if comma
-            n.compile(self, true)
-            comma = true
-          end
-
-          @method.print("))")
-        else
-          # elements, as non-expressions
-          # TODO: ensure they're all reference types!
-          node.children.each do |n|
-            n.compile(self, false)
-          end
-        end
-      end
-
-      def build_string(orig_nodes, expression)
-        if expression
-          nodes = precompile_nodes(orig_nodes)
-          simple = nodes.equal?(orig_nodes)
-          if !simple
-            @method.print(lvalue)
-          end
-          first = true
-          unless nodes[0].kind_of?(Mirah::AST::String)
-            @method.print '""'
-            first = false
-          end
-          nodes.each do |node|
-            @method.print ' + ' unless first
-            first = false
-            node.compile(self, true)
-          end
-          @method.puts ';' unless simple
-        else
-          orig_nodes.each {|n| n.compile(self, false)}
-        end
-      end
-
-      def to_string(body, expression)
-        body.compile(self, expression)
-      end
-
-      def null
-        @method.print 'null'
-      end
-
-      def binding_reference
-        @method.print '$binding'
-      end
-
-      def real_self
-        @method.print 'this'
-      end
-
-      def print(node)
-        value = node.parameters[0]
-        value = value && value.precompile(self)
-        if node.println
-          @method.print "System.out.println("
-        else
-          @method.print "System.out.print("
-        end
-        value.compile(self, true) if value
-        @method.puts ');'
-      end
-
-      class ClosureCompiler < JavaSource
-        def initialize(file, type, parent)
-          @file = file
-          @type = type
-          @parent = parent
-        end
-
-        def prepare_binding(scope)
-          if scope.has_binding?
-            type = scope.binding_type
-            @binding = @parent.get_binding(type)
-            @method.puts("#{type.to_source} $binding = this.binding;")
-          end
-          begin
-            yield
-          ensure
-            if scope.has_binding?
-              @binding = nil
-            end
-          end
-        end
-
-        def declared_captures
-          @parent.declared_captures(@binding)
-        end
-      end
-    end
-  end
-end