mirah 0.1.2-java → 0.1.3-java

data/lib/mirah/commands/parse.rb

@@ -1,36 +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/parser'
-
-module Mirah
-  module Commands
-    class Parse < Base
-      def execute
-        execute_base do
-          parser = Mirah::Parser.new(@state, nil, false)
-
-          parser.parse_from_args(args).each do |ast|
-            puts parser.format_ast(ast)
-          end
-        end
-      end
-
-      def command_name
-        :parse
-      end
-    end
-  end
-end

data/lib/mirah/commands/run.rb

@@ -1,78 +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/generator'
-require 'mirah/util/class_loader'
-
-module Mirah
-  module Commands
-    class Run < Base
-      def execute
-        execute_base do
-          class_map = generate_classes
-          $CLASSPATH << Mirah::Env.decode_paths(@state.classpath) if @state.classpath
-          class_loader = load_classes class_map
-
-          main = find_main class_map, class_loader
-
-          run_main(main)
-        end
-      end
-
-      def command_name
-        :run
-      end
-
-      private
-
-      def load_classes(class_map)
-        Mirah::Util::ClassLoader.new(JRuby.runtime.jruby_class_loader, class_map)
-      end
-
-      def find_main class_map, class_loader
-        # TODO: using first main; find correct one?
-        class_map.keys.each do |name|
-          cls = class_loader.load_class(name)
-          main = cls.get_method("main", java::lang::String[].java_class)
-          return main if main
-        end
-        nil
-      end
-
-      def run_main(main)
-        if main
-          begin
-            main.invoke(nil, [args.to_java(:string)].to_java)
-          rescue java.lang.Exception => e
-            e = e.cause if e.cause
-            raise e
-          end
-        else
-          puts "No main found" unless @state.version_printed || @state.help_printed
-        end
-      end
-
-      def generate_classes
-        # generate all bytes for all classes
-        generator = Mirah::Generator.new(@state, @state.compiler_class, false, @state.verbose)
-        class_map = {}
-        generator.generate(args).each do |result|
-          class_map[result.classname.gsub(/\//, '.')] = Mirah::Util::ClassLoader.binary_string result.bytes
-        end
-        class_map
-      end
-    end
-  end
-end

data/lib/mirah/generator.rb

@@ -1,150 +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/util/process_errors'
-require 'mirah/util/logging'
-
-module Mirah
-  class Generator
-    include Mirah::Util::ProcessErrors
-    include Mirah::Logging::Logged
-    java_import 'org.mirah.typer.simple.SimpleScoper'
-    java_import 'org.mirah.typer.simple.TypePrinter'
-    java_import 'org.mirah.macros.JvmBackend'
-
-    def initialize(state, compiler_class, logging, verbose)
-      @state = state
-
-      # TODO untie this from the jvm backend (nh)
-      if state.type_system
-        # Using new type system
-        @scoper = SimpleScoper.new do |scoper, node|
-          scope = Java::OrgMirahJvmMirrors::JVMScope.new(scoper)
-          scope.context_set(node)
-          scope
-        end
-        type_system = state.type_system
-      else
-        @scoper = SimpleScoper.new {|scoper, node| Mirah::AST::StaticScope.new(node, scoper)}
-        type_system = Mirah::JVM::Types::TypeFactory.new
-        type_system.classpath = state.classpath if state.classpath
-        type_system.bootclasspath = state.bootclasspath
-      end
-
-      @typer = Mirah::Typer::Typer.new(type_system, @scoper, self, nil)
-      @parser = Mirah::Parser.new(state, @typer, logging)
-      @compiler = Mirah::Compiler::ASTCompiler.new(state, compiler_class, logging)
-      @extension_compiler = Mirah::Compiler::ASTCompiler.new(state, compiler_class, logging)
-      if type_system.respond_to?(:maybe_initialize_builtins)
-        type_system.maybe_initialize_builtins(@typer.macro_compiler)
-      end
-      @logging = logging
-      @verbose = verbose
-    end
-
-    attr_accessor :parser, :compiler, :typer, :logging, :verbose
-
-    def generate(arguments)
-      # collect all ASTs from all files
-      top_nodes = parser.parse_from_args(arguments)
-
-      # enter all ASTs into inference engine
-      puts "Inferring types..." if logging
-      scoper, typer = infer_asts(top_nodes)
-      do_transforms top_nodes
-      # compile each AST in turn
-      compiler_results = compiler.compile_asts(top_nodes, scoper, typer)
-
-      puts "Done!" if logging
-
-      compiler_results
-    end
-
-    def do_transforms nodes
-      log("Starting Transform")
-
-      java_import 'org.mirah.jvm.compiler.ClosureTransformer' rescue puts $!
-      java_import 'org.mirah.util.Context' rescue puts $!
-      #java_import 'org.mirah.typer.Typer'
-      #java_import 'org.mirah.macros.Compiler'
-      transformer = ClosureTransformer.new(Context.new.tap{|c|c.add(Java::org.mirah.typer::Typer, @typer) }) rescue nil
-      if transformer
-        nodes.each{|n| n.accept transformer, nil } # rescue log("transformer exception", $!.cause)
-        log("POST Transform")
-        log_types nodes
-      else
-        log "No transformer, skipping"
-      end
-    end
-
-    def infer_asts(nodes, should_raise=false)
-      log_and_reraise "Caught exception during type inference" do
-        nodes.each {|ast| @typer.infer(ast, false) }
-        if should_raise
-          error_handler = lambda do |errors|
-            message, position = errors[0].message[0].to_a
-            raise Mirah::MirahError.new(message, position)
-          end
-        end
-        process_inference_errors(@typer, nodes, &error_handler)
-      end
-      [@scoper, @typer]
-    ensure
-      log_types(nodes)
-    end
-
-    def log_and_reraise message
-      yield
-    rescue NativeException => ex
-      log(message, ex.cause)
-      raise ex
-    end
-
-    def log_types(nodes)
-      if self.logging?
-        buf = java.io.ByteArrayOutputStream.new
-        ps = java.io.PrintStream.new(buf)
-        printer = TypePrinter.new(@typer, ps)
-        nodes.each {|ast| printer.scan(ast, nil)}
-        ps.close()
-        log("Inferred types:\n{0}", java.lang.String.new(buf.toByteArray))
-      end
-
-    end
-
-    def compileAndLoadExtension(ast)
-      log_types([ast])
-      process_inference_errors(@typer, [ast])
-      results = @extension_compiler.compile_asts([ast], @scoper, @typer)
-      class_map = {}
-      first_class_name = nil
-      results.each do |result|
-        classname = result.classname.gsub(/\//, '.')
-        first_class_name ||= classname if classname.include?('$Extension')
-        class_map[classname] = Mirah::Util::ClassLoader.binary_string result.bytes
-        if @state.save_extensions
-          filename = "#{@state.destination}#{result.filename}"
-          FileUtils.mkdir_p(File.dirname(filename))
-          File.open(filename, 'wb') {|f| f.write(result.bytes)}
-        end
-      end
-      dcl = Mirah::Util::ClassLoader.new(JRuby.runtime.jruby_class_loader, class_map)
-      dcl.load_class(first_class_name)
-    end
-
-    def logExtensionAst(ast)
-      log("Extension ast:\n#{parser.format_ast(ast)}")
-    end
-  end
-end

data/lib/mirah/jvm/compiler.rb

@@ -1,50 +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/jvm/compiler/base'
-require 'mirah/jvm/method_lookup'
-require 'mirah/jvm/types'
-require 'bitescript'
-require 'mirah/jvm/compiler/jvm_bytecode'
-require 'mirah/transform/ast_ext'
-
-module Mirah
-  module AST
-    class FunctionalCall
-      attr_accessor :target
-    end
-
-    class Super
-      attr_accessor :target
-    end
-  end
-end
-
-module Mirah
-  module JVM
-    module Compiler
-      begin
-        class Backend < Java::OrgMirahJvmCompiler::Backend
-          def initialize(config, scoper, typer)
-            super(typer)
-          end
-        end
-      rescue NameError
-        puts "Unable to load new Backend"
-      end
-    end
-  end
-end

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

@@ -1,421 +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 JVM
-    module Compiler
-      java_import 'mirah.lang.ast.ClassDefinition'
-      java_import 'mirah.lang.ast.StaticMethodDefinition'
-      java_import 'mirah.lang.ast.SimpleNodeVisitor'
-      java_import 'mirah.lang.ast.NodeScanner'
-
-      class Base < SimpleNodeVisitor
-        attr_accessor :filename, :method, :static, :class
-        include Mirah::Logging::Logged
-
-        class CompilationError < Mirah::NodeError
-        end
-
-        def logger_name
-          "org.mirah.ruby.JVM.Compiler.Base"
-        end
-
-        def initialize(config, scoper, typer)
-          super()
-          @config = config
-          @jump_scope = []
-          @bindings = Hash.new {|h, type| h[type] = type.define(@file)}
-          @captured_locals = Hash.new {|h, binding| h[binding] = {}}
-          @self_scope = nil
-          @scoper = typer.scoper
-          @typer = typer
-        end
-
-        def target_jvm_version
-          @config.target_jvm_version
-        end
-
-        def supports_invokedynamic?
-          @config.supports_invokedynamic?
-        end
-
-        def defaultNode(node, expression)
-          raise ArgumentError, "Can't compile node #{node}"
-        end
-
-        def visit(node, expression)
-          begin
-            node.accept(self, expression)
-          rescue Exception => ex
-            raise Mirah::InternalCompilerError.wrap(ex, node)
-          end
-        end
-
-        def get_scope(node)
-          @scoper.get_scope(node)
-        end
-
-        def introduced_scope(node)
-          @scoper.get_introduced_scope(node)
-        end
-
-        def containing_scope(node)
-          scope = get_scope(node)
-          name = node.name.identifier
-          while (!scope.shadowed?(name) && scope.parent && scope.parent.include?(name))
-            scope = scope.parent
-          end
-          scope
-        end
-
-        def inferred_type(node)
-          begin
-            @typer.get_inferred_type(node).resolve
-          rescue Exception => ex
-            raise Mirah::InternalCompilerError.wrap(ex, node)
-          end
-        end
-
-        def error(message, node)
-          raise CompilationError.new(message, node)
-        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
-
-        # Scans the top level of a file to see if it contains anything outside of a ClassDefinition.
-        class ScriptScanner < NodeScanner
-          attr_reader :found_other, :found_method
-          def enterDefault(node, arg)
-            @found_other = true
-            false
-          end
-          def enterMethodDefinition(node, arg)
-            @found_method = true
-            false
-          end
-          def enterStaticMethodDefinition(node, arg)
-            @found_method = true
-            false
-          end
-          def enterConstructorDefinition(node, arg)
-            @found_method = true
-            false
-          end
-          def enterPackage(node, arg)
-            # ignore
-            false
-          end
-          def enterClassDefinition(node, arg)
-            # ignore
-            false
-          end
-          def enterInterfaceDeclaration(node, arg)
-            # ignore
-            false
-          end
-          def enterImport(node, arg)
-            # ignore
-            false
-          end
-          def enterNodeList(node, arg)
-            # Scan the children
-            true
-          end
-        end
-
-        def visitMacroDefinition(node, expression)
-          # ignore. It was already compiled
-        end
-
-        def visitScript(script, expression)
-          @static = true
-          @filename = File.basename(script.position.source.name)
-          classname = Mirah::JVM::Compiler::JVMBytecode.classname_from_filename(@filename)
-          @type = @typer.type_system.type(get_scope(script), classname)
-          @file = file_builder(@filename)
-          body = script.body
-          scanner = ScriptScanner.new
-          scanner.scan(body, expression)
-          need_class = scanner.found_method || scanner.found_other
-          if need_class
-            @class = @type.define(@file)
-            if scanner.found_other
-              # Generate the main method
-              with :method => @class.main do
-                log "Starting main method"
-
-                @method.start
-                @current_scope = get_scope(script)
-                declare_locals(@current_scope)
-                begin_main
-
-                prepare_binding(script) do
-                  visit(body, false)
-                end
-
-                finish_main
-                @method.stop
-              end
-              log "Main method complete!"
-            else
-              visit(body, false)
-            end
-            @class.stop
-          else
-            visit(body, false)
-          end
-        end
-
-        def visitNoop(node, expression)
-        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)
-          return_type = nil if return_type.name == ':unreachable'
-          visibility = :public  # TODO
-          flags = BiteScript::ASM::Opcodes::ACC_PUBLIC
-          flags |= BiteScript::ASM::Opcodes::ACC_STATIC if static
-          flags |= BiteScript::ASM::Opcodes::ACC_ABSTRACT if node.annotated_abstract?
-          @class.method(flags, name.to_s, [return_type, *arg_types], exceptions)
-        end
-
-        def base_define_method(node)
-          name = node.name.identifier.sub(/=$/, '_set')
-          args = visit(node.arguments, true)
-          is_static = self.static || node.kind_of?(StaticMethodDefinition)
-          if name == "initialize" && is_static
-            name = "<clinit>"
-          end
-          arg_types = args.map { |arg| inferred_type(arg) }
-          return_type = inferred_type(node).return_type
-          exceptions = []  # TODO
-
-          with :static => is_static, :current_scope => introduced_scope(node) 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 = arg_types_for_opt
-                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 << inferred_type(arg)
-              args_for_opt << arg
-            end
-          end
-        end
-
-        def visitConstructorDefinition(node, expression)
-          args = visit(node.arguments, true)
-          arg_types = args.map { |arg| inferred_type(arg) }
-          exceptions = []  # node.signature[:throws]
-          visibility = :public  # node.visibility
-          method = @class.build_constructor(visibility, exceptions, *arg_types)
-          annotate(method, node.annotations)
-          with :current_scope => introduced_scope(node) do
-            yield(method, args)
-          end
-        end
-
-        def visitClassDefinition(class_def, expression)
-          log "Compiling class #{class_def.name.identifier}"
-          with(:type => inferred_type(class_def),
-               :class => inferred_type(class_def).define(@file),
-               :static => false) do
-            annotate(@class, class_def.annotations)
-            visit(class_def.body, false) if class_def.body
-            @class.stop
-          end
-        end
-
-        def visitArguments(args, expression)
-          result = []
-          args.required.each {|arg| result << arg}
-          args.optional.each {|arg| result << arg}
-          result << args.rest if args.rest
-          args.required2.each {|arg| result << arg}
-          result << args.block if args.block
-          result
-        end
-
-        def visitStaticMethodDefinition(mdef, expression)
-          visitMethodDefinition(mdef, expression)
-        end
-
-        def visitNodeList(body, expression)
-          saved_self = @self_scope
-          new_scope = introduced_scope(body)
-          if new_scope
-            declare_locals(new_scope)
-            if new_scope != @self_scope
-              if new_scope.self_node && new_scope.self_node != :self
-                # FIXME This is a horrible hack!
-                # Instead we should eliminate unused self's.
-                unless new_scope.self_type.name == 'mirah.impl.Builtin'
-                  local_assign(
-                  new_scope, 'self', new_scope.self_type, false, new_scope.self_node)
-                end
-              end
-              @self_scope = new_scope
-            end
-          end
-          # all except the last element in a body of code is treated as a statement
-          i, last = 0, body.size - 1
-          while i < last
-            visit(body.get(i), false)
-            i += 1
-          end
-          if last >= 0
-            yield body.get(last)
-          else
-            yield nil
-          end
-          @self_scope = saved_self
-        end
-
-        def visitClassAppendSelf(node, expression)
-          with :static => true, :current_scope => introduced_scope(node) do
-            visit(node.body, expression)
-          end
-        end
-
-        def visitPackage(node, expression)
-          visit(node.body, expression) if node.body
-        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 visitImport(node, expression)
-        end
-
-        def visitFixnum(node, expression)
-          if expression
-            inferred_type(node).literal(method, node.value)
-          end
-        end
-        
-        def visitCharLiteral(node, expression)
-          if expression
-            inferred_type(node).literal(method, node.value)
-          end
-        end
-        
-        alias visitFloat visitFixnum
-
-        def visitSelf(node, expression)
-          if expression
-            set_position(node.position)
-            scope = get_scope(node)
-            if scope.self_node && scope.self_node != :self
-              local(scope, 'self', scope.self_type)
-            else
-              real_self
-            end
-          end
-        end
-
-        def visitImplicitSelf(node, expression)
-          visitSelf(node, expression)
-        end
-
-        def visitUnquote(node, expression)
-          body = node.nodes
-          i, last = 0, body.size - 1
-          while i < last
-            visit(body.get(i), false)
-            i += 1
-          end
-          if last >= 0
-            visit(body.get(last), expression)
-          else
-            visitImplicitNil(node, expression)
-          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