rdl 2.0.0.rc2 → 2.0.0.rc3

data/lib/types/core-ruby-2.x/object.rb

@@ -0,0 +1,75 @@
+class Object
+  # Instead of rdl_nowrap, mark individual methods as not being wrapped so
+  # we can wrap stuff defined by the user at the top level (since those
+  # methods are added to Object).
+
+  # type :ARGF, ARGF
+  # type :ARGV, 'Array<String>'
+  # type :DATA, 'File'
+  # type :ENV, ENV
+  # type :FALSE, '%false'
+  # type :NIL, 'nil'
+  # type :RUBY_COPYRIGHT, 'String'
+  # type :RUBY_DESCRIPTION, 'String'
+  # type :RUBY_ENGINE, 'String'
+  # type :RUBY_PATCHLEVEL, Fixnum
+  # type :RUBY_PLATFORM, 'String'
+  # type :RUBY_RELEASE_DATE, 'String'
+  # type :RUBY_REVISION, Fixnum
+  # type :RUBY_VERSION, 'String'
+  # type :STDERR, 'IO'
+  # type :STDIN, 'IO'
+  # type :STDOUT, 'IO'
+  # type :TOPLEVEL_BINDING, 'Binding'
+  # type :TRUE, '%true'
+
+  type :!~, '(%any other) -> %bool', wrap: false
+  type :<=>, '(%any other) -> Fixnum or nil', wrap: false
+  type :===, '(%any other) -> %bool', wrap: false
+  type :=~, '(%any other) -> nil', wrap: false
+  type :class, '() -> Class', wrap: false
+  type :clone, '() -> self', wrap: false
+#  type :define_singleton_method, '(XXXX : *XXXX)') # TODO
+  type :display, '(IO port) -> nil', wrap: false
+  type :dup, '() -> self an_object', wrap: false
+  type :enum_for, '(?Symbol method, *%any args) -> Enumerator<%any>', wrap: false
+  type :enum_for, '(?Symbol method, *%any args) { (*%any args) -> %any } -> Enumerator<%any>', wrap: false
+  type :eql?, '(%any other) -> %bool', wrap: false
+#  type :extend, '(XXXX : *XXXX)') # TODO
+  type :freeze, '() -> self', wrap: false
+  type :frozen?, '() -> %bool', wrap: false
+  type :hash, '() -> Fixnum', wrap: false
+  type :inspect, '() -> String', wrap: false
+  type :instance_of?, '(Class) -> %bool', wrap: false
+  type :instance_variable_defined?, '(Symbol or String) -> %bool', wrap: false
+  type :instance_variable_get, '(Symbol or String) -> %any', wrap: false
+  type :instance_variable_set, '(Symbol or String, %any) -> %any', wrap: false # returns 2nd argument
+  type :instance_variables, '() -> Array<Symbol>', wrap: false
+  type :is_a?, '(Class or Module) -> %bool', wrap: false
+  type :kind_of?, '(Class) -> %bool', wrap: false
+  type :method, '(Symbol) -> Method', wrap: false
+  type :methods, '(?%bool regular) -> Array<Symbol>', wrap: false
+  type :nil?, '() -> %bool', wrap: false
+  type :private_methods, '(?%bool all) -> Array<Symbol>', wrap: false
+  type :protected_methods, '(?%bool all) -> Array<Symbol>', wrap: false
+  type :public_method, '(Symbol) -> Method', wrap: false
+  type :public_methods, '(?%bool all) -> Array<Symbol>', wrap: false
+  type :public_send, '(Symbol or String, *%any args) -> %any', wrap: false
+  type :remove_instance_variable, '(Symbol) -> %any', wrap: false
+#  type :respond_to?, '(Symbol or String, ?%bool include_all) -> %bool'
+  type :send, '(Symbol or String, *%any args) -> %any', wrap: false # Can't wrap this, used outside wrap switch
+  type :singleton_class, '() -> Class', wrap: false
+  type :singleton_method, '(Symbol) -> Method', wrap: false
+  type :singleton_methods, '(?%bool all) -> Array<Symbol>', wrap: false
+  type :taint, '() -> self', wrap: false
+  type :tainted?, '() -> %bool', wrap: false
+#  type :tap, '()') # TODO
+  type :to_enum, '(?Symbol method, *%any args) -> Enumerator<%any>', wrap: false
+  type :to_enum, '(?Symbol method, *%any args) {(*%any args) -> %any} -> Enumerator<%any>', wrap: false
+# TODO: above alias for enum_for?
+  type :to_s, '() -> String', wrap: false
+  type :trust, '() -> self', wrap: false
+  type :untaint, '() -> self', wrap: false
+  type :untrust, '() -> self', wrap: false
+  type :untrusted?, '() -> %bool', wrap: false
+end

data/lib/types/core.rb

@@ -0,0 +1,4 @@
+dir = RUBY_VERSION.split('.')[0] + ".x"
+
+require_relative "core-ruby-#{dir}/_aliases.rb" # load type aliases first
+Dir[File.dirname(__FILE__) + "/core-ruby-#{dir}/**/*.rb"].each { |f| require f }

data/rdl.gemspec

@@ -4,8 +4,8 @@
 
 Gem::Specification.new do |s|
   s.name        = 'rdl'
-  s.version     = '2.0.0.rc2'
-  s.date        = '2016-07-19'
+  s.version     = '2.0.0.rc3'
+  s.date        = '2016-08-11'
   s.summary     = 'Ruby type and contract system'
   s.description = <<-EOF
 RDL is a gem that adds types and contracts to Ruby. RDL includes extensive

data/test/test_le.rb

@@ -15,6 +15,11 @@ class TestLe < Minitest::Test
   class C < B
   end
 
+  # convert arg string to a type
+  def tt(t)
+    $__rdl_parser.scan_str('#T ' + t)
+  end
+
   def setup
     @tbasicobject = NominalType.new "BasicObject"
     @tsymfoo = SingletonType.new :foo
@@ -93,45 +98,42 @@ class TestLe < Minitest::Test
     assert (not (t2 <= t1))
     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)
+    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("[Object, Object, Object]"))
 
     # 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>"
+    tfs_1 = tt "[Fixnum, String]"
+    tafs_1 = tt "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]"
+    tfs2_1 = tt "[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]"
+    tfs_2 = tt "[Fixnum, String]"
+    tfs2_2 = tt "[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>"
+    tafs_2 = tt "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]"
+    tfs_3 = tt "[Fixnum, String]"
+    tfs2_3 = tt "[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>"
+    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 = $__rdl_parser.scan_str "#T [Fixnum, String]"
-    tfs2_4 = $__rdl_parser.scan_str "#T [Fixnum, String]"
+    tfs_4 = tt "[Fixnum, String]"
+    tfs2_4 = tt "[Fixnum, String]"
     assert (tfs_4 <= tfs2_4) # allowed, types are the same
-    tafs_4 = $__rdl_parser.scan_str "#T Array<Fixnum or String>"
+    tafs_4 = tt "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]"
+    tfs3_4 = tt "[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}"
+    t12 = tt "{a: 1, b: 2}"
+    tfs = tt "{a: Fixnum, b: Fixnum}"
+    too = tt "{a: Object, b: Object}"
     assert (t12 <= tfs)
     assert (t12 <= too)
     assert (tfs <= too)
@@ -141,30 +143,30 @@ class TestLe < Minitest::Test
 
     # 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>"
+    tfs_1 = tt "{x: Fixnum, y: String}"
+    thfs_1 = tt "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}"
+    tfs2_1 = tt "{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}"
+    tfs_2 = tt "{x: Fixnum, y: String}"
+    tfs2_2 = tt "{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>"
+    thfs_2 = tt "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}"
+    tfs_3 = tt "{x: Fixnum, 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 = $__rdl_parser.scan_str "#T Hash<Symbol, Object>"
+    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 = $__rdl_parser.scan_str "#T {x: Fixnum, y: String}"
-    tfs2_4 = $__rdl_parser.scan_str "#T {x: Fixnum, y: String}"
+    tfs_4 = tt "{x: Fixnum, y: String}"
+    tfs2_4 = tt "{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>"
+    thfs_4 = tt "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}"
+    tfs3_4 = tt "{x: Fixnum, y: String}"
     assert (not(tfs_4 <= tfs3_4)) # not allowed, tfs_4 has been promoted
   end
 
@@ -251,6 +253,46 @@ class TestLe < Minitest::Test
     assert (not (tnomt <= ts4))
   end
 
+  def test_leq_inst
+    # when return of do_leq is false, ignore resulting inst, since that's very implementation dependent
+    assert_equal [true, {t: @ta}], do_leq(tt("t"), @ta, true)
+    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, {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
+  end
+
+  def do_leq(tleft, tright, ileft)
+    inst = Hash.new
+    r = Type.leq(tleft, tright, inst, ileft)
+    return [r, inst]
+  end
+
+  # 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")
+  end
+
   # def test_intersection
   #   skip "<= not defined on intersection"
   #   tobject_and_basicobject = IntersectionType.new($__rdl_object_type, @tbasicobject)

data/test/test_parser.rb

@@ -26,168 +26,184 @@ class TestParser < Minitest::Test
     @tsymbolx = AnnotatedArgType.new("x", @tsymbol)
   end
 
+  def tt(t)
+    $__rdl_parser.scan_str('#T ' + t)
+  end
+
+  def tm(t)
+    $__rdl_parser.scan_str t
+  end
+
   def test_basic
-    t1 = $__rdl_parser.scan_str "(nil) -> nil"
+    t1 = tm "(nil) -> nil"
     assert_equal (MethodType.new [$__rdl_nil_type], nil, $__rdl_nil_type), t1
-    t2 = $__rdl_parser.scan_str "(Fixnum, Fixnum) -> Fixnum"
+    t2 = tm "(Fixnum, Fixnum) -> Fixnum"
     assert_equal (MethodType.new [$__rdl_fixnum_type, $__rdl_fixnum_type], nil, $__rdl_fixnum_type), t2
-    t3 = $__rdl_parser.scan_str "() -> Enumerator"
+    t3 = tm "() -> Enumerator"
     assert_equal (MethodType.new [], nil, @tenum), t3
-    t4 = $__rdl_parser.scan_str "(%any) -> nil"
+    t4 = tm "(%any) -> nil"
     assert_equal (MethodType.new [$__rdl_top_type], nil, $__rdl_nil_type), t4
-    t5 = $__rdl_parser.scan_str "(%bool) -> Fixnum"
+    t5 = tm "(%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_raises(RuntimeError) { tm "(%foo) -> nil" }
+    t6 = tm "(A) -> nil"
     assert_equal (MethodType.new [@ta], nil, $__rdl_nil_type), t6
-    t7 = $__rdl_parser.scan_str "(TestParser::A) -> nil"
+    t7 = tm "(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"
+    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
-    t9 = $__rdl_parser.scan_str "(true) -> false"
+    t9 = tm "(true) -> false"
     assert_equal (MethodType.new [$__rdl_true_type], nil, $__rdl_false_type), t9
   end
 
   def test_opt_vararg
-    t1 = $__rdl_parser.scan_str "(Fixnum, ?Fixnum) -> Fixnum"
+    t1 = tm "(Fixnum, ?Fixnum) -> Fixnum"
     assert_equal (MethodType.new [$__rdl_fixnum_type, @tfixnumopt], nil, $__rdl_fixnum_type), t1
-    t2 = $__rdl_parser.scan_str "(Fixnum, *Fixnum) -> Fixnum"
+    t2 = tm "(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"
+    t3 = tm "(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"
+    t4 = tm "(?Fixnum) -> nil"
     assert_equal (MethodType.new [@tfixnumopt], nil, $__rdl_nil_type), t4
-    t5 = $__rdl_parser.scan_str "(*Fixnum) -> nil"
+    t5 = tm "(*Fixnum) -> nil"
     assert_equal (MethodType.new [@tfixnumvararg], nil, $__rdl_nil_type), t5
   end
 
   def test_union
-    t1 = $__rdl_parser.scan_str "(Fixnum or String) -> nil"
+    t1 = tm "(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"
+    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 = $__rdl_parser.scan_str "() -> Fixnum or String or Symbol"
+    t3 = tm "() -> 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 = $__rdl_parser.scan_str "#T nil"
+    t1 = tt "nil"
     assert_equal $__rdl_nil_type, t1
-    t2 = $__rdl_parser.scan_str "#T %any"
+    t2 = tt "%any"
     assert_equal $__rdl_top_type, t2
-    t3 = $__rdl_parser.scan_str "#T A"
+    t3 = tt "A"
     assert_equal NominalType.new("A"), t3
   end
 
   def test_symbol
-    t1 = $__rdl_parser.scan_str "#T :symbol"
+    t1 = tt ":symbol"
     assert_equal @tsymbol, t1
   end
 
   def test_annotated_params
-    t1 = $__rdl_parser.scan_str "(Fixnum x, Fixnum) -> Fixnum"
+    t1 = tm "(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"
+    t2 = tm "(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"
+    t3 = tm "(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"
+    t4 = tm "(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"
+    t5 = tm "(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"
+    t6 = tm "(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"
+    t7 = tm "(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"
+    t8 = tm "(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"
+    t9 = tm "(Fixnum x, Fixnum y) -> Fixnum ret"
     assert_equal (MethodType.new [@tfixnumx, @tfixnumy], nil, @tfixnumret), t9
-    t10 = $__rdl_parser.scan_str "(:symbol x) -> Fixnum"
+    t10 = tm "(:symbol x) -> Fixnum"
     assert_equal (MethodType.new [@tsymbolx], nil, $__rdl_fixnum_type), t10
   end
 
   def test_generic
-    t1 = $__rdl_parser.scan_str "#T t"
+    t1 = tt "t"
     assert_equal (VarType.new "t"), t1
-    t2 = $__rdl_parser.scan_str "#T Array"
+    t2 = tt "Array"
     assert_equal (NominalType.new "Array"), t2
-    t3 = $__rdl_parser.scan_str "#T Array<t>"
+    t3 = tt "Array<t>"
     assert_equal (GenericType.new(t2, t1)), t3
-    t4 = $__rdl_parser.scan_str "#T Array<Array<t>>"
+    t4 = tt "Array<Array<t>>"
     assert_equal (GenericType.new(t2, t3)), t4
-    t5 = $__rdl_parser.scan_str "#T Hash"
+    t5 = tt "Hash"
     assert_equal (NominalType.new "Hash"), t5
-    t6 = $__rdl_parser.scan_str "#T Hash<u, v>"
+    t6 = tt "Hash<u, v>"
     assert_equal (GenericType.new(t5, VarType.new("u"), VarType.new("v"))), t6
-    t7 = $__rdl_parser.scan_str "#T Foo<String, Array<t>, Array<Array<t>>>"
+    t7 = tt "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 = $__rdl_parser.scan_str "#T [Fixnum, String]"
+    t1 = tt "[Fixnum, String]"
     assert_equal (TupleType.new($__rdl_fixnum_type, $__rdl_string_type)), t1
-    t2 = $__rdl_parser.scan_str "#T [String]"
+    t2 = tt "[String]"
     assert_equal (TupleType.new($__rdl_string_type)), t2
   end
 
   def test_fixnum
-    t1 = $__rdl_parser.scan_str "#T 42"
+    t1 = tt "42"
     assert_equal (SingletonType.new(42)), t1
-    t2 = $__rdl_parser.scan_str "#T -42"
+    t2 = tt "-42"
     assert_equal (SingletonType.new(-42)), t2
   end
 
   def test_float
-    t1 = $__rdl_parser.scan_str "#T 3.14"
+    t1 = tt "3.14"
     assert_equal (SingletonType.new(3.14)), t1
   end
 
   def test_const
-    t1 = $__rdl_parser.scan_str "#T ${Math::PI}"
+    t1 = tt "${Math::PI}"
     assert_equal (SingletonType.new(Math::PI)), t1
   end
 
   def test_type_alias
     type_alias '%foobarbaz', $__rdl_nil_type
-    assert_equal $__rdl_nil_type, ($__rdl_parser.scan_str "#T %foobarbaz")
+    assert_equal $__rdl_nil_type, (tt "%foobarbaz")
     type_alias '%quxquxqux', 'nil'
-    assert_equal $__rdl_nil_type, ($__rdl_parser.scan_str "#T %quxquxqux")
+    assert_equal $__rdl_nil_type, (tt "%quxquxqux")
     assert_raises(RuntimeError) { type_alias '%quxquxqux', 'nil' }
-    assert_raises(RuntimeError) { $__rdl_parser.scan_str "#T %qux" }
+    assert_raises(RuntimeError) { tt "%qux" }
   end
 
   def test_structural
-    t1 = $__rdl_parser.scan_str "#T [to_str: () -> String]"
+    t1 = tt "[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 = $__rdl_parser.scan_str "#T {a: Fixnum, b: String}"
+    t1 = tt "{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}"
+    t2 = tt "{'a'=>Fixnum, 2=>String}"
     assert_equal (FiniteHashType.new({"a"=>$__rdl_fixnum_type, 2=>$__rdl_string_type})), t2
   end
 
   def test_named_params
-    t1 = $__rdl_parser.scan_str "(Fixnum, x: Fixnum) -> Fixnum"
+    t1 = tm "(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"
+    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, $__rdl_fixnum_type), t2
-    t3 = $__rdl_parser.scan_str "(Fixnum, y: String, x: Fixnum) -> Fixnum"
+    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, $__rdl_fixnum_type), t3
-    t4 = $__rdl_parser.scan_str "(Fixnum, y: String, x: ?Fixnum) -> Fixnum"
+    t4 = tm "(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"
+    t4 = tm "(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"
+    t5 = tm "(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"
+    t6 = tm "(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"
+    t7 = tm "(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
 
+  def test_nonnull
+    assert_equal NonNullType.new(@ta), tt("!A")
+    tm2 = MethodType.new [], nil, $__rdl_string_type
+    ts2 = StructuralType.new(to_str: tm2)
+    assert_equal NonNullType.new(ts2), tt("![to_str: () -> String]")
+    assert_raises(RuntimeError) { tt("!3") }
+  end
+
 end