rdl 2.0.1 → 2.1.0

data/test/test_parser.rb

@@ -10,79 +10,79 @@ class TestParser < Minitest::Test
   class C; end
 
   def setup
-    @tfixnumopt = OptionalType.new $__rdl_fixnum_type
-    @tfixnumvararg = VarargType.new $__rdl_fixnum_type
-    @tstringopt = OptionalType.new $__rdl_string_type
+    @tintegeropt = OptionalType.new RDL::Globals.types[:integer]
+    @tintegervararg = VarargType.new RDL::Globals.types[:integer]
+    @tstringopt = OptionalType.new RDL::Globals.types[:string]
     @tenum = NominalType.new :Enumerator
     @ta = NominalType.new :A
     @tb = NominalType.new :B
     @tc = NominalType.new :C
-    @tfixnumx = AnnotatedArgType.new("x", $__rdl_fixnum_type)
-    @tfixnumy = AnnotatedArgType.new("y", $__rdl_fixnum_type)
-    @tfixnumret = AnnotatedArgType.new("ret", $__rdl_fixnum_type)
-    @tfixnumoptx = AnnotatedArgType.new("x", @tfixnumopt)
-    @tfixnumvarargx = AnnotatedArgType.new("x", @tfixnumvararg)
+    @tintegerx = AnnotatedArgType.new("x", RDL::Globals.types[:integer])
+    @tintegery = AnnotatedArgType.new("y", RDL::Globals.types[:integer])
+    @tintegerret = AnnotatedArgType.new("ret", RDL::Globals.types[:integer])
+    @tintegeroptx = AnnotatedArgType.new("x", @tintegeropt)
+    @tintegervarargx = AnnotatedArgType.new("x", @tintegervararg)
     @tsymbol = SingletonType.new(:symbol)
     @tsymbolx = AnnotatedArgType.new("x", @tsymbol)
   end
 
   def tt(t)
-    $__rdl_parser.scan_str('#T ' + t)
+    RDL::Globals.parser.scan_str('#T ' + t)
   end
 
   def tm(t)
-    $__rdl_parser.scan_str t
+    RDL::Globals.parser.scan_str t
   end
 
   def test_basic
     t1 = tm "(nil) -> nil"
-    assert_equal (MethodType.new [$__rdl_nil_type], nil, $__rdl_nil_type), t1
-    t2 = tm "(Fixnum, Fixnum) -> Fixnum"
-    assert_equal (MethodType.new [$__rdl_fixnum_type, $__rdl_fixnum_type], nil, $__rdl_fixnum_type), t2
+    assert_equal (MethodType.new [RDL::Globals.types[:nil]], nil, RDL::Globals.types[:nil]), t1
+    t2 = tm "(Integer, Integer) -> Integer"
+    assert_equal (MethodType.new [RDL::Globals.types[:integer], RDL::Globals.types[:integer]], nil, RDL::Globals.types[:integer]), t2
     t3 = tm "() -> Enumerator"
     assert_equal (MethodType.new [], nil, @tenum), t3
     t4 = tm "(%any) -> nil"
-    assert_equal (MethodType.new [$__rdl_top_type], nil, $__rdl_nil_type), t4
-    t5 = tm "(%bool) -> Fixnum"
-    assert_equal (MethodType.new [$__rdl_bool_type], nil, $__rdl_fixnum_type), t5
+    assert_equal (MethodType.new [RDL::Globals.types[:top]], nil, RDL::Globals.types[:nil]), t4
+    t5 = tm "(%bool) -> Integer"
+    assert_equal (MethodType.new [RDL::Globals.types[:bool]], nil, RDL::Globals.types[:integer]), t5
     assert_raises(RuntimeError) { tm "(%foo) -> nil" }
     t6 = tm "(A) -> nil"
-    assert_equal (MethodType.new [@ta], nil, $__rdl_nil_type), t6
+    assert_equal (MethodType.new [@ta], nil, RDL::Globals.types[:nil]), t6
     t7 = tm "(TestParser::A) -> nil"
-    assert_equal (MethodType.new [NominalType.new("TestParser::A")], nil, $__rdl_nil_type), t7
-    t8 = tm "(Fixnum) { (%any, String) -> nil } -> :symbol"
-    assert_equal (MethodType.new [$__rdl_fixnum_type], MethodType.new([$__rdl_top_type, $__rdl_string_type], nil, $__rdl_nil_type), @tsymbol), t8
+    assert_equal (MethodType.new [NominalType.new("TestParser::A")], nil, RDL::Globals.types[:nil]), t7
+    t8 = tm "(Integer) { (%any, String) -> nil } -> :symbol"
+    assert_equal (MethodType.new [RDL::Globals.types[:integer]], MethodType.new([RDL::Globals.types[:top], RDL::Globals.types[:string]], nil, RDL::Globals.types[:nil]), @tsymbol), t8
     t9 = tm "(true) -> false"
-    assert_equal (MethodType.new [$__rdl_true_type], nil, $__rdl_false_type), t9
+    assert_equal (MethodType.new [RDL::Globals.types[:true]], nil, RDL::Globals.types[:false]), t9
   end
 
   def test_opt_vararg
-    t1 = tm "(Fixnum, ?Fixnum) -> Fixnum"
-    assert_equal (MethodType.new [$__rdl_fixnum_type, @tfixnumopt], nil, $__rdl_fixnum_type), t1
-    t2 = tm "(Fixnum, *Fixnum) -> Fixnum"
-    assert_equal (MethodType.new [$__rdl_fixnum_type, @tfixnumvararg], nil, $__rdl_fixnum_type), t2
-    t3 = tm "(Fixnum, ?Fixnum, ?Fixnum, *Fixnum) -> Fixnum"
-    assert_equal (MethodType.new [$__rdl_fixnum_type, @tfixnumopt, @tfixnumopt, @tfixnumvararg], nil, $__rdl_fixnum_type), t3
-    t4 = tm "(?Fixnum) -> nil"
-    assert_equal (MethodType.new [@tfixnumopt], nil, $__rdl_nil_type), t4
-    t5 = tm "(*Fixnum) -> nil"
-    assert_equal (MethodType.new [@tfixnumvararg], nil, $__rdl_nil_type), t5
+    t1 = tm "(Integer, ?Integer) -> Integer"
+    assert_equal (MethodType.new [RDL::Globals.types[:integer], @tintegeropt], nil, RDL::Globals.types[:integer]), t1
+    t2 = tm "(Integer, *Integer) -> Integer"
+    assert_equal (MethodType.new [RDL::Globals.types[:integer], @tintegervararg], nil, RDL::Globals.types[:integer]), t2
+    t3 = tm "(Integer, ?Integer, ?Integer, *Integer) -> Integer"
+    assert_equal (MethodType.new [RDL::Globals.types[:integer], @tintegeropt, @tintegeropt, @tintegervararg], nil, RDL::Globals.types[:integer]), t3
+    t4 = tm "(?Integer) -> nil"
+    assert_equal (MethodType.new [@tintegeropt], nil, RDL::Globals.types[:nil]), t4
+    t5 = tm "(*Integer) -> nil"
+    assert_equal (MethodType.new [@tintegervararg], nil, RDL::Globals.types[:nil]), t5
   end
 
   def test_union
-    t1 = tm "(Fixnum or String) -> nil"
-    assert_equal (MethodType.new [UnionType.new($__rdl_fixnum_type, $__rdl_string_type)], nil, $__rdl_nil_type), t1
-    t2 = tm "(Fixnum or String or Symbol) -> nil"
-    assert_equal (MethodType.new [UnionType.new($__rdl_fixnum_type, $__rdl_string_type, $__rdl_symbol_type)], nil, $__rdl_nil_type), t2
-    t3 = tm "() -> Fixnum or String or Symbol"
-    assert_equal (MethodType.new [], nil, UnionType.new($__rdl_fixnum_type, $__rdl_string_type, $__rdl_symbol_type)), t3
+    t1 = tm "(Integer or String) -> nil"
+    assert_equal (MethodType.new [UnionType.new(RDL::Globals.types[:integer], RDL::Globals.types[:string])], nil, RDL::Globals.types[:nil]), t1
+    t2 = tm "(Integer or String or Symbol) -> nil"
+    assert_equal (MethodType.new [UnionType.new(RDL::Globals.types[:integer], RDL::Globals.types[:string], RDL::Globals.types[:symbol])], nil, RDL::Globals.types[:nil]), t2
+    t3 = tm "() -> Integer or String or Symbol"
+    assert_equal (MethodType.new [], nil, UnionType.new(RDL::Globals.types[:integer], RDL::Globals.types[:string], RDL::Globals.types[:symbol])), t3
   end
 
   def test_bare
     t1 = tt "nil"
-    assert_equal $__rdl_nil_type, t1
+    assert_equal RDL::Globals.types[:nil], t1
     t2 = tt "%any"
-    assert_equal $__rdl_top_type, t2
+    assert_equal RDL::Globals.types[:top], t2
     t3 = tt "A"
     assert_equal NominalType.new("A"), t3
   end
@@ -93,26 +93,26 @@ class TestParser < Minitest::Test
   end
 
   def test_annotated_params
-    t1 = tm "(Fixnum x, Fixnum) -> Fixnum"
-    assert_equal (MethodType.new [@tfixnumx, $__rdl_fixnum_type], nil, $__rdl_fixnum_type), t1
-    t2 = tm "(Fixnum, ?Fixnum x) -> Fixnum"
-    assert_equal (MethodType.new [$__rdl_fixnum_type, @tfixnumoptx], nil, $__rdl_fixnum_type), t2
-    t3 = tm "(Fixnum, *Fixnum x) -> Fixnum"
-    assert_equal (MethodType.new [$__rdl_fixnum_type, @tfixnumvarargx], nil, $__rdl_fixnum_type), t3
-    t4 = tm "(Fixnum, Fixnum y) -> Fixnum"
-    assert_equal (MethodType.new [$__rdl_fixnum_type, @tfixnumy], nil, $__rdl_fixnum_type), t4
-    t5 = tm "(Fixnum x, Fixnum y) -> Fixnum"
-    assert_equal (MethodType.new [@tfixnumx, @tfixnumy], nil, $__rdl_fixnum_type), t5
-    t6 = tm "(Fixnum, Fixnum) -> Fixnum ret"
-    assert_equal (MethodType.new [$__rdl_fixnum_type, $__rdl_fixnum_type], nil, @tfixnumret), t6
-    t7 = tm "(Fixnum x, Fixnum) -> Fixnum ret"
-    assert_equal (MethodType.new [@tfixnumx, $__rdl_fixnum_type], nil, @tfixnumret), t7
-    t8 = tm "(Fixnum, Fixnum y) -> Fixnum ret"
-    assert_equal (MethodType.new [$__rdl_fixnum_type, @tfixnumy], nil, @tfixnumret), t8
-    t9 = tm "(Fixnum x, Fixnum y) -> Fixnum ret"
-    assert_equal (MethodType.new [@tfixnumx, @tfixnumy], nil, @tfixnumret), t9
-    t10 = tm "(:symbol x) -> Fixnum"
-    assert_equal (MethodType.new [@tsymbolx], nil, $__rdl_fixnum_type), t10
+    t1 = tm "(Integer x, Integer) -> Integer"
+    assert_equal (MethodType.new [@tintegerx, RDL::Globals.types[:integer]], nil, RDL::Globals.types[:integer]), t1
+    t2 = tm "(Integer, ?Integer x) -> Integer"
+    assert_equal (MethodType.new [RDL::Globals.types[:integer], @tintegeroptx], nil, RDL::Globals.types[:integer]), t2
+    t3 = tm "(Integer, *Integer x) -> Integer"
+    assert_equal (MethodType.new [RDL::Globals.types[:integer], @tintegervarargx], nil, RDL::Globals.types[:integer]), t3
+    t4 = tm "(Integer, Integer y) -> Integer"
+    assert_equal (MethodType.new [RDL::Globals.types[:integer], @tintegery], nil, RDL::Globals.types[:integer]), t4
+    t5 = tm "(Integer x, Integer y) -> Integer"
+    assert_equal (MethodType.new [@tintegerx, @tintegery], nil, RDL::Globals.types[:integer]), t5
+    t6 = tm "(Integer, Integer) -> Integer ret"
+    assert_equal (MethodType.new [RDL::Globals.types[:integer], RDL::Globals.types[:integer]], nil, @tintegerret), t6
+    t7 = tm "(Integer x, Integer) -> Integer ret"
+    assert_equal (MethodType.new [@tintegerx, RDL::Globals.types[:integer]], nil, @tintegerret), t7
+    t8 = tm "(Integer, Integer y) -> Integer ret"
+    assert_equal (MethodType.new [RDL::Globals.types[:integer], @tintegery], nil, @tintegerret), t8
+    t9 = tm "(Integer x, Integer y) -> Integer ret"
+    assert_equal (MethodType.new [@tintegerx, @tintegery], nil, @tintegerret), t9
+    t10 = tm "(:symbol x) -> Integer"
+    assert_equal (MethodType.new [@tsymbolx], nil, RDL::Globals.types[:integer]), t10
   end
 
   def test_generic
@@ -129,17 +129,17 @@ class TestParser < Minitest::Test
     t6 = tt "Hash<u, v>"
     assert_equal (GenericType.new(t5, VarType.new("u"), VarType.new("v"))), t6
     t7 = tt "Foo<String, Array<t>, Array<Array<t>>>"
-    assert_equal (GenericType.new(NominalType.new("Foo"), $__rdl_string_type, t3, t4)), t7
+    assert_equal (GenericType.new(NominalType.new("Foo"), RDL::Globals.types[:string], t3, t4)), t7
   end
 
   def test_tuple
-    t1 = tt "[Fixnum, String]"
-    assert_equal (TupleType.new($__rdl_fixnum_type, $__rdl_string_type)), t1
+    t1 = tt "[Integer, String]"
+    assert_equal (TupleType.new(RDL::Globals.types[:integer], RDL::Globals.types[:string])), t1
     t2 = tt "[String]"
-    assert_equal (TupleType.new($__rdl_string_type)), t2
+    assert_equal (TupleType.new(RDL::Globals.types[:string])), t2
   end
 
-  def test_fixnum
+  def test_integer
     t1 = tt "42"
     assert_equal (SingletonType.new(42)), t1
     t2 = tt "-42"
@@ -157,52 +157,52 @@ class TestParser < Minitest::Test
   end
 
   def test_type_alias
-    type_alias '%foobarbaz', $__rdl_nil_type
-    assert_equal $__rdl_nil_type, (tt "%foobarbaz")
-    type_alias '%quxquxqux', 'nil'
-    assert_equal $__rdl_nil_type, (tt "%quxquxqux")
-    assert_raises(RuntimeError) { type_alias '%quxquxqux', 'nil' }
+    RDL.type_alias '%foobarbaz', RDL::Globals.types[:nil]
+    assert_equal RDL::Globals.types[:nil], (tt "%foobarbaz")
+    RDL.type_alias '%quxquxqux', 'nil'
+    assert_equal RDL::Globals.types[:nil], (tt "%quxquxqux")
+    assert_raises(RuntimeError) { RDL.type_alias '%quxquxqux', 'nil' }
     assert_raises(RuntimeError) { tt "%qux" }
   end
 
   def test_structural
     t1 = tt "[to_str: () -> String]"
-    tm1 = MethodType.new [], nil, $__rdl_string_type
+    tm1 = MethodType.new [], nil, RDL::Globals.types[:string]
     ts1 = StructuralType.new(to_str: tm1)
     assert_equal ts1, t1
   end
 
   def test_finite_hash
-    t1 = tt "{a: Fixnum, b: String}"
-    assert_equal (FiniteHashType.new({a: $__rdl_fixnum_type, b: $__rdl_string_type}, nil)), t1
-    t2 = tt "{'a'=>Fixnum, 2=>String}"
-    assert_equal (FiniteHashType.new({"a"=>$__rdl_fixnum_type, 2=>$__rdl_string_type}, nil)), t2
+    t1 = tt "{a: Integer, b: String}"
+    assert_equal (FiniteHashType.new({a: RDL::Globals.types[:integer], b: RDL::Globals.types[:string]}, nil)), t1
+    t2 = tt "{'a'=>Integer, 2=>String}"
+    assert_equal (FiniteHashType.new({"a"=>RDL::Globals.types[:integer], 2=>RDL::Globals.types[:string]}, nil)), t2
   end
 
   def test_named_params
-    t1 = tm "(Fixnum, x: Fixnum) -> Fixnum"
-    assert_equal (MethodType.new [$__rdl_fixnum_type, FiniteHashType.new({x: $__rdl_fixnum_type}, nil)], nil, $__rdl_fixnum_type), t1
-    t2 = tm "(Fixnum, x: Fixnum, y: String) -> Fixnum"
-    assert_equal (MethodType.new [$__rdl_fixnum_type, FiniteHashType.new({x: $__rdl_fixnum_type, y: $__rdl_string_type}, nil)], nil, $__rdl_fixnum_type), t2
-    t3 = tm "(Fixnum, y: String, x: Fixnum) -> Fixnum"
-    assert_equal (MethodType.new [$__rdl_fixnum_type, FiniteHashType.new({x: $__rdl_fixnum_type, y: $__rdl_string_type}, nil)], nil, $__rdl_fixnum_type), t3
-    t4 = tm "(Fixnum, y: String, x: ?Fixnum) -> Fixnum"
-    assert_equal (MethodType.new [$__rdl_fixnum_type, FiniteHashType.new({x: @tfixnumopt, y: $__rdl_string_type}, nil)], nil, $__rdl_fixnum_type), t4
-    t4 = tm "(Fixnum, y: ?String, x: Fixnum) -> Fixnum"
-    assert_equal (MethodType.new [$__rdl_fixnum_type, FiniteHashType.new({x: $__rdl_fixnum_type, y: @tstringopt}, nil)], nil, $__rdl_fixnum_type), t4
-    t5 = tm "(Fixnum x, x: Fixnum) -> Fixnum"
-    assert_equal (MethodType.new [@tfixnumx, FiniteHashType.new({x: $__rdl_fixnum_type}, nil)], nil, $__rdl_fixnum_type), t5
-    t6 = tm "(x: Fixnum) -> Fixnum"
-    assert_equal (MethodType.new [FiniteHashType.new({x: $__rdl_fixnum_type}, nil)], nil, $__rdl_fixnum_type), t6
-    t7 = tm "(x: Fixnum) { (%any, String) -> nil } -> :symbol"
-    assert_equal (MethodType.new [FiniteHashType.new({x: $__rdl_fixnum_type}, nil)], MethodType.new([$__rdl_top_type, $__rdl_string_type], nil, $__rdl_nil_type), @tsymbol), t7
-    t8 = tm "(Fixnum, x: Fixnum, **String) -> Fixnum"
-    assert_equal (MethodType.new [$__rdl_fixnum_type, FiniteHashType.new({x: $__rdl_fixnum_type}, $__rdl_string_type)], nil, $__rdl_fixnum_type), t8
+    t1 = tm "(Integer, x: Integer) -> Integer"
+    assert_equal (MethodType.new [RDL::Globals.types[:integer], FiniteHashType.new({x: RDL::Globals.types[:integer]}, nil)], nil, RDL::Globals.types[:integer]), t1
+    t2 = tm "(Integer, x: Integer, y: String) -> Integer"
+    assert_equal (MethodType.new [RDL::Globals.types[:integer], FiniteHashType.new({x: RDL::Globals.types[:integer], y: RDL::Globals.types[:string]}, nil)], nil, RDL::Globals.types[:integer]), t2
+    t3 = tm "(Integer, y: String, x: Integer) -> Integer"
+    assert_equal (MethodType.new [RDL::Globals.types[:integer], FiniteHashType.new({x: RDL::Globals.types[:integer], y: RDL::Globals.types[:string]}, nil)], nil, RDL::Globals.types[:integer]), t3
+    t4 = tm "(Integer, y: String, x: ?Integer) -> Integer"
+    assert_equal (MethodType.new [RDL::Globals.types[:integer], FiniteHashType.new({x: @tintegeropt, y: RDL::Globals.types[:string]}, nil)], nil, RDL::Globals.types[:integer]), t4
+    t4 = tm "(Integer, y: ?String, x: Integer) -> Integer"
+    assert_equal (MethodType.new [RDL::Globals.types[:integer], FiniteHashType.new({x: RDL::Globals.types[:integer], y: @tstringopt}, nil)], nil, RDL::Globals.types[:integer]), t4
+    t5 = tm "(Integer x, x: Integer) -> Integer"
+    assert_equal (MethodType.new [@tintegerx, FiniteHashType.new({x: RDL::Globals.types[:integer]}, nil)], nil, RDL::Globals.types[:integer]), t5
+    t6 = tm "(x: Integer) -> Integer"
+    assert_equal (MethodType.new [FiniteHashType.new({x: RDL::Globals.types[:integer]}, nil)], nil, RDL::Globals.types[:integer]), t6
+    t7 = tm "(x: Integer) { (%any, String) -> nil } -> :symbol"
+    assert_equal (MethodType.new [FiniteHashType.new({x: RDL::Globals.types[:integer]}, nil)], MethodType.new([RDL::Globals.types[:top], RDL::Globals.types[:string]], nil, RDL::Globals.types[:nil]), @tsymbol), t7
+    t8 = tm "(Integer, x: Integer, **String) -> Integer"
+    assert_equal (MethodType.new [RDL::Globals.types[:integer], FiniteHashType.new({x: RDL::Globals.types[:integer]}, RDL::Globals.types[:string])], nil, RDL::Globals.types[:integer]), t8
   end
 
   def test_nonnull
     assert_equal NonNullType.new(@ta), tt("!A")
-    tm2 = MethodType.new [], nil, $__rdl_string_type
+    tm2 = MethodType.new [], nil, RDL::Globals.types[:string]
     ts2 = StructuralType.new(to_str: tm2)
     assert_equal NonNullType.new(ts2), tt("![to_str: () -> String]")
     assert_raises(RuntimeError) { tt("!3") }
@@ -210,11 +210,16 @@ class TestParser < Minitest::Test
 
   def test_optional_block
     t1 = tm "() { (%any) -> nil } -> %any"
-    assert_equal (MethodType.new [], MethodType.new([$__rdl_top_type], nil, $__rdl_nil_type), $__rdl_top_type), t1
+    assert_equal (MethodType.new [], MethodType.new([RDL::Globals.types[:top]], nil, RDL::Globals.types[:nil]), RDL::Globals.types[:top]), t1
     t2 = tm "() ?{ (%any) -> nil } -> %any"
-    assert_equal (MethodType.new [], OptionalType.new(MethodType.new([$__rdl_top_type], nil, $__rdl_nil_type)), $__rdl_top_type), t2
+    assert_equal (MethodType.new [], OptionalType.new(MethodType.new([RDL::Globals.types[:top]], nil, RDL::Globals.types[:nil])), RDL::Globals.types[:top]), t2
     t3 = tm "() ?{ (t) -> nil } -> %any"
-    assert_equal (MethodType.new [], OptionalType.new(MethodType.new([VarType.new('t')], nil, $__rdl_nil_type)), $__rdl_top_type), t3
+    assert_equal (MethodType.new [], OptionalType.new(MethodType.new([VarType.new('t')], nil, RDL::Globals.types[:nil])), RDL::Globals.types[:top]), t3
+  end
+
+  def test_or
+    assert_equal (FiniteHashType.new({aorganization: RDL::Globals.types[:symbol]}, nil)), tt('{aorganization: Symbol}')
+    assert_equal (FiniteHashType.new({organization: RDL::Globals.types[:symbol]}, nil)), tt('{organization: Symbol}')
   end
 
 end

data/test/test_query.rb

@@ -7,7 +7,7 @@ class TestQuery < Minitest::Test
 
   def setup
     @p = Parser.new
-    @tfixnum = NominalType.new Fixnum
+    @tinteger = NominalType.new Integer
     @tarray = NominalType.new Array
     @qwild = WildQuery.new
     @qwildopt = OptionalType.new @qwild
@@ -19,94 +19,94 @@ class TestQuery < Minitest::Test
   def test_parse
     q1 = @p.scan_str "#Q (.) -> ."
     assert_equal (MethodType.new [@qwild], nil, @qwild), q1
-    q2 = @p.scan_str "#Q (., Fixnum) -> Fixnum"
-    assert_equal (MethodType.new [@qwild, @tfixnum], nil, @tfixnum), q2
-    q3 = @p.scan_str "#Q (Fixnum, ?.) -> Fixnum"
-    assert_equal (MethodType.new [@tfixnum, @qwildopt], nil, @tfixnum), q3
-    q4 = @p.scan_str "#Q (*.) -> Fixnum"
-    assert_equal (MethodType.new [@qwildvararg], nil, @tfixnum), q4
-    q5 = @p.scan_str "#Q (. or Fixnum) -> Fixnum"
-    assert_equal (MethodType.new [UnionType.new(@qwild, @tfixnum)], nil, @tfixnum), q5
-    q6 = @p.scan_str "#Q (. x, Fixnum) -> Fixnum"
-    assert_equal (MethodType.new [@qwildx, @tfixnum], nil, @tfixnum), q6
-    q7 = @p.scan_str "#Q (Array<.>) -> Fixnum"
-    assert_equal (MethodType.new [GenericType.new(@tarray, @qwild)], nil, @tfixnum), q7
-#    q8 = @p.scan_str "#Q (.<Fixnum>) -> Fixnum"
-#    assert_equal (MethodType.new [GenericType.new(@twild, @tfixnum)], nil, @tfixnum), q8
-    q9 = @p.scan_str "#Q ([Fixnum, .]) -> Fixnum"
-    assert_equal (MethodType.new [TupleType.new(@tfixnum, @qwild)], nil, @tfixnum), q9
-    q10 = @p.scan_str "#Q ([to_str: () -> .]) -> Fixnum"
-    assert_equal (MethodType.new [StructuralType.new(to_str: (MethodType.new [], nil, @qwild))], nil, @tfixnum), q10
-    q11 = @p.scan_str "#Q ({a: Fixnum, b: .}) -> Fixnum"
-    assert_equal (MethodType.new [FiniteHashType.new({a: @tfixnum, b: @qwild}, nil)], nil, @tfixnum), q11
-    q12 = @p.scan_str "#Q (Fixnum, x: .) -> Fixnum"
-    assert_equal (MethodType.new [@tfixnum, FiniteHashType.new({x: @qwild}, nil)], nil, @tfixnum), q12
-    q13 = @p.scan_str "#Q (Fixnum, ..., Fixnum) -> Fixnum"
-    assert_equal (MethodType.new [@tfixnum, @qdots, @tfixnum], nil, @tfixnum), q13
-    q14 = @p.scan_str "#Q (Fixnum, ...) -> Fixnum"
-    assert_equal (MethodType.new [@tfixnum, @qdots], nil, @tfixnum), q14
-    q15 = @p.scan_str "#Q (...) -> Fixnum"
-    assert_equal (MethodType.new [@qdots], nil, @tfixnum), q15
+    q2 = @p.scan_str "#Q (., Integer) -> Integer"
+    assert_equal (MethodType.new [@qwild, @tinteger], nil, @tinteger), q2
+    q3 = @p.scan_str "#Q (Integer, ?.) -> Integer"
+    assert_equal (MethodType.new [@tinteger, @qwildopt], nil, @tinteger), q3
+    q4 = @p.scan_str "#Q (*.) -> Integer"
+    assert_equal (MethodType.new [@qwildvararg], nil, @tinteger), q4
+    q5 = @p.scan_str "#Q (. or Integer) -> Integer"
+    assert_equal (MethodType.new [UnionType.new(@qwild, @tinteger)], nil, @tinteger), q5
+    q6 = @p.scan_str "#Q (. x, Integer) -> Integer"
+    assert_equal (MethodType.new [@qwildx, @tinteger], nil, @tinteger), q6
+    q7 = @p.scan_str "#Q (Array<.>) -> Integer"
+    assert_equal (MethodType.new [GenericType.new(@tarray, @qwild)], nil, @tinteger), q7
+#    q8 = @p.scan_str "#Q (.<Integer>) -> Integer"
+#    assert_equal (MethodType.new [GenericType.new(@twild, @tinteger)], nil, @tinteger), q8
+    q9 = @p.scan_str "#Q ([Integer, .]) -> Integer"
+    assert_equal (MethodType.new [TupleType.new(@tinteger, @qwild)], nil, @tinteger), q9
+    q10 = @p.scan_str "#Q ([to_str: () -> .]) -> Integer"
+    assert_equal (MethodType.new [StructuralType.new(to_str: (MethodType.new [], nil, @qwild))], nil, @tinteger), q10
+    q11 = @p.scan_str "#Q ({a: Integer, b: .}) -> Integer"
+    assert_equal (MethodType.new [FiniteHashType.new({a: @tinteger, b: @qwild}, nil)], nil, @tinteger), q11
+    q12 = @p.scan_str "#Q (Integer, x: .) -> Integer"
+    assert_equal (MethodType.new [@tinteger, FiniteHashType.new({x: @qwild}, nil)], nil, @tinteger), q12
+    q13 = @p.scan_str "#Q (Integer, ..., Integer) -> Integer"
+    assert_equal (MethodType.new [@tinteger, @qdots, @tinteger], nil, @tinteger), q13
+    q14 = @p.scan_str "#Q (Integer, ...) -> Integer"
+    assert_equal (MethodType.new [@tinteger, @qdots], nil, @tinteger), q14
+    q15 = @p.scan_str "#Q (...) -> Integer"
+    assert_equal (MethodType.new [@qdots], nil, @tinteger), q15
   end
 
   def test_match
-    t1 = @p.scan_str "(Fixnum, Fixnum) -> Fixnum"
-    assert (@p.scan_str "#Q (Fixnum, Fixnum) -> Fixnum").match(t1)
+    t1 = @p.scan_str "(Integer, Integer) -> Integer"
+    assert (@p.scan_str "#Q (Integer, Integer) -> Integer").match(t1)
     assert (@p.scan_str "#Q (., .) -> .").match(t1)
-    assert (@p.scan_str "#Q (..., Fixnum) -> Fixnum").match(t1)
-    assert (@p.scan_str "#Q (Fixnum, ...) -> Fixnum").match(t1)
-    assert (@p.scan_str "#Q (...) -> Fixnum").match(t1)
-    assert (not (@p.scan_str "#Q (Fixnum, String) -> Fixnum").match(t1))
-    assert (not (@p.scan_str "#Q (String, Fixnum) -> Fixnum").match(t1))
-    assert (not (@p.scan_str "#Q (Fixnum, String) -> String").match(t1))
+    assert (@p.scan_str "#Q (..., Integer) -> Integer").match(t1)
+    assert (@p.scan_str "#Q (Integer, ...) -> Integer").match(t1)
+    assert (@p.scan_str "#Q (...) -> Integer").match(t1)
+    assert (not (@p.scan_str "#Q (Integer, String) -> Integer").match(t1))
+    assert (not (@p.scan_str "#Q (String, Integer) -> Integer").match(t1))
+    assert (not (@p.scan_str "#Q (Integer, String) -> String").match(t1))
     assert (not (@p.scan_str "#Q (..., String) -> String").match(t1))
     assert (not (@p.scan_str "#Q (String, ...) -> String").match(t1))
-    t2 = @p.scan_str "(String or Fixnum) -> Fixnum"
-    assert (@p.scan_str "#Q (String or Fixnum) -> Fixnum").match(t2)
-    assert (@p.scan_str "#Q (String or .) -> Fixnum").match(t2)
-    assert (@p.scan_str "#Q (. or Fixnum) -> Fixnum").match(t2)
-    assert (@p.scan_str "#Q (Fixnum or String) -> Fixnum").match(t2)
-    assert (@p.scan_str "#Q (Fixnum or .) -> Fixnum").match(t2)
-    assert (@p.scan_str "#Q (. or String) -> Fixnum").match(t2)
-    t3 = @p.scan_str "(Array<Fixnum>) -> Fixnum"
-    assert (@p.scan_str "#Q (Array<Fixnum>) -> Fixnum").match(t3)
-    assert (@p.scan_str "#Q (Array<.>) -> Fixnum").match(t3)
-    t4 = @p.scan_str "([Fixnum, String]) -> Fixnum"
-    assert (@p.scan_str "#Q ([Fixnum, String]) -> Fixnum").match(t4)
-    assert (@p.scan_str "#Q ([Fixnum, .]) -> Fixnum").match(t4)
-    assert (@p.scan_str "#Q ([., String]) -> Fixnum").match(t4)
-    t5 = @p.scan_str "([to_str: () -> Fixnum]) -> Fixnum"
-    assert (@p.scan_str "#Q ([to_str: () -> Fixnum]) -> Fixnum").match(t5)
-    assert (@p.scan_str "#Q ([to_str: () -> .]) -> Fixnum").match(t5)
-    t6 = @p.scan_str "(Fixnum, ?Fixnum) -> Fixnum"
-    assert (@p.scan_str "#Q (Fixnum, ?Fixnum) -> Fixnum").match(t6)
-    assert (@p.scan_str "#Q (Fixnum, ?.) -> Fixnum").match(t6)
-    assert (@p.scan_str "#Q (Fixnum, .) -> Fixnum").match(t6)
-    t7 = @p.scan_str "(*Fixnum) -> Fixnum"
-    assert (@p.scan_str "#Q (*Fixnum) -> Fixnum").match(t7)
-    assert (@p.scan_str "#Q (*.) -> Fixnum").match(t7)
-    assert (@p.scan_str "#Q (.) -> Fixnum").match(t7)
-    t8 = @p.scan_str "({a: Fixnum, b: String}) -> Fixnum"
-    assert (@p.scan_str "#Q ({a: Fixnum, b: String}) -> Fixnum").match(t8)
-    assert (@p.scan_str "#Q ({a: Fixnum, b: .}) -> Fixnum").match(t8)
-    assert (@p.scan_str "#Q ({a: ., b: String}) -> Fixnum").match(t8)
-    assert (@p.scan_str "#Q ({a: ., b: .}) -> Fixnum").match(t8)
-    assert (@p.scan_str "#Q ({b: String, a: Fixnum}) -> Fixnum").match(t8)
-    assert (@p.scan_str "#Q ({b: ., a: Fixnum}) -> Fixnum").match(t8)
-    assert (@p.scan_str "#Q ({b: String, a: .}) -> Fixnum").match(t8)
-    assert (@p.scan_str "#Q ({b: ., a: .}) -> Fixnum").match(t8)
-    assert (@p.scan_str "#Q (.) -> Fixnum").match(t8)
-    t9 = @p.scan_str "(Fixnum, x: String) -> Fixnum"
-    assert (@p.scan_str "#Q (Fixnum, x: String) -> Fixnum").match(t9)
-    assert (@p.scan_str "#Q (Fixnum, x: .) -> Fixnum").match(t9)
-    assert (@p.scan_str "#Q (Fixnum, .) -> Fixnum").match(t9)
-    t10 = @p.scan_str "(String x, Fixnum) -> Fixnum"
-    assert (@p.scan_str "#Q (String x, Fixnum) -> Fixnum").match(t10)
-    assert (@p.scan_str "#Q (. x, Fixnum) -> Fixnum").match(t10)
-    assert (@p.scan_str "#Q (String, Fixnum) -> Fixnum").match(t10)
-    assert (@p.scan_str "#Q (., Fixnum) -> Fixnum").match(t10)
-    t11 = @p.scan_str "(Fixnum, x: String, **Float) -> Fixnum"
-    assert (@p.scan_str "#Q (Fixnum, x: String, **Float) -> Fixnum").match(t11)
-    assert (@p.scan_str "#Q (Fixnum, x: String, **.) -> Fixnum").match(t11)
+    t2 = @p.scan_str "(String or Integer) -> Integer"
+    assert (@p.scan_str "#Q (String or Integer) -> Integer").match(t2)
+    assert (@p.scan_str "#Q (String or .) -> Integer").match(t2)
+    assert (@p.scan_str "#Q (. or Integer) -> Integer").match(t2)
+    assert (@p.scan_str "#Q (Integer or String) -> Integer").match(t2)
+    assert (@p.scan_str "#Q (Integer or .) -> Integer").match(t2)
+    assert (@p.scan_str "#Q (. or String) -> Integer").match(t2)
+    t3 = @p.scan_str "(Array<Integer>) -> Integer"
+    assert (@p.scan_str "#Q (Array<Integer>) -> Integer").match(t3)
+    assert (@p.scan_str "#Q (Array<.>) -> Integer").match(t3)
+    t4 = @p.scan_str "([Integer, String]) -> Integer"
+    assert (@p.scan_str "#Q ([Integer, String]) -> Integer").match(t4)
+    assert (@p.scan_str "#Q ([Integer, .]) -> Integer").match(t4)
+    assert (@p.scan_str "#Q ([., String]) -> Integer").match(t4)
+    t5 = @p.scan_str "([to_str: () -> Integer]) -> Integer"
+    assert (@p.scan_str "#Q ([to_str: () -> Integer]) -> Integer").match(t5)
+    assert (@p.scan_str "#Q ([to_str: () -> .]) -> Integer").match(t5)
+    t6 = @p.scan_str "(Integer, ?Integer) -> Integer"
+    assert (@p.scan_str "#Q (Integer, ?Integer) -> Integer").match(t6)
+    assert (@p.scan_str "#Q (Integer, ?.) -> Integer").match(t6)
+    assert (@p.scan_str "#Q (Integer, .) -> Integer").match(t6)
+    t7 = @p.scan_str "(*Integer) -> Integer"
+    assert (@p.scan_str "#Q (*Integer) -> Integer").match(t7)
+    assert (@p.scan_str "#Q (*.) -> Integer").match(t7)
+    assert (@p.scan_str "#Q (.) -> Integer").match(t7)
+    t8 = @p.scan_str "({a: Integer, b: String}) -> Integer"
+    assert (@p.scan_str "#Q ({a: Integer, b: String}) -> Integer").match(t8)
+    assert (@p.scan_str "#Q ({a: Integer, b: .}) -> Integer").match(t8)
+    assert (@p.scan_str "#Q ({a: ., b: String}) -> Integer").match(t8)
+    assert (@p.scan_str "#Q ({a: ., b: .}) -> Integer").match(t8)
+    assert (@p.scan_str "#Q ({b: String, a: Integer}) -> Integer").match(t8)
+    assert (@p.scan_str "#Q ({b: ., a: Integer}) -> Integer").match(t8)
+    assert (@p.scan_str "#Q ({b: String, a: .}) -> Integer").match(t8)
+    assert (@p.scan_str "#Q ({b: ., a: .}) -> Integer").match(t8)
+    assert (@p.scan_str "#Q (.) -> Integer").match(t8)
+    t9 = @p.scan_str "(Integer, x: String) -> Integer"
+    assert (@p.scan_str "#Q (Integer, x: String) -> Integer").match(t9)
+    assert (@p.scan_str "#Q (Integer, x: .) -> Integer").match(t9)
+    assert (@p.scan_str "#Q (Integer, .) -> Integer").match(t9)
+    t10 = @p.scan_str "(String x, Integer) -> Integer"
+    assert (@p.scan_str "#Q (String x, Integer) -> Integer").match(t10)
+    assert (@p.scan_str "#Q (. x, Integer) -> Integer").match(t10)
+    assert (@p.scan_str "#Q (String, Integer) -> Integer").match(t10)
+    assert (@p.scan_str "#Q (., Integer) -> Integer").match(t10)
+    t11 = @p.scan_str "(Integer, x: String, **Float) -> Integer"
+    assert (@p.scan_str "#Q (Integer, x: String, **Float) -> Integer").match(t11)
+    assert (@p.scan_str "#Q (Integer, x: String, **.) -> Integer").match(t11)
   end
 end