mirah 0.0.12-java → 0.1.0-java

data/lib/mirah/typer/simple.rb

@@ -1,384 +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/ast'
-require 'mirah/transform'
-
-module Mirah
-  module Typer
-    class Simple < Base
-      attr_accessor :known_types, :errors, :last_chance
-
-      def initialize(self_type)
-        @known_types = {}
-
-        @known_types["self"] = type_reference(nil, self_type)
-        @known_types["fixnum"] = type_reference(nil, "fixnum")
-        @known_types["float"] = type_reference(nil, "float")
-        @known_types["string"] = type_reference(nil, "string")
-        @known_types["boolean"] = type_reference(nil, "boolean")
-        @errors = []
-      end
-
-      def name
-        "Simple"
-      end
-
-      def set_filename(scope, name); end
-
-      def self_type
-        known_types["self"]
-      end
-
-      def default_type
-        nil
-      end
-
-      def fixnum_type(value=0)
-        known_types["fixnum"]
-      end
-
-      def float_type(value=0)
-        known_types["float"]
-      end
-
-      def string_type
-        known_types["string"]
-      end
-
-      def boolean_type
-        known_types["boolean"]
-      end
-
-      def null_type
-        AST::TypeReference::NullType
-      end
-
-      def no_type
-        AST::TypeReference::NoType
-      end
-
-      # to be overridden
-      def array_type
-        AST::TypeReference::NullType
-      end
-
-      # to be overridden
-      def hash_type
-        AST::TypeReference::NullType
-      end
-
-      def known_type(scope, name)
-        @known_types[name]
-      end
-
-      def define_type(scope, name, superclass, interfaces)
-        log "New type defined: '#{name}' < '#{superclass}'"
-        result = type_definition(scope, name, superclass, interfaces)
-
-        # TODO Get rid of known_types["self"]
-        old_self, known_types["self"] = known_types["self"], result
-        yield
-        known_types["self"] = old_self
-
-        result
-      end
-
-      def learn_local_type(scope, name, type)
-        return if type.null? && !@last_chance
-        type = scope.learn_local_type(name, known_types[type] || type)
-        log "Learned local type under #{scope} : #{name} = #{type}" if type
-        type
-      end
-
-      def local_type(scope, name)
-        type = scope.local_type(name)
-        log "Retrieved local type in #{scope} : #{name} = #{type}" if type
-        type
-      end
-
-      def local_types
-        @local_types ||= {}
-      end
-
-      def local_type_hash(scope)
-        local_types[scope] ||= {}
-      end
-
-      def field_types
-        @field_types ||= {}
-      end
-
-      def field_type_hash(cls)
-        field_types[cls] ||= {}
-      end
-
-      def static_field_types
-        @static_field_types ||= {}
-      end
-
-      def static_field_type_hash(cls)
-        static_field_types[cls] ||= {}
-      end
-      
-      def infer_signature(method_def)
-      end
-
-      def learn_field_type(cls, name, type)
-        log "Learned field type under #{cls} : #{name} = #{type}" if type
-
-        # TODO check for compatibility?
-        field_type_hash(cls)[name] ||= known_types[type] || type
-
-        type
-      end
-
-      def field_type(cls, name)
-        field_type_hash(cls)[name]
-      end
-
-      def learn_static_field_type(cls, name, type)
-        log "Learned field type under #{cls} : #{name} = #{type}" if type
-
-        # TODO check for compatibility?
-        static_field_type_hash(cls)[name] ||= known_types[type] || type
-
-        type
-      end
-
-      def static_field_type(cls, name)
-        static_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}" if type
-
-        get_method_type_hash(target_type, name, parameter_types)[:type] = known_types[type] || type
-
-        # if it's any args are imported types, also add a mapping for the expanded name
-        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?}
-          return AST.error_type
-        end
-        constructor = (name == 'new' && target_type && target_type.meta?)
-
-        if constructor
-          # constructor handled different from other methods
-          simple_type = get_method_type_hash(target_type.unmeta, 'initialize', parameter_types)[:type]
-        else
-          simple_type = get_method_type_hash(target_type, name, parameter_types)[:type]
-        end
-
-
-        if !simple_type
-          log "Method type for \"#{name}\" #{parameter_types} on #{target_type} not found."
-
-          # allow plugins a go if we're in the inference phase
-          simple_type = plugins do |plugin|
-            plugin.method_type(self, target_type, name, parameter_types)
-          end
-        end
-
-        return nil unless simple_type
-
-        if constructor
-          log "Method type for \"#{name}\" #{parameter_types} on #{target_type} = #{target_type}"
-          target_type.unmeta
-        else
-          log "Method type for \"#{name}\" #{parameter_types} on #{target_type} = #{simple_type}"
-          simple_type
-        end
-      end
-
-      def plugins
-        if cycling?
-          Mirah.typer_plugins.each do |plugin|
-            log "Invoking plugin: #{plugin}"
-
-            result = yield plugin
-            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|
-          begin
-            log "[Cycle #{i}]: Started... (#{@deferred_nodes.size} nodes to resolve)"
-            yield i
-          ensure
-            log "[Cycle #{i}]: Complete!"
-          end
-        end
-      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(scope, name, array=false, meta=false)
-        AST::TypeReference.new(name, array, meta)
-      end
-
-      def type_definition(scope, name, superclass, interfaces)
-        AST::TypeDefinition.new(name, AST::TypeReference.new(superclass), interfaces)
-      end
-
-      def deferred_nodes
-        @deferred_nodes ||= {}
-      end
-
-      def infer(node, expression=true)
-        begin
-          node.infer(self, expression)
-        rescue InferenceError => ex
-          ex.node ||= node
-          error(node, ex)
-        rescue Exception => ex
-          raise Mirah::InternalCompilerError.wrap(ex, node)
-        end
-      end
-
-      def error(node, error_or_msg=nil, backtrace=nil)
-        if error_or_msg.kind_of? InferenceError
-          error = error_or_msg
-        elsif error_or_msg
-          error = InferenceError.new(error_or_msg, node)
-          error.set_backtrace(backtrace) if backtrace
-        else
-          error = InferenceError.new("Unable to infer type.", node)
-        end
-        @errors << error
-        node.resolve_if(self) do
-          AST.error_type
-        end
-      end
-
-      def defer(node, error_message=nil)
-        if @error_next
-          log "Marking #{node} as an error"
-          @error_next = false
-          error(node, error_message)
-        else
-          raise "Can't defer nil" if node.nil?
-          return if deferred_nodes.include? node
-          log "Deferring inference for #{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 = {}
-          old_deferred.each do |node, saved_type|
-            known_types["self"] = saved_type
-            type = infer(node)
-
-            log "[Cycle #{i}]: Inferred type for #{node}: #{type || 'FAILED'}"
-
-            if type == default_type
-              @deferred_nodes[node] = saved_type
-            end
-          end
-
-          if @deferred_nodes.empty?
-            log "[Cycle #{i}]:  Resolved all types, exiting"
-            break
-          elsif old_deferred == @deferred_nodes
-            if @error_next || retried
-              log "[Cycle #{i}]: Made no progress, bailing out"
-              break
-            elsif @last_chance
-              break unless @errors.empty?
-              # 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
-          elsif @errors.size > 15
-            log "Too many errors, giving up"
-            break
-          end
-          retried = false
-        end
-
-        # done with n sweeps, if any remain mark them as errors
-        error_nodes = @errors.map {|e| e.node}
-        if error_nodes.empty?
-          (deferred_nodes.keys - error_nodes).each do |deferred_node|
-            break if @errors.size > 15
-            error_nodes << deferred_node
-            error(deferred_node)
-          end
-        end
-        if raise && !error_nodes.empty?
-          msg = "Could not infer typing for nodes:"
-          error_nodes.map do |e|
-            msg << "\n  "
-            msg << "#{e.inspect} at line #{e.line_number} (child of #{e.parent})"
-          end
-          raise InferenceError.new(msg)
-        end
-      end
-    end
-  end
-end

data/lib/mirah/version.rb~

@@ -1,18 +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
-  VERSION = "0.0.9"
-end

data/test/core/ast_test.rb

@@ -1,382 +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 'test_helper'
-
-class AstTest < Test::Unit::TestCase
-  include Mirah
-
-  def test_args
-    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)
-    assert_equal(5, children.size)
-    assert(Array === children[0])
-    assert(AST::RequiredArgument === children[0][0])
-    assert_equal("a", children[0][0].name)
-    assert_equal(arguments, children[0][0].parent)
-    assert(AST::RestArgument === children[2])
-    assert_equal("c", children[2].name)
-    assert_equal(arguments, children[2].parent)
-    assert(AST::BlockArgument === children[4])
-    assert_equal("d", children[4].name)
-    assert_equal(arguments, children[4].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 FunctionalCall(a)"
-    assert_equal(inspected, new_ast.inspect)
-
-    asgn = new_ast[0]
-    var = new_ast[1]
-
-    assert(AST::LocalAssignment === asgn)
-    assert_equal("a", asgn.name)
-    assert(AST::Fixnum === asgn.value)
-    assert(AST::FunctionalCall === var)
-    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)
-
-    asgn = new_ast[0]
-    var = new_ast[1]
-
-    assert(AST::FieldAssignment === asgn)
-    assert_equal("a", asgn.name)
-    assert(AST::Fixnum === asgn.value)
-    assert(AST::Field === var)
-    assert_equal("a", var.name)
-  end
-
-  def test_array
-    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[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[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[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   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)
-    assert(AST::If === new_ast.else)
-    assert(AST::Condition === new_ast.else.condition)
-    assert(AST::Fixnum === new_ast.else.condition.predicate)
-    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[0]
-    assert(AST::Fixnum === 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[0]
-    assert(AST::Fixnum === new_ast)
-  end
-
-  def test_fixnum
-    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[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[0]
-
-    assert_not_nil(new_ast)
-    assert_equal("ClassDefinition(Foo)\n Constant(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::Body === new_ast.body)
-    assert(AST::Fixnum === new_ast.body[0][0])
-
-    new_ast = AST.parse("class Foo < Bar; def foo; end; end").body[0]
-
-    assert_not_nil(new_ast)
-    assert_equal("ClassDefinition(Foo)\n Constant(Bar)\n Body\n  MethodDefinition(foo)\n   {:return=>nil}\n   Arguments\n   Null(nil)", 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[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)
-    assert_equal("foo", new_ast.name)
-    assert_not_nil(new_ast.signature)
-    assert_equal(1, new_ast.signature.size)
-    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[0]
-
-    assert_not_nil(new_ast)
-    assert_equal("MethodDefinition(foo)\n {:return=>nil}\n Arguments\n Null(nil)", new_ast.inspect)
-    assert_not_nil(new_ast.arguments)
-    assert_equal([], new_ast.arguments.args)
-    assert_equal(nil, new_ast.arguments.opt_args)
-    assert_equal(nil, new_ast.arguments.rest_arg)
-    assert_equal(nil, new_ast.arguments.block_arg)
-
-    new_ast = AST.parse("def foo(a, b):int; 1; end").body[0]
-    assert_equal("FunctionalCall(int)", new_ast.return_type.to_s)
-  end
-
-  def test_defs
-    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)
-    assert(AST::StaticMethodDefinition === new_ast)
-    assert_equal("foo", new_ast.name)
-    assert_not_nil(new_ast.signature)
-    assert_equal(1, new_ast.signature.size)
-    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[0]
-
-    assert_not_nil(new_ast)
-    assert_equal("StaticMethodDefinition(foo)\n {:return=>nil}\n Arguments\n Null(nil)", new_ast.inspect)
-    assert_not_nil(new_ast.arguments)
-    assert_equal([], new_ast.arguments.args)
-    assert_equal(nil, new_ast.arguments.opt_args)
-    assert_equal(nil, new_ast.arguments.rest_arg)
-    assert_equal(nil, new_ast.arguments.block_arg)
-  end
-
-  def test_return
-    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[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[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 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[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 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[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 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[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 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[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[0]
-
-    assert_not_nil(new_ast)
-    assert(AST::Fixnum === new_ast)
-  end
-
-  def test_boolean
-    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)
-    assert(AST::Boolean === new_ast2)
-    assert(new_ast1.literal)
-    assert(!new_ast2.literal)
-  end
-
-  def test_return
-    new_ast = AST.parse("return 1").body[0]
-
-    assert_not_nil(new_ast)
-    assert(AST::Return === new_ast)
-    assert(AST::Fixnum === new_ast.value)
-    assert(1, new_ast.value.literal)
-  end
-
-  def test_empty_array
-    new_ast = AST.parse("int[5]").body[0]
-
-    assert_not_nil(new_ast)
-    assert(AST::EmptyArray === new_ast)
-    assert_equal(5, new_ast.size.literal)
-
-    assert_equal("int", new_ast.type_node.name)
-  end
-
-  def test_block_comment
-    new_ast = AST.parse("/* foo\nbar*/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_incorrect_syntax_raises_syntax_error
-    assert_raises SyntaxError do
-      AST.parse("puts( 'aoue'")
-    end
-  end
-  
-  def test_parsing_empty_string_raises_no_error
-    AST.parse("")
-  end
-end