mirah 0.0.12-java → 0.1.0-java

data/lib/mirah/errors.rb

@@ -1,3 +1,18 @@
+# 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
   class MirahError < StandardError
     attr_accessor :position
@@ -57,4 +72,4 @@ module Mirah
 
   class InternalCompilerError < NodeError
   end
-end
+end

data/lib/mirah/generator.rb

@@ -13,65 +13,105 @@
 # 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)
-      @parser = Mirah::Parser.new(state, logging)
-      @compiler = Mirah::Compiler::ASTCompiler.new(compiler_class, logging)
+      @state = state
+      @scoper = SimpleScoper.new {|scoper, node| Mirah::AST::StaticScope.new(node, scoper)}
+
+      # TODO untie this from the jvm backend (nh)
+      type_system = Mirah::JVM::Types::TypeFactory.new
+      type_system.classpath = state.classpath
+      type_system.bootclasspath = state.bootclasspath
+
+      @typer = Mirah::Typer::Typer.new(type_system, @scoper, self)
+      @parser = Mirah::Parser.new(state, @typer, logging)
+      @compiler = Mirah::Compiler::ASTCompiler.new(state, compiler_class, logging)
+      @extension_compiler = Mirah::Compiler::ASTCompiler.new(state, Mirah::JVM::Compiler::JVMBytecode, logging)
+      type_system.maybe_initialize_builtins(@typer.macro_compiler)
       @logging = logging
       @verbose = verbose
     end
-    
-    attr_accessor :parser, :compiler, :logging, :verbose
-      
+
+    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
-      infer_asts(top_nodes)
-      
+      scoper, typer = infer_asts(top_nodes)
+
       # compile each AST in turn
-      compiler_results = compiler.compile_asts(top_nodes)
-      
+      compiler_results = compiler.compile_asts(top_nodes, scoper, typer)
+
       puts "Done!" if logging
-      
+
       compiler_results
     end
-      
-    def infer_asts(nodes)
-      typer = Mirah::JVM::Typer.new(parser.transformer)
-      nodes.each {|ast| typer.infer(ast, true) }
+
+    def infer_asts(nodes, should_raise=false)
       begin
-        typer.resolve(false)
+        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)
+      rescue NativeException => ex
+        log("Caught exception during type inference", ex.cause)
+        raise ex
       ensure
-        puts nodes.inspect if verbose
-        
-        failed = !typer.errors.empty?
-        # extra_errors = []
-        # nodes.each do |ast|
-        #   ast.each_descendant do |node|
-        #     if node.respond_to?(:inferred_type) && node.inferred_type && node.inferred_type.error?
-        #       extra_errors << node
-        #     end
-        #   end
-        # end unless failed
-        # unless extra_errors.empty?
-        #   typer_errors = typer.errors.map {|e| e.node}
-        #   new_errors = extra_errors - typer_errors
-        #   new_errors.each do |n|
-        #     typer.error(n)
-        #   end
-        #   failed = true
-        # end
-        if failed
-          puts "Inference Error:"
-          process_errors(typer.errors)
+        log_types(nodes)
+      end
+      [@scoper, @typer]
+    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
+end

data/lib/mirah/jvm/compiler.rb

@@ -17,8 +17,6 @@ require 'mirah'
 require 'mirah/jvm/compiler/base'
 require 'mirah/jvm/method_lookup'
 require 'mirah/jvm/types'
-require 'mirah/typer'
-require 'mirah/plugin/java'
 require 'bitescript'
 require 'mirah/jvm/compiler/jvm_bytecode'
 
@@ -27,25 +25,9 @@ module Mirah
     class FunctionalCall
       attr_accessor :target
     end
-    
+
     class Super
       attr_accessor :target
     end
   end
 end
-
-if __FILE__ == $0
-  Mirah::Typer.verbose = true
-  Mirah::AST.verbose = true
-  Mirah::JVM::Compiler::JVMBytecode.verbose = true
-  ast = Mirah::AST.parse(File.read(ARGV[0]))
-  
-  typer = Mirah::Typer::Simple.new(:script)
-  ast.infer(typer)
-  typer.resolve(true)
-  
-  compiler = Mirah::JVM::Compiler::JVMBytecode.new(ARGV[0])
-  compiler.compile(ast)
-  
-  compiler.generate
-end

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

@@ -16,33 +16,81 @@
 module Mirah
   module JVM
     module Compiler
-      class Base
+      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 initialize
+        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 = scoper
+          @typer = typer
         end
 
-        def error(message, node)
-          raise CompilationError.new(message, node)
+        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 compile(ast, expression = false)
+        def visit(node, expression)
           begin
-            ast.compile(self, expression)
+            node.accept(self, expression)
           rescue Exception => ex
-            raise Mirah::InternalCompilerError.wrap(ex, ast)
+            raise Mirah::InternalCompilerError.wrap(ex, node)
           end
-          log "Compilation successful!"
         end
 
-        def log(message); Mirah::JVM::Compiler::JVMBytecode.log(message); 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)
@@ -61,66 +109,119 @@ module Mirah
           log "...done!"
         end
 
-        def define_main(script)
+        # 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.filename)
+          @filename = File.basename(script.position.source.name)
           classname = Mirah::JVM::Compiler::JVMBytecode.classname_from_filename(@filename)
-          @type = AST.type(script, classname)
+          @type = @typer.type_system.type(get_scope(script), classname)
           @file = file_builder(@filename)
-
-          # Define a main method unless all of the script's children are 'top level'
-          # nodes (e.g. Import, ClassDefinition, InterfaceDeclaration).
-          unless script.body.children.all? { |c| c && c.top_level? }
+          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)
-            with :method => @class.main do
-              log "Starting main method"
-
-              @method.start
-              @current_scope = script.static_scope
-              declare_locals(@current_scope)
-              begin_main
+            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
 
-              prepare_binding(script) do
-                script.body.compile(self, false)
+                finish_main
+                @method.stop
               end
-
-              finish_main
-              @method.stop
+              log "Main method complete!"
+            else
+              visit(body, false)
             end
             @class.stop
-
-            log "Main method complete!"
           else
-            script.body.compile(self, false)
+            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)
-          @class.build_method(name.to_s, node.visibility, static,
-          exceptions, return_type, *arg_types)
+          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, args_are_types)
-          name, signature, args = node.name, node.signature, node.arguments.args
-          if name == "initialize" && node.static?
+        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
-          if args_are_types
-            arg_types = args.map { |arg| arg.inferred_type } if args
-          else
-            arg_types = args
-          end
-          arg_types ||= []
-          return_type = signature[:return]
-          exceptions = signature[:throws]
+          arg_types = args.map { |arg| inferred_type(arg) }
+          return_type = inferred_type(node).return_type
+          exceptions = []  # TODO
 
-          with :static => @static || node.static?, :current_scope => node.static_scope do
+          with :static => is_static, :current_scope => introduced_scope(node) do
             method = create_method_builder(name, node, @static, exceptions,
-            return_type, arg_types)
+                                           return_type, arg_types)
             annotate(method, node.annotations)
             yield method, arg_types
           end
@@ -130,11 +231,7 @@ module Mirah
           if args
             args.each do |arg|
               if AST::OptionalArgument === arg
-                new_args = if args_are_types
-                  arg_types_for_opt
-                else
-                  args_for_opt
-                end
+                new_args = arg_types_for_opt
                 method = create_method_builder(name, node, @static, exceptions,
                 return_type, new_args)
                 with :method => method do
@@ -151,68 +248,90 @@ module Mirah
                   @method.stop
                 end
               end
-              arg_types_for_opt << arg.inferred_type
+              arg_types_for_opt << inferred_type(arg)
               args_for_opt << arg
             end
           end
         end
 
-        def constructor(node, args_are_types)
-          args = node.arguments.args || []
-          arg_types = if args_are_types
-            args.map { |arg| arg.inferred_type }
-          else
-            args
-          end
-          exceptions = node.signature[:throws]
-          method = @class.build_constructor(node.visibility, exceptions, *arg_types)
+        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 => node.static_scope do
+          with :current_scope => introduced_scope(node) do
             yield(method, args)
           end
         end
 
-        def define_class(class_def, expression)
-          with(:type => class_def.inferred_type,
-          :class => class_def.inferred_type.define(@file),
-          :static => false) do
+        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)
-            class_def.body.compile(self, false) if class_def.body
+            visit(class_def.body, false) if class_def.body
             @class.stop
           end
         end
 
-        def declare_argument(name, type)
-          # declare local vars for arguments here
+        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 body(body, expression)
+        def visitNodeList(body, expression)
           saved_self = @self_scope
-          if body.kind_of?(Mirah::AST::ScopedBody)
-            scope = body.static_scope
-            declare_locals(scope)
-            if scope != @self_scope
-              if scope.self_node && scope.self_node != :self
+          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 scope.self_type.name == 'mirah.impl.Builtin'
+                unless new_scope.self_type.name == 'mirah.impl.Builtin'
                   local_assign(
-                  scope, 'self', scope.self_type, false, scope.self_node)
+                  new_scope, 'self', new_scope.self_type, false, new_scope.self_node)
                 end
               end
-              @self_scope = scope
+              @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.children.size - 1
+          i, last = 0, body.size - 1
           while i < last
-            body.children[i].compile(self, false)
+            visit(body.get(i), false)
             i += 1
           end
-          yield body.children[last] if last >= 0
+          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
@@ -225,19 +344,43 @@ module Mirah
           end
         end
 
-        def import(short, long)
+        def visitImport(node, expression)
         end
 
-        def fixnum(type, value)
-          type.literal(method, value)
+        def visitFixnum(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
-        alias float fixnum
 
-        def compile_self
-          if @self_scope && @self_scope.self_node && @self_scope.self_node != :self
-            local(@self_scope, 'self', @self_scope.self_type)
+        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
-            real_self
+            visitImplicitNil(node, expression)
           end
         end
 
@@ -267,4 +410,4 @@ module Mirah
       end
     end
   end
-end
+end