mirah 0.0.7-java → 0.0.8-java

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

@@ -0,0 +1,851 @@
+module Mirah  
+  module JVM
+    module Compiler
+      class JVMBytecode < Base
+        java_import java.lang.System
+        java_import java.io.PrintStream
+        include Mirah::JVM::MethodLookup
+        Types = Mirah::JVM::Types
+        
+        class << self
+          attr_accessor :verbose
+          
+          def log(message)
+            puts "* [#{name}] #{message}" if JVMBytecode.verbose
+          end
+          
+          def classname_from_filename(filename)
+            basename = File.basename(filename).sub(/\.(duby|mirah)$/, '')
+            basename.split(/_/).map{|x| x[0...1].upcase + x[1..-1]}.join
+          end
+        end
+        
+        module JVMLogger
+          def log(message); JVMBytecode.log(message); end
+        end
+        
+        class ImplicitSelf
+          attr_reader :inferred_type
+          
+          def initialize(type)
+            @inferred_type = type
+          end
+          
+          def compile(compiler, expression)
+            compiler.compile_self if expression
+          end
+        end
+        
+        def initialize
+          super
+          @jump_scope = []
+        end
+        
+        def file_builder(filename)
+          builder = BiteScript::FileBuilder.new(filename)
+          AST.type_factory.define_types(builder)
+          builder
+        end
+        
+        def output_type
+          "classes"
+        end
+        
+        def push_jump_scope(node)
+          raise "Not a node" unless Mirah::AST::Node === node
+          begin
+            @jump_scope << node
+            yield
+          ensure
+            @jump_scope.pop
+          end
+        end
+        
+        def find_ensures(before)
+          found = []
+          @jump_scope.reverse_each do |scope|
+            if Mirah::AST::Ensure === scope
+              found << scope
+            end
+            break if before === scope
+          end
+          found
+        end
+        
+        def begin_main
+          # declare argv variable
+          @method.local('argv', AST.type(nil, 'string', true))
+        end
+        
+        def finish_main
+          @method.returnvoid
+        end
+        
+        def prepare_binding(scope)
+          if scope.has_binding?
+            type = scope.binding_type
+            @binding = @bindings[type]
+            @method.new type
+            @method.dup
+            @method.invokespecial type, "<init>", [@method.void]
+            if scope.respond_to? :arguments
+              scope.arguments.args.each do |param|
+                name = param.name
+                param_type = param.inferred_type
+                if scope.static_scope.captured?(param.name)
+                  @method.dup
+                  type.load(@method, @method.local(name, param_type))
+                  @method.putfield(type, name, param_type)
+                end
+              end
+            end
+            type.store(@method, @method.local('$binding', type))
+          end
+          begin
+            yield
+          ensure
+            if scope.has_binding?
+              @binding.stop
+              @binding = nil
+            end
+          end
+        end
+        
+        def define_method(node)
+          push_jump_scope(node) do
+            base_define_method(node, true) do |method, arg_types|
+              return if @class.interface?
+              
+              log "Starting new #{node.static? ? 'static ' : ''}method #{node.name}(#{arg_types})"
+              args = node.arguments.args
+              method_body(method, args, node, node.signature[:return])
+              log "Method #{node.name}(#{arg_types}) complete!"
+            end
+          end
+        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.aload(0) unless @static
+          args_for_opt.each do |req_arg|
+            req_arg.inferred_type.load(@method, @method.local(req_arg.name, req_arg.inferred_type))
+          end
+          arg.value.compile(self, true)
+          
+          # invoke the next one in the chain
+          if @static
+            @method.invokestatic(@class, name.to_s, [return_type] + arg_types_for_opt + [arg.inferred_type])
+          else
+            @method.invokevirtual(@class, name.to_s, [return_type] + arg_types_for_opt + [arg.inferred_type])
+          end
+          
+          return_type.return(@method)
+        end
+        
+        def constructor(node)
+          push_jump_scope(node) do
+            super(node, true) do |method, args|
+              method_body(method, args, node, Types::Void) do
+                method.aload 0
+                if node.delegate_args
+                  if node.calls_super
+                    delegate_class = @type.superclass
+                  else
+                    delegate_class = @type
+                  end
+                  delegate_types = node.delegate_args.map do |arg|
+                    arg.inferred_type
+                  end
+                  constructor = delegate_class.constructor(*delegate_types)
+                  node.delegate_args.each do |arg|
+                    arg.compile(self, true)
+                  end
+                  method.invokespecial(
+                  delegate_class, "<init>",
+                  [@method.void, *constructor.argument_types])
+                else
+                  method.invokespecial @class.superclass, "<init>", [@method.void]
+                end
+              end
+            end
+          end
+        end
+        
+        def method_body(method, args, node, return_type)
+          body = node.body
+          with(:method => method,
+          :declared_locals => {}) do
+            
+            method.start
+            
+            scope = node.static_scope
+            
+            # declare all args so they get their values
+            if args
+              args.each {|arg| declare_local(scope, arg.name, arg.inferred_type)}
+            end
+            declare_locals(scope)
+            
+            yield if block_given?
+            
+            prepare_binding(node) do
+              expression = return_type != Types::Void
+              body.compile(self, expression) if body
+            end
+            
+            return_type.return(@method)
+            
+            @method.stop
+          end
+        end
+        
+        def define_closure(class_def, expression)
+          compiler = ClosureCompiler.new(@file, @type, self)
+          compiler.define_class(class_def, expression)
+        end
+        
+        def branch(iff, expression)
+          elselabel = @method.label
+          donelabel = @method.label
+          
+          # this is ugly...need a better way to abstract the idea of compiling a
+          # conditional branch while still fitting into JVM opcodes
+          predicate = iff.condition.predicate
+          if iff.body || expression
+            jump_if_not(predicate, elselabel)
+            
+            if iff.body
+              iff.body.compile(self, expression)
+            elsif expression
+              iff.inferred_type.init_value(@method)
+            end
+            
+            @method.goto(donelabel)
+          else
+            jump_if(predicate, donelabel)
+          end
+          
+          elselabel.set!
+          
+          if iff.else
+            iff.else.compile(self, expression)
+          elsif expression
+            iff.inferred_type.init_value(@method)
+          end
+          
+          donelabel.set!
+        end
+        
+        def loop(loop, expression)
+          push_jump_scope(loop) do
+            with(:break_label => @method.label,
+            :redo_label => @method.label,
+            :next_label => @method.label) do
+              predicate = loop.condition.predicate
+              
+              loop.init.compile(self, false) if loop.init?
+              
+              pre_label = @redo_label
+              
+              if loop.check_first
+                @next_label.set! unless loop.post?
+                if loop.negative
+                  # if condition, exit
+                  jump_if(predicate, @break_label)
+                else
+                  # if not condition, exit
+                  jump_if_not(predicate, @break_label)
+                end
+              end
+              
+              if loop.pre?
+                pre_label = method.label
+                pre_label.set!
+                loop.pre.compile(self, false)
+              end
+              
+              
+              @redo_label.set!
+              loop.body.compile(self, false) if loop.body
+              
+              if loop.check_first && !loop.post?
+                @method.goto(@next_label)
+              else
+                @next_label.set!
+                loop.post.compile(self, false) if loop.post?
+                if loop.negative
+                  # if not condition, continue
+                  jump_if_not(predicate, pre_label)
+                else
+                  # if condition, continue
+                  jump_if(predicate, pre_label)
+                end
+              end
+              
+              @break_label.set!
+              
+              # loops always evaluate to null
+              @method.aconst_null if expression
+            end
+          end
+        end
+        
+        def break(node)
+          error("break outside of loop", node) unless @break_label
+          handle_ensures(find_ensures(Mirah::AST::Loop))
+          @method.goto(@break_label)
+        end
+        
+        def next(node)
+          error("next outside of loop", node) unless @next_label
+          handle_ensures(find_ensures(Mirah::AST::Loop))
+          @method.goto(@next_label)
+        end
+        
+        def redo(node)
+          error("redo outside of loop", node) unless @redo_label
+          handle_ensures(find_ensures(Mirah::AST::Loop))
+          @method.goto(@redo_label)
+        end
+        
+        def jump_if(predicate, target)
+          unless predicate.inferred_type == Types::Boolean
+            raise "Expected boolean, found #{predicate.inferred_type}"
+          end
+          if Mirah::AST::Call === predicate
+            method = extract_method(predicate)
+            if method.respond_to? :jump_if
+              method.jump_if(self, predicate, target)
+              return
+            end
+          end
+          predicate.compile(self, true)
+          @method.ifne(target)
+        end
+        
+        def jump_if_not(predicate, target)
+          unless predicate.inferred_type == Types::Boolean
+            raise "Expected boolean, found #{predicate.inferred_type}"
+          end
+          if Mirah::AST::Call === predicate
+            method = extract_method(predicate)
+            if method.respond_to? :jump_if_not
+              method.jump_if_not(self, predicate, target)
+              return
+            end
+          end
+          predicate.compile(self, true)
+          @method.ifeq(target)
+        end
+        
+        def extract_method(call)
+          target = call.target.inferred_type!
+          params = call.parameters.map do |param|
+            param.inferred_type!
+          end
+          target.get_method(call.name, params)
+        end
+        
+        def call(call, expression)
+          return cast(call, expression) if call.cast?
+          method = extract_method(call)
+          if method
+            method.call(self, call, expression)
+          else
+            raise "Missing method #{target}.#{call.name}(#{params.join ', '})"
+          end
+        end
+        
+        def self_call(fcall, expression)
+          return cast(fcall, expression) if fcall.cast?
+          type = fcall.scope.static_scope.self_type
+          type = type.meta if (@static && type == @type)
+          fcall.target = ImplicitSelf.new(type)
+          
+          params = fcall.parameters.map do |param|
+            param.inferred_type
+          end
+          method = type.get_method(fcall.name, params)
+          unless method
+            target = static ? @class.name : 'self'
+            
+            raise NameError, "No method %s.%s(%s)" %
+            [target, fcall.name, params.join(', ')]
+          end
+          method.call(self, fcall, expression)
+        end
+        
+        def super_call(sup, expression)
+          type = @type.superclass
+          sup.target = ImplicitSelf.new(type)
+          
+          params = sup.parameters.map do |param|
+            param.inferred_type
+          end
+          method = type.get_method(sup.name, params)
+          unless method
+            
+            raise NameError, "No method %s.%s(%s)" %
+            [type, sup.name, params.join(', ')]
+          end
+          method.call_special(self, sup, expression)
+        end
+        
+        def cast(fcall, expression)
+          # casting operation, not a call
+          castee = fcall.parameters[0]
+          
+          # TODO move errors to inference phase
+          source_type_name = castee.inferred_type.name
+          target_type_name = fcall.inferred_type.name
+          if castee.inferred_type.primitive?
+            if fcall.inferred_type.primitive?
+              if source_type_name == 'boolean' && target_type_name != "boolean"
+                raise TypeError.new "not a boolean type: #{castee.inferred_type}"
+              end
+              # ok
+              primitive = true
+            else
+              raise TypeError.new "Cannot cast #{castee.inferred_type} to #{fcall.inferred_type}: not a reference type."
+            end
+          elsif fcall.inferred_type.primitive?
+            raise TypeError.new "not a primitive type: #{castee.inferred_type}"
+          else
+            # ok
+            primitive = false
+          end
+          
+          castee.compile(self, expression)
+          if expression
+            if primitive
+              source_type_name = 'int' if %w[byte short char].include? source_type_name
+              if (source_type_name != 'int') && (%w[byte short char].include? target_type_name)
+                target_type_name = 'int'
+              end
+              
+              if source_type_name != target_type_name
+                if RUBY_VERSION == "1.9"
+                  @method.send "#{source_type_name[0]}2#{target_type_name[0]}"
+                else
+                  @method.send "#{source_type_name[0].chr}2#{target_type_name[0].chr}"
+                end
+              end
+            else
+              if (source_type_name != target_type_name ||
+                castee.inferred_type.array? != fcall.inferred_type.array?)
+                @method.checkcast fcall.inferred_type
+              end
+            end
+          end
+        end
+        
+        def body(body, expression)
+          # last element is an expression only if the body is an expression
+          super(body, expression) do |last|
+            compile(last, expression)
+          end
+        end
+        
+        def local(scope, name, type)
+          type.load(@method, @method.local(scoped_local_name(name, scope), type))
+        end
+        
+        def local_assign(scope, name, type, expression, value)
+          declare_local(scope, name, type)
+          
+          value.compile(self, true)
+          
+          # if expression, dup the value we're assigning
+          @method.dup if expression
+          
+          type.store(@method, @method.local(scoped_local_name(name, scope), type))
+        end
+        
+        def declared_locals
+          @declared_locals ||= {}
+        end
+        
+        def annotate(builder, annotations)
+          annotations.each do |annotation|
+            type = annotation.type
+            type = type.jvm_type if type.respond_to?(:jvm_type)
+            builder.annotate(type, annotation.runtime?) do |visitor|
+              annotation.values.each do |name, value|
+                annotation_value(visitor, name, value)
+              end
+            end
+          end
+        end
+        
+        def annotation_value(builder, name, value)
+          case value
+          when Mirah::AST::Annotation
+            type = value.type
+            type = type.jvm_type if type.respond_to?(:jvm_type)
+            builder.annotation(name, type) do |child|
+              value.values.each do |name, value|
+                annotation_value(child, name, value)
+              end
+            end
+          when ::Array
+            builder.array(name) do |array|
+              value.each do |item|
+                annotation_value(array, nil, item)
+              end
+            end
+          else
+            builder.value(name, value)
+          end
+        end
+        
+        def declared?(scope, name)
+          declared_locals.include?(scoped_local_name(name, scope))
+        end
+        
+        def declare_local(scope, name, type)
+          # TODO confirm types are compatible
+          name = scoped_local_name(name, scope)
+          unless declared_locals[name]
+            declared_locals[name] = type
+            index = @method.local(name, type)
+          end
+        end
+        
+        def local_declare(scope, name, type)
+        end
+        
+        def declare_locals(scope)
+          scope.locals.each do |name|
+            unless scope.captured?(name) || declared?(scope, name)
+              type = scope.local_type(name)
+              declare_local(scope, name, type)
+              type.init_value(@method)
+              type.store(@method, @method.local(scoped_local_name(name, scope), type))
+            end
+          end
+        end
+        
+        def get_binding(type)
+          @bindings[type]
+        end
+        
+        def declared_captures(binding=nil)
+          @captured_locals[binding || @binding]
+        end
+        
+        def captured_local_declare(scope, name, type)
+          unless declared_captures[name]
+            declared_captures[name] = type
+            # default should be fine, but I don't think bitescript supports it.
+            @binding.protected_field(name, type)
+          end
+        end
+        
+        def captured_local(scope, name, type)
+          captured_local_declare(scope, name, type)
+          binding_reference
+          @method.getfield(scope.binding_type, name, type)
+        end
+        
+        def captured_local_assign(node, expression)
+          scope, name, type = node.containing_scope, node.name, node.inferred_type
+          captured_local_declare(scope, name, type)
+          binding_reference
+          node.value.compile(self, true)
+          @method.dup_x2 if expression
+          @method.putfield(scope.binding_type, name, type)
+        end
+        
+        def field(name, type, annotations, static_field)
+          name = name[1..-1] if name =~ /^@/
+          
+          real_type = declared_fields[name] || type
+          
+          declare_field(name, real_type, annotations, static_field)
+          
+          # load self object unless static
+          method.aload 0 unless static || static_field
+          
+          if static || static_field
+            @method.getstatic(@class, name, type)
+          else
+            @method.getfield(@class, name, type)
+          end
+        end
+        
+        def declared_fields
+          @declared_fields ||= {}
+          @declared_fields[@class] ||= {}
+        end
+        
+        def declare_field(name, type, annotations, static_field)
+          # TODO confirm types are compatible
+          unless declared_fields[name]
+            declared_fields[name] = type
+            field = if static || static_field
+              @class.private_static_field name, type
+            else
+              @class.private_field name, type
+            end
+            annotate(field, annotations)
+          end
+        end
+        
+        def field_declare(name, type, annotations, static_field)
+          name = name[1..-1] if name =~ /^@/
+          declare_field(name, type, annotations, static_field)
+        end
+        
+        def field_assign(name, type, expression, value, annotations, static_field)
+          name = name[1..-1] if name =~ /^@/
+          
+          real_type = declared_fields[name] || type
+          
+          declare_field(name, real_type, annotations, static_field)
+          
+          method.aload 0 unless static || static_field
+          value.compile(self, true)
+          if expression
+            instruction = 'dup'
+            instruction << '2' if type.wide?
+            instruction << '_x1' unless static || static_field
+            method.send instruction
+          end
+          
+          if static || static_field
+            @method.putstatic(@class, name, real_type)
+          else
+            @method.putfield(@class, name, real_type)
+          end
+        end
+        
+        def string(value)
+          @method.ldc(value)
+        end
+        
+        def build_string(nodes, expression)
+          if expression
+            # could probably be more efficient with non-default constructor
+            builder_class = Mirah::AST.type(nil, 'java.lang.StringBuilder')
+            @method.new builder_class
+            @method.dup
+            @method.invokespecial builder_class, "<init>", [@method.void]
+            
+            nodes.each do |node|
+              node.compile(self, true)
+              method = find_method(builder_class, "append", [node.inferred_type], false)
+              if method
+                @method.invokevirtual builder_class, "append", [method.return_type, *method.argument_types]
+              else
+                log "Could not find a match for #{java::lang::StringBuilder}.append(#{node.inferred_type})"
+                fail "Could not compile"
+              end
+            end
+            
+            # convert to string
+            @method.invokevirtual java::lang::StringBuilder.java_class, "toString", [@method.string]
+          else
+            nodes.each do |node|
+              node.compile(self, false)
+            end
+          end
+        end
+        
+        def to_string(body, expression)
+          if expression
+            body.compile(self, true)
+            body.inferred_type.box(@method) if body.inferred_type.primitive?
+            null = method.label
+            done = method.label
+            method.dup
+            method.ifnull(null)
+            @method.invokevirtual @method.object, "toString", [@method.string]
+            @method.goto(done)
+            null.set!
+            method.pop
+            method.ldc("null")
+            done.set!
+          else
+            body.compile(self, false)
+          end
+        end
+        
+        def boolean(value)
+          value ? @method.iconst_1 : @method.iconst_0
+        end
+        
+        def regexp(value, flags = 0)
+          # TODO: translate flags to Java-appropriate values
+          @method.ldc(value)
+          @method.invokestatic java::util::regex::Pattern, "compile", [java::util::regex::Pattern, @method.string]
+        end
+        
+        def array(node, expression)
+          if expression
+            # create basic arraylist
+            @method.new java::util::ArrayList
+            @method.dup
+            @method.ldc_int node.children ? node.children.size : 0
+            @method.invokespecial java::util::ArrayList, "<init>", [@method.void, @method.int]
+            
+            # elements, as expressions
+            # TODO: ensure they're all reference types!
+            node.children.each do |n|
+              @method.dup
+              n.compile(self, true)
+              # TODO this feels like it should be in the node.compile itself
+              if n.inferred_type!.primitive?
+                n.inferred_type.box(@method)
+              end
+              @method.invokeinterface java::util::List, "add", [@method.boolean, @method.object]
+              @method.pop
+            end
+            
+            # make it unmodifiable
+            @method.invokestatic java::util::Collections, "unmodifiableList", [java::util::List, java::util::List]
+          else
+            # elements, as non-expressions
+            # TODO: ensure they're all reference types!
+            node.children.each do |n|
+              n.compile(self, true)
+              # TODO this feels like it should be in the node.compile itself
+              if n.inferred_type.primitive?
+                n.inferred_type.box(@method)
+              end
+            end
+          end
+        end
+        
+        def null
+          @method.aconst_null
+        end
+        
+        def binding_reference
+          @method.aload(@method.local('$binding'))
+        end
+        
+        def real_self
+          method.aload(0)
+        end
+        
+        def line(num)
+          @method.line(num - 1) if @method
+        end
+        
+        def print(print_node)
+          @method.getstatic System, "out", PrintStream
+          print_node.parameters.each {|param| param.compile(self, true)}
+          params = print_node.parameters.map {|param| param.inferred_type.jvm_type}
+          method_name = print_node.println ? "println" : "print"
+          method = find_method(PrintStream.java_class, method_name, params, false)
+          if (method)
+            @method.invokevirtual(
+            PrintStream,
+            method_name,
+            [method.return_type, *method.parameter_types])
+          else
+            log "Could not find a match for #{PrintStream}.#{method_name}(#{params})"
+            fail "Could not compile"
+          end
+        end
+        
+        def return(return_node)
+          return_node.value.compile(self, true) if return_node.value
+          handle_ensures(find_ensures(Mirah::AST::MethodDefinition))
+          return_node.inferred_type.return(@method)
+        end
+        
+        def _raise(exception)
+          exception.compile(self, true)
+          @method.athrow
+        end
+        
+        def rescue(rescue_node, expression)
+          start = @method.label.set!
+          body_end = @method.label
+          done = @method.label
+          rescue_node.body.compile(self, expression && rescue_node.else_node.nil?) if rescue_node.body
+          body_end.set!
+          rescue_node.else_node.compile(self, expression) if rescue_node.else_node
+          return if start.label.offset == body_end.label.offset
+          @method.goto(done)
+          rescue_node.clauses.each do |clause|
+            target = @method.label.set!
+            if clause.name
+              @method.astore(declare_local(clause.static_scope, clause.name, clause.type))
+            else
+              @method.pop
+            end
+            declare_locals(clause.static_scope)
+            clause.body.compile(self, expression)
+            @method.goto(done)
+            clause.types.each do |type|
+              @method.trycatch(start, body_end, target, type)
+            end
+          end
+          done.set!
+        end
+        
+        def handle_ensures(nodes)
+          nodes.each do |ensure_node|
+            ensure_node.clause.compile(self, false)
+          end
+        end
+        
+        def ensure(node, expression)
+          node.state = @method.label  # Save the ensure target for JumpNodes
+          start = @method.label.set!
+          body_end = @method.label
+          done = @method.label
+          push_jump_scope(node) do
+            node.body.compile(self, expression)  # First compile the body
+          end
+          body_end.set!
+          handle_ensures([node])  # run the ensure clause
+          @method.goto(done)  # and continue on after the exception handler
+          target = @method.label.set!  # Finally, create the exception handler
+          @method.trycatch(start, body_end, target, nil)
+          handle_ensures([node])
+          @method.athrow
+          done.set!
+        end
+        
+        def empty_array(type, size)
+          size.compile(self, true)
+          type.newarray(@method)
+        end
+        
+        class ClosureCompiler < JVMBytecode
+          def initialize(file, type, parent)
+            @file = file
+            @type = type
+            @jump_scope = []
+            @parent = parent
+          end
+          
+          def prepare_binding(scope)
+            if scope.has_binding?
+              type = scope.binding_type
+              @binding = @parent.get_binding(type)
+              @method.aload 0
+              @method.getfield(@class, 'binding', @binding)
+              type.store(@method, @method.local('$binding', type))
+            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