duby 0.0.2-java → 0.0.3-java

data/lib/duby/jvm/compiler.rb

@@ -1,4 +1,5 @@
 require 'duby'
+require 'duby/jvm/base'
 require 'duby/jvm/method_lookup'
 require 'duby/jvm/types'
 require 'duby/typer'
@@ -15,9 +16,9 @@ module Duby
       attr_accessor :target
     end
   end
-  
+
   module Compiler
-    class JVM
+    class JVM < JVMCompilerBase
       java_import java.lang.System
       java_import java.io.PrintStream
       include Duby::JVM::MethodLookup
@@ -29,46 +30,39 @@ module Duby
         def log(message)
           puts "* [#{name}] #{message}" if JVM.verbose
         end
+
+        def classname_from_filename(filename)
+          basename = File.basename(filename, '.duby')
+          basename.split(/_/).map{|x| x[0...1].upcase + x[1..-1]}.join
+        end
       end
 
       module JVMLogger
         def log(message); JVM.log(message); end
       end
-      include JVMLogger
 
       class ImplicitSelf
         attr_reader :inferred_type
-        
+
         def initialize(type)
           @inferred_type = type
         end
-        
+
         def compile(compiler, expression)
           compiler.compile_self if expression
         end
       end
-      
-      attr_accessor :filename, :src, :method, :static, :class
 
       def initialize(filename)
-        @filename = File.basename(filename)
-        @src = ""
-        @static = true
-        classname = File.basename(filename, '.duby')
+        super
         BiteScript.bytecode_version = BiteScript::JAVA1_5
         @file = BiteScript::FileBuilder.new(@filename)
         AST.type_factory.define_types(@file)
-        @type = AST::type(classname)
         @jump_scope = []
       end
 
-      def compile(ast, expression = false)
-        ast.compile(self, expression)
-        log "Compilation successful!"
-      end
-
-      def toplevel_class
-        @class = @type.define(@file)
+      def output_type
+        "classes"
       end
 
       def push_jump_scope(node)
@@ -80,7 +74,7 @@ module Duby
           @jump_scope.pop
         end
       end
-      
+
       def find_ensures(before)
         found = []
         @jump_scope.reverse_each do |scope|
@@ -92,132 +86,99 @@ module Duby
         found
       end
 
-      def define_main(body)
-        if body.class != AST::ClassDefinition
-          @class = @type.define(@file)
-          with :method => @class.main do
-            log "Starting main method"
-
-            @method.start
-
-            # declare argv variable
-            @method.local('argv', AST.type('string', true))
+      def begin_main
+        # declare argv variable
+        @method.local('argv', AST.type('string', true))
+      end
 
-            body.compile(self, false)
+      def finish_main
+        @method.returnvoid
+      end
 
-            @method.returnvoid
-            @method.stop
+      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]
+          type.store(@method, @method.local('$binding', type))
+        end
+        begin
+          yield
+        ensure
+          if scope.has_binding?
+            @binding.stop
+            @binding = nil
           end
-          @class.stop
-        else
-          body.compile(self, false)
         end
-
-        log "Main method complete!"
       end
-      
+
       def define_method(node)
         push_jump_scope(node) do
-          name, signature, args = node.name, node.signature, node.arguments.args
-          arg_types = if args
-            args.map { |arg| arg.inferred_type }
-          else
-            []
-          end
-          return_type = signature[:return]
-          exceptions = signature[:throws]
-
-          with :static => @static || node.static? do
-            if @static
-              method = @class.public_static_method(name.to_s, exceptions, return_type, *arg_types)
-            else
-              method = @class.public_method(name.to_s, exceptions, return_type, *arg_types)
-            end
-
-            annotate(method, node.annotations)
-
+          super(node, true) do |method, arg_types|
             return if @class.interface?
 
-            log "Starting new method #{name}(#{arg_types})"
-            method_body(method, args, node.body, signature[:return])
-
-            arg_types_for_opt = []
-            args_for_opt = []
-            if args
-              args.each do |arg|
-                if AST::OptionalArgument === arg
-                  if @static
-                    method = @class.public_static_method(name.to_s, exceptions, return_type, *arg_types_for_opt)
-                  else
-                    method = @class.public_method(name.to_s, exceptions, return_type, *arg_types_for_opt)
-                  end
-
-                  with :method => method do
-                    log "Starting new method #{name}(#{arg_types_for_opt})"
-
-                    @method.start unless started
-
-                    # declare all args so they get their values
-
-                    expression = signature[:return] != Types::Void
-
-                    @method.aload(0) unless @static
-                    args_for_opt.each {|req_arg| @method.local(req_arg.name, req_arg.inferred_type)}
-                    arg.children[0].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
+            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
 
-                    signature[:return].return(@method)
+      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.children[0].value.compile(self, true)
 
-                    @method.stop
-                  end
-                end
-                arg_types_for_opt << arg.inferred_type
-                args_for_opt << arg
-              end
-            end
-          end
+        # 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
 
-          log "Method #{name}(#{arg_types}) complete!"        end
+        return_type.return(@method)
       end
-      
+
       def constructor(node)
         push_jump_scope(node) do
-          args = node.arguments.args || []
-          arg_types = args.map { |arg| arg.inferred_type }
-          exceptions = node.signature[:throws]
-          method = @class.public_constructor(exceptions, *arg_types)
-          annotate(method, node.annotations)
-          method_body(method, args, node.body, Types::Void) do
-            method.aload 0
-            if node.delegate_args
-              if node.calls_super
-                delegate_class = @type.superclass
+          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
-                delegate_class = @type
+                method.invokespecial @class.superclass, "<init>", [@method.void]
               end
-              delegate_types = node.delegate_args.map {|arg| arg.inferred_type}
-              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
 
-      def method_body(method, args, body, return_type)
-        with :method => method do
+      def method_body(method, args, node, return_type)
+        body = node.body
+        with(:method => method,
+             :declared_locals => {}) do
 
           method.start
 
@@ -225,36 +186,32 @@ module Duby
           if args
             args.each {|arg| @method.local(arg.name, arg.inferred_type)}
           end
-
           yield if block_given?
 
-          expression = return_type != Types::Void
-          body.compile(self, expression) if body
+          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_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
+      def define_closure(class_def, expression)
+        compiler = ClosureCompiler.new(@file, @type, self)
+        compiler.define_class(class_def, expression)
       end
-      
+
       def declare_argument(name, type)
         # declare local vars for arguments here
       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
@@ -314,7 +271,7 @@ module Duby
 
             @redo_label.set!
             loop.body.compile(self, false)
-        
+
             if loop.check_first && !loop.post?
               @method.goto(@next_label)
             else
@@ -328,9 +285,9 @@ module Duby
                 jump_if(predicate, pre_label)
               end
             end
-        
+
             @break_label.set!
-        
+
             # loops always evaluate to null
             @method.aconst_null if expression
           end
@@ -341,29 +298,29 @@ module Duby
         handle_ensures(find_ensures(Duby::AST::Loop))
         @method.goto(@break_label)
       end
-      
+
       def next(node)
         handle_ensures(find_ensures(Duby::AST::Loop))
         @method.goto(@next_label)
       end
-      
+
       def redo(node)
         handle_ensures(find_ensures(Duby::AST::Loop))
         @method.goto(@redo_label)
       end
-      
+
       def jump_if(predicate, target)
         raise "Expected boolean, found #{predicate.inferred_type}" unless predicate.inferred_type == Types::Boolean
         predicate.compile(self, true)
         @method.ifne(target)
       end
-      
+
       def jump_if_not(predicate, target)
         raise "Expected boolean, found #{predicate.inferred_type}" unless predicate.inferred_type == Types::Boolean
         predicate.compile(self, true)
         @method.ifeq(target)
       end
-      
+
       def call(call, expression)
         target = call.target.inferred_type
         params = call.parameters.map do |param|
@@ -376,7 +333,7 @@ module Duby
           raise "Missing method #{target}.#{call.name}(#{params.join ', '})"
         end
       end
-      
+
       def self_call(fcall, expression)
         return cast(fcall, expression) if fcall.cast?
         type = @type
@@ -389,7 +346,7 @@ module Duby
         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
@@ -415,7 +372,7 @@ module Duby
       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
@@ -465,31 +422,27 @@ module Duby
           end
         end
       end
-      
+
       def body(body, expression)
-        # 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
         # last element is an expression only if the body is an expression
-        body.children[last].compile(self, expression)
+        super(body, expression) do |last|
+          last.compile(self, expression)
+        end
       end
-      
-      def local(name, type)
-        type.load(@method, @method.local(name, type))
+
+      def local(scope, name, type)
+        type.load(@method, @method.local(scoped_local_name(name, scope), type))
       end
 
-      def local_assign(name, type, expression, value)
-        declare_local(name, type)
-        
+      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(name, type))
+
+        type.store(@method, @method.local(scoped_local_name(name, scope), type))
       end
 
       def declared_locals
@@ -498,24 +451,81 @@ module Duby
 
       def annotate(builder, annotations)
         annotations.each do |annotation|
-          builder.annotate(annotation.type.jvm_type) do |visitor|
-            # todo values
+          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 declare_local(name, type)
+      def annotation_value(builder, name, value)
+        case value
+        when Duby::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 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(name, type)
-        declare_local(name, type)
+      def local_declare(scope, name, type)
+        declare_local(scope, name, type)
         type.init_value(@method)
-        type.store(@method, @method.local(name, type))
+        type.store(@method, @method.local(scoped_local_name(name, scope), type))
+      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)
@@ -527,7 +537,7 @@ module Duby
 
         # load self object unless static
         method.aload 0 unless static
-        
+
         if static
           @method.getstatic(@class, name, type)
         else
@@ -562,7 +572,7 @@ module Duby
         name = name[1..-1]
 
         real_type = declared_fields[name] || type
-        
+
         declare_field(name, real_type, annotations)
 
         method.aload 0 unless static
@@ -580,15 +590,59 @@ module Duby
           @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 = Duby::AST.type('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?
+          @method.invokevirtual @method.object, "toString", [@method.string]
+        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
@@ -599,9 +653,13 @@ module Duby
 
           # elements, as expressions
           # TODO: ensure they're all reference types!
-          node.children.each do |node|
+          node.children.each do |n|
             @method.dup
-            node.compile(self, true)
+            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
@@ -611,43 +669,31 @@ module Duby
         else
           # elements, as non-expressions
           # TODO: ensure they're all reference types!
-          node.children.each do |node|
-            node.compile(self, false)
+          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 compile_self
         method.aload(0)
       end
-      
-      def newline
-        # TODO: line numbering
-      end
-      
+
       def line(num)
         @method.line(num) if @method
       end
-      
-      def generate
-        log "Generating classes..."
-        @file.generate do |filename, builder|
-          log "  #{builder.class_name}"
-          if block_given?
-            yield filename, builder
-          else
-            File.open(filename, 'w') {|f| f.write(builder.generate)}
-          end
-        end
-        log "...done!"
-      end
-      
-      def import(short, long)
-      end
 
       def print(print_node)
         @method.getstatic System, "out", PrintStream
@@ -676,7 +722,7 @@ module Duby
         exception.compile(self, true)
         @method.athrow
       end
-      
+
       def rescue(rescue_node, expression)
         start = @method.label.set!
         body_end = @method.label
@@ -729,21 +775,49 @@ module Duby
         size.compile(self, true)
         type.newarray(@method)
       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
+
+      def bootstrap_dynamic
+        # hacky, I know
+        unless defined? @class.bootstrapped
+          def @class.bootstrapped; true; end
+          method = @class.public_static_method("<clinit>", [], Java::void)
+          method.start
+          method.ldc org.jruby.duby.DynalangBootstrap
+          method.ldc "bootstrap"
+          method.invokestatic java.dyn.Linkage, "registerBootstrapMethod", [method.void, java.lang.Class, method.string]
+          method.returnvoid
+          method.stop
+        end
+      end
+
+      class ClosureCompiler < Duby::Compiler::JVM
+        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
-          yield
-        ensure
-          orig_values.each do |name, value|
-            instance_variable_set name, value
+          begin
+            yield
+          ensure
+            if scope.has_binding?
+              @binding = nil
+            end
           end
         end
+
+        def declared_captures
+          @parent.declared_captures(@binding)
+        end
       end
     end
   end
@@ -754,13 +828,13 @@ if __FILE__ == $0
   Duby::AST.verbose = true
   Duby::Compiler::JVM.verbose = true
   ast = Duby::AST.parse(File.read(ARGV[0]))
-  
+
   typer = Duby::Typer::Simple.new(:script)
   ast.infer(typer)
   typer.resolve(true)
-  
+
   compiler = Duby::Compiler::JVM.new(ARGV[0])
   compiler.compile(ast)
-  
+
   compiler.generate
 end