rdl 1.0.0.rc3 → 1.0.0.rc4

data/test/test_lib_types.rb

@@ -0,0 +1,194 @@
+require 'set'
+require 'abbrev'
+require 'base64'
+require 'benchmark'
+require 'bigdecimal'
+require 'bigdecimal/math'
+require 'coverage.so'
+require 'uri'
+
+require 'minitest/autorun'
+require_relative '../lib/rdl.rb'
+require_relative '../lib/rdl_types.rb'
+
+class Dummy
+  def self.each
+  end
+  def each
+  end
+end
+
+class TestStdlibTypes < Minitest::Test
+
+  def test_abbrev
+    skip "Skip when nowrap is enabled"
+    assert_raises(RDL::Type::TypeError) { s0 = Abbrev.abbrev 5}
+    # From the Ruby stdlib documentation
+    s1 = Abbrev.abbrev(['ruby']) # -> {"ruby"=>"ruby", "rub"=>"ruby", "ru"=>"ruby", "r"=>"ruby"}
+    ev = {"ruby"=>"ruby", "rub"=>"ruby", "ru"=>"ruby", "r"=>"ruby"}
+    assert_equal(s1,ev)
+    # Other tests
+    assert_raises(RDL::Type::TypeError) { s2 = Abbrev.abbrev Dummy.new }
+  end
+
+  def test_base64
+    skip "Skip when nowrap is enabled"
+    # From the Ruby stdlib documentation
+    e0 = Base64.encode64('Send reinforcements') # -> "U2VuZCByZWluZm9yY2VtZW50cw==\n"
+    d0 = Base64.decode64(e0) # -> "Send reinforcements"
+    #assert_equal(e0,d0)
+    e1 = Base64.strict_encode64('Send reinforcements')
+    d1 = Base64.strict_decode64(e1)
+    #assert_equal(e1,d1)
+    e2 = Base64.urlsafe_encode64('Send reinforcements')
+    d2 = Base64.urlsafe_decode64(e2)
+    #assert_equal(e2,d2)
+  end
+
+  def test_benchmark
+    skip "Skip these because they print to stdout"
+    # From the Ruby stdlib documentation
+    Benchmark.measure { "a"*1_000_000_000 }
+    n = 5000000
+    Benchmark.bm do |x|
+      x.report { for i in 1..n; a = "1"; end }
+      x.report { n.times do   ; a = "1"; end }
+      x.report { 1.upto(n) do ; a = "1"; end }
+    end
+    Benchmark.bm(7) do |x|
+      x.report("for:")   { for i in 1..n; a = "1"; end }
+      x.report("times:") { n.times do   ; a = "1"; end }
+      x.report("upto:")  { 1.upto(n) do ; a = "1"; end }
+    end
+    array = (1..1000000).map { rand }
+    Benchmark.bmbm do |x|
+      #x.report("sort!") { array.dup.sort! } # TODO this causes a hang
+      #x.report("sort")  { array.dup.sort  }
+    end
+    Benchmark.benchmark(Benchmark::CAPTION, 7, Benchmark::FORMAT, ">total:", ">avg:") do |x|
+      tf = x.report("for:")   { for i in 1..n; a = "1"; end }
+      tt = x.report("times:") { n.times do   ; a = "1"; end }
+      tu = x.report("upto:")  { 1.upto(n) do ; a = "1"; end }
+      [tf+tt+tu, (tf+tt+tu)/3]
+    end
+  end
+
+  def test_bigdecimal
+    skip "Skip when nowrap is enabled"
+    # From the RUby stdlib documentation
+    BigDecimal.save_exception_mode do
+      BigDecimal.mode(BigDecimal::EXCEPTION_OVERFLOW, false)
+      BigDecimal.mode(BigDecimal::EXCEPTION_NaN, false)
+
+      BigDecimal.new(BigDecimal('Infinity'))
+      BigDecimal.new(BigDecimal('-Infinity'))
+      BigDecimal(BigDecimal.new('NaN'))
+    end
+    BigDecimal.save_limit do
+      BigDecimal.limit(200)
+    end
+    BigDecimal.save_rounding_mode do
+      BigDecimal.mode(BigDecimal::ROUND_MODE, :up)
+    end
+    # Additional test calls for coverage
+    BigDecimal.double_fig
+    BigDecimal.limit(5)
+    BigDecimal.mode(BigDecimal::EXCEPTION_NaN, true)
+    BigDecimal.mode(BigDecimal::EXCEPTION_NaN, false)
+    BigDecimal.mode(BigDecimal::EXCEPTION_NaN)
+    BigDecimal.ver
+    
+    # TODO
+  end
+
+  def test_bigmath
+    # From the Ruby stdlib documentation
+    BigMath.E(10)
+    BigMath.PI(10)
+    BigMath.atan(BigDecimal.new('-1'), 16)
+    BigMath.cos(BigMath.PI(4), 16)
+    BigMath.sin(BigMath.PI(5)/4, 5)
+    BigMath.sqrt(BigDecimal.new('2'), 16)
+  end
+  
+  def test_class
+    Dummy.allocate
+    Dummy.new
+    Dummy.superclass
+  end
+
+  def test_coverage
+    skip "Skip when nowrap is enabled"
+    Coverage.start
+    Coverage.result
+    #Coverage.result # TODO This cannot be typechecked
+  end
+  
+  def test_exception
+    e1 = Exception.new
+    e1 == 5
+    tmp = e1.backtrace
+    e1.backtrace_locations
+    e1.cause
+    e1.exception
+    e1.inspect
+    e1.message
+    e1.set_backtrace(tmp)
+    e1.to_s
+  end
+  
+  def test_set
+    skip "Skip when nowrap is enabled"
+    assert_raises(RDL::Type::TypeError) { s6 = Set.new(1,2) }
+    # From the Ruby stdlib documentation
+    s1 = Set.new [1, 2]                   # -> #<Set: {1, 2}>
+    s2 = [1, 2].to_set                    # -> #<Set: {1, 2}>
+    s1 == s2                              # -> true
+    s1.add("foo")                         # -> #<Set: {1, 2, "foo"}>
+    s1.merge([2, 6])                      # -> #<Set: {1, 2, "foo", 6}>
+    s1.subset? s2                         # -> false
+    s2.subset? s1                         # -> true
+    Set[1, 2, 3].disjoint? Set[3, 4] # => false
+    Set[1, 2, 3].disjoint? Set[4, 5] # => true
+    numbers = Set[1, 3, 4, 6, 9, 10, 11]
+    set = numbers.divide { |i,j| (i - j).abs == 1 }
+    Set[1, 2, 3].intersect? Set[4, 5] # => false
+    Set[1, 2, 3].intersect? Set[3, 4] # => true
+    # Some more tests, just to make sure type checking doesn't cause crashes
+    s3 = s1 - s2
+    s1.proper_subset? s2
+    s1.superset? s2
+    s1 ^ s2
+    s1.add?("bar")
+    h = s1.classify { |x| x.size }
+    s2.clear
+    s4 = s1.map { |x| 42 }
+    s1.delete "foo"
+    s1.delete? "bar"
+    s1.delete_if { |x| false }
+    s1.each { |x| nil }
+    s1.empty?
+    s1.member? 42
+    s1.intersection [1,2,3]
+    s1.keep_if { |x| true }
+    s1.size
+    s1.difference [1,2,3]
+    s1.to_a
+    s5 = s1 + s2
+  end
+  
+  def test_uri
+    URI.decode_www_form("a=1&a=2&b=3")
+    URI.encode_www_form([["q", "ruby"], ["lang", "en"]]) # Internally uses _component
+    URI.encode_www_form("q" => "ruby", "lang" => "en")
+    URI.encode_www_form("q" => ["ruby", "perl"], "lang" => "en")
+    URI.encode_www_form([["q", "ruby"], ["q", "perl"], ["lang", "en"]])
+    URI.extract("text here http://foo.example.org/bla and here mailto:test@example.com and here also.")
+    URI.join("http://example.com/","main.rbx")
+    URI.parse("http://www.ruby-lang.org/")
+    URI.scheme_list
+    URI.split("http://www.ruby-lang.org/")
+    enc_uri = URI.escape("http://example.com/?a=\11\15")
+    URI.unescape(enc_uri)
+  end
+end

data/test/test_member.rb

@@ -0,0 +1,148 @@
+require 'minitest/autorun'
+require_relative '../lib/rdl.rb'
+
+class TestMember < Minitest::Test
+  include RDL::Type
+
+  class A
+  end
+
+  class B < A
+  end
+
+  class C < B
+  end
+  
+  def setup
+    @tnil = NilType.new
+    @ttop = TopType.new
+    @tstring = NominalType.new "String"
+    @tobject = NominalType.new "Object"
+    @tbasicobject = NominalType.new "BasicObject"
+    @tsymfoo = SingletonType.new :foo
+    @tsym = NominalType.new Symbol
+    @tarray = NominalType.new Array
+    @tarraystring = GenericType.new(@tarray, @tstring)
+    @tarrayobject = GenericType.new(@tarray, @tobject)
+    @tarrayarraystring = GenericType.new(@tarray, @tarraystring)
+    @tarrayarrayobject = GenericType.new(@tarray, @tarrayobject)
+    @thash = NominalType.new Hash
+    @thashstringstring = GenericType.new(@thash, @tstring, @tstring)
+    @thashobjectobject = GenericType.new(@thash, @tobject, @tobject)
+    @tstring_or_sym = UnionType.new(@tstring, @tsym)
+    @tstring_and_sym = IntersectionType.new(@tstring, @tsym)
+    @tobject_and_basicobject = IntersectionType.new(@tobject, @tbasicobject)
+    @ta = NominalType.new A
+    @tb = NominalType.new B
+    @tc = NominalType.new C
+    @tkernel = NominalType.new Kernel
+    @tarray = NominalType.new Array
+    @tarraystring = GenericType.new(@tarray, @tstring)
+    @tarrayobject = GenericType.new(@tarray, @tobject)
+    @tarrayarraystring = GenericType.new(@tarray, @tarraystring)
+    @tarrayarrayobject = GenericType.new(@tarray, @tarrayobject)
+    @thash = NominalType.new Hash
+    @thashsymstring = GenericType.new(@thash, @tsym, @tstring)
+    @thashobjectobject = GenericType.new(@thash, @tobject, @tobject)
+    @tavar = VarType.new :a
+  end
+
+  def test_nil
+    assert (@tnil.member? nil)
+    assert (not (@tnil.member? "foo"))
+    assert (not (@tnil.member? (Object.new)))
+  end
+
+  def test_top
+    assert (@ttop.member? nil)
+    assert (@ttop.member? "foo")
+    assert (@ttop.member? (Object.new))
+  end
+
+  def test_nominal
+    o = Object.new
+    assert (@tstring.member? "Foo")
+    assert (not (@tstring.member? :Foo))
+    assert (not (@tstring.member? o))
+
+    assert (@tobject.member? "Foo")
+    assert (@tobject.member? :Foo)
+    assert (@tobject.member? o)
+
+    assert (@tkernel.member? "Foo")
+    assert (@tkernel.member? :Foo)
+    assert (@tkernel.member? o)
+    
+    a = A.new
+    b = B.new
+    c = C.new
+    assert (@ta.member? a)
+    assert (@ta.member? b)
+    assert (@ta.member? c)
+    assert (not (@tb.member? a))
+    assert (@tb.member? b)
+    assert (@tb.member? c)
+    assert (not (@tc.member? a))
+    assert (not (@tc.member? b))
+    assert (@tc.member? c)
+
+    assert (@tstring.member? nil)
+    assert (@tobject.member? nil)
+end
+
+  def test_symbol
+    assert (@tsym.member? :foo)
+    assert (@tsym.member? :bar)
+    assert (not (@tsym.member? "foo"))
+    assert (@tsymfoo.member? :foo)
+    assert (not (@tsymfoo.member? :bar))
+    assert (not (@tsymfoo.member? "foo"))
+    assert (@tsymfoo.member? nil)
+  end
+
+  def test_union_intersection
+    o = Object.new
+
+    assert (@tstring_or_sym.member? "foo")
+    assert (@tstring_or_sym.member? :foo)
+    assert (not (@tstring_or_sym.member? o))
+    assert (@tstring_or_sym.member? nil)
+
+    assert (not (@tstring_and_sym.member? "foo"))
+    assert (not (@tstring_and_sym.member? :foo))
+    assert (not (@tstring_and_sym.member? o))
+    assert (@tstring_and_sym.member? nil)
+
+    assert (@tobject_and_basicobject.member? o)
+    assert (@tobject_and_basicobject.member? nil)
+  end
+
+  def test_var
+    assert_raises(TypeError) { @tavar.member? "foo" }
+  end
+
+  def test_tuple
+    t1 = TupleType.new(@tsym, @tstring)
+    assert (t1.member? [:foo, "foo"])
+    assert (not (t1.member? ["foo", :foo]))
+    assert (not (t1.member? [:foo, "foo", "bar"]))
+    t2 = TupleType.new
+    assert (t2.member? [])
+    assert (not (t2.member? [:foo]))
+  end
+
+  def test_finite_hash
+    t1 = FiniteHashType.new(a: @tsym, b: @tstring)
+    assert (t1.member?(a: :foo, b: "foo"))
+    assert (not (t1.member?(a: 1, b: "foo")))
+    assert (not (t1.member?(a: :foo)))
+    assert (not (t1.member?(b: "foo")))
+    assert (not (t1.member?(a: :foo, b: "foo", c: :baz)))
+    t2 = FiniteHashType.new({"a"=>@tsym, 2=>@tstring})
+    assert (t2.member?({"a"=>:foo, 2=>"foo"}))
+    assert (not (t2.member?({"a"=>2, 2=>"foo"})))
+    assert (not (t2.member?({"a"=>:foo})))
+    assert (not (t2.member?({2=>"foo"})))
+    assert (not (t2.member?({"a"=>:foo, 2=>"foo", 3=>"bar"})))
+  end
+end

data/test/test_parser.rb

@@ -0,0 +1,196 @@
+require 'minitest/autorun'
+require_relative '../lib/rdl.rb'
+
+class TestParser < Minitest::Test
+  include RDL::Type
+
+  def setup
+    @p = Parser.new
+    @tnil = NilType.new
+    @ttop = TopType.new
+    @tfixnum = NominalType.new Fixnum
+    @tfixnumopt = OptionalType.new @tfixnum
+    @tfixnumvararg = VarargType.new @tfixnum
+    @tstring = NominalType.new String
+    @tstringopt = OptionalType.new @tstring
+    @tenum = NominalType.new :Enumerator
+    @ttrue = NominalType.new TrueClass
+    @tfalse = NominalType.new FalseClass
+    @tbool = UnionType.new @ttrue, @tfalse
+    @ta = NominalType.new :A
+    @tb = NominalType.new :B
+    @tc = NominalType.new :C
+    @tfixnumx = AnnotatedArgType.new("x", @tfixnum)
+    @tfixnumy = AnnotatedArgType.new("y", @tfixnum)
+    @tfixnumret = AnnotatedArgType.new("ret", @tfixnum)
+    @tfixnumoptx = AnnotatedArgType.new("x", @tfixnumopt)
+    @tfixnumvarargx = AnnotatedArgType.new("x", @tfixnumvararg)
+    @tsymbol = SingletonType.new(:symbol)
+    @tsymbolx = AnnotatedArgType.new("x", @tsymbol)
+  end
+
+  def test_basic
+    t1 = @p.scan_str "(nil) -> nil"
+    assert_equal (MethodType.new [@tnil], nil, @tnil), t1
+    t2 = @p.scan_str "(Fixnum, Fixnum) -> Fixnum"
+    assert_equal (MethodType.new [@tfixnum, @tfixnum], nil, @tfixnum), t2
+    t3 = @p.scan_str "() -> Enumerator"
+    assert_equal (MethodType.new [], nil, @tenum), t3
+    t4 = @p.scan_str "(%any) -> nil"
+    assert_equal (MethodType.new [@ttop], nil, @tnil), t4
+    t5 = @p.scan_str "(%bool) -> Fixnum"
+    assert_equal (MethodType.new [@tbool], nil, @tfixnum), t5
+    assert_raises(RuntimeError) { @p.scan_str "(%foo) -> nil" }
+    t6 = @p.scan_str "(A) -> nil"
+    assert_equal (MethodType.new [@ta], nil, @tnil), t6
+    t7 = @p.scan_str "(TestParser::A) -> nil"
+    assert_equal (MethodType.new [NominalType.new("TestParser::A")], nil, @tnil), t7
+    t8 = @p.scan_str "(Fixnum) { (%any, String) -> nil } -> :symbol"
+    assert_equal (MethodType.new [@tfixnum], MethodType.new([@ttop, @tstring], nil, @tnil), @tsymbol), t8
+  end
+
+  def test_opt_vararg
+    t1 = @p.scan_str "(Fixnum, ?Fixnum) -> Fixnum"
+    assert_equal (MethodType.new [@tfixnum, @tfixnumopt], nil, @tfixnum), t1
+    t2 = @p.scan_str "(Fixnum, *Fixnum) -> Fixnum"
+    assert_equal (MethodType.new [@tfixnum, @tfixnumvararg], nil, @tfixnum), t2
+    t3 = @p.scan_str "(Fixnum, ?Fixnum, ?Fixnum, *Fixnum) -> Fixnum"
+    assert_equal (MethodType.new [@tfixnum, @tfixnumopt, @tfixnumopt, @tfixnumvararg], nil, @tfixnum), t3
+    t4 = @p.scan_str "(?Fixnum) -> nil"
+    assert_equal (MethodType.new [@tfixnumopt], nil, @tnil), t4
+    t5 = @p.scan_str "(*Fixnum) -> nil"
+    assert_equal (MethodType.new [@tfixnumvararg], nil, @tnil), t5
+  end
+
+  def test_union
+    t1 = @p.scan_str "(A or B) -> nil"
+    assert_equal (MethodType.new [UnionType.new(@ta, @tb)], nil, @tnil), t1
+    t2 = @p.scan_str "(A or B or C) -> nil"
+    assert_equal (MethodType.new [UnionType.new(@ta, @tb, @tc)], nil, @tnil), t2
+    t3 = @p.scan_str "() -> A or B or C"
+    assert_equal (MethodType.new [], nil, UnionType.new(@ta, @tb, @tc)), t3
+  end
+
+  def test_bare
+    t1 = @p.scan_str "## nil"
+    assert_equal @tnil, t1
+    t2 = @p.scan_str "## %any"
+    assert_equal @ttop, t2
+    t3 = @p.scan_str "## A"
+    assert_equal NominalType.new("A"), t3
+  end
+
+  def test_symbol
+    t1 = @p.scan_str "## :symbol"
+    assert_equal @tsymbol, t1
+  end
+
+  def test_annotated_params
+    t1 = @p.scan_str "(Fixnum x, Fixnum) -> Fixnum"
+    assert_equal (MethodType.new [@tfixnumx, @tfixnum], nil, @tfixnum), t1
+    t2 = @p.scan_str "(Fixnum, ?Fixnum x) -> Fixnum"
+    assert_equal (MethodType.new [@tfixnum, @tfixnumoptx], nil, @tfixnum), t2
+    t3 = @p.scan_str "(Fixnum, *Fixnum x) -> Fixnum"
+    assert_equal (MethodType.new [@tfixnum, @tfixnumvarargx], nil, @tfixnum), t3
+    t4 = @p.scan_str "(Fixnum, Fixnum y) -> Fixnum"
+    assert_equal (MethodType.new [@tfixnum, @tfixnumy], nil, @tfixnum), t4
+    t5 = @p.scan_str "(Fixnum x, Fixnum y) -> Fixnum"
+    assert_equal (MethodType.new [@tfixnumx, @tfixnumy], nil, @tfixnum), t5
+    t6 = @p.scan_str "(Fixnum, Fixnum) -> Fixnum ret"
+    assert_equal (MethodType.new [@tfixnum, @tfixnum], nil, @tfixnumret), t6
+    t7 = @p.scan_str "(Fixnum x, Fixnum) -> Fixnum ret"
+    assert_equal (MethodType.new [@tfixnumx, @tfixnum], nil, @tfixnumret), t7
+    t8 = @p.scan_str "(Fixnum, Fixnum y) -> Fixnum ret"
+    assert_equal (MethodType.new [@tfixnum, @tfixnumy], nil, @tfixnumret), t8
+    t9 = @p.scan_str "(Fixnum x, Fixnum y) -> Fixnum ret"
+    assert_equal (MethodType.new [@tfixnumx, @tfixnumy], nil, @tfixnumret), t9
+    t10 = @p.scan_str "(:symbol x) -> Fixnum"
+    assert_equal (MethodType.new [@tsymbolx], nil, @tfixnum), t10
+  end
+
+  def test_generic
+    t1 = @p.scan_str "## t"
+    assert_equal (VarType.new "t"), t1
+    t2 = @p.scan_str "## Array"
+    assert_equal (NominalType.new "Array"), t2
+    t3 = @p.scan_str "## Array<t>"
+    assert_equal (GenericType.new(t2, t1)), t3
+    t4 = @p.scan_str "## Array<Array<t>>"
+    assert_equal (GenericType.new(t2, t3)), t4
+    t5 = @p.scan_str "## Hash"
+    assert_equal (NominalType.new "Hash"), t5
+    t6 = @p.scan_str "## Hash<u, v>"
+    assert_equal (GenericType.new(t5, VarType.new("u"), VarType.new("v"))), t6
+    t7 = @p.scan_str "## Foo<String, Array<t>, Array<Array<t>>>"
+    assert_equal (GenericType.new(NominalType.new("Foo"), @tstring, t3, t4)), t7
+  end
+
+  def test_tuple
+    t1 = @p.scan_str "## [Fixnum, String]"
+    assert_equal (TupleType.new(@tfixnum, @tstring)), t1
+    t2 = @p.scan_str "## [String]"
+    assert_equal (TupleType.new(@tstring)), t2
+  end 
+
+  def test_fixnum
+    t1 = @p.scan_str "## 42"
+    assert_equal (SingletonType.new(42)), t1
+    t2 = @p.scan_str "## -42"
+    assert_equal (SingletonType.new(-42)), t2
+  end
+
+  def test_float
+    t1 = @p.scan_str "## 3.14"
+    assert_equal (SingletonType.new(3.14)), t1
+  end
+
+  def test_const
+    t1 = @p.scan_str "## ${Math::PI}"
+    assert_equal (SingletonType.new(Math::PI)), t1
+  end
+
+  def test_type_alias
+    type_alias '%foobarbaz', @tnil
+    assert_equal @tnil, (@p.scan_str "## %foobarbaz")
+    type_alias '%quxquxqux', 'nil'
+    assert_equal @tnil, (@p.scan_str "## %quxquxqux")
+    assert_raises(RuntimeError) { type_alias '%quxquxqux', 'nil' }
+    assert_raises(RuntimeError) { @p.scan_str "## %qux" }
+  end
+
+  def test_structural
+    t1 = @p.scan_str "## [to_str: () -> String]"
+    tm1 = MethodType.new [], nil, @tstring
+    ts1 = StructuralType.new(to_str: tm1)
+    assert_equal ts1, t1
+  end
+
+  def test_finite_hash
+    t1 = @p.scan_str "## {a: Fixnum, b: String}"
+    assert_equal (FiniteHashType.new({a: @tfixnum, b: @tstring})), t1
+    t2 = @p.scan_str "## {'a'=>Fixnum, 2=>String}"
+    assert_equal (FiniteHashType.new({"a"=>@tfixnum, 2=>@tstring})), t2
+  end
+
+  def test_named_params
+    t1 = @p.scan_str "(Fixnum, x: Fixnum) -> Fixnum"
+    assert_equal (MethodType.new [@tfixnum, FiniteHashType.new(x: @tfixnum)], nil, @tfixnum), t1
+    t2 = @p.scan_str "(Fixnum, x: Fixnum, y: String) -> Fixnum"
+    assert_equal (MethodType.new [@tfixnum, FiniteHashType.new(x: @tfixnum, y: @tstring)], nil, @tfixnum), t2
+    t3 = @p.scan_str "(Fixnum, y: String, x: Fixnum) -> Fixnum"
+    assert_equal (MethodType.new [@tfixnum, FiniteHashType.new(x: @tfixnum, y: @tstring)], nil, @tfixnum), t3
+    t4 = @p.scan_str "(Fixnum, y: String, x: ?Fixnum) -> Fixnum"
+    assert_equal (MethodType.new [@tfixnum, FiniteHashType.new(x: @tfixnumopt, y: @tstring)], nil, @tfixnum), t4
+    t4 = @p.scan_str "(Fixnum, y: ?String, x: Fixnum) -> Fixnum"
+    assert_equal (MethodType.new [@tfixnum, FiniteHashType.new(x: @tfixnum, y: @tstringopt)], nil, @tfixnum), t4
+    t5 = @p.scan_str "(Fixnum x, x: Fixnum) -> Fixnum"
+    assert_equal (MethodType.new [@tfixnumx, FiniteHashType.new(x: @tfixnum)], nil, @tfixnum), t5
+    t5 = @p.scan_str "(Fixnum x, x: Fixnum) -> Fixnum"
+    assert_equal (MethodType.new [@tfixnumx, FiniteHashType.new(x: @tfixnum)], nil, @tfixnum), t5
+    t6 = @p.scan_str "(x: Fixnum) -> Fixnum"
+    assert_equal (MethodType.new [FiniteHashType.new(x: @tfixnum)], nil, @tfixnum), t6
+    t7 = @p.scan_str "(x: Fixnum) { (%any, String) -> nil } -> :symbol"
+    assert_equal (MethodType.new [FiniteHashType.new(x: @tfixnum)], MethodType.new([@ttop, @tstring], nil, @tnil), @tsymbol), t7
+  end
+
+end