mirah 0.0.7-java → 0.0.8-java

data/lib/mirah/jvm/compiler/base.rb

@@ -0,0 +1,270 @@
+# 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 JVM
+    module Compiler
+      class Base
+        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); Mirah::JVM::Compiler::JVMBytecode.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 = Mirah::JVM::Compiler::JVMBytecode.classname_from_filename(@filename)
+          @type = AST.type(script, classname)
+          @file = file_builder(@filename)
+
+          # Define a main method unless all of the script's children are 'top level'
+          # nodes (e.g. Import, ClassDefinition, InterfaceDeclaration).
+          unless script.body.children.all? { |c| c && c.top_level? }
+            @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
+                script.body.compile(self, false)
+              end
+
+              finish_main
+              @method.stop
+            end
+            @class.stop
+
+            log "Main method complete!"
+          else
+            script.body.compile(self, false)
+          end
+        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
+end

data/lib/mirah/jvm/compiler/java_source.rb

@@ -0,0 +1,779 @@
+# 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 JVM
+    module Compiler
+      class JavaSource < Base
+        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_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 unless @method && @method.name == 'main' && @class == @method.klass
+          end
+        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
+            if node.else_node.nil?
+              maybe_store(node.body, expression) if node.body
+            else
+              node.body.compile(self, false) if node.body
+            end
+          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
+          if node.else_node
+            maybe_store(node.else_node, expression)
+          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
+end