duby 0.0.2-java → 0.0.3-java

data/lib/duby/typer.rb

@@ -10,7 +10,7 @@ module Duby
         puts "* [#{name}] #{message}" if Typer.verbose
       end
     end
-    
+
     class InferenceError < Exception
       attr_accessor :node
       def initialize(msg, node = nil)
@@ -18,23 +18,23 @@ module Duby
         @node = node
       end
     end
-    
+
     class BaseTyper
       include Duby
 
       def log(message); Typer.log(message); end
-      
+
       def to_s
         name
       end
     end
-    
+
     class Simple < BaseTyper
-      attr_accessor :known_types, :errors
+      attr_accessor :known_types, :errors, :last_chance
 
       def initialize(self_type)
         @known_types = {}
-        
+
         @known_types["self"] = type_reference(self_type)
         @known_types["fixnum"] = type_reference("fixnum")
         @known_types["float"] = type_reference("float")
@@ -42,11 +42,11 @@ module Duby
         @known_types["boolean"] = type_reference("boolean")
         @errors = []
       end
-      
+
       def name
         "Simple"
       end
-      
+
       def self_type
         known_types["self"]
       end
@@ -54,19 +54,19 @@ module Duby
       def default_type
         nil
       end
-      
+
       def fixnum_type
         known_types["fixnum"]
       end
-      
+
       def float_type
         known_types["float"]
       end
-      
+
       def string_type
         known_types["string"]
       end
-      
+
       def boolean_type
         known_types["boolean"]
       end
@@ -89,36 +89,44 @@ module Duby
         AST::TypeReference::NullType
       end
 
+      def known_type(name)
+        @known_types[name]
+      end
+
       def define_type(name, superclass, interfaces)
         log "New type defined: '#{name}' < '#{superclass}'"
         known_types[name] = type_definition(name, superclass, interfaces)
-        
+
         old_self, known_types["self"] = known_types["self"], known_types[name]
         yield
         known_types["self"] = old_self
-        
+
         known_types[name]
       end
-      
+
       def learn_local_type(scope, name, type)
-        log "Learned local type under #{scope} : #{name} = #{type}"
+        existing_type = local_type_hash(scope)[name]
+        if existing_type
+          # TODO check for compatibility?
+          existing_type
+        elsif type
+          log "Learned local type under #{scope} : #{name} = #{type}"
+
+          local_type_hash(scope)[name] = known_types[type] || type
+        end
+      end
 
-        # TODO check for compatibility?
-        local_type_hash(scope)[name] ||= known_types[type] || type
+      def local_type(scope, name)
+        type = local_type_hash(scope)[name]
+        log "Retrieved local type in #{scope} : #{name} = #{type}" if type
 
         type
       end
-      
-      def local_type(scope, name)
-        log "Retrieved local type in #{scope} : #{name} = #{local_type_hash(scope)[name]}"
 
-        local_type_hash(scope)[name]
-      end
-      
       def local_types
         @local_types ||= {}
       end
-      
+
       def local_type_hash(scope)
         local_types[scope] ||= {}
       end
@@ -146,7 +154,7 @@ module Duby
       def field_type(cls, name)
         field_type_hash(cls)[name]
       end
-      
+
       def learn_method_type(target_type, name, parameter_types, type, exceptions)
         log "Learned method #{name} (#{parameter_types}) on #{target_type} = #{type}"
 
@@ -156,7 +164,7 @@ module Duby
         imported_types = parameter_types.map {|param| known_types[param] || param}
         get_method_type_hash(target_type, name, imported_types)[:type] = type
       end
-      
+
       def method_type(target_type, name, parameter_types)
         if (target_type && target_type.error?) ||
             parameter_types.any? {|t| t && t.error?}
@@ -191,7 +199,7 @@ module Duby
           simple_type
         end
       end
-      
+
       def plugins
         if cycling?
           Duby.typer_plugins.each do |plugin|
@@ -201,18 +209,18 @@ module Duby
             return result if result
           end
         end
-        
+
         nil
       end
-      
+
       def cycling?
         @cycling
       end
-      
+
       def cycling=(c)
         @cycling = c
       end
-      
+
       def cycle(count)
         @cycling = true
         count.times do |i|
@@ -226,23 +234,23 @@ module Duby
       ensure
         @cycling = false
       end
-      
+
       def method_types
         @method_types ||= {}
       end
-      
+
       def get_method_type_hash(target_type, name, parameter_types)
         method_types[target_type] ||= {}
         method_types[target_type][name] ||= {}
         method_types[target_type][name][parameter_types.size] ||= {}
-        
+
         current = method_types[target_type][name][parameter_types.size]
 
         parameter_types.each {|type| current[type] ||= {}; current = current[type]}
 
         current
       end
-      
+
       def type_reference(name, array=false, meta=false)
         AST::TypeReference.new(name, array, meta)
       end
@@ -257,7 +265,7 @@ module Duby
       end
 
       def deferred_nodes
-        @deferred_nodes ||= []
+        @deferred_nodes ||= {}
       end
 
       def infer(node)
@@ -294,27 +302,31 @@ module Duby
         else
           return if deferred_nodes.include? node
           log "Deferring inference for #{node}"
-        
-          deferred_nodes << node
+
+          deferred_nodes[node] = self_type
         end
       end
 
       def resolve(raise = false)
         count = deferred_nodes.size + 1
-        
+
         log "Entering type inference cycle"
-        
+
         retried = false
         cycle(count) do |i|
           old_deferred = @deferred_nodes
-          @deferred_nodes = deferred_nodes.select do |node|
+          @deferred_nodes = {}
+          old_deferred.each do |node, saved_type|
+            known_types["self"] = saved_type
             type = infer(node)
 
             log "[Cycle #{i}]: Inferred type for #{node}: #{type || 'FAILED'}"
 
-            type == default_type
+            if type == default_type
+              @deferred_nodes[node] = saved_type
+            end
           end
-          
+
           if @deferred_nodes.size == 0
             log "[Cycle #{i}]:  Resolved all types, exiting"
             break
@@ -322,31 +334,44 @@ module Duby
             if @error_next || retried
               log "[Cycle #{i}]: Made no progress, bailing out"
               break
-            else
+            elsif @last_chance
               # Retry this iteration, and mark the first deferred
               # type as an error.
               retried = true
               @error_next = true
               redo
+            else
+              # This is a hack for default constructor support.  The right fix
+              # is probably to check the AST for constructors. Instead we
+              # tell the plugins that we're near the end of inference so they
+              # can assume no new constructors are being added.  You could
+              # easily write some circular constructors that would compile
+              # with this technique but fail to run.
+              @last_chance = true
+              redo
             end
           end
           retried = false
         end
 
-        # done with n sweeps, if any remain raise errors
-        error_nodes = @errors.map {|e| e.node} + deferred_nodes
+        # done with n sweeps, if any remain mark them as errors
+        error_nodes = @errors.map {|e| e.node}
+        (deferred_nodes.keys - error_nodes).each do |deferred_node|
+          error_nodes << deferred_node
+          error(deferred_node)
+        end
         if raise && !error_nodes.empty?
           msg = "Could not infer typing for nodes:"
           error_nodes.map do |e|
             msg << "\n  "
-            msg << "#{e} at line #{e.line_number} (child of #{e.parent})"
+            msg << "#{e.inspect} at line #{e.line_number} (child of #{e.parent})"
           end
           raise InferenceError.new(msg)
         end
       end
     end
   end
-  
+
   def self.typer_plugins
     @typer_plugins ||= []
   end
@@ -363,7 +388,7 @@ if __FILE__ == $0
   rescue Duby::Typer::InferenceError => e
     puts e.message
   end
-  
+
   puts "\nAST:"
   p ast
 end

data/test/test_ast.rb

@@ -4,15 +4,15 @@ require 'jruby'
 
 class TestAst < Test::Unit::TestCase
   include Duby
-  
+
   def test_args
-    new_ast = AST.parse("def foo(a, *c, &d); end").body
+    new_ast = AST.parse("def foo(a, *c, &d); end").body[0]
     arguments = new_ast.arguments
-    
+
     assert_not_nil(arguments)
     inspected = "Arguments\n RequiredArgument(a)\n RestArgument(c)\n BlockArgument(d)"
     assert_equal(inspected, arguments.inspect)
-    
+
     assert(AST::Arguments === arguments)
     children = arguments.children
     assert_not_nil(children)
@@ -28,41 +28,41 @@ class TestAst < Test::Unit::TestCase
     assert_equal("d", children[3].name)
     assert_equal(arguments, children[3].parent)
   end
-  
+
   def test_locals
     new_ast = AST.parse("a = 1; a").body
-    
+
     assert_not_nil(new_ast)
     assert(AST::Body === new_ast)
-    inspected = "Body\n LocalAssignment(name = a, scope = Script, captured = false)\n  Fixnum(1)\n Local(name = a, scope = Script, captured = false)"
+    inspected = "Body\n LocalAssignment(name = a, scope = Script, captured = false)\n  Fixnum(1)\n FunctionalCall(a)"
     assert_equal(inspected, new_ast.inspect)
     assert(!new_ast.newline)
-    
+
     asgn = new_ast[0]
     var = new_ast[1]
-    
+
     assert(AST::LocalAssignment === asgn)
     assert(asgn.newline)
     assert_equal("a", asgn.name)
     assert(AST::Fixnum === asgn.value)
     assert(!asgn.value.newline)
-    assert(AST::Local === var)
+    assert(AST::FunctionalCall === var)
     assert(var.newline)
     assert_equal("a", var.name)
   end
-  
+
   def test_fields
     new_ast = AST.parse("@a = 1; @a").body
-    
+
     assert_not_nil(new_ast)
     assert(AST::Body === new_ast)
     inspected = "Body\n FieldAssignment(@a)\n  Fixnum(1)\n Field(@a)"
     assert_equal(inspected, new_ast.inspect)
     assert(!new_ast.newline)
-    
+
     asgn = new_ast[0]
     var = new_ast[1]
-    
+
     assert(AST::FieldAssignment === asgn)
     assert(asgn.newline)
     assert_equal("@a", asgn.name)
@@ -72,52 +72,52 @@ class TestAst < Test::Unit::TestCase
     assert(var.newline)
     assert_equal("@a", var.name)
   end
-  
+
   def test_array
-    new_ast = AST.parse("[a = 1, 1]").body
-    
+    new_ast = AST.parse("[a = 1, 1]").body[0]
+
     assert_not_nil(new_ast)
     assert(AST::Array === new_ast)
     assert_equal("Array\n LocalAssignment(name = a, scope = Script, captured = false)\n  Fixnum(1)\n Fixnum(1)", new_ast.inspect)
-    
+
     assert(AST::LocalAssignment === new_ast[0])
     assert(AST::Fixnum === new_ast[1])
   end
-  
+
   def test_call
-    new_ast = AST.parse("1.foo(1)").body
-    
+    new_ast = AST.parse("1.foo(1)").body[0]
+
     assert_not_nil(new_ast)
     assert(AST::Call === new_ast)
     assert_equal("Call(foo)\n Fixnum(1)\n Fixnum(1)", new_ast.inspect)
-    
+
     assert_equal("foo", new_ast.name)
     assert(AST::Fixnum === new_ast.target)
     assert_not_nil(new_ast.parameters)
     assert_equal(1, new_ast.parameters.size)
     assert(AST::Fixnum === new_ast.parameters[0])
   end
-  
+
   def test_fcall
-    new_ast = AST.parse("foo(1)").body
-    
+    new_ast = AST.parse("foo(1)").body[0]
+
     assert_not_nil(new_ast)
     assert(AST::FunctionalCall === new_ast)
     assert_equal("FunctionalCall(foo)\n Fixnum(1)", new_ast.inspect)
-    
+
     assert_equal("foo", new_ast.name)
     assert_not_nil(new_ast.parameters)
     assert_equal(1, new_ast.parameters.size)
     assert(AST::Fixnum === new_ast.parameters[0])
   end
-  
+
   def test_if
-    new_ast = AST.parse("if 1; 2; elsif !3; 4; else; 5; end").body
-    
+    new_ast = AST.parse("if 1; 2; elsif !3; 4; else; 5; end").body[0]
+
     assert_not_nil(new_ast)
     assert(AST::If === new_ast)
     assert_equal("If\n Condition\n  Fixnum(1)\n Fixnum(2)\n If\n  Condition\n   Not\n    Fixnum(3)\n  Fixnum(4)\n  Fixnum(5)", new_ast.inspect)
-    
+
     assert(AST::Condition === new_ast.condition)
     assert(AST::Fixnum === new_ast.condition.predicate)
     assert(AST::Fixnum === new_ast.body)
@@ -127,74 +127,74 @@ class TestAst < Test::Unit::TestCase
     assert(AST::Fixnum === new_ast.else.body)
     assert(AST::Fixnum === new_ast.else.else)
   end
-  
+
   def test_begin
     new_ast = AST.parse("begin; 1; 2; end").body
-    
+
     assert_not_nil(new_ast)
     assert_equal("Body\n Fixnum(1)\n Fixnum(2)", new_ast.inspect)
     assert(AST::Body === new_ast)
     assert(AST::Fixnum === new_ast[0])
-    
-    new_ast = AST.parse("begin; 1; end").body
+
+    new_ast = AST.parse("begin; 1; end").body[0]
     assert(AST::Fixnum === new_ast)
-    
-    new_ast = AST.parse("begin; end").body
+
+    new_ast = AST.parse("begin; end").body[0]
     assert(AST::Noop === new_ast)
   end
-  
+
   def test_block
     new_ast = AST.parse("1; 2").body
-    
+
     assert_not_nil(new_ast)
     assert_equal("Body\n Fixnum(1)\n Fixnum(2)", new_ast.inspect)
     assert(AST::Body === new_ast)
     assert(AST::Fixnum === new_ast[0])
-    
-    new_ast = AST.parse("1").body
+
+    new_ast = AST.parse("1").body[0]
     assert(AST::Fixnum === new_ast)
   end
-  
+
   def test_fixnum
-    new_ast = AST.parse("1").body
-    
+    new_ast = AST.parse("1").body[0]
+
     assert_not_nil(new_ast)
     assert_equal("Fixnum(1)", new_ast.inspect)
     assert(AST::Fixnum === new_ast)
     assert_equal(1, new_ast.literal)
   end
-  
+
   def test_float
-    new_ast = AST.parse("1.0").body
-    
+    new_ast = AST.parse("1.0").body[0]
+
     assert_not_nil(new_ast)
     assert_equal("Float(1.0)", new_ast.inspect)
     assert(AST::Float === new_ast)
     assert_equal(1.0, new_ast.literal)
   end
-  
+
   def test_class
-    new_ast = AST.parse("class Foo < Bar; 1; 2; end").body
-    
+    new_ast = AST.parse("class Foo < Bar; 1; 2; end").body[0]
+
     assert_not_nil(new_ast)
-    assert_equal("ClassDefinition(Foo)\n Type(Bar)\n Body\n  Fixnum(1)\n  Fixnum(2)", new_ast.inspect)
+    assert_equal("ClassDefinition(Foo)\n Type(Bar)\n Body\n  Body\n   Fixnum(1)\n   Fixnum(2)", new_ast.inspect)
     assert(AST::ClassDefinition === new_ast)
     assert_equal("Foo", new_ast.name)
-    
+
     assert(AST::TypeReference === new_ast.superclass)
     assert(AST::Body === new_ast.body)
-    assert(AST::Fixnum === new_ast.body[0])
+    assert(AST::Fixnum === new_ast.body[0][0])
 
-    new_ast = AST.parse("class Foo < Bar; def foo; end; end").body
+    new_ast = AST.parse("class Foo < Bar; def foo; end; end").body[0]
 
     assert_not_nil(new_ast)
-    assert_equal("ClassDefinition(Foo)\n Type(Bar)\n MethodDefinition(foo)\n  {:return=>nil}\n  Arguments", new_ast.inspect)
+    assert_equal("ClassDefinition(Foo)\n Type(Bar)\n Body\n  MethodDefinition(foo)\n   {:return=>nil}\n   Arguments", new_ast.inspect)
     assert_equal(new_ast, new_ast.body.parent)
   end
-  
+
   def test_defn
-    new_ast = AST.parse("def foo(a, b); 1; end").body
-    
+    new_ast = AST.parse("def foo(a, b); 1; end").body[0]
+
     assert_not_nil(new_ast)
     assert_equal("MethodDefinition(foo)\n {:return=>nil}\n Arguments\n  RequiredArgument(a)\n  RequiredArgument(b)\n Fixnum(1)", new_ast.inspect)
     assert(AST::MethodDefinition === new_ast)
@@ -204,9 +204,9 @@ class TestAst < Test::Unit::TestCase
     assert(nil === new_ast.signature[:return])
     assert(AST::Arguments === new_ast.arguments)
     assert(AST::Fixnum === new_ast.body)
-    
-    new_ast = AST.parse("def foo; end").body
-    
+
+    new_ast = AST.parse("def foo; end").body[0]
+
     assert_not_nil(new_ast)
     assert_equal("MethodDefinition(foo)\n {:return=>nil}\n Arguments", new_ast.inspect)
     assert_not_nil(new_ast.arguments)
@@ -216,10 +216,10 @@ class TestAst < Test::Unit::TestCase
     assert_equal(nil, new_ast.arguments.block_arg)
     assert_nil(new_ast.body)
   end
-  
+
   def test_defs
-    new_ast = AST.parse("def self.foo(a, b); 1; end").body
-    
+    new_ast = AST.parse("def self.foo(a, b); 1; end").body[0]
+
     assert_not_nil(new_ast)
     inspected = "StaticMethodDefinition(foo)\n {:return=>nil}\n Arguments\n  RequiredArgument(a)\n  RequiredArgument(b)\n Fixnum(1)"
     assert_equal(inspected, new_ast.inspect)
@@ -230,9 +230,9 @@ class TestAst < Test::Unit::TestCase
     assert(nil === new_ast.signature[:return])
     assert(AST::Arguments === new_ast.arguments)
     assert(AST::Fixnum === new_ast.body)
-    
-    new_ast = AST.parse("def self.foo; end").body
-    
+
+    new_ast = AST.parse("def self.foo; end").body[0]
+
     assert_not_nil(new_ast)
     assert_equal("StaticMethodDefinition(foo)\n {:return=>nil}\n Arguments", new_ast.inspect)
     assert_not_nil(new_ast.arguments)
@@ -242,10 +242,10 @@ class TestAst < Test::Unit::TestCase
     assert_equal(nil, new_ast.arguments.block_arg)
     assert_nil(new_ast.body)
   end
-  
+
   def test_signature
-    new_ast = AST.parse("def self.foo(a, b); {a => :foo, b => :bar, :return => :baz}; 1; end").body
-    
+    new_ast = AST.parse("def self.foo(a, b); {a => :foo, b => :bar, :return => :baz}; 1; end").body[0]
+
     assert_not_nil(new_ast.signature)
     inspected = "StaticMethodDefinition(foo)\n {:return=>Type(baz), :a=>Type(foo), :b=>Type(bar)}\n Arguments\n  RequiredArgument(a)\n  RequiredArgument(b)\n Body\n  Noop\n  Fixnum(1)"
     assert_equal(inspected, new_ast.inspect)
@@ -258,10 +258,10 @@ class TestAst < Test::Unit::TestCase
     assert(AST::TypeReference === signature[:b])
     assert_equal("bar", signature[:b].name)
   end
-  
+
   def test_type_reference
     signature = AST.parse_ruby("{a => :foo, b => java.lang.Object, :return => ArrayList}").child_nodes[0].signature(nil)
-    
+
     inspected = "{:return=>Type(ArrayList), :a=>Type(foo), :b=>Type(java.lang.Object)}"
     assert_equal(inspected, signature.inspect)
     assert_equal(3, signature.size)
@@ -272,97 +272,97 @@ class TestAst < Test::Unit::TestCase
     assert(AST::TypeReference === signature[:b])
     assert_equal("java.lang.Object", signature[:b].name)
   end
-  
+
   def test_return
-    new_ast = AST.parse("return 1").body
-    
+    new_ast = AST.parse("return 1").body[0]
+
     assert_not_nil(new_ast)
     inspected = "Return\n Fixnum(1)"
     assert_equal(inspected, new_ast.inspect)
     assert(AST::Return === new_ast)
     assert(AST::Fixnum === new_ast.value)
   end
-  
+
   def test_vcall
-    new_ast = AST.parse("foo").body
-    
+    new_ast = AST.parse("foo").body[0]
+
     assert_not_nil(new_ast)
     assert(AST::FunctionalCall === new_ast)
     assert_equal("FunctionalCall(foo)", new_ast.inspect)
-    
+
     assert_equal("foo", new_ast.name)
     assert_not_nil(new_ast.parameters)
     assert_equal(0, new_ast.parameters.size)
   end
-  
+
   def test_while
-    new_ast = AST.parse("while 1; 2; end").body
-    
+    new_ast = AST.parse("while 1; 2; end").body[0]
+
     assert_not_nil(new_ast)
     assert(AST::Loop === new_ast)
-    assert_equal("Loop(check_first = true, negative = false)\n Body\n Condition\n  Fixnum(1)\n Body\n Body\n Fixnum(2)", new_ast.inspect)
+    assert_equal("Loop(check_first = true, negative = false)\n Body\n Condition\n  Fixnum(1)\n Body\n Fixnum(2)\n Body", new_ast.inspect)
     assert(new_ast.check_first?)
     assert(!new_ast.negative?)
     assert(AST::Condition === new_ast.condition)
     assert(AST::Fixnum === new_ast.condition.predicate)
     assert(AST::Fixnum === new_ast.body)
-    
-    new_ast = AST.parse("begin; 2; end while 1").body
-    
+
+    new_ast = AST.parse("begin; 2; end while 1").body[0]
+
     assert_not_nil(new_ast)
     assert(AST::Loop === new_ast)
-    assert_equal("Loop(check_first = false, negative = false)\n Body\n Condition\n  Fixnum(1)\n Body\n Body\n Fixnum(2)", new_ast.inspect)
+    assert_equal("Loop(check_first = false, negative = false)\n Body\n Condition\n  Fixnum(1)\n Body\n Fixnum(2)\n Body", new_ast.inspect)
     assert(!new_ast.check_first?)
     assert(!new_ast.negative?)
     assert(AST::Condition === new_ast.condition)
     assert(AST::Fixnum === new_ast.condition.predicate)
     assert(AST::Fixnum === new_ast.body)
   end
-  
+
   def test_until
-    new_ast = AST.parse("until 1; 2; end").body
-    
+    new_ast = AST.parse("until 1; 2; end").body[0]
+
     assert_not_nil(new_ast)
     assert(AST::Loop === new_ast)
-    assert_equal("Loop(check_first = true, negative = true)\n Body\n Condition\n  Fixnum(1)\n Body\n Body\n Fixnum(2)", new_ast.inspect)
+    assert_equal("Loop(check_first = true, negative = true)\n Body\n Condition\n  Fixnum(1)\n Body\n Fixnum(2)\n Body", new_ast.inspect)
     assert(new_ast.check_first?)
     assert(new_ast.negative?)
     assert(AST::Condition === new_ast.condition)
     assert(AST::Fixnum === new_ast.condition.predicate)
     assert(AST::Fixnum === new_ast.body)
-    
-    new_ast = AST.parse("begin; 2; end until 1").body
-    
+
+    new_ast = AST.parse("begin; 2; end until 1").body[0]
+
     assert_not_nil(new_ast)
     assert(AST::Loop === new_ast)
-    assert_equal("Loop(check_first = false, negative = true)\n Body\n Condition\n  Fixnum(1)\n Body\n Body\n Fixnum(2)", new_ast.inspect)
+    assert_equal("Loop(check_first = false, negative = true)\n Body\n Condition\n  Fixnum(1)\n Body\n Fixnum(2)\n Body", new_ast.inspect)
     assert(!new_ast.check_first?)
     assert(new_ast.negative?)
     assert(AST::Condition === new_ast.condition)
     assert(AST::Fixnum === new_ast.condition.predicate)
     assert(AST::Fixnum === new_ast.body)
   end
-  
+
   def test_string
-    new_ast = AST.parse("'foo'").body
-    
+    new_ast = AST.parse("'foo'").body[0]
+
     assert_not_nil(new_ast)
     assert(AST::String === new_ast)
     assert_equal("String(\"foo\")", new_ast.inspect)
     assert_equal("foo", new_ast.literal)
   end
-  
+
   def test_root
-    new_ast = AST.parse("1").body
-    
+    new_ast = AST.parse("1").body[0]
+
     assert_not_nil(new_ast)
     assert(AST::Fixnum === new_ast)
   end
-  
+
   def test_boolean
-    new_ast1 = AST.parse("true").body
-    new_ast2 = AST.parse("false").body
-    
+    new_ast1 = AST.parse("true").body[0]
+    new_ast2 = AST.parse("false").body[0]
+
     assert_not_nil(new_ast1)
     assert_not_nil(new_ast2)
     assert(AST::Boolean === new_ast1)
@@ -372,7 +372,7 @@ class TestAst < Test::Unit::TestCase
   end
 
   def test_return
-    new_ast = AST.parse("return 1").body
+    new_ast = AST.parse("return 1").body[0]
 
     assert_not_nil(new_ast)
     assert(AST::Return === new_ast)
@@ -381,7 +381,7 @@ class TestAst < Test::Unit::TestCase
   end
 
   def test_empty_array
-    new_ast = AST.parse("int[5]").body
+    new_ast = AST.parse("int[5]").body[0]
 
     assert_not_nil(new_ast)
     assert(AST::EmptyArray === new_ast)