mirah 0.0.12-java → 0.1.0-java

data/lib/mirah/compiler/method.rb

@@ -1,44 +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 AST
-    class Arguments
-      def compile(compiler, expression)
-        # TODO: what does it mean for a method to be an expression?
-        args.each {|arg| compiler.declare_argument(arg.name, arg.inferred_type)} if args
-      rescue Exception => ex
-        raise Mirah::InternalCompilerError.wrap(ex, self)
-      end
-    end
-
-    class MethodDefinition
-      def compile(compiler, expression)
-        # TODO: what does it mean for a method to be an expression?
-        compiler.define_method(self)
-      rescue Exception => ex
-        raise Mirah::InternalCompilerError.wrap(ex, self)
-      end
-    end
-
-    class ConstructorDefinition
-      def compile(compiler, expression)
-        compiler.constructor(self)
-      rescue Exception => ex
-        raise Mirah::InternalCompilerError.wrap(ex, self)
-      end
-    end
-  end
-end

data/lib/mirah/compiler/structure.rb

@@ -1,65 +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 AST
-    class Body
-      def compile(compiler, expression)
-        compiler.line(line_number)
-        compiler.body(self, expression)
-      rescue Exception => ex
-        raise Mirah::InternalCompilerError.wrap(ex, self)
-      end
-    end
-    
-    class ScopedBody
-      def compile(compiler, expression)
-        compiler.line(line_number)
-        compiler.scoped_body(self, expression)
-      rescue Exception => ex
-        raise Mirah::InternalCompilerError.wrap(ex, self)
-      end
-    end
-    
-    class BindingReference
-      def compile(compiler, expression)
-        if expression
-          compiler.line(line_number)
-          compiler.binding_reference
-        end
-      rescue Exception => ex
-        raise Mirah::InternalCompilerError.wrap(ex, self)
-      end
-    end
-    
-    class Script
-      def compile(compiler, expression)
-        # TODO: what does it mean for a script to be an expression? possible?
-        compiler.define_main(self)
-      rescue Exception => ex
-        raise Mirah::InternalCompilerError.wrap(ex, self)
-      end
-    end
-    
-    class Noop
-      def compile(compiler, expression)
-        # TODO: what does it mean for a noop to be an expression
-        # nothing
-      rescue Exception => ex
-        raise Mirah::InternalCompilerError.wrap(ex, self)
-      end
-    end
-  end
-end

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

@@ -1,787 +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 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.returns_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.returns_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.returns_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)
-          if @method
-            @method.block do
-              super
-            end
-          else
-            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
-            @method.print "("             if Mirah::AST::StringConcat === target
-            target.compile(self, true)
-            @method.print ")"             if Mirah::AST::StringConcat === target
-            @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)
-
-            unless simple
-              @method.print(lvalue)
-            end
-
-            @method.print '"" + ' unless nodes.first.kind_of?(Mirah::AST::String)
-
-            nodes.first.compile(self, true)
-
-            nodes[1..-1].each do |node|
-              @method.print ' + '
-              node.compile(self, true)
-            end
-            unless simple
-              @method.puts ';'
-            end
-          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