rdl 1.1.1 → 2.0.0.rc1

data/test/test_intersection.rb

@@ -1,5 +1,6 @@
 require 'minitest/autorun'
-require_relative '../lib/rdl.rb'
+$LOAD_PATH << File.dirname(__FILE__) + "/../lib"
+require 'rdl'
 
 class TestIntersection < Minitest::Test
   include RDL::Type
@@ -14,7 +15,7 @@ class TestIntersection < Minitest::Test
     @true_n = NominalType.new(TrueClass)
 
     @tparam_t = VarType.new(:t)
-    
+
     @f_or_s = UnionType.new(@fixnum, @string)
     @string_or_true = UnionType.new(@string, @true_n)
 
@@ -38,4 +39,3 @@ class TestIntersection < Minitest::Test
     assert_equal(t1, i)
   end
 end
-

data/test/test_le.rb

@@ -1,5 +1,7 @@
 require 'minitest/autorun'
-require_relative '../lib/rdl.rb'
+$LOAD_PATH << File.dirname(__FILE__) + "/../lib"
+require 'rdl'
+require 'rdl_types'
 
 class TestLe < Minitest::Test
   include RDL::Type
@@ -14,63 +16,57 @@ class TestLe < Minitest::Test
   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
     @ta = NominalType.new A
     @tb = NominalType.new B
     @tc = NominalType.new C
-    @tfixnum = NominalType.new "Fixnum"
   end
 
   def test_nil
-    assert (@tnil <= @ttop)
-    assert (@tnil <= @tstring)
-    assert (@tnil <= @tobject)
-    assert (@tnil <= @tbasicobject)
-    assert (@tnil <= @tsymfoo)
-    assert (not (@ttop <= @tnil))
-    assert (not (@tstring <= @tnil))
-    assert (not (@tobject <= @tnil))
-    assert (not (@tbasicobject <= @tnil))
-    assert (not (@tsymfoo <= @tnil))
+    assert ($__rdl_nil_type <= $__rdl_top_type)
+    assert ($__rdl_nil_type <= $__rdl_string_type)
+    assert ($__rdl_nil_type <= $__rdl_object_type)
+    assert ($__rdl_nil_type <= @tbasicobject)
+    assert (not ($__rdl_nil_type <= @tsymfoo)) # nil no longer <= other singleton types
+    assert (not ($__rdl_top_type <= $__rdl_nil_type))
+    assert (not ($__rdl_string_type <= $__rdl_nil_type))
+    assert (not ($__rdl_object_type <= $__rdl_nil_type))
+    assert (not (@tbasicobject <= $__rdl_nil_type))
+    assert (not (@tsymfoo <= $__rdl_nil_type))
   end
 
   def test_top
-    assert (not (@ttop <= @tnil))
-    assert (not (@ttop <= @tstring))
-    assert (not (@ttop <= @tobject))
-    assert (not (@ttop <= @tbasicobject))
-    assert (not (@ttop <= @tsymfoo))
-    assert (@ttop <= @ttop)
-    assert (@tstring <= @ttop)
-    assert (@tobject <= @ttop)
-    assert (@tbasicobject <= @ttop)
-    assert (@tsymfoo <= @ttop)
+    assert (not ($__rdl_top_type <= $__rdl_nil_type))
+    assert (not ($__rdl_top_type <= $__rdl_string_type))
+    assert (not ($__rdl_top_type <= $__rdl_object_type))
+    assert (not ($__rdl_top_type <= @tbasicobject))
+    assert (not ($__rdl_top_type <= @tsymfoo))
+    assert ($__rdl_top_type <= $__rdl_top_type)
+    assert ($__rdl_string_type <= $__rdl_top_type)
+    assert ($__rdl_object_type <= $__rdl_top_type)
+    assert (@tbasicobject <= $__rdl_top_type)
+    assert (@tsymfoo <= $__rdl_top_type)
   end
 
   def test_sym
-    assert (@tsym <= @tsym)
+    assert ($__rdl_symbol_type <= $__rdl_symbol_type)
     assert (@tsymfoo <= @tsymfoo)
-    assert (@tsymfoo <= @tsym)
-    assert (not (@tsym <= @tsymfoo))
+    assert (@tsymfoo <= $__rdl_symbol_type)
+    assert (not ($__rdl_symbol_type <= @tsymfoo))
   end
 
   def test_nominal
-    assert (@tstring <= @tstring)
-    assert (@tsym <= @tsym)
-    assert (not (@tstring <= @tsym))
-    assert (not (@tsym <= @tstring))
-    assert (@tstring <= @tobject)
-    assert (@tstring <= @tbasicobject)
-    assert (@tobject <= @tbasicobject)
-    assert (not (@tobject <= @tstring))
-    assert (not (@tbasicobject <= @tstring))
-    assert (not (@tbasicobject <= @tobject))
+    assert ($__rdl_string_type <= $__rdl_string_type)
+    assert ($__rdl_symbol_type <= $__rdl_symbol_type)
+    assert (not ($__rdl_string_type <= $__rdl_symbol_type))
+    assert (not ($__rdl_symbol_type <= $__rdl_string_type))
+    assert ($__rdl_string_type <= $__rdl_object_type)
+    assert ($__rdl_string_type <= @tbasicobject)
+    assert ($__rdl_object_type <= @tbasicobject)
+    assert (not ($__rdl_object_type <= $__rdl_string_type))
+    assert (not (@tbasicobject <= $__rdl_string_type))
+    assert (not (@tbasicobject <= $__rdl_object_type))
     assert (@ta <= @ta)
     assert (@tb <= @ta)
     assert (@tc <= @ta)
@@ -83,28 +79,100 @@ class TestLe < Minitest::Test
   end
 
   def test_union
-    tstring_or_sym = UnionType.new(@tstring, @tsym)
-    assert (tstring_or_sym <= @tobject)
-    assert (not (@tobject <= tstring_or_sym))
+    tstring_or_sym = UnionType.new($__rdl_string_type, $__rdl_symbol_type)
+    assert (tstring_or_sym <= $__rdl_object_type)
+    assert (not ($__rdl_object_type <= tstring_or_sym))
   end
 
   def test_tuple
-    t1 = TupleType.new(@tsym, @tstring)
-    t2 = TupleType.new(@tobject, @tobject)
+    t1 = TupleType.new($__rdl_symbol_type, $__rdl_string_type)
+    t2 = TupleType.new($__rdl_object_type, $__rdl_object_type)
     tarray = NominalType.new("Array")
     assert (t1 <= t1)
     assert (t2 <= t2)
-    assert (not (t1 <= t2)) # invariant subtyping since tuples are mutable
     assert (not (t2 <= t1))
-    assert (not (t1 <= tarray)) # no convertability to arrays due to mutability
     assert (not (tarray <= t1))
+    assert (t1 <= t2) # covariant subtyping since tuples are *immutable*
+    t123 = $__rdl_parser.scan_str "#T [1, 2, 3]"
+    tfff = $__rdl_parser.scan_str "#T [Fixnum, Fixnum, Fixnum]"
+    tooo = $__rdl_parser.scan_str "#T [Object, Object, Object]"
+    assert (t123 <= tfff) # covariant subtyping with singletons
+    assert (tfff <= tooo)
+    assert (t123 <= tooo)
+
+    # subtyping of tuples and arrays
+    tfs_1 = $__rdl_parser.scan_str "#T [Fixnum, String]"
+    tafs_1 = $__rdl_parser.scan_str "#T Array<Fixnum or String>"
+    assert (tfs_1 <= tafs_1) # subtyping allowed by tfs_1 promoted to array
+    tfs2_1 = $__rdl_parser.scan_str "#T [Fixnum, String]"
+    assert (not (tfs_1 <= tfs2_1)) # t12 has been promoted to array, no longer subtype
+
+    tfs_2 = $__rdl_parser.scan_str "#T [Fixnum, String]"
+    tfs2_2 = $__rdl_parser.scan_str "#T [Fixnum, String]"
+    assert (tfs_2 <= tfs2_2) # this is allowed here because tfs_2 is still a tuple
+    tafs_2 = $__rdl_parser.scan_str "#T Array<Fixnum or String>"
+    assert (not (tfs_2 <= tafs_2)) # subtyping not allowed because tfs_2 <= tfs2_2 unsatisfiable after tfs_2 promoted
+
+    tfs_3 = $__rdl_parser.scan_str "#T [Fixnum, String]"
+    tfs2_3 = $__rdl_parser.scan_str "#T [Object, Object]"
+    assert (tfs_3 <= tfs2_3) # this is allowed here because t12a is still a tuple
+    tafs_3 = $__rdl_parser.scan_str "#T Array<Object>"
+    assert (not (tfs2_3 <= tafs_3)) # subtyping not allowed because tfs_3 <= tfs2_3 unsatisfiable after tfs2_3 promoted
+
+    tfs_4 = $__rdl_parser.scan_str "#T [Fixnum, String]"
+    tfs2_4 = $__rdl_parser.scan_str "#T [Fixnum, String]"
+    assert (tfs_4 <= tfs2_4) # allowed, types are the same
+    tafs_4 = $__rdl_parser.scan_str "#T Array<Fixnum or String>"
+    assert (tfs2_4 <= tafs_4) # allowed, both tfs2_4 and tfs_4 promoted to array
+    tfs3_4 = $__rdl_parser.scan_str "#T [Fixnum, String]"
+    assert (not(tfs_4 <= tfs3_4)) # not allowed, tfs_4 has been promoted
+  end
+
+  def test_finite_hash
+    t12 = $__rdl_parser.scan_str "#T {a: 1, b: 2}"
+    tfs = $__rdl_parser.scan_str "#T {a: Fixnum, b: Fixnum}"
+    too = $__rdl_parser.scan_str "#T {a: Object, b: Object}"
+    assert (t12 <= tfs)
+    assert (t12 <= too)
+    assert (tfs <= too)
+    assert (not (tfs <= t12))
+    assert (not (too <= tfs))
+    assert (not (too <= t12))
+
+    # subtyping of finite hashes and hashes; same pattern as tuples
+    # subtyping of tuples and arrays
+    tfs_1 = $__rdl_parser.scan_str "#T {x: Fixnum, y: String}"
+    thfs_1 = $__rdl_parser.scan_str "#T Hash<Symbol, Fixnum or String>"
+    assert (tfs_1 <= thfs_1) # subtyping allowed because tfs_1 promoted to hash
+    tfs2_1 = $__rdl_parser.scan_str "#T {x: Fixnum, y: String}"
+    assert (not (tfs_1 <= tfs2_1)) # t12 has been promoted to hash, no longer subtype
+
+    tfs_2 = $__rdl_parser.scan_str "#T {x: Fixnum, y: String}"
+    tfs2_2 = $__rdl_parser.scan_str "#T {x: Fixnum, y: String}"
+    assert (tfs_2 <= tfs2_2) # this is allowed here because tfs_2 is still finite
+    thfs_2 = $__rdl_parser.scan_str "#T Hash<Symbol, Fixnum or String>"
+    assert (not (tfs_2 <= thfs_2)) # subtyping not allowed because tfs_2 <= tfs2_2 unsatisfiable after tfs_2 promoted
+
+    tfs_3 = $__rdl_parser.scan_str "#T {x: Fixnum, y: String}"
+    tfs2_3 = $__rdl_parser.scan_str "#T {x: Object, y: Object}"
+    assert (tfs_3 <= tfs2_3) # this is allowed here because t12a is still finite
+    thfs_3 = $__rdl_parser.scan_str "#T Hash<Symbol, Object>"
+    assert (not (tfs2_3 <= thfs_3)) # subtyping not allowed because tfs_3 <= tfs2_3 unsatisfiable after tfs2_3 promoted
+
+    tfs_4 = $__rdl_parser.scan_str "#T {x: Fixnum, y: String}"
+    tfs2_4 = $__rdl_parser.scan_str "#T {x: Fixnum, y: String}"
+    assert (tfs_4 <= tfs2_4) # allowed, types are the same
+    thfs_4 = $__rdl_parser.scan_str "#T Hash<Symbol, Fixnum or String>"
+    assert (tfs2_4 <= thfs_4) # allowed, both tfs2_4 and tfs_4 promoted to hash
+    tfs3_4 = $__rdl_parser.scan_str "#T {x: Fixnum, y: String}"
+    assert (not(tfs_4 <= tfs3_4)) # not allowed, tfs_4 has been promoted
   end
 
   def test_method
-    tss = MethodType.new([@tstring], nil, @tstring)
-    tso = MethodType.new([@tstring], nil, @tobject)
-    tos = MethodType.new([@tobject], nil, @tstring)
-    too = MethodType.new([@tobject], nil, @tobject)
+    tss = MethodType.new([$__rdl_string_type], nil, $__rdl_string_type)
+    tso = MethodType.new([$__rdl_string_type], nil, $__rdl_object_type)
+    tos = MethodType.new([$__rdl_object_type], nil, $__rdl_string_type)
+    too = MethodType.new([$__rdl_object_type], nil, $__rdl_object_type)
     assert (tss <= tss)
     assert (tss <= tso)
     assert (not (tss <= tos))
@@ -121,8 +189,8 @@ class TestLe < Minitest::Test
     assert (too <= tso)
     assert (not (too <= tos))
     assert (too <= too)
-    tbos = MethodType.new([], tos, @tobject)
-    tbso = MethodType.new([], tso, @tobject)
+    tbos = MethodType.new([], tos, $__rdl_object_type)
+    tbso = MethodType.new([], tso, $__rdl_object_type)
     assert (tbos <= tbos)
     assert (not (tbos <= tbso))
     assert (tbso <= tbso)
@@ -130,11 +198,11 @@ class TestLe < Minitest::Test
   end
 
   def test_structural
-    tso = MethodType.new([@tstring], nil, @tobject)
-    tos = MethodType.new([@tobject], nil, @tstring)
+    tso = MethodType.new([$__rdl_string_type], nil, $__rdl_object_type)
+    tos = MethodType.new([$__rdl_object_type], nil, $__rdl_string_type)
     ts1 = StructuralType.new(m1: tso)
     ts2 = StructuralType.new(m1: tos)
-    assert (ts1 <= @ttop)
+    assert (ts1 <= $__rdl_top_type)
     assert (ts1 <= ts1)
     assert (ts2 <= ts2)
     assert (ts2 <= ts1)
@@ -167,8 +235,8 @@ class TestLe < Minitest::Test
   def test_nominal_structural
     tnom = NominalType.new(Nom)
     tnomt = NominalType.new(NomT)
-    tma = MethodType.new([], nil, @tnil)
-    tmb = MethodType.new([@tfixnum], nil, @tnil)
+    tma = MethodType.new([], nil, $__rdl_nil_type)
+    tmb = MethodType.new([$__rdl_fixnum_type], nil, $__rdl_nil_type)
     ts1 = StructuralType.new(m1: tma)
     assert (tnom <= ts1)
     assert (tnomt <= ts1)
@@ -185,9 +253,9 @@ class TestLe < Minitest::Test
 
   # def test_intersection
   #   skip "<= not defined on intersection"
-  #   tobject_and_basicobject = IntersectionType.new(@tobject, @tbasicobject)
-  #   assert (not (tobject_and_basicobject <= @tobject))
-  #   assert (@tobject <= tobject_and_basicobject)
+  #   tobject_and_basicobject = IntersectionType.new($__rdl_object_type, @tbasicobject)
+  #   assert (not (tobject_and_basicobject <= $__rdl_object_type))
+  #   assert ($__rdl_object_type <= tobject_and_basicobject)
   # end
 
 end

data/test/test_lib_types.rb

@@ -8,8 +8,9 @@ require 'coverage.so'
 require 'uri'
 
 require 'minitest/autorun'
-require_relative '../lib/rdl.rb'
-require_relative '../lib/rdl_types.rb'
+$LOAD_PATH << File.dirname(__FILE__) + "/../lib"
+require 'rdl'
+require 'rdl_types.rb'
 
 class Dummy
   def self.each

data/test/test_member.rb

@@ -1,5 +1,6 @@
 require 'minitest/autorun'
-require_relative '../lib/rdl.rb'
+$LOAD_PATH << File.dirname(__FILE__) + "/../lib"
+require 'rdl'
 
 class TestMember < Minitest::Test
   include RDL::Type
@@ -14,60 +15,46 @@ class TestMember < Minitest::Test
   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)
+    @tarraystring = GenericType.new($__rdl_array_type, $__rdl_string_type)
+    @tarrayobject = GenericType.new($__rdl_array_type, $__rdl_object_type)
+    @tarrayarraystring = GenericType.new($__rdl_array_type, @tarraystring)
+    @tarrayarrayobject = GenericType.new($__rdl_array_type, @tarrayobject)
+    $__rdl_hash_type = NominalType.new Hash
+    @thashstringstring = GenericType.new($__rdl_hash_type, $__rdl_string_type, $__rdl_string_type)
+    @thashobjectobject = GenericType.new($__rdl_hash_type, $__rdl_object_type, $__rdl_object_type)
+    @tstring_or_sym = UnionType.new($__rdl_string_type, $__rdl_symbol_type)
+    @tstring_and_sym = IntersectionType.new($__rdl_string_type, $__rdl_symbol_type)
+    @tobject_and_basicobject = IntersectionType.new($__rdl_object_type, @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)))
+    assert ($__rdl_nil_type.member? nil)
+    assert (not ($__rdl_nil_type.member? "foo"))
+    assert (not ($__rdl_nil_type.member? (Object.new)))
   end
 
   def test_top
-    assert (@ttop.member? nil)
-    assert (@ttop.member? "foo")
-    assert (@ttop.member? (Object.new))
+    assert ($__rdl_top_type.member? nil)
+    assert ($__rdl_top_type.member? "foo")
+    assert ($__rdl_top_type.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 ($__rdl_string_type.member? "Foo")
+    assert (not ($__rdl_string_type.member? :Foo))
+    assert (not ($__rdl_string_type.member? o))
 
-    assert (@tobject.member? "Foo")
-    assert (@tobject.member? :Foo)
-    assert (@tobject.member? o)
+    assert ($__rdl_object_type.member? "Foo")
+    assert ($__rdl_object_type.member? :Foo)
+    assert ($__rdl_object_type.member? o)
 
     assert (@tkernel.member? "Foo")
     assert (@tkernel.member? :Foo)
@@ -86,18 +73,18 @@ class TestMember < Minitest::Test
     assert (not (@tc.member? b))
     assert (@tc.member? c)
 
-    assert (@tstring.member? nil)
-    assert (@tobject.member? nil)
+    assert ($__rdl_string_type.member? nil)
+    assert ($__rdl_object_type.member? nil)
   end
 
   def test_symbol
-    assert (@tsym.member? :foo)
-    assert (@tsym.member? :bar)
-    assert (not (@tsym.member? "foo"))
+    assert ($__rdl_symbol_type.member? :foo)
+    assert ($__rdl_symbol_type.member? :bar)
+    assert (not ($__rdl_symbol_type.member? "foo"))
     assert (@tsymfoo.member? :foo)
     assert (not (@tsymfoo.member? :bar))
     assert (not (@tsymfoo.member? "foo"))
-    assert (@tsymfoo.member? nil)
+    assert (not(@tsymfoo.member? nil)) # nil no longer subtype of other singletons
   end
 
   def test_union_intersection
@@ -122,7 +109,7 @@ class TestMember < Minitest::Test
   end
 
   def test_tuple
-    t1 = TupleType.new(@tsym, @tstring)
+    t1 = TupleType.new($__rdl_symbol_type, $__rdl_string_type)
     assert (t1.member? [:foo, "foo"])
     assert (not (t1.member? ["foo", :foo]))
     assert (not (t1.member? [:foo, "foo", "bar"]))
@@ -132,13 +119,13 @@ class TestMember < Minitest::Test
   end
 
   def test_finite_hash
-    t1 = FiniteHashType.new(a: @tsym, b: @tstring)
+    t1 = FiniteHashType.new(a: $__rdl_symbol_type, b: $__rdl_string_type)
     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})
+    t2 = FiniteHashType.new({"a"=>$__rdl_symbol_type, 2=>$__rdl_string_type})
     assert (t2.member?({"a"=>:foo, 2=>"foo"}))
     assert (not (t2.member?({"a"=>2, 2=>"foo"})))
     assert (not (t2.member?({"a"=>:foo})))

data/test/test_parser.rb

@@ -1,28 +1,25 @@
 require 'minitest/autorun'
-require_relative '../lib/rdl.rb'
+$LOAD_PATH << File.dirname(__FILE__) + "/../lib"
+require 'rdl'
 
 class TestParser < Minitest::Test
   include RDL::Type
 
+  class A; end
+  class B; end
+  class C; end
+
   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
+    @tfixnumopt = OptionalType.new $__rdl_fixnum_type
+    @tfixnumvararg = VarargType.new $__rdl_fixnum_type
+    @tstringopt = OptionalType.new $__rdl_string_type
     @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)
+    @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)
     @tsymbol = SingletonType.new(:symbol)
@@ -30,167 +27,167 @@ class TestParser < Minitest::Test
   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"
+    t1 = $__rdl_parser.scan_str "(nil) -> nil"
+    assert_equal (MethodType.new [$__rdl_nil_type], nil, $__rdl_nil_type), t1
+    t2 = $__rdl_parser.scan_str "(Fixnum, Fixnum) -> Fixnum"
+    assert_equal (MethodType.new [$__rdl_fixnum_type, $__rdl_fixnum_type], nil, $__rdl_fixnum_type), t2
+    t3 = $__rdl_parser.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
+    t4 = $__rdl_parser.scan_str "(%any) -> nil"
+    assert_equal (MethodType.new [$__rdl_top_type], nil, $__rdl_nil_type), t4
+    t5 = $__rdl_parser.scan_str "(%bool) -> Fixnum"
+    assert_equal (MethodType.new [$__rdl_bool_type], nil, $__rdl_fixnum_type), t5
+    assert_raises(RuntimeError) { $__rdl_parser.scan_str "(%foo) -> nil" }
+    t6 = $__rdl_parser.scan_str "(A) -> nil"
+    assert_equal (MethodType.new [@ta], nil, $__rdl_nil_type), t6
+    t7 = $__rdl_parser.scan_str "(TestParser::A) -> nil"
+    assert_equal (MethodType.new [NominalType.new("TestParser::A")], nil, $__rdl_nil_type), t7
+    t8 = $__rdl_parser.scan_str "(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
+    t9 = $__rdl_parser.scan_str "(true) -> false"
+    assert_equal (MethodType.new [$__rdl_true_type], nil, $__rdl_false_type), t9
   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
+    t1 = $__rdl_parser.scan_str "(Fixnum, ?Fixnum) -> Fixnum"
+    assert_equal (MethodType.new [$__rdl_fixnum_type, @tfixnumopt], nil, $__rdl_fixnum_type), t1
+    t2 = $__rdl_parser.scan_str "(Fixnum, *Fixnum) -> Fixnum"
+    assert_equal (MethodType.new [$__rdl_fixnum_type, @tfixnumvararg], nil, $__rdl_fixnum_type), t2
+    t3 = $__rdl_parser.scan_str "(Fixnum, ?Fixnum, ?Fixnum, *Fixnum) -> Fixnum"
+    assert_equal (MethodType.new [$__rdl_fixnum_type, @tfixnumopt, @tfixnumopt, @tfixnumvararg], nil, $__rdl_fixnum_type), t3
+    t4 = $__rdl_parser.scan_str "(?Fixnum) -> nil"
+    assert_equal (MethodType.new [@tfixnumopt], nil, $__rdl_nil_type), t4
+    t5 = $__rdl_parser.scan_str "(*Fixnum) -> nil"
+    assert_equal (MethodType.new [@tfixnumvararg], nil, $__rdl_nil_type), 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
+    t1 = $__rdl_parser.scan_str "(Fixnum or String) -> nil"
+    assert_equal (MethodType.new [UnionType.new($__rdl_fixnum_type, $__rdl_string_type)], nil, $__rdl_nil_type), t1
+    t2 = $__rdl_parser.scan_str "(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 = $__rdl_parser.scan_str "() -> Fixnum or String or Symbol"
+    assert_equal (MethodType.new [], nil, UnionType.new($__rdl_fixnum_type, $__rdl_string_type, $__rdl_symbol_type)), t3
   end
 
   def test_bare
-    t1 = @p.scan_str "#T nil"
-    assert_equal @tnil, t1
-    t2 = @p.scan_str "#T %any"
-    assert_equal @ttop, t2
-    t3 = @p.scan_str "#T A"
+    t1 = $__rdl_parser.scan_str "#T nil"
+    assert_equal $__rdl_nil_type, t1
+    t2 = $__rdl_parser.scan_str "#T %any"
+    assert_equal $__rdl_top_type, t2
+    t3 = $__rdl_parser.scan_str "#T A"
     assert_equal NominalType.new("A"), t3
   end
 
   def test_symbol
-    t1 = @p.scan_str "#T :symbol"
+    t1 = $__rdl_parser.scan_str "#T :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"
+    t1 = $__rdl_parser.scan_str "(Fixnum x, Fixnum) -> Fixnum"
+    assert_equal (MethodType.new [@tfixnumx, $__rdl_fixnum_type], nil, $__rdl_fixnum_type), t1
+    t2 = $__rdl_parser.scan_str "(Fixnum, ?Fixnum x) -> Fixnum"
+    assert_equal (MethodType.new [$__rdl_fixnum_type, @tfixnumoptx], nil, $__rdl_fixnum_type), t2
+    t3 = $__rdl_parser.scan_str "(Fixnum, *Fixnum x) -> Fixnum"
+    assert_equal (MethodType.new [$__rdl_fixnum_type, @tfixnumvarargx], nil, $__rdl_fixnum_type), t3
+    t4 = $__rdl_parser.scan_str "(Fixnum, Fixnum y) -> Fixnum"
+    assert_equal (MethodType.new [$__rdl_fixnum_type, @tfixnumy], nil, $__rdl_fixnum_type), t4
+    t5 = $__rdl_parser.scan_str "(Fixnum x, Fixnum y) -> Fixnum"
+    assert_equal (MethodType.new [@tfixnumx, @tfixnumy], nil, $__rdl_fixnum_type), t5
+    t6 = $__rdl_parser.scan_str "(Fixnum, Fixnum) -> Fixnum ret"
+    assert_equal (MethodType.new [$__rdl_fixnum_type, $__rdl_fixnum_type], nil, @tfixnumret), t6
+    t7 = $__rdl_parser.scan_str "(Fixnum x, Fixnum) -> Fixnum ret"
+    assert_equal (MethodType.new [@tfixnumx, $__rdl_fixnum_type], nil, @tfixnumret), t7
+    t8 = $__rdl_parser.scan_str "(Fixnum, Fixnum y) -> Fixnum ret"
+    assert_equal (MethodType.new [$__rdl_fixnum_type, @tfixnumy], nil, @tfixnumret), t8
+    t9 = $__rdl_parser.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
+    t10 = $__rdl_parser.scan_str "(:symbol x) -> Fixnum"
+    assert_equal (MethodType.new [@tsymbolx], nil, $__rdl_fixnum_type), t10
   end
 
   def test_generic
-    t1 = @p.scan_str "#T t"
+    t1 = $__rdl_parser.scan_str "#T t"
     assert_equal (VarType.new "t"), t1
-    t2 = @p.scan_str "#T Array"
+    t2 = $__rdl_parser.scan_str "#T Array"
     assert_equal (NominalType.new "Array"), t2
-    t3 = @p.scan_str "#T Array<t>"
+    t3 = $__rdl_parser.scan_str "#T Array<t>"
     assert_equal (GenericType.new(t2, t1)), t3
-    t4 = @p.scan_str "#T Array<Array<t>>"
+    t4 = $__rdl_parser.scan_str "#T Array<Array<t>>"
     assert_equal (GenericType.new(t2, t3)), t4
-    t5 = @p.scan_str "#T Hash"
+    t5 = $__rdl_parser.scan_str "#T Hash"
     assert_equal (NominalType.new "Hash"), t5
-    t6 = @p.scan_str "#T Hash<u, v>"
+    t6 = $__rdl_parser.scan_str "#T Hash<u, v>"
     assert_equal (GenericType.new(t5, VarType.new("u"), VarType.new("v"))), t6
-    t7 = @p.scan_str "#T Foo<String, Array<t>, Array<Array<t>>>"
-    assert_equal (GenericType.new(NominalType.new("Foo"), @tstring, t3, t4)), t7
+    t7 = $__rdl_parser.scan_str "#T Foo<String, Array<t>, Array<Array<t>>>"
+    assert_equal (GenericType.new(NominalType.new("Foo"), $__rdl_string_type, t3, t4)), t7
   end
 
   def test_tuple
-    t1 = @p.scan_str "#T [Fixnum, String]"
-    assert_equal (TupleType.new(@tfixnum, @tstring)), t1
-    t2 = @p.scan_str "#T [String]"
-    assert_equal (TupleType.new(@tstring)), t2
+    t1 = $__rdl_parser.scan_str "#T [Fixnum, String]"
+    assert_equal (TupleType.new($__rdl_fixnum_type, $__rdl_string_type)), t1
+    t2 = $__rdl_parser.scan_str "#T [String]"
+    assert_equal (TupleType.new($__rdl_string_type)), t2
   end
 
   def test_fixnum
-    t1 = @p.scan_str "#T 42"
+    t1 = $__rdl_parser.scan_str "#T 42"
     assert_equal (SingletonType.new(42)), t1
-    t2 = @p.scan_str "#T -42"
+    t2 = $__rdl_parser.scan_str "#T -42"
     assert_equal (SingletonType.new(-42)), t2
   end
 
   def test_float
-    t1 = @p.scan_str "#T 3.14"
+    t1 = $__rdl_parser.scan_str "#T 3.14"
     assert_equal (SingletonType.new(3.14)), t1
   end
 
   def test_const
-    t1 = @p.scan_str "#T ${Math::PI}"
+    t1 = $__rdl_parser.scan_str "#T ${Math::PI}"
     assert_equal (SingletonType.new(Math::PI)), t1
   end
 
   def test_type_alias
-    type_alias '%foobarbaz', @tnil
-    assert_equal @tnil, (@p.scan_str "#T %foobarbaz")
+    type_alias '%foobarbaz', $__rdl_nil_type
+    assert_equal $__rdl_nil_type, ($__rdl_parser.scan_str "#T %foobarbaz")
     type_alias '%quxquxqux', 'nil'
-    assert_equal @tnil, (@p.scan_str "#T %quxquxqux")
+    assert_equal $__rdl_nil_type, ($__rdl_parser.scan_str "#T %quxquxqux")
     assert_raises(RuntimeError) { type_alias '%quxquxqux', 'nil' }
-    assert_raises(RuntimeError) { @p.scan_str "#T %qux" }
+    assert_raises(RuntimeError) { $__rdl_parser.scan_str "#T %qux" }
   end
 
   def test_structural
-    t1 = @p.scan_str "#T [to_str: () -> String]"
-    tm1 = MethodType.new [], nil, @tstring
+    t1 = $__rdl_parser.scan_str "#T [to_str: () -> String]"
+    tm1 = MethodType.new [], nil, $__rdl_string_type
     ts1 = StructuralType.new(to_str: tm1)
     assert_equal ts1, t1
   end
 
   def test_finite_hash
-    t1 = @p.scan_str "#T {a: Fixnum, b: String}"
-    assert_equal (FiniteHashType.new({a: @tfixnum, b: @tstring})), t1
-    t2 = @p.scan_str "#T {'a'=>Fixnum, 2=>String}"
-    assert_equal (FiniteHashType.new({"a"=>@tfixnum, 2=>@tstring})), t2
+    t1 = $__rdl_parser.scan_str "#T {a: Fixnum, b: String}"
+    assert_equal (FiniteHashType.new({a: $__rdl_fixnum_type, b: $__rdl_string_type})), t1
+    t2 = $__rdl_parser.scan_str "#T {'a'=>Fixnum, 2=>String}"
+    assert_equal (FiniteHashType.new({"a"=>$__rdl_fixnum_type, 2=>$__rdl_string_type})), 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
+    t1 = $__rdl_parser.scan_str "(Fixnum, x: Fixnum) -> Fixnum"
+    assert_equal (MethodType.new [$__rdl_fixnum_type, FiniteHashType.new(x: $__rdl_fixnum_type)], nil, $__rdl_fixnum_type), t1
+    t2 = $__rdl_parser.scan_str "(Fixnum, x: Fixnum, y: String) -> Fixnum"
+    assert_equal (MethodType.new [$__rdl_fixnum_type, FiniteHashType.new(x: $__rdl_fixnum_type, y: $__rdl_string_type)], nil, $__rdl_fixnum_type), t2
+    t3 = $__rdl_parser.scan_str "(Fixnum, y: String, x: Fixnum) -> Fixnum"
+    assert_equal (MethodType.new [$__rdl_fixnum_type, FiniteHashType.new(x: $__rdl_fixnum_type, y: $__rdl_string_type)], nil, $__rdl_fixnum_type), t3
+    t4 = $__rdl_parser.scan_str "(Fixnum, y: String, x: ?Fixnum) -> Fixnum"
+    assert_equal (MethodType.new [$__rdl_fixnum_type, FiniteHashType.new(x: @tfixnumopt, y: $__rdl_string_type)], nil, $__rdl_fixnum_type), t4
+    t4 = $__rdl_parser.scan_str "(Fixnum, y: ?String, x: Fixnum) -> Fixnum"
+    assert_equal (MethodType.new [$__rdl_fixnum_type, FiniteHashType.new(x: $__rdl_fixnum_type, y: @tstringopt)], nil, $__rdl_fixnum_type), t4
+    t5 = $__rdl_parser.scan_str "(Fixnum x, x: Fixnum) -> Fixnum"
+    assert_equal (MethodType.new [@tfixnumx, FiniteHashType.new(x: $__rdl_fixnum_type)], nil, $__rdl_fixnum_type), t5
+    t6 = $__rdl_parser.scan_str "(x: Fixnum) -> Fixnum"
+    assert_equal (MethodType.new [FiniteHashType.new(x: $__rdl_fixnum_type)], nil, $__rdl_fixnum_type), t6
+    t7 = $__rdl_parser.scan_str "(x: Fixnum) { (%any, String) -> nil } -> :symbol"
+    assert_equal (MethodType.new [FiniteHashType.new(x: $__rdl_fixnum_type)], MethodType.new([$__rdl_top_type, $__rdl_string_type], nil, $__rdl_nil_type), @tsymbol), t7
   end
 
 end