rdl 2.0.1 → 2.1.0

data/test/test_le.rb

@@ -17,7 +17,7 @@ class TestLe < Minitest::Test
 
   # convert arg string to a type
   def tt(t)
-    $__rdl_parser.scan_str('#T ' + t)
+    RDL::Globals.parser.scan_str('#T ' + t)
   end
 
   def setup
@@ -29,49 +29,49 @@ class TestLe < Minitest::Test
   end
 
   def test_nil
-    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))
+    assert (RDL::Globals.types[:nil] <= RDL::Globals.types[:top])
+    assert (RDL::Globals.types[:nil] <= RDL::Globals.types[:string])
+    assert (RDL::Globals.types[:nil] <= RDL::Globals.types[:object])
+    assert (RDL::Globals.types[:nil] <= @tbasicobject)
+    assert (not (RDL::Globals.types[:nil] <= @tsymfoo)) # nil no longer <= other singleton types
+    assert (not (RDL::Globals.types[:top] <= RDL::Globals.types[:nil]))
+    assert (not (RDL::Globals.types[:string] <= RDL::Globals.types[:nil]))
+    assert (not (RDL::Globals.types[:object] <= RDL::Globals.types[:nil]))
+    assert (not (@tbasicobject <= RDL::Globals.types[:nil]))
+    assert (not (@tsymfoo <= RDL::Globals.types[:nil]))
   end
 
   def test_top
-    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)
+    assert (not (RDL::Globals.types[:top] <= RDL::Globals.types[:nil]))
+    assert (not (RDL::Globals.types[:top] <= RDL::Globals.types[:string]))
+    assert (not (RDL::Globals.types[:top] <= RDL::Globals.types[:object]))
+    assert (not (RDL::Globals.types[:top] <= @tbasicobject))
+    assert (not (RDL::Globals.types[:top] <= @tsymfoo))
+    assert (RDL::Globals.types[:top] <= RDL::Globals.types[:top])
+    assert (RDL::Globals.types[:string] <= RDL::Globals.types[:top])
+    assert (RDL::Globals.types[:object] <= RDL::Globals.types[:top])
+    assert (@tbasicobject <= RDL::Globals.types[:top])
+    assert (@tsymfoo <= RDL::Globals.types[:top])
   end
 
   def test_sym
-    assert ($__rdl_symbol_type <= $__rdl_symbol_type)
+    assert (RDL::Globals.types[:symbol] <= RDL::Globals.types[:symbol])
     assert (@tsymfoo <= @tsymfoo)
-    assert (@tsymfoo <= $__rdl_symbol_type)
-    assert (not ($__rdl_symbol_type <= @tsymfoo))
+    assert (@tsymfoo <= RDL::Globals.types[:symbol])
+    assert (not (RDL::Globals.types[:symbol] <= @tsymfoo))
   end
 
   def test_nominal
-    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 (RDL::Globals.types[:string] <= RDL::Globals.types[:string])
+    assert (RDL::Globals.types[:symbol] <= RDL::Globals.types[:symbol])
+    assert (not (RDL::Globals.types[:string] <= RDL::Globals.types[:symbol]))
+    assert (not (RDL::Globals.types[:symbol] <= RDL::Globals.types[:string]))
+    assert (RDL::Globals.types[:string] <= RDL::Globals.types[:object])
+    assert (RDL::Globals.types[:string] <= @tbasicobject)
+    assert (RDL::Globals.types[:object] <= @tbasicobject)
+    assert (not (RDL::Globals.types[:object] <= RDL::Globals.types[:string]))
+    assert (not (@tbasicobject <= RDL::Globals.types[:string]))
+    assert (not (@tbasicobject <= RDL::Globals.types[:object]))
     assert (@ta <= @ta)
     assert (@tb <= @ta)
     assert (@tc <= @ta)
@@ -84,55 +84,55 @@ class TestLe < Minitest::Test
   end
 
   def test_union
-    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))
+    tstring_or_sym = UnionType.new(RDL::Globals.types[:string], RDL::Globals.types[:symbol])
+    assert (tstring_or_sym <= RDL::Globals.types[:object])
+    assert (not (RDL::Globals.types[:object] <= tstring_or_sym))
   end
 
   def test_tuple
-    t1 = TupleType.new($__rdl_symbol_type, $__rdl_string_type)
-    t2 = TupleType.new($__rdl_object_type, $__rdl_object_type)
+    t1 = TupleType.new(RDL::Globals.types[:symbol], RDL::Globals.types[:string])
+    t2 = TupleType.new(RDL::Globals.types[:object], RDL::Globals.types[:object])
     tarray = NominalType.new("Array")
     assert (t1 <= t1)
     assert (t2 <= t2)
     assert (not (t2 <= t1))
     assert (not (tarray <= t1))
     assert (t1 <= t2) # covariant subtyping since tuples are *immutable*
-    assert (tt("[1, 2, 3]") <= tt("[Fixnum, Fixnum, Fixnum]")) # covariant subtyping with singletons
-    assert (tt("[Fixnum, Fixnum, Fixnum]") <= tt("[Object, Object, Object]"))
+    assert (tt("[1, 2, 3]") <= tt("[Integer, Integer, Integer]")) # covariant subtyping with singletons
+    assert (tt("[Integer, Integer, Integer]") <= tt("[Object, Object, Object]"))
     assert (tt("[1, 2, 3]") <= tt("[Object, Object, Object]"))
 
     # subtyping of tuples and arrays
-    tfs_1 = tt "[Fixnum, String]"
-    tafs_1 = tt "Array<Fixnum or String>"
+    tfs_1 = tt "[Integer, String]"
+    tafs_1 = tt "Array<Integer or String>"
     assert (tfs_1 <= tafs_1) # subtyping allowed by tfs_1 promoted to array
-    tfs2_1 = tt "[Fixnum, String]"
+    tfs2_1 = tt "[Integer, String]"
     assert (not (tfs_1 <= tfs2_1)) # t12 has been promoted to array, no longer subtype
 
-    tfs_2 = tt "[Fixnum, String]"
-    tfs2_2 = tt "[Fixnum, String]"
+    tfs_2 = tt "[Integer, String]"
+    tfs2_2 = tt "[Integer, String]"
     assert (tfs_2 <= tfs2_2) # this is allowed here because tfs_2 is still a tuple
-    tafs_2 = tt "Array<Fixnum or String>"
+    tafs_2 = tt "Array<Integer or String>"
     assert (not (tfs_2 <= tafs_2)) # subtyping not allowed because tfs_2 <= tfs2_2 unsatisfiable after tfs_2 promoted
 
-    tfs_3 = tt "[Fixnum, String]"
+    tfs_3 = tt "[Integer, String]"
     tfs2_3 = tt "[Object, Object]"
     assert (tfs_3 <= tfs2_3) # this is allowed here because t12a is still a tuple
     tafs_3 = tt "Array<Object>"
     assert (not (tfs2_3 <= tafs_3)) # subtyping not allowed because tfs_3 <= tfs2_3 unsatisfiable after tfs2_3 promoted
 
-    tfs_4 = tt "[Fixnum, String]"
-    tfs2_4 = tt "[Fixnum, String]"
+    tfs_4 = tt "[Integer, String]"
+    tfs2_4 = tt "[Integer, String]"
     assert (tfs_4 <= tfs2_4) # allowed, types are the same
-    tafs_4 = tt "Array<Fixnum or String>"
+    tafs_4 = tt "Array<Integer or String>"
     assert (tfs2_4 <= tafs_4) # allowed, both tfs2_4 and tfs_4 promoted to array
-    tfs3_4 = tt "[Fixnum, String]"
+    tfs3_4 = tt "[Integer, String]"
     assert (not(tfs_4 <= tfs3_4)) # not allowed, tfs_4 has been promoted
   end
 
   def test_finite_hash
     t12 = tt "{a: 1, b: 2}"
-    tfs = tt "{a: Fixnum, b: Fixnum}"
+    tfs = tt "{a: Integer, b: Integer}"
     too = tt "{a: Object, b: Object}"
     assert (t12 <= tfs)
     assert (t12 <= too)
@@ -143,36 +143,36 @@ class TestLe < Minitest::Test
 
     # subtyping of finite hashes and hashes; same pattern as tuples
     # subtyping of tuples and arrays
-    tfs_1 = tt "{x: Fixnum, y: String}"
-    thfs_1 = tt "Hash<Symbol, Fixnum or String>"
+    tfs_1 = tt "{x: Integer, y: String}"
+    thfs_1 = tt "Hash<Symbol, Integer or String>"
     assert (tfs_1 <= thfs_1) # subtyping allowed because tfs_1 promoted to hash
-    tfs2_1 = tt "{x: Fixnum, y: String}"
+    tfs2_1 = tt "{x: Integer, y: String}"
     assert (not (tfs_1 <= tfs2_1)) # t12 has been promoted to hash, no longer subtype
 
-    tfs_2 = tt "{x: Fixnum, y: String}"
-    tfs2_2 = tt "{x: Fixnum, y: String}"
+    tfs_2 = tt "{x: Integer, y: String}"
+    tfs2_2 = tt "{x: Integer, y: String}"
     assert (tfs_2 <= tfs2_2) # this is allowed here because tfs_2 is still finite
-    thfs_2 = tt "Hash<Symbol, Fixnum or String>"
+    thfs_2 = tt "Hash<Symbol, Integer or String>"
     assert (not (tfs_2 <= thfs_2)) # subtyping not allowed because tfs_2 <= tfs2_2 unsatisfiable after tfs_2 promoted
 
-    tfs_3 = tt "{x: Fixnum, y: String}"
+    tfs_3 = tt "{x: Integer, y: String}"
     tfs2_3 = tt "{x: Object, y: Object}"
     assert (tfs_3 <= tfs2_3) # this is allowed here because t12a is still finite
     thfs_3 = tt "Hash<Symbol, Object>"
     assert (not (tfs2_3 <= thfs_3)) # subtyping not allowed because tfs_3 <= tfs2_3 unsatisfiable after tfs2_3 promoted
 
-    tfs_4 = tt "{x: Fixnum, y: String}"
-    tfs2_4 = tt "{x: Fixnum, y: String}"
+    tfs_4 = tt "{x: Integer, y: String}"
+    tfs2_4 = tt "{x: Integer, y: String}"
     assert (tfs_4 <= tfs2_4) # allowed, types are the same
-    thfs_4 = tt "Hash<Symbol, Fixnum or String>"
+    thfs_4 = tt "Hash<Symbol, Integer or String>"
     assert (tfs2_4 <= thfs_4) # allowed, both tfs2_4 and tfs_4 promoted to hash
-    tfs3_4 = tt "{x: Fixnum, y: String}"
+    tfs3_4 = tt "{x: Integer, y: String}"
     assert (not(tfs_4 <= tfs3_4)) # not allowed, tfs_4 has been promoted
 
-    tfss_5 = tt "{x: Fixnum, y: String, **Symbol}"
-    tfns_5 = tt "{x: Fixnum, **Symbol}"
-    tfsn_5 = tt "{x: Fixnum, y: String}"
-    tftn_5 = tt "{x: Fixnum, z: Symbol}"
+    tfss_5 = tt "{x: Integer, y: String, **Symbol}"
+    tfns_5 = tt "{x: Integer, **Symbol}"
+    tfsn_5 = tt "{x: Integer, y: String}"
+    tftn_5 = tt "{x: Integer, z: Symbol}"
     tooo_5 = tt "{x: Object, y: Object, **Object}"
     tono_5 = tt "{x: Object, **Object}"
     assert (tfss_5 <= tooo_5)
@@ -190,14 +190,14 @@ class TestLe < Minitest::Test
     assert (tftn_5 <= tfns_5)
     assert (not (tftn_5 <= tfsn_5))
 
-    assert (not (tt("{x: ?Fixnum}") <= tt("{x: Fixnum}")))
+    assert (not (tt("{x: ?Integer}") <= tt("{x: Integer}")))
   end
 
   def test_method
-    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)
+    tss = MethodType.new([RDL::Globals.types[:string]], nil, RDL::Globals.types[:string])
+    tso = MethodType.new([RDL::Globals.types[:string]], nil, RDL::Globals.types[:object])
+    tos = MethodType.new([RDL::Globals.types[:object]], nil, RDL::Globals.types[:string])
+    too = MethodType.new([RDL::Globals.types[:object]], nil, RDL::Globals.types[:object])
     assert (tss <= tss)
     assert (tss <= tso)
     assert (not (tss <= tos))
@@ -214,21 +214,21 @@ class TestLe < Minitest::Test
     assert (too <= tso)
     assert (not (too <= tos))
     assert (too <= too)
-    tbos = MethodType.new([], tos, $__rdl_object_type)
-    tbso = MethodType.new([], tso, $__rdl_object_type)
+    tbos = MethodType.new([], tos, RDL::Globals.types[:object])
+    tbso = MethodType.new([], tso, RDL::Globals.types[:object])
     assert (tbos <= tbos)
     assert (not (tbos <= tbso))
     assert (tbso <= tbso)
     assert (tbso <= tbos)
-    assert (tss <= $__rdl_proc_type)
+    assert (tss <= RDL::Globals.types[:proc])
   end
 
   def test_structural
-    tso = MethodType.new([$__rdl_string_type], nil, $__rdl_object_type)
-    tos = MethodType.new([$__rdl_object_type], nil, $__rdl_string_type)
+    tso = MethodType.new([RDL::Globals.types[:string]], nil, RDL::Globals.types[:object])
+    tos = MethodType.new([RDL::Globals.types[:object]], nil, RDL::Globals.types[:string])
     ts1 = StructuralType.new(m1: tso)
     ts2 = StructuralType.new(m1: tos)
-    assert (ts1 <= $__rdl_top_type)
+    assert (ts1 <= RDL::Globals.types[:top])
     assert (ts1 <= ts1)
     assert (ts2 <= ts2)
     assert (ts2 <= ts1)
@@ -248,6 +248,7 @@ class TestLe < Minitest::Test
   end
 
   class NomT
+    extend RDL::Annotate
     type "() -> nil"
     def m1()
       nil
@@ -261,8 +262,8 @@ class TestLe < Minitest::Test
   def test_nominal_structural
     tnom = NominalType.new(Nom)
     tnomt = NominalType.new(NomT)
-    tma = MethodType.new([], nil, $__rdl_nil_type)
-    tmb = MethodType.new([$__rdl_fixnum_type], nil, $__rdl_nil_type)
+    tma = MethodType.new([], nil, RDL::Globals.types[:nil])
+    tmb = MethodType.new([RDL::Globals.types[:integer]], nil, RDL::Globals.types[:nil])
     ts1 = StructuralType.new(m1: tma)
     assert (tnom <= ts1)
     assert (tnomt <= ts1)
@@ -283,22 +284,22 @@ class TestLe < Minitest::Test
     assert_equal false, do_leq(tt("t"), @ta, false)[0]
     assert_equal false, do_leq(@ta, tt("t"), true)[0]
     assert_equal [true, {t: @ta}], do_leq(@ta, tt("t"), false)
-    assert_equal [true, {}], do_leq($__rdl_bot_type, tt("t"), true)
-    assert_equal [true, {}], do_leq($__rdl_bot_type, tt("t"), false)
-    assert_equal false, do_leq($__rdl_top_type, tt("t"), true)[0]
-    assert_equal [true, {t: $__rdl_top_type}], do_leq($__rdl_top_type, tt("t"), false)
+    assert_equal [true, {}], do_leq(RDL::Globals.types[:bot], tt("t"), true)
+    assert_equal [true, {}], do_leq(RDL::Globals.types[:bot], tt("t"), false)
+    assert_equal false, do_leq(RDL::Globals.types[:top], tt("t"), true)[0]
+    assert_equal [true, {t: RDL::Globals.types[:top]}], do_leq(RDL::Globals.types[:top], tt("t"), false)
     assert_equal [true, {t: @ta, u: @ta}], do_leq(tt("t or u"), @ta, true)
     assert_equal false, do_leq(tt("t or u"), @ta, false)[0]
     assert_equal false, do_leq(tt("3"), tt("t"), true)[0]
     assert_equal [true, {t: tt("3")}], do_leq(tt("3"), tt("t"), false)
-    assert_equal [true, {t: $__rdl_fixnum_type}], do_leq(tt("Array<t>"), tt("Array<Fixnum>"), true)
-    assert_equal false, do_leq(tt("Array<t>"), tt("Array<Fixnum>"), false)[0]
-    assert_equal [true, {t: $__rdl_fixnum_type}], do_leq(tt("Array<Fixnum>"), tt("Array<t>"), false)
-    assert_equal false, do_leq(tt("Array<Fixnum>"), tt("Array<t>"), true)[0]
-    assert_equal [true, {t: $__rdl_fixnum_type, u: $__rdl_string_type}], do_leq(tt("Hash<t,u>"), tt("Hash<Fixnum,String>"), true)
-    assert_equal [true, {t: $__rdl_fixnum_type}], do_leq(tt("Hash<t,t>"), tt("Hash<Fixnum,Fixnum>"), true)
-    assert_equal false, do_leq(tt("Hash<t,t>"), tt("Hash<Fixnum,String>"), true)[0]
-    assert_equal false, do_leq(tt("[m:()->t]"), tt("[m:()->Fixnum]"), true)[0] # no inst inside structural types
+    assert_equal [true, {t: RDL::Globals.types[:integer]}], do_leq(tt("Array<t>"), tt("Array<Integer>"), true)
+    assert_equal false, do_leq(tt("Array<t>"), tt("Array<Integer>"), false)[0]
+    assert_equal [true, {t: RDL::Globals.types[:integer]}], do_leq(tt("Array<Integer>"), tt("Array<t>"), false)
+    assert_equal false, do_leq(tt("Array<Integer>"), tt("Array<t>"), true)[0]
+    assert_equal [true, {t: RDL::Globals.types[:integer], u: RDL::Globals.types[:string]}], do_leq(tt("Hash<t,u>"), tt("Hash<Integer,String>"), true)
+    assert_equal [true, {t: RDL::Globals.types[:integer]}], do_leq(tt("Hash<t,t>"), tt("Hash<Integer,Integer>"), true)
+    assert_equal false, do_leq(tt("Hash<t,t>"), tt("Hash<Integer,String>"), true)[0]
+    assert_equal false, do_leq(tt("[m:()->t]"), tt("[m:()->Integer]"), true)[0] # no inst inside structural types
   end
 
   def do_leq(tleft, tright, ileft)
@@ -309,19 +310,19 @@ class TestLe < Minitest::Test
 
   # nonnull annotation is simply removed! so doesn't matter
   def test_leq_nonnull
-    assert tt("!Fixnum") <= tt("!Fixnum")
-    assert tt("!Fixnum") <= tt("Fixnum")
-    assert tt("Fixnum") <= tt("!Fixnum")
-    assert tt("!Fixnum") <= tt("!Object")
-    assert tt("!Fixnum") <= tt("Object")
-    assert tt("Fixnum") <= tt("!Object")
+    assert tt("!Integer") <= tt("!Integer")
+    assert tt("!Integer") <= tt("Integer")
+    assert tt("Integer") <= tt("!Integer")
+    assert tt("!Integer") <= tt("!Object")
+    assert tt("!Integer") <= tt("Object")
+    assert tt("Integer") <= tt("!Object")
   end
 
   # def test_intersection
   #   skip "<= not defined on intersection"
-  #   tobject_and_basicobject = IntersectionType.new($__rdl_object_type, @tbasicobject)
-  #   assert (not (tobject_and_basicobject <= $__rdl_object_type))
-  #   assert ($__rdl_object_type <= tobject_and_basicobject)
+  #   tobject_and_basicobject = IntersectionType.new(RDL::Globals.types[:object], @tbasicobject)
+  #   assert (not (tobject_and_basicobject <= RDL::Globals.types[:object]))
+  #   assert (RDL::Globals.types[:object] <= tobject_and_basicobject)
   # end
 
 end

data/test/test_member.rb

@@ -17,16 +17,16 @@ class TestMember < Minitest::Test
   def setup
     @tbasicobject = NominalType.new "BasicObject"
     @tsymfoo = SingletonType.new :foo
-    @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)
+    @tarraystring = GenericType.new(RDL::Globals.types[:array], RDL::Globals.types[:string])
+    @tarrayobject = GenericType.new(RDL::Globals.types[:array], RDL::Globals.types[:object])
+    @tarrayarraystring = GenericType.new(RDL::Globals.types[:array], @tarraystring)
+    @tarrayarrayobject = GenericType.new(RDL::Globals.types[:array], @tarrayobject)
+    RDL::Globals.types[:hash] = NominalType.new Hash
+    @thashstringstring = GenericType.new(RDL::Globals.types[:hash], RDL::Globals.types[:string], RDL::Globals.types[:string])
+    @thashobjectobject = GenericType.new(RDL::Globals.types[:hash], RDL::Globals.types[:object], RDL::Globals.types[:object])
+    @tstring_or_sym = UnionType.new(RDL::Globals.types[:string], RDL::Globals.types[:symbol])
+    @tstring_and_sym = IntersectionType.new(RDL::Globals.types[:string], RDL::Globals.types[:symbol])
+    @tobject_and_basicobject = IntersectionType.new(RDL::Globals.types[:object], @tbasicobject)
     @ta = NominalType.new A
     @tb = NominalType.new B
     @tc = NominalType.new C
@@ -35,26 +35,26 @@ class TestMember < Minitest::Test
   end
 
   def test_nil
-    assert ($__rdl_nil_type.member? nil)
-    assert (not ($__rdl_nil_type.member? "foo"))
-    assert (not ($__rdl_nil_type.member? (Object.new)))
+    assert (RDL::Globals.types[:nil].member? nil)
+    assert (not (RDL::Globals.types[:nil].member? "foo"))
+    assert (not (RDL::Globals.types[:nil].member? (Object.new)))
   end
 
   def test_top
-    assert ($__rdl_top_type.member? nil)
-    assert ($__rdl_top_type.member? "foo")
-    assert ($__rdl_top_type.member? (Object.new))
+    assert (RDL::Globals.types[:top].member? nil)
+    assert (RDL::Globals.types[:top].member? "foo")
+    assert (RDL::Globals.types[:top].member? (Object.new))
   end
 
   def test_nominal
     o = Object.new
-    assert ($__rdl_string_type.member? "Foo")
-    assert (not ($__rdl_string_type.member? :Foo))
-    assert (not ($__rdl_string_type.member? o))
+    assert (RDL::Globals.types[:string].member? "Foo")
+    assert (not (RDL::Globals.types[:string].member? :Foo))
+    assert (not (RDL::Globals.types[:string].member? o))
 
-    assert ($__rdl_object_type.member? "Foo")
-    assert ($__rdl_object_type.member? :Foo)
-    assert ($__rdl_object_type.member? o)
+    assert (RDL::Globals.types[:object].member? "Foo")
+    assert (RDL::Globals.types[:object].member? :Foo)
+    assert (RDL::Globals.types[:object].member? o)
 
     assert (@tkernel.member? "Foo")
     assert (@tkernel.member? :Foo)
@@ -73,14 +73,14 @@ class TestMember < Minitest::Test
     assert (not (@tc.member? b))
     assert (@tc.member? c)
 
-    assert ($__rdl_string_type.member? nil)
-    assert ($__rdl_object_type.member? nil)
+    assert (RDL::Globals.types[:string].member? nil)
+    assert (RDL::Globals.types[:object].member? nil)
   end
 
   def test_symbol
-    assert ($__rdl_symbol_type.member? :foo)
-    assert ($__rdl_symbol_type.member? :bar)
-    assert (not ($__rdl_symbol_type.member? "foo"))
+    assert (RDL::Globals.types[:symbol].member? :foo)
+    assert (RDL::Globals.types[:symbol].member? :bar)
+    assert (not (RDL::Globals.types[:symbol].member? "foo"))
     assert (@tsymfoo.member? :foo)
     assert (not (@tsymfoo.member? :bar))
     assert (not (@tsymfoo.member? "foo"))
@@ -109,7 +109,7 @@ class TestMember < Minitest::Test
   end
 
   def test_tuple
-    t1 = TupleType.new($__rdl_symbol_type, $__rdl_string_type)
+    t1 = TupleType.new(RDL::Globals.types[:symbol], RDL::Globals.types[:string])
     assert (t1.member? [:foo, "foo"])
     assert (not (t1.member? ["foo", :foo]))
     assert (not (t1.member? [:foo, "foo", "bar"]))
@@ -119,19 +119,19 @@ class TestMember < Minitest::Test
   end
 
   def test_finite_hash
-    t1 = FiniteHashType.new({a: $__rdl_symbol_type, b: $__rdl_string_type}, nil)
+    t1 = FiniteHashType.new({a: RDL::Globals.types[:symbol], b: RDL::Globals.types[:string]}, nil)
     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"=>$__rdl_symbol_type, 2=>$__rdl_string_type}, nil)
+    t2 = FiniteHashType.new({"a"=>RDL::Globals.types[:symbol], 2=>RDL::Globals.types[:string]}, nil)
     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"})))
-    t3 = FiniteHashType.new({"a"=>$__rdl_symbol_type, 2=>$__rdl_string_type}, $__rdl_fixnum_type)
+    t3 = FiniteHashType.new({"a"=>RDL::Globals.types[:symbol], 2=>RDL::Globals.types[:string]}, RDL::Globals.types[:integer])
     assert (t3.member?({"a"=>:foo, 2=>"foo"}))
     assert (t3.member?({"a"=>:foo, 2=>"foo", two: 2}))
     assert (t3.member?({"a"=>:foo, 2=>"foo", two: 2, three: 3}))
@@ -139,12 +139,12 @@ class TestMember < Minitest::Test
     assert (not (t3.member?({"a"=>:foo, 2=>"foo", two: 2, three: 'three'})))
     assert (not (t3.member?({"a"=>:foo, two: 2})))
     assert (not (t3.member?({2=>"foo", two: 2})))
-    t4 = FiniteHashType.new({a: $__rdl_symbol_type, b: $__rdl_string_type}, $__rdl_fixnum_type)
+    t4 = FiniteHashType.new({a: RDL::Globals.types[:symbol], b: RDL::Globals.types[:string]}, RDL::Globals.types[:integer])
     assert (t4.member?(a: :foo, b: "foo"))
     assert (t4.member?(a: :foo, b: "foo", c: 3))
     assert (t4.member?(a: :foo, b: "foo", c: 3, d: 4))
     assert (not (t4.member?(a: :foo, b: "foo", c: "three")))
-    t5 = FiniteHashType.new({a: $__rdl_symbol_type, b: OptionalType.new($__rdl_string_type)}, $__rdl_fixnum_type)
+    t5 = FiniteHashType.new({a: RDL::Globals.types[:symbol], b: OptionalType.new(RDL::Globals.types[:string])}, RDL::Globals.types[:integer])
     assert (t5.member?(a: :foo, b: "foo"))
     assert (t5.member?(a: :foo, b: "foo", c: 3))
     assert (t5.member?(a: :foo, b: "foo", c: 3, d: 4))