mirah 0.1.0.pre-java → 0.1.1-java

data/examples/macros/{string-each-char.mirah → string_each_char.mirah}

@@ -14,10 +14,9 @@
 # limitations under the License.
 
 
-macro def eachChar(value, &block)
-
+macro def eachChar(value, block:Block)
     quote {
-        `value`.toCharArray.each do | my_char |
+        `value`.toCharArray.each do |`block.arguments` |
             `block.body`
         end
     }

data/examples/simple_class.mirah

@@ -13,15 +13,15 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-class Foo
+class SimpleClass
   def initialize
     puts 'constructor'
     @hello = 'Hello, '
   end
 
-  def hello(a:string)
+  def hello(a:String)
     puts @hello; puts a
   end
 end
 
-Foo.new.hello('Mirah')
+SimpleClass.new.hello('Mirah')

data/examples/{dynamic.mirah → simple_class.mirah~}

@@ -13,20 +13,15 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-# Example of using a dynamic type in a method definition
-def foo(a:dynamic)
-  puts "I got a #{a.getClass.getName} of size #{a.size}"
-end
-
-class SizeThing
-  def initialize(size:int)
-    @size = size
+class Foo
+  def initialize
+    puts 'constructor'
+    @hello = 'Hello, '
   end
 
-  def size
-    @size
+  def hello(a:string)
+    puts @hello; puts a
   end
 end
 
-foo([1,2,3])
-foo(SizeThing.new(12))
+Foo.new.hello('Mirah')

data/lib/mirah.rb

@@ -17,6 +17,13 @@ require 'fileutils'
 require 'rbconfig'
 require 'bitescript'
 
+$CLASSPATH << File.dirname(__FILE__) + '/../javalib/mirah-builtins.jar'
+$CLASSPATH << File.dirname(__FILE__) + '/../javalib/mirah-parser.jar'
+$CLASSPATH << File.dirname(__FILE__) + '/../javalib/mirah-bootstrap.jar'
+$CLASSPATH << File.dirname(__FILE__) + '/../javalib/mirah-util.jar'
+$CLASSPATH << File.dirname(__FILE__) + '/../javalib/mirah-compiler.jar'
+$CLASSPATH << File.dirname(__FILE__) + '/../javalib/mirah-mirrors.jar'
+
 require 'mirah/version'
 require 'mirah/transform'
 require 'mirah/ast'
@@ -78,7 +85,7 @@ module Mirah
     end_col -= adjustment
 
     result = ""
-    position.source.contents.each_with_index do |line, lineno|
+    position.source.contents.each_line.with_index do |line, lineno|
       break if lineno > end_line
       next if lineno < start_line
 

data/lib/mirah/ast.rb

@@ -34,10 +34,10 @@ module Mirah
     java_import 'mirah.lang.ast.NodeList'
     java_import 'mirah.lang.ast.Noop'
     java_import 'mirah.lang.ast.OptionalArgument'
+    java_import 'mirah.lang.ast.Position'
     java_import 'mirah.lang.ast.SimpleString'
     java_import 'mirah.lang.ast.TypeName'
     java_import 'mirah.lang.ast.TypeRef'
 
-
   end
 end

data/lib/mirah/ast/scope.rb

@@ -19,6 +19,7 @@ module Mirah
       java_import 'java.util.LinkedHashMap'
       java_import 'org.mirah.typer.Scope'
       java_import 'org.mirah.typer.AssignableTypeFuture'
+      java_import 'org.mirah.typer.BaseTypeFuture'
       java_import 'org.mirah.typer.LocalFuture'
       java_import 'org.mirah.typer.ErrorType'
       include Scope
@@ -85,6 +86,10 @@ module Mirah
       def locals
         @vars.keys
       end
+      
+      def capturedLocals
+        locals.select {|name| self.captured?(name)}
+      end
 
       def temp(name="tmp")
         "$#{name}$#{@temps[name] += 1}"
@@ -117,6 +122,10 @@ module Mirah
         end
       end
 
+      def isCaptured(name)
+        self.captured?(name)
+      end
+
       def children
         @children.keys
       end
@@ -214,6 +223,13 @@ module Mirah
         @cached_packages ||= fetch_packages([])
       end
 
+      def staticImport(type)
+        future = BaseTypeFuture.new(self_type.position)
+        extended = self_type.resolve.include(type.resolve)
+        future.resolved(extended)
+        self.self_type = future
+      end
+
       def import(full_name, short_name)
         return if full_name == short_name
         if short_name == '*'

data/lib/mirah/commands/base.rb

@@ -1,4 +1,4 @@
-# Copyright (c) 2010 The Mirah project authors. All Rights Reserved.
+# Copyright (c) 2010-2013 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");
@@ -13,7 +13,6 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-#require 'mirah/jvm/types'
 require 'mirah/util/compilation_state'
 require 'mirah/util/argument_processor'
 require 'mirah/errors'
@@ -23,7 +22,6 @@ module Mirah
     class Base
       include Mirah::Logging::Logged
       def initialize(args)
-        #Mirah::AST.type_factory = Mirah::JVM::Types::TypeFactory.new
         @state = Mirah::Util::CompilationState.new
         @state.command = command_name
         @args = args

data/lib/mirah/compiler.rb

@@ -16,7 +16,8 @@
 module Mirah
   module Compiler
     class ASTCompiler
-      def initialize(compiler_class, logging)
+      def initialize(config, compiler_class, logging)
+        @config = config
         @compiler_class = compiler_class
         @logging = logging
       end
@@ -29,16 +30,29 @@ module Mirah
         nodes.each do |ast|
           puts "  #{ast.position.source.name}" if logging
           compile_ast(ast, scoper, typer) do |filename, builder|
-            results << CompilerResult.new(filename, builder.class_name, builder.generate)
+            if builder.respond_to?(:class_name)
+              class_name = builder.class_name
+              bytes = builder.generate
+            else
+              class_name = filename
+              bytes = String.from_java_bytes(builder)
+              filename = class_name.tr('.', '/') + ".class"
+            end
+            results << CompilerResult.new(filename, class_name, bytes)
           end
         end
         results
       end
 
       def compile_ast(ast, scoper, typer, &block)
-        @compiler = compiler_class.new(scoper, typer)
+        @compiler = compiler_class.new(@config, scoper, typer)
         compiler.visit(ast, nil)
         compiler.generate(&block)
+      rescue java.lang.UnsupportedOperationException => ex
+        raise MirahError.new(ex.message)
+      rescue java.lang.Throwable => ex
+        ex.cause.printStackTrace if ex.cause
+        raise ex
       end
     end
 

data/lib/mirah/errors.rb

@@ -1,4 +1,4 @@
-# Copyright (c) 2010 The Mirah project authors. All Rights Reserved.
+# Copyright (c) 2010-2013 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");
@@ -34,23 +34,24 @@ module Mirah
     end
 
     def node=(node)
-      @position = node ? node.position : nil
-      @node = node
+      @position = node.position if node
+      @node     = node
     end
 
     def self.wrap(ex, node)
-      if ex.kind_of?(NodeError)
+      case ex
+      when NodeError
         ex.node ||= node
-        return ex
-      elsif ex.kind_of?(MirahError)
+        ex
+      when MirahError
         ex.position ||= node.position
-        return ex
+        ex
       else
         new_ex = new(ex.message, node)
-        new_ex.cause = ex
+        new_ex.cause      = ex
         new_ex.position ||= ex.position if ex.respond_to?(:position)
         new_ex.set_backtrace(ex.backtrace)
-        return new_ex
+        new_ex
       end
     end
 
@@ -66,7 +67,6 @@ module Mirah
   class SyntaxError < NodeError
   end
 
-
   class InferenceError < NodeError
   end
 

data/lib/mirah/generator.rb

@@ -25,18 +25,30 @@ module Mirah
 
     def initialize(state, compiler_class, logging, verbose)
       @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
+      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)
+      @typer = Mirah::Typer::Typer.new(type_system, @scoper, self, nil)
       @parser = Mirah::Parser.new(state, @typer, logging)
-      @compiler = Mirah::Compiler::ASTCompiler.new(compiler_class, logging)
-      @jvm_compiler = Mirah::Compiler::ASTCompiler.new(Mirah::JVM::Compiler::JVMBytecode, logging)
-      type_system.maybe_initialize_builtins(@typer.macro_compiler)
+      @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
@@ -93,7 +105,7 @@ module Mirah
     def compileAndLoadExtension(ast)
       log_types([ast])
       process_inference_errors(@typer, [ast])
-      results = @jvm_compiler.compile_asts([ast], @scoper, @typer)
+      results = @extension_compiler.compile_asts([ast], @scoper, @typer)
       class_map = {}
       first_class_name = nil
       results.each do |result|

data/lib/mirah/jvm/compiler.rb

@@ -19,6 +19,7 @@ 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
@@ -31,3 +32,19 @@ module Mirah
     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

@@ -32,16 +32,25 @@ module Mirah
           "org.mirah.ruby.JVM.Compiler.Base"
         end
 
-        def initialize(scoper, typer)
+        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
+          @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
@@ -192,9 +201,12 @@ module Mirah
 
         # 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
-          @class.build_method(name.to_s, visibility, static,
-          exceptions, return_type, *arg_types)
+          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)
@@ -205,7 +217,7 @@ module Mirah
             name = "<clinit>"
           end
           arg_types = args.map { |arg| inferred_type(arg) }
-          return_type = inferred_type(node)
+          return_type = inferred_type(node).return_type
           exceptions = []  # TODO
 
           with :static => is_static, :current_scope => introduced_scope(node) do
@@ -341,6 +353,13 @@ module Mirah
             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)

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

@@ -1,3 +1,5 @@
+require 'mirah/jvm/types/ast_ext'
+
 module Mirah
   module JVM
     module Compiler
@@ -40,7 +42,7 @@ module Mirah
           end
         end
 
-        def initialize(scoper, typer)
+        def initialize(config, scoper, typer)
           super
           @jump_scope = []
         end
@@ -52,8 +54,8 @@ module Mirah
         def file_builder(filename)
           builder = BiteScript::FileBuilder.new(filename)
           builder.to_widen do |_a, _b|
-            a = @typer.type_system.get_type(_a)
-            b = @typer.type_system.get_type(_b)
+            a = @typer.type_system.get_type(_a.tr('/', '.'))
+            b = @typer.type_system.get_type(_b.tr('/', '.'))
             a_ancestors = []
             while a
               a_ancestors << a.name
@@ -65,7 +67,13 @@ module Mirah
               b = b.superclass
             end
             intersection = (a_ancestors & b_ancestors)
-            intersection[0].gsub('.', '/')
+            if intersection.size == 0
+              puts "#{_a} => #{a}, #{_b} => #{b}"
+              puts "#{a_ancestors.inspect} & #{b_ancestors.inspect} = []"
+              'java/lang/Object'
+            else
+              intersection[0].gsub('.', '/')
+            end
           end
           @typer.type_system.define_types(builder)
           builder
@@ -139,12 +147,12 @@ module Mirah
         def visitMethodDefinition(node, expression)
           push_jump_scope(node) do
             base_define_method(node) do |method, arg_types|
-              return if @class.interface?
+              return if @class.interface? || node.annotated_abstract?
               is_static = self.static || node.kind_of?(StaticMethodDefinition)
 
               log "Starting new #{is_static ? 'static ' : ''}method #{node.name.identifier}(#{arg_types})"
               args = visit(node.arguments, true)
-              method_body(method, args, node, inferred_type(node))
+              method_body(method, args, node, inferred_type(node).returnType)
               log "Method #{node.name.identifier}(#{arg_types}) complete!"
             end
           end
@@ -233,17 +241,26 @@ module Mirah
 
             prepare_binding(node) do
               expression = return_type.name != 'void'
-              visit(body, expression) if body
+              if body
+                if expression
+                  body_type = inferred_type(body)
+                  unless return_type.assignableFrom(body_type)
+                    error("Invalid return type #{body_type.name}, expected #{return_type.name}", body)
+                  end
+                end
+                visit(body, expression)
+                convert_value inferred_type(body), return_type if expression
+              end
             end
 
-            return_type.return(@method)
+            return_type.return(@method) unless return_type.name == ':unreachable'
 
             @method.stop
           end
         end
 
         def visitClosureDefinition(class_def, expression)
-          compiler = ClosureCompiler.new(@file, @type, self, @scoper, @typer)
+          compiler = ClosureCompiler.new(@config, @file, @type, self, @scoper, @typer)
           compiler.visitClassDefinition(class_def, expression)
         end
 
@@ -440,6 +457,18 @@ module Mirah
           end
         end
 
+        def visitVarargsArray type, parameters
+          @method.push_int parameters.size
+          @method.anewarray type.component_type
+          parameters.each.with_index do |value, i|
+            @method.dup
+            @method.push_int i
+            visit(value, true)
+            convert_value inferred_type(value), type.component_type
+            @method.aastore
+          end
+        end
+
         def visitFunctionalCall(fcall, expression)
           scope = get_scope(fcall)
           type = get_scope(fcall).self_type.resolve
@@ -562,6 +591,7 @@ module Mirah
 
         def annotate(builder, annotations)
           annotations.each do |annotation|
+            next if annotation.type.typeref.name.start_with?('org.mirah.jvm.')
             type = inferred_type(annotation)
             mirror = type.jvm_type
             if mirror.respond_to?(:getDeclaredAnnotation)
@@ -730,19 +760,29 @@ module Mirah
           declare_local(scope, name, type)
 
           visit(local.value, true)
+          convert_value inferred_type(local.value), type
 
           # if expression, dup the value we're assigning
-          @method.dup if expression
+          if expression
+            dup_value type
+          end
+
           set_position(local.position)
           type.store(@method, @method.local(scoped_local_name(name, scope), type))
         end
 
         def captured_local_assign(node, expression)
-          scope, name, type = containing_scope(node), node.name.identifier, inferred_type(node)
+          scope, name = containing_scope(node), node.name.identifier
+          type = get_scope(node).local_type(name).resolve
           captured_local_declare(scope, name, type)
           binding_reference
           visit(node.value, true)
-          @method.dup_x2 if expression
+          convert_value(inferred_type(node.value), type)
+
+          # if expression, dup the value we're assigning
+          if expression
+            dup_x2_value type
+          end
           set_position(node.position)
           @method.putfield(scope.binding_type, name, type)
         end
@@ -906,9 +946,6 @@ module Mirah
               @method.invokeinterface java::util::List, "add", [@method.boolean, @method.object]
               @method.pop
             end
-
-            # make it unmodifiable
-            @method.invokestatic java::util::Collections, "unmodifiableList", [java::util::List, java::util::List]
           else
             # elements, as non-expressions
             # TODO: ensure they're all reference types!
@@ -997,7 +1034,7 @@ module Mirah
 
         def set_position(position)
           # TODO support positions from multiple files
-          @method.line(position.start_line - 1) if @method && position
+          @method.line(position.start_line) if @method && position
         end
 
         def print(print_node)
@@ -1034,10 +1071,14 @@ module Mirah
           start = @method.label.set!
           body_end = @method.label
           done = @method.label
-          visit(rescue_node.body, expression && rescue_node.else_clause.size == 0)
+          no_else_clauses = rescue_node.else_clause.size == 0
+
+          visit(rescue_node.body, expression && no_else_clauses)
           body_end.set!
-          visit(rescue_node.else_clause, expression) if rescue_node.else_clause.size > 0
+
+          visit(rescue_node.else_clause, expression) unless no_else_clauses
           return if start.label.offset == body_end.label.offset
+
           @method.goto(done)
           rescue_node.clauses.each do |clause|
             target = @method.label.set!
@@ -1092,9 +1133,31 @@ module Mirah
           end
         end
 
+        private
+
+        def convert_value in_type, out_type
+          in_type.compile_widen(@method, out_type) if in_type.name != ':unreachable' &&  in_type.primitive?
+        end
+
+        def dup_value type
+          if type.primitive? && type.wide?
+            @method.dup2
+          else
+            @method.dup
+          end
+        end
+
+        def dup_x2_value type
+          if type.primitive? && type.wide?
+            @method.dup2_x2
+          else
+            @method.dup_x2
+          end
+        end
+
         class ClosureCompiler < JVMBytecode
-          def initialize(file, type, parent, scoper, typer)
-            super(scoper, typer)
+          def initialize(config, file, type, parent, scoper, typer)
+            super(config, scoper, typer)
             @file = file
             @type = type
             @jump_scope = []