mirah 0.0.9-java → 0.0.10-java

data/History.txt

@@ -1,3 +1,43 @@
+=== 0.0.10 / 2011-11-20
+
+f6035d0 set version to 0.0.10
+3b06353 use test_helper in gwt test
+4d29eeb turns out a number of things rely on MirahCommands being truthy on success
+46e6719 fixes 156 for real, also do the ant lowercase thing
+9e40121 don't exit on successful compile
+1155765 move comment about class loader to line it refers to
+985c70f add jvm_version option to Compile ant task w/ 1.6 default
+e5a60b2 replace duby with mirah in lib/mirah/ast/flow.rb
+5690e6f split rescue error tests to deal w/ caching expression value
+1f77ed8 add some white space, use #empty? instead of size==0
+677e4aa fixes #52 by raising an inference error when types arent compat
+81be877 add assert_raise_java to get around the NativeException thing
+d744f44 use assert_raise instead of begin;fail/rescue
+05afc6e pull out rescue tests for jvm into separate file
+7a933f3 raise an inference error when method has same name as macro. fixes #123
+6517a90 clean up the Block#add_methods method a bit
+0a826dd ensure that a block body is created even when the block is empty
+d8b0641 change duby to mirah in Binding#binding_type
+47883e9 change duby to mirah in StaticScope#binding_type
+8f3fddf Fix whitespace.
+74b6195 use turn for prettying up test output
+23d0693 add license header to test_macros
+143ac6c add a test_helper to put global test config in
+6fe3241 fix #149 exit 1 when there are errors
+31074c6 fix #146 by not reassigning self to Builtin
+8fb471e s/duby/mirah/ in jvm types intrinsics
+ff06791 s/qote/quote/
+972a9f9 refactor void checking on method return into method
+605c377 fix #148 in the simplest way possible
+f1b5c19 fix inspect_children typo
+4140fa7 use case statements instead of === & if elses in UnquotedValueAssign#node
+b82bbeb in Node#inspect_children, replace if elses w/ a case statement
+049a4cf clean up body inference a little
+d9e92b4 Merge remote branch 'thomaslee/master' into thomaslee
+0c72195 fix name of compilation test
+cfbf4c5 bump versions to 0.0.10{.dev,-SNAPSHOT}
+8c0ecec Fix test_empty_array.
+
 === 0.0.9 / 2011-09-12
 
 a5963ef use self hosted classloader fixes #144

data/Rakefile

@@ -56,6 +56,7 @@ namespace :test do
 
   desc "run the core tests"
   Rake::TestTask.new :core do |t|
+    t.libs << 'test'
     t.test_files = FileList["test/core/**/test*.rb"]
     java.lang.System.set_property("jruby.duby.enabled", "true")
   end
@@ -75,7 +76,7 @@ namespace :test do
   namespace :jvm do
     desc "run jvm tests compiling to bytecode"
     Rake::TestTask.new :bytecode do |t|
-      t.libs << 'test/jvm'
+      t.libs << 'test' <<'test/jvm'
       t.ruby_opts.concat ["-r", "bytecode_test_helper"]
       t.test_files = FileList["test/jvm/**/test*.rb"]
       java.lang.System.set_property("jruby.duby.enabled", "true")
@@ -83,7 +84,7 @@ namespace :test do
     
     desc "run jvm tests compiling to java source, then bytecode"
     Rake::TestTask.new :javac do |t|
-      t.libs << 'test/jvm'
+      t.libs << 'test' <<'test/jvm'
       t.ruby_opts.concat ["-r", "javac_test_helper"]
       t.test_files = FileList["test/jvm/**/test*.rb"]
       java.lang.System.set_property("jruby.duby.enabled", "true")

data/lib/mirah/ast.rb

@@ -160,23 +160,33 @@ module Mirah
           extra_indent = 0
           if child
             name = self.class.child_name(i)
+            
+            wrong_parent = lambda do |child|
+              if Node === child && child.parent != self 
+                "\n#{indent_str} (wrong parent)"
+              else
+                ""
+              end
+            end
+            
             if Mirah::AST.verbose && name
               str << "\n#{indent_str} #{name}:"
               extra_indent = 1
             end
-            if ::Array === child
-              child.each {|ary_child|
-                if Mirah::AST.verbose && Node === ary_child && ary_child.parent != self
-                   str << "\n#{indent_str} (wrong parent)"
-                 end
+            
+            case child
+            when ::Array
+              child.each do |ary_child|
+                
+                str << wrong_parent[ary_child] if Mirah::AST.verbose
+                
                 str << "\n#{ary_child.inspect(indent + extra_indent + 1)}"
-              }
-            elsif ::Hash === child || ::String === child
+              end
+            when ::Hash, ::String
               str << "\n#{indent_str} #{child.inspect}"
             else
-              if Mirah::AST.verbose && Node === child && child.parent != self
-                str << "\n#{indent_str} (wrong parent)"
-              end
+              str << wrong_parent[child] if Mirah::AST.verbose
+              
               begin
                 str << "\n#{child.inspect(indent + extra_indent + 1)}"
               rescue ArgumentError => ex
@@ -358,8 +368,8 @@ module Mirah
     end
 
     module Binding
-      def binding_type(duby=nil)
-        static_scope.binding_type(defining_class, duby)
+      def binding_type(mirah=nil)
+        static_scope.binding_type(defining_class, mirah)
       end
 
       def binding_type=(type)

data/lib/mirah/ast/flow.rb

@@ -64,6 +64,7 @@ module Mirah
           if expression
             have_body_type = body.nil? || then_type
             have_else_type = self.else.nil? || else_type
+            
             if have_body_type && have_else_type
               if then_type && else_type
                 # both then and else inferred, ensure they're compatible
@@ -299,8 +300,8 @@ module Mirah
         @inferred_type
       end
 
-      def binding_type(duby=nil)
-        static_scope.parent.binding_type(defining_class, duby)
+      def binding_type(mirah=nil)
+        static_scope.parent.binding_type(defining_class, mirah)
       end
 
       def binding_type=(type)
@@ -323,24 +324,37 @@ module Mirah
 
       def infer(typer, expression)
         unless resolved?
-          types = []
-          body_type = typer.infer(body, else_node.nil?) if body
-          else_type = typer.infer(else_node, true) if else_node
-          if else_node
-            types << else_type
+          # TODO: generalize this s.t.
+          # the problem with deferred inference
+          # assuming expression == true is dealt with
+          @expression = expression if @expression == nil
+          expression = @expression
+          
+          primary_type = if else_node
+            typer.infer(body, false) if body
+            typer.infer(else_node, expression)
           elsif body
-            types << body_type
+            typer.infer(body, expression)
           end
-          types += clauses.map {|c| typer.infer(c, true)}
+          
+          clause_types = clauses.map {|c| typer.infer(c, expression)}
+          types = []
+          types << primary_type if primary_type
+          types += clause_types
           if types.any? {|t| t.nil?}
             typer.defer(self)
           else
-            # TODO check types for compatibility (maybe only if an expression)
-            resolved!
-            types.each do |type|
-              @inferred_type ||= type unless type.unreachable?
+            if !expression || clause_types.all?{ |t| primary_type.compatible? t}
+              resolved!
+              types.each do |type|
+                @inferred_type ||= type unless type.unreachable?
+              end
+              @inferred_type ||= primary_type
+            else
+              clause, clause_type = clauses.zip(clause_types).find{ |clause, t| !primary_type.compatible? t }
+              
+              raise Mirah::Typer::InferenceError.new("rescue statement with incompatible result types #{primary_type} and #{clause_type}", clause)
             end
-            @inferred_type ||= types[0]
           end
         end
         @inferred_type

data/lib/mirah/ast/intrinsics.rb

@@ -51,19 +51,19 @@ module Mirah::AST
     end
 
     def self.__extracted
-      Thread.current[:'Mirah::AST::Unqote.extracted']
+      Thread.current[:'Mirah::AST::Unquote.extracted']
     end
 
     def self.__extracted=(value)
-      Thread.current[:'Mirah::AST::Unqote.extracted'] = value
+      Thread.current[:'Mirah::AST::Unquote.extracted'] = value
     end
 
     def self.__injected
-      Thread.current[:'Mirah::AST::Unqote.injected']
+      Thread.current[:'Mirah::AST::Unquote.injected']
     end
 
     def self.__injected=(value)
-      Thread.current[:'Mirah::AST::Unqote.injected'] = value
+      Thread.current[:'Mirah::AST::Unquote.injected'] = value
     end
 
     def self.extract_values
@@ -212,27 +212,30 @@ module Mirah::AST
       else
         name_node = self.name_node
       end
+      
       klass = LocalAssignment
-      if Field === name_node
-        name = name_node.name
-        klass = FieldAssignment
-      # TODO support AttrAssign
-      elsif Named === name_node
-        name = name_node.name
-      elsif String === name_node
-        name = name_node.literal
-      elsif ::String === name_node
-        name = name_node
-      else
-        raise "Bad unquote value"
-      end
+      name = case name_node
+        when Field
+        # TODO support AttrAssign
+          klass = FieldAssignment
+          name_node.name
+        when Named
+          name_node.name
+        when String
+          name_node.literal
+        else
+          raise "Bad unquote value"
+        end
+        
       if name[0] == ?@
         name = name[1, name.length]
         klass = FieldAssignment
       end
+      
       n = klass.new(nil, position, name)
       n << value
       n.validate_children
+      
       if scope
         scope.children.clear
         scope << n

data/lib/mirah/ast/method.rb

@@ -255,6 +255,7 @@ module Mirah::AST
           end
           signature[:return] = @return_type.type_reference(typer)
         end
+        
         if @exceptions
           signature[:throws] = @exceptions.map {|e| e.type_reference(typer)}
         end
@@ -264,11 +265,16 @@ module Mirah::AST
         inferred_type = body ? typer.infer(body, body_is_expression) : typer.no_type
 
         if inferred_type && arguments.inferred_type.all?
-          actual_type = if forced_type.nil?
-            inferred_type
-          else
+          actual_type = if forced_type
             forced_type
+          else
+            inferred_type
+          end
+          
+          if actual_type.kind_of? Mirah::AST::InlineCode
+            raise Mirah::Typer::InferenceError.new("Method %s has the same signature as macro of the same name." % name,self) 
           end
+
           if actual_type.unreachable?
             actual_type = typer.no_type
           end

data/lib/mirah/ast/scope.rb

@@ -156,12 +156,12 @@ module Mirah
         @self_node
       end
 
-      def binding_type(defining_class=nil, duby=nil)
+      def binding_type(defining_class=nil, mirah=nil)
         @binding_type ||= begin
           if parent
-            parent.binding_type(defining_class, duby)
+            parent.binding_type(defining_class, mirah)
           else
-            name = "#{defining_class.name}$#{duby.tmp}"
+            name = "#{defining_class.name}$#{mirah.tmp}"
             factory = Mirah::AST.type_factory
             if factory
               factory.declare_type(@scope_node, name)

data/lib/mirah/ast/structure.rb

@@ -26,14 +26,14 @@ module Mirah::AST
       unless @inferred_type
         @typer ||= typer
         @self_type ||= typer.self_type
-        if children.size == 0
+        
+        if children.empty?
           @inferred_type = typer.no_type
         else
-          last = children.size - 1
-          children.each_with_index do |child, i|
-            child_is_expression = (i == last && expression)
-            @inferred_type = typer.infer(child, child_is_expression)
+          children[0..-2].each do |child|
+            typer.infer(child, false)
           end
+          @inferred_type = typer.infer(children.last, expression)
         end
 
         if @inferred_type
@@ -175,16 +175,19 @@ module Mirah::AST
     end
 
     def add_methods(klass, binding, typer)
-      found_def = false
-      body.each do |node|
-        if node.kind_of?(MethodDefinition)
-          found_def = true
+      method_definitions = body.select{ |node| node.kind_of? MethodDefinition }
+      
+      if method_definitions.empty?
+        build_method(klass, binding, typer)
+      else
+        # TODO warn if there are non method definition nodes
+        # they won't be used at all currently--so it'd be nice to note that.
+        method_definitions.each do |node|
           node.static_scope = static_scope
           node.binding_type = binding
           klass.append_node(node)
         end
       end
-      build_method(klass, binding, typer) unless found_def
     end
 
     def build_method(klass, binding, typer)
@@ -338,13 +341,13 @@ module Mirah::AST
       case node
       when String
         java.lang.String.new(node.literal)
+      when Fixnum
+        java.lang.Integer.new(node.literal)
       when Array
         node.children.map {|node| annotation_value(node, typer)}
       else
         # TODO Support other types
-        ref = value.type_refence(typer)
-        desc = BiteScript::Signature.class_id(ref)
-        BiteScript::ASM::Type.getType(desc)
+        raise "Unsupported Annotation Value Type"
       end
     end
   end

data/lib/mirah/commands/base.rb

@@ -34,8 +34,8 @@ module Mirah
       def execute_base
         # because MirahCommand is a JRuby Java class, SystemExit bubbles through and makes noise
         # so we use a catch/throw to early exit instead
-        # see process_errors.rb
-        catch(:exit) do
+        # see util/process_errors.rb
+        status = catch(:exit) do
           begin
             argument_processor.process
             yield
@@ -46,8 +46,12 @@ module Mirah
           rescue Mirah::MirahError => ex
             Mirah.print_error(ex.message, ex.position)
             puts ex.backtrace if state.verbose
+            throw :exit, 1
           end
+          0
         end
+        exit status if status > 0
+        true
       end
     end
   end

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

@@ -75,7 +75,7 @@ module Mirah
 
               prepare_binding(node) do
                 declare_locals(node.static_scope)
-                unless @method.type.nil? || @method.type.void?
+                unless method.returns_void?
                   self.return(ImplicitReturn.new(node.body))
                 else
                   node.body.compile(self, false) if node.body
@@ -87,7 +87,7 @@ module Mirah
             end
           end
         end
-
+        
         def annotate(node, annotations)
           node.annotate(annotations)
         end
@@ -95,7 +95,7 @@ module Mirah
         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.type.nil? || @method.type.void?
+          @method.print "return " unless method.returns_void?
           @method.print "this." unless @static
           @method.print "#{name}("
           @method.print args_for_opt.map(&:name).join(', ')
@@ -164,7 +164,7 @@ module Mirah
         end
 
         def return(node)
-          if @method.type.nil? || @method.type.void?
+          if method.returns_void?
             @method.puts 'return;'
             return
           end

data/lib/mirah/jvm/source_generator/builder.rb

@@ -157,6 +157,8 @@ module Mirah
 
       def annotation_value(value)
         case value
+        when Java::JavaLang::Integer
+          value.to_s
         when Java::JavaLang::String, String
           value.to_s.inspect
         when Array
@@ -394,6 +396,10 @@ module Mirah
         dedent
         puts "}"
       end
+      
+      def returns_void?
+        type.nil? || type.void?
+      end
 
       def declare_local(type, name, initialize=true)
         unless @locals[name]