duby 0.0.1

data/lib/duby/typer.rb

@@ -0,0 +1,359 @@
+require 'duby/ast'
+require 'duby/transform'
+
+module Duby
+  module Typer
+    class << self
+      attr_accessor :verbose
+
+      def log(message)
+        puts "* [#{name}] #{message}" if Typer.verbose
+      end
+    end
+    
+    class InferenceError < Exception
+      attr_accessor :node
+      def initialize(msg, node = nil)
+        super(msg)
+        @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
+
+      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")
+        @known_types["string"] = type_reference("string")
+        @known_types["boolean"] = type_reference("boolean")
+        @errors = []
+      end
+      
+      def name
+        "Simple"
+      end
+      
+      def self_type
+        known_types["self"]
+      end
+
+      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
+
+      def null_type
+        AST::TypeReference::NullType
+      end
+
+      def no_type
+        AST::TypeReference::NoType
+      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}"
+
+        # TODO check for compatibility?
+        local_type_hash(scope)[name] ||= known_types[type] || 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
+
+      def field_types
+        @field_types ||= {}
+      end
+
+      def field_type_hash(cls)
+        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}"
+
+        # 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_method_type(target_type, name, parameter_types, type, exceptions)
+        log "Learned method #{name} (#{parameter_types}) on #{target_type} = #{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?
+          Duby.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..."
+            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(name, array=false, meta=false)
+        AST::TypeReference.new(name, array, meta)
+      end
+
+      def type_definition(name, superclass, interfaces)
+        AST::TypeDefinition.new(name, AST::TypeReference.new(superclass), interfaces)
+      end
+
+      def alias_type(short, long)
+        @known_types[type_reference(short, false, false)] = type_reference(long, false, false)
+        @known_types[type_reference(short, false, true)] = type_reference(long, false, true)
+      end
+
+      def deferred_nodes
+        @deferred_nodes ||= []
+      end
+
+      def infer(node)
+        begin
+          node.infer(self)
+        rescue InferenceError => ex
+          ex.node ||= node
+          error(node, ex)
+        rescue Exception => ex
+          error(node, ex.message, ex.backtrace)
+        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)
+        if @error_next
+          log "Marking #{node} as an error"
+          @error_next = false
+          error(node)
+        else
+          return if deferred_nodes.include? node
+          log "Deferring inference for #{node}"
+        
+          deferred_nodes << node
+        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|
+            type = infer(node)
+
+            log "[Cycle #{i}]: Inferred type for #{node}: #{type || 'FAILED'}"
+
+            type == default_type
+          end
+          
+          if @deferred_nodes.size == 0
+            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
+            else
+              # Retry this iteration, and mark the first deferred
+              # type as an error.
+              retried = true
+              @error_next = 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
+        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})"
+          end
+          raise InferenceError.new(msg)
+        end
+      end
+    end
+  end
+  
+  def self.typer_plugins
+    @typer_plugins ||= []
+  end
+end
+
+if __FILE__ == $0
+  Duby::AST.verbose = true
+  Duby::Typer.verbose = true
+  ast = Duby::AST.parse(File.read(ARGV[0]))
+  typer = Duby::Typer::Simple.new("script")
+  typer.infer(ast)
+  begin
+    typer.resolve(true)
+  rescue Duby::Typer::InferenceError => e
+    puts e.message
+  end
+  
+  puts "\nAST:"
+  p ast
+end

data/test/test_ast.rb

@@ -0,0 +1,391 @@
+require 'duby'
+require 'test/unit'
+require 'jruby'
+
+class TestAst < Test::Unit::TestCase
+  include Duby
+  
+  def test_args
+    new_ast = AST.parse("def foo(a, *c, &d); end").body
+    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(4, 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[3])
+    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)\n  Fixnum(1)\n Local(name = a, scope = Script)"
+    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(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)
+    assert(AST::Fixnum === asgn.value)
+    assert(!asgn.value.newline)
+    assert(AST::Field === var)
+    assert(var.newline)
+    assert_equal("@a", var.name)
+  end
+  
+  def test_array
+    new_ast = AST.parse("[a = 1, 1]").body
+    
+    assert_not_nil(new_ast)
+    assert(AST::Array === new_ast)
+    assert_equal("Array\n LocalAssignment(name = a, scope = Script)\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
+    
+    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
+    
+    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
+    
+    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)
+    assert(AST::If === new_ast.else)
+    assert(AST::Condition === new_ast.else.condition)
+    assert(AST::Not === 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
+    assert(AST::Fixnum === new_ast)
+    
+    new_ast = AST.parse("begin; end").body
+    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
+    assert(AST::Fixnum === new_ast)
+  end
+  
+  def test_fixnum
+    new_ast = AST.parse("1").body
+    
+    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
+    
+    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
+    
+    assert_not_nil(new_ast)
+    assert_equal("ClassDefinition(Foo)\n Type(Bar)\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])
+
+    new_ast = AST.parse("class Foo < Bar; def foo; end; end").body
+
+    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(new_ast, new_ast.body.parent)
+  end
+  
+  def test_defn
+    new_ast = AST.parse("def foo(a, b); 1; end").body
+    
+    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
+    
+    assert_not_nil(new_ast)
+    assert_equal("MethodDefinition(foo)\n {:return=>nil}\n Arguments", new_ast.inspect)
+    assert_not_nil(new_ast.arguments)
+    assert_equal(nil, 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)
+    assert_nil(new_ast.body)
+  end
+  
+  def test_defs
+    new_ast = AST.parse("def self.foo(a, b); 1; end").body
+    
+    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
+    
+    assert_not_nil(new_ast)
+    assert_equal("StaticMethodDefinition(foo)\n {:return=>nil}\n Arguments", new_ast.inspect)
+    assert_not_nil(new_ast.arguments)
+    assert_equal(nil, 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)
+    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
+    
+    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)
+    signature = new_ast.signature
+    assert_equal(3, signature.size)
+    assert(AST::TypeReference === signature[:return])
+    assert_equal("baz", signature[:return].name)
+    assert(AST::TypeReference === signature[:a])
+    assert_equal("foo", signature[:a].name)
+    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)
+    assert(AST::TypeReference === signature[:return])
+    assert_equal("ArrayList", signature[:return].name)
+    assert(AST::TypeReference === signature[:a])
+    assert_equal("foo", signature[:a].name)
+    assert(AST::TypeReference === signature[:b])
+    assert_equal("java.lang.Object", signature[:b].name)
+  end
+  
+  def test_return
+    new_ast = AST.parse("return 1").body
+    
+    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
+    
+    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
+    
+    assert_not_nil(new_ast)
+    assert(AST::Loop === new_ast)
+    assert_equal("WhileLoop(check_first = true, negative = false)\n Condition\n  Fixnum(1)\n Fixnum(2)", 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
+    
+    assert_not_nil(new_ast)
+    assert(AST::Loop === new_ast)
+    assert_equal("WhileLoop(check_first = false, negative = false)\n Condition\n  Fixnum(1)\n Fixnum(2)", 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
+    
+    assert_not_nil(new_ast)
+    assert(AST::Loop === new_ast)
+    assert_equal("WhileLoop(check_first = true, negative = true)\n Condition\n  Fixnum(1)\n Fixnum(2)", 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
+    
+    assert_not_nil(new_ast)
+    assert(AST::Loop === new_ast)
+    assert_equal("WhileLoop(check_first = false, negative = true)\n Condition\n  Fixnum(1)\n Fixnum(2)", 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
+    
+    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
+    
+    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
+    
+    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
+
+    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
+
+    assert_not_nil(new_ast)
+    assert(AST::EmptyArray === new_ast)
+    assert_equal(5, new_ast.size.literal)
+    assert_equal(AST.type(:int), new_ast.inferred_type)
+  end
+end