rdl 2.0.0.rc4 → 2.0.0.rc5

data/test/test_member.rb

@@ -119,17 +119,39 @@ class TestMember < Minitest::Test
   end
 
   def test_finite_hash
-    t1 = FiniteHashType.new(a: $__rdl_symbol_type, b: $__rdl_string_type)
+    t1 = FiniteHashType.new({a: $__rdl_symbol_type, b: $__rdl_string_type}, 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})
+    t2 = FiniteHashType.new({"a"=>$__rdl_symbol_type, 2=>$__rdl_string_type}, 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)
+    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}))
+    assert (not (t3.member?({"a"=>:foo, 2=>"foo", two: 'two'})))
+    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)
+    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)
+    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))
+    assert (not (t5.member?(a: :foo, b: "foo", c: "three")))
+    assert (t5.member?(a: :foo))
+    assert (t5.member?(a: :foo, c: 3))
+    assert (t5.member?(a: :foo, c: 3, d: 4))
+    assert (not (t5.member?(a: :foo, c: "three")))
   end
 end

data/test/test_parser.rb

@@ -174,28 +174,30 @@ class TestParser < Minitest::Test
 
   def test_finite_hash
     t1 = tt "{a: Fixnum, b: String}"
-    assert_equal (FiniteHashType.new({a: $__rdl_fixnum_type, b: $__rdl_string_type})), t1
+    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})), t2
+    assert_equal (FiniteHashType.new({"a"=>$__rdl_fixnum_type, 2=>$__rdl_string_type}, 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, $__rdl_fixnum_type), t1
+    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, $__rdl_fixnum_type), t2
+    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, $__rdl_fixnum_type), t3
+    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, $__rdl_fixnum_type), t4
+    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, $__rdl_fixnum_type), t4
+    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, $__rdl_fixnum_type), t5
+    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, $__rdl_fixnum_type), t6
+    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)], MethodType.new([$__rdl_top_type, $__rdl_string_type], nil, $__rdl_nil_type), @tsymbol), t7
+    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
   end
 
   def test_nonnull
@@ -206,4 +208,13 @@ class TestParser < Minitest::Test
     assert_raises(RuntimeError) { tt("!3") }
   end
 
+  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
+    t2 = tm "() ?{ (%any) -> nil } -> %any"
+    assert_equal (MethodType.new [], OptionalType.new(MethodType.new([$__rdl_top_type], nil, $__rdl_nil_type)), $__rdl_top_type), 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
+  end
+
 end

data/test/test_query.rb

@@ -38,9 +38,9 @@ class TestQuery < Minitest::Test
     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, @tfixnum), q11
+    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, @tfixnum), q12
+    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"
@@ -105,5 +105,8 @@ class TestQuery < Minitest::Test
     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)
   end
 end

data/test/test_type_contract.rb

@@ -152,6 +152,10 @@ class TestTypeContract < Minitest::Test
     assert_raises(TypeError) { block_contract_test2(42) {|z| z} }
     assert_raises(TypeError) { block_contract_test1(42) }
     assert_raises(TypeError) { block_contract_test3(42) { |x| x } }
+    assert_equal 42, block_contract_test4(42)
+    assert_equal 42, block_contract_test4(41) {|x| x+1}
+    assert_raises(TypeError) { block_contract_test4(40.5) }
+    assert_raises(TypeError) { block_contract_test4(42) {|x| x+1.5} }
 
     t15 = @p.scan_str "(Fixnum x {{x>y}}, Fixnum y) -> Fixnum"
     p15 = t15.to_contract.wrap(self) { |x, y| x+y }
@@ -172,6 +176,18 @@ class TestTypeContract < Minitest::Test
     assert_raises(TypeError) { p17.call(42) }
     assert_raises(TypeError) { p17.call(42, '43') }
     assert_raises(TypeError) { p17.call(42, 43, '44') }
+
+    t18 = @p.scan_str "(Fixnum, ?{(Fixnum) -> Fixnum}) -> Fixnum"
+    p18 = t18.to_higher_contract(self) { |x,p=nil| if p then p.call(x) else x end }
+    assert_equal 42, p18.call(41, Proc.new {|x| x+1})
+    assert_equal 42, p18.call(42)
+    assert_raises(TypeError) { p18.call(41.5, Proc.new {|x| x+1}) }
+    assert_raises(TypeError) { p18.call(41, 1) }
+    assert_raises(TypeError) { p18.call(41, Proc.new {|x| x+1.5}) }
+    p18b = t18.to_higher_contract(self) { |x,p=nil| if p then p.call(x+0.5) else x end }
+    assert_raises(TypeError) { p18b.call(41, Proc.new {|x| x+1}) }
+
+
   end
 
   type '(Fixnum) { (Fixnum) -> Fixnum } -> Fixnum'
@@ -189,6 +205,12 @@ class TestTypeContract < Minitest::Test
     42
   end
 
+  type '(Fixnum) ?{(Fixnum) -> Fixnum} -> Fixnum'
+  def block_contract_test4(x,&blk)
+    return yield(x) if blk
+    return x
+  end
+
   def test_proc_names
     t1 = @p.scan_str "(x: Fixnum) -> Fixnum"
     p1 = t1.to_contract.wrap(self) { |x:| x }
@@ -243,7 +265,7 @@ class TestTypeContract < Minitest::Test
     assert_raises(TypeError) { p6.call(x: 43, y: "44", z: 45) }
     t7 = @p.scan_str "(x: ?Fixnum, y: ?String) -> Fixnum"
     p7 = t7.to_contract.wrap(self) { |**args| 42 }
-    assert_equal 42, p7.call()
+    assert_equal 42, p7.call
     assert_equal 42, p7.call(x: 43)
     assert_equal 42, p7.call(y: "44")
     assert_equal 42, p7.call(x: 43, y: "44")
@@ -252,7 +274,7 @@ class TestTypeContract < Minitest::Test
     assert_raises(TypeError) { p7.call(x: 43, y: "44", z: 45) }
     t8 = @p.scan_str "(?Fixnum, x: ?Symbol, y: ?String) -> Fixnum"
     p8 = t8.to_contract.wrap(self) { |*args| 42 }
-    assert_equal 42, p8.call()
+    assert_equal 42, p8.call
     assert_equal 42, p8.call(43)
     assert_equal 42, p8.call(x: :foo)
     assert_equal 42, p8.call(43, x: :foo)
@@ -263,6 +285,16 @@ class TestTypeContract < Minitest::Test
     assert_raises(TypeError) { p8.call(43, 44, x: :foo, y: "foo") }
     assert_raises(TypeError) { p8.call(43, x: "foo", y: "foo") }
     assert_raises(TypeError) { p8.call(43, x: :foo, y: "foo", z: 44) }
+    t9 = @p.scan_str "(Fixnum, x: String, y: Fixnum, **Float) -> Fixnum"
+    p9 = t9.to_contract.wrap(self) { |*args| 42 }
+    assert_raises(TypeError) { p9.call }
+    assert_raises(TypeError) { p9.call(43) }
+    assert_raises(TypeError) { p9.call(43, x: "foo") }
+    assert_equal 42, p9.call(43, x: "foo", y: 44)
+    assert_equal 42, p9.call(43, x: "foo", y: 44, pi: 3.14)
+    assert_equal 42, p9.call(43, x: "foo", y: 44, pi: 3.14, e: 2.72)
+    assert_raises(TypeError) { p9.call(43, x: "foo", y: 44, pi: 3) }
+    assert_raises(TypeError) { p9.call(43, x: "foo", y: 44, pi: 3.14, e: 3) }
   end
 
   type '() { () -> nil } -> nil'

data/test/test_typecheck.rb

@@ -412,52 +412,53 @@ class TestTypecheck < Minitest::Test
       type :_send_named_args6, "(x: ?Fixnum, y: String) -> Fixnum"
       type :_send_named_args7, "(x: ?Fixnum, y: ?String) -> Fixnum"
       type :_send_named_args8, "(?Fixnum, x: ?Symbol, y: ?String) -> Fixnum"
+      type :_send_named_args9, "(Fixnum, x: String, y: Fixnum, **Float) -> Fixnum"
     }
     assert_equal $__rdl_fixnum_type, do_tc("_send_named_args1(x: 42)", env: @env)
-    assert_raises(RDL::Typecheck::StaticTypeError) { assert do_tc("_send_named_args1(x: '42')", env: @env) }
-    assert_raises(RDL::Typecheck::StaticTypeError) { assert do_tc("_send_named_args1()", env: @env) }
-    assert_raises(RDL::Typecheck::StaticTypeError) { assert do_tc("_send_named_args1(x: 42, y: 42)", env: @env) }
-    assert_raises(RDL::Typecheck::StaticTypeError) { assert do_tc("_send_named_args1(y: 42)", env: @env) }
-    assert_raises(RDL::Typecheck::StaticTypeError) { assert do_tc("_send_named_args1(42)", env: @env) }
-    assert_raises(RDL::Typecheck::StaticTypeError) { assert do_tc("_send_named_args1(42, x: '42')", env: @env) }
+    assert_raises(RDL::Typecheck::StaticTypeError) { do_tc("_send_named_args1(x: '42')", env: @env) }
+    assert_raises(RDL::Typecheck::StaticTypeError) { do_tc("_send_named_args1()", env: @env) }
+    assert_raises(RDL::Typecheck::StaticTypeError) { do_tc("_send_named_args1(x: 42, y: 42)", env: @env) }
+    assert_raises(RDL::Typecheck::StaticTypeError) { do_tc("_send_named_args1(y: 42)", env: @env) }
+    assert_raises(RDL::Typecheck::StaticTypeError) { do_tc("_send_named_args1(42)", env: @env) }
+    assert_raises(RDL::Typecheck::StaticTypeError) { do_tc("_send_named_args1(42, x: '42')", env: @env) }
     assert_equal $__rdl_fixnum_type, do_tc("_send_named_args2(x: 42, y: '43')", env: @env)
-    assert_raises(RDL::Typecheck::StaticTypeError) { assert do_tc("_send_named_args2()", env: @env) }
-    assert_raises(RDL::Typecheck::StaticTypeError) { assert do_tc("_send_named_args2(x: 42)", env: @env) }
-    assert_raises(RDL::Typecheck::StaticTypeError) { assert do_tc("_send_named_args2(x: '42', y: '43')", env: @env) }
-    assert_raises(RDL::Typecheck::StaticTypeError) { assert do_tc("_send_named_args2(42, '43')", env: @env) }
-    assert_raises(RDL::Typecheck::StaticTypeError) { assert do_tc("_send_named_args2(42, x: 42, y: '43')", env: @env) }
-    assert_raises(RDL::Typecheck::StaticTypeError) { assert do_tc("_send_named_args2(x: 42, y: '43', z: 44)", env: @env) }
+    assert_raises(RDL::Typecheck::StaticTypeError) { do_tc("_send_named_args2()", env: @env) }
+    assert_raises(RDL::Typecheck::StaticTypeError) { do_tc("_send_named_args2(x: 42)", env: @env) }
+    assert_raises(RDL::Typecheck::StaticTypeError) { do_tc("_send_named_args2(x: '42', y: '43')", env: @env) }
+    assert_raises(RDL::Typecheck::StaticTypeError) { do_tc("_send_named_args2(42, '43')", env: @env) }
+    assert_raises(RDL::Typecheck::StaticTypeError) { do_tc("_send_named_args2(42, x: 42, y: '43')", env: @env) }
+    assert_raises(RDL::Typecheck::StaticTypeError) { do_tc("_send_named_args2(x: 42, y: '43', z: 44)", env: @env) }
     assert_equal $__rdl_fixnum_type, do_tc("_send_named_args3(42, y: '43')", env: @env)
-    assert_raises(RDL::Typecheck::StaticTypeError) { assert do_tc("_send_named_args3(42, y: 43)", env: @env) }
-    assert_raises(RDL::Typecheck::StaticTypeError) { assert do_tc("_send_named_args3()", env: @env) }
-    assert_raises(RDL::Typecheck::StaticTypeError) { assert do_tc("_send_named_args3(42, 43, y: 44)", env: @env) }
-    assert_raises(RDL::Typecheck::StaticTypeError) { assert do_tc("_send_named_args3(42, y: 43, z: 44)", env: @env) }
+    assert_raises(RDL::Typecheck::StaticTypeError) { do_tc("_send_named_args3(42, y: 43)", env: @env) }
+    assert_raises(RDL::Typecheck::StaticTypeError) { do_tc("_send_named_args3()", env: @env) }
+    assert_raises(RDL::Typecheck::StaticTypeError) { do_tc("_send_named_args3(42, 43, y: 44)", env: @env) }
+    assert_raises(RDL::Typecheck::StaticTypeError) { do_tc("_send_named_args3(42, y: 43, z: 44)", env: @env) }
     assert_equal $__rdl_fixnum_type, do_tc("_send_named_args4(42, x: 43, y: '44')", env: @env)
-    assert_raises(RDL::Typecheck::StaticTypeError) { assert do_tc("_send_named_args4(42, x: 43)", env: @env) }
-    assert_raises(RDL::Typecheck::StaticTypeError) { assert do_tc("_send_named_args4(42, y: '43')", env: @env) }
-    assert_raises(RDL::Typecheck::StaticTypeError) { assert do_tc("_send_named_args4()", env: @env) }
-    assert_raises(RDL::Typecheck::StaticTypeError) { assert do_tc("_send_named_args4(42, 43, x: 44, y: '45')", env: @env) }
-    assert_raises(RDL::Typecheck::StaticTypeError) { assert do_tc("_send_named_args4(42, x: 43, y: '44', z: 45)", env: @env) }
+    assert_raises(RDL::Typecheck::StaticTypeError) { do_tc("_send_named_args4(42, x: 43)", env: @env) }
+    assert_raises(RDL::Typecheck::StaticTypeError) { do_tc("_send_named_args4(42, y: '43')", env: @env) }
+    assert_raises(RDL::Typecheck::StaticTypeError) { do_tc("_send_named_args4()", env: @env) }
+    assert_raises(RDL::Typecheck::StaticTypeError) { do_tc("_send_named_args4(42, 43, x: 44, y: '45')", env: @env) }
+    assert_raises(RDL::Typecheck::StaticTypeError) { do_tc("_send_named_args4(42, x: 43, y: '44', z: 45)", env: @env) }
     assert_equal $__rdl_fixnum_type, do_tc("_send_named_args5(x: 42, y: '43')", env: @env)
     assert_equal $__rdl_fixnum_type, do_tc("_send_named_args5(x: 42)", env: @env)
-    assert_raises(RDL::Typecheck::StaticTypeError) { assert do_tc("_send_named_args5()", env: @env) }
-    assert_raises(RDL::Typecheck::StaticTypeError) { assert do_tc("_send_named_args5(x: 42, y: 43)", env: @env) }
-    assert_raises(RDL::Typecheck::StaticTypeError) { assert do_tc("_send_named_args5(x: 42, y: 43, z: 44)", env: @env) }
-    assert_raises(RDL::Typecheck::StaticTypeError) { assert do_tc("_send_named_args5(3, x: 42, y: 43)", env: @env) }
-    assert_raises(RDL::Typecheck::StaticTypeError) { assert do_tc("_send_named_args5(3, x: 42)", env: @env) }
+    assert_raises(RDL::Typecheck::StaticTypeError) { do_tc("_send_named_args5()", env: @env) }
+    assert_raises(RDL::Typecheck::StaticTypeError) { do_tc("_send_named_args5(x: 42, y: 43)", env: @env) }
+    assert_raises(RDL::Typecheck::StaticTypeError) { do_tc("_send_named_args5(x: 42, y: 43, z: 44)", env: @env) }
+    assert_raises(RDL::Typecheck::StaticTypeError) { do_tc("_send_named_args5(3, x: 42, y: 43)", env: @env) }
+    assert_raises(RDL::Typecheck::StaticTypeError) { do_tc("_send_named_args5(3, x: 42)", env: @env) }
     assert_equal $__rdl_fixnum_type, do_tc("_send_named_args6(x: 43, y: '44')", env: @env)
     assert_equal $__rdl_fixnum_type, do_tc("_send_named_args6(y: '44')", env: @env)
-    assert_raises(RDL::Typecheck::StaticTypeError) { assert do_tc("_send_named_args6()", env: @env) }
-    assert_raises(RDL::Typecheck::StaticTypeError) { assert do_tc("_send_named_args6(x: '43', y: '44')", env: @env) }
-    assert_raises(RDL::Typecheck::StaticTypeError) { assert do_tc("_send_named_args6(42, x: 43, y: '44')", env: @env) }
-    assert_raises(RDL::Typecheck::StaticTypeError) { assert do_tc("_send_named_args6(x: 43, y: '44', z: 45)", env: @env) }
+    assert_raises(RDL::Typecheck::StaticTypeError) { do_tc("_send_named_args6()", env: @env) }
+    assert_raises(RDL::Typecheck::StaticTypeError) { do_tc("_send_named_args6(x: '43', y: '44')", env: @env) }
+    assert_raises(RDL::Typecheck::StaticTypeError) { do_tc("_send_named_args6(42, x: 43, y: '44')", env: @env) }
+    assert_raises(RDL::Typecheck::StaticTypeError) { do_tc("_send_named_args6(x: 43, y: '44', z: 45)", env: @env) }
     assert_equal $__rdl_fixnum_type, do_tc("_send_named_args7()", env: @env)
     assert_equal $__rdl_fixnum_type, do_tc("_send_named_args7(x: 43)", env: @env)
     assert_equal $__rdl_fixnum_type, do_tc("_send_named_args7(y: '44')", env: @env)
     assert_equal $__rdl_fixnum_type, do_tc("_send_named_args7(x: 43, y: '44')", env: @env)
-    assert_raises(RDL::Typecheck::StaticTypeError) { assert do_tc("_send_named_args7(x: '43', y: '44')", env: @env) }
-    assert_raises(RDL::Typecheck::StaticTypeError) { assert do_tc("_send_named_args7(41, x: 43, y: '44')", env: @env) }
-    assert_raises(RDL::Typecheck::StaticTypeError) { assert do_tc("_send_named_args7(x: 43, y: '44', z: 45)", env: @env) }
+    assert_raises(RDL::Typecheck::StaticTypeError) { do_tc("_send_named_args7(x: '43', y: '44')", env: @env) }
+    assert_raises(RDL::Typecheck::StaticTypeError) { do_tc("_send_named_args7(41, x: 43, y: '44')", env: @env) }
+    assert_raises(RDL::Typecheck::StaticTypeError) { do_tc("_send_named_args7(x: 43, y: '44', z: 45)", env: @env) }
     assert_equal $__rdl_fixnum_type, do_tc("_send_named_args8()", env: @env)
     assert_equal $__rdl_fixnum_type, do_tc("_send_named_args8(43)", env: @env)
     assert_equal $__rdl_fixnum_type, do_tc("_send_named_args8(x: :foo)", env: @env)
@@ -466,9 +467,17 @@ class TestTypecheck < Minitest::Test
     assert_equal $__rdl_fixnum_type, do_tc("_send_named_args8(43, y: 'foo')", env: @env)
     assert_equal $__rdl_fixnum_type, do_tc("_send_named_args8(x: :foo, y: 'foo')", env: @env)
     assert_equal $__rdl_fixnum_type, do_tc("_send_named_args8(43, x: :foo, y: 'foo')", env: @env)
-    assert_raises(RDL::Typecheck::StaticTypeError) { assert do_tc("_send_named_args8(43, 44, x: :foo, y: 'foo')", env: @env) }
-    assert_raises(RDL::Typecheck::StaticTypeError) { assert do_tc("_send_named_args8(43, x: 'foo', y: 'foo')", env: @env) }
-    assert_raises(RDL::Typecheck::StaticTypeError) { assert do_tc("_send_named_args8(43, x: :foo, y: 'foo', z: 44)", env: @env) }
+    assert_raises(RDL::Typecheck::StaticTypeError) { do_tc("_send_named_args8(43, 44, x: :foo, y: 'foo')", env: @env) }
+    assert_raises(RDL::Typecheck::StaticTypeError) { do_tc("_send_named_args8(43, x: 'foo', y: 'foo')", env: @env) }
+    assert_raises(RDL::Typecheck::StaticTypeError) { do_tc("_send_named_args8(43, x: :foo, y: 'foo', z: 44)", env: @env) }
+    assert_raises(RDL::Typecheck::StaticTypeError) { do_tc("_send_named_args9", env: @env) }
+    assert_raises(RDL::Typecheck::StaticTypeError) { do_tc("_send_named_args9(43)", env: @env) }
+    assert_raises(RDL::Typecheck::StaticTypeError) { do_tc("_send_named_args9(43, x: 'foo')", env: @env) }
+    assert_equal $__rdl_fixnum_type, do_tc("_send_named_args9(43, x:'foo', y: 44)", env: @env)
+    assert_equal $__rdl_fixnum_type, do_tc("_send_named_args9(43, x:'foo', y: 44, pi: 3.14)", env: @env)
+    assert_equal $__rdl_fixnum_type, do_tc("_send_named_args9(43, x:'foo', y: 44, pi: 3.14, e: 2.72)", env: @env)
+    assert_raises(RDL::Typecheck::StaticTypeError) { do_tc("_send_named_args9(43, x: 'foo', y: 44, pi: 3)", env: @env) }
+    assert_raises(RDL::Typecheck::StaticTypeError) { do_tc("_send_named_args9(43, x: 'foo', y: 44, pi: 3.14, e: 3)", env: @env) }
   end
 
   def test_send_singleton
@@ -608,6 +617,85 @@ class TestTypecheck < Minitest::Test
     }
   end
 
+  def test_block_arg
+    self.class.class_eval {
+      type "(Fixnum) { (Fixnum) -> Fixnum } -> Fixnum", typecheck: :now
+      def _block_arg1(x, &blk)
+        blk.call x
+      end
+    }
+
+    assert_raises(RDL::Typecheck::StaticTypeError) {
+      self.class.class_eval {
+        type "(Fixnum) { (Fixnum) -> Fixnum } -> Fixnum", typecheck: :now
+        def _block_arg2(x, &blk)
+          blk.call 'forty-two'
+        end
+      }
+    }
+
+    assert_raises(RDL::Typecheck::StaticTypeError) {
+      self.class.class_eval {
+        type "(Fixnum) { (Fixnum) -> String } -> Fixnum", typecheck: :now
+        def _block_arg3(x, &foo)
+          foo.call 42
+        end
+      }
+    }
+
+    assert_raises(RDL::Typecheck::StaticTypeError) {
+      self.class.class_eval {
+        type "(Fixnum) -> Fixnum", typecheck: :now
+        def _block_arg4(x, &blk)
+          blk.call 42
+        end
+      }
+    }
+
+    assert_raises(RDL::Typecheck::StaticTypeError) {
+      self.class.class_eval {
+        type "(Fixnum) { (Fixnum) { (Fixnum) -> Fixnum } -> Fixnum } -> Fixnum", typecheck: :now
+        def _block_arg5(x, &blk)
+          blk.call 42
+        end
+      }
+    }
+
+    self.class.class_eval {
+      type :_block_arg6, "(Fixnum) { (Fixnum) -> Fixnum } -> Fixnum"
+      type "() { (Fixnum) -> Fixnum } -> Fixnum", typecheck: :now
+      def _block_arg7(&blk)
+        _block_arg6(42, &blk)
+      end
+    }
+
+    assert_raises(RDL::Typecheck::StaticTypeError) {
+      self.class.class_eval {
+        type "() { (Fixnum) -> String } -> Fixnum", typecheck: :now
+        def _block_arg8(&blk)
+          _block_arg6(42, &blk)
+        end
+      }
+    }
+
+    assert_raises(RDL::Typecheck::StaticTypeError) {
+      self.class.class_eval {
+        type "() -> Fixnum", typecheck: :now
+        def _block_arg9()
+          _block_arg6(42, &(1+2))
+        end
+      }
+    }
+
+    self.class.class_eval {
+      type :_block_arg10, "(Fixnum) -> Fixnum"
+      type :_block_arg11, "(Fixnum) -> String"
+    }
+    assert_equal $__rdl_fixnum_type, do_tc("_block_arg6(42, &:_block_arg10)", env: @env)
+    assert_raises(RDL::Typecheck::StaticTypeError) { do_tc("_block_arg6(42, &:_block_arg11)", env: @env) }
+    assert_raises(RDL::Typecheck::StaticTypeError) { do_tc("_block_arg6(42, &:_block_arg_does_not_exist)", env: @env) }
+  end
+
   # class Sup1
   #   type '(Fixnum) -> Fixnum', typecheck: :call
   #   def foo(y)
@@ -999,4 +1087,176 @@ class TestTypecheck < Minitest::Test
     }
   end
 
+  def test_optional_varargs_mapping
+    assert_raises(RDL::Typecheck::StaticTypeError) {
+      self.class.class_eval {
+        type '(?Fixnum) -> Fixnum', typecheck: :now
+        def _optional_varargs_mapping1(x)
+          42
+        end
+      }
+    }
+
+    assert_raises(RDL::Typecheck::StaticTypeError) {
+      self.class.class_eval {
+        type '(Fixnum) -> Fixnum', typecheck: :now
+        def _optional_varargs_mapping2(x=42)
+          x
+        end
+      }
+    }
+
+    assert_raises(RDL::Typecheck::StaticTypeError) {
+      self.class.class_eval {
+        type '(*Fixnum) -> Fixnum', typecheck: :now
+        def _optional_varargs_mapping3(x=42)
+          x
+        end
+      }
+    }
+
+    self.class.class_eval {
+      type '(?Fixnum) -> Fixnum', typecheck: :now
+      def _optional_varargs_mapping4(x=42)
+        x
+      end
+    }
+
+    assert_raises(RDL::Typecheck::StaticTypeError) {
+      self.class.class_eval {
+        type '(?Fixnum) -> Fixnum', typecheck: :now
+        def _optional_varargs_mapping5(x='forty-two')
+          42
+        end
+      }
+    }
+
+    assert_raises(RDL::Typecheck::StaticTypeError) {
+      self.class.class_eval {
+        type '(Fixnum) -> Fixnum', typecheck: :now
+        def _optional_varargs_mapping6(*x)
+          42
+        end
+      }
+    }
+
+    assert_raises(RDL::Typecheck::StaticTypeError) {
+      self.class.class_eval {
+        type '(?Fixnum) -> Fixnum', typecheck: :now
+        def _optional_varargs_mapping7(*x)
+          42
+        end
+      }
+    }
+
+    self.class.class_eval {
+      type '(*Fixnum) -> Array<Fixnum>', typecheck: :now
+      def _optional_varargs_mapping8(*x)
+        x
+      end
+    }
+
+  end
+
+  def test_kw_mapping
+    self.class.class_eval {
+      type '(kw: Fixnum) -> Fixnum', typecheck: :now
+      def _kw_mapping1(kw:)
+        kw
+      end
+    }
+
+    assert_raises(RDL::Typecheck::StaticTypeError) {
+      self.class.class_eval {
+        type '(Fixnum) -> Fixnum', typecheck: :now
+        def _kw_mapping2(kw:)
+          kw
+        end
+      }
+    }
+
+    self.class.class_eval {
+      type '(kw: Fixnum) -> Fixnum', typecheck: :now
+      def _kw_mapping3(kw_args) # slightly awkward example
+        kw_args[:kw]
+      end
+    }
+
+    assert_raises(RDL::Typecheck::StaticTypeError) {
+      self.class.class_eval {
+        type '(kw: Fixnum) -> Fixnum', typecheck: :now
+        def _kw_mapping4(kw: 42)
+          kw
+        end
+      }
+    }
+
+    assert_raises(RDL::Typecheck::StaticTypeError) {
+      self.class.class_eval {
+        type '(kw: ?Fixnum) -> Fixnum', typecheck: :now
+        def _kw_mapping5(kw:)
+          kw
+        end
+      }
+    }
+
+    self.class.class_eval {
+      type '(kw: ?Fixnum) -> Fixnum', typecheck: :now
+      def _kw_mapping6(kw: 42)
+        kw
+      end
+    }
+
+    assert_raises(RDL::Typecheck::StaticTypeError) {
+      self.class.class_eval {
+        type '(kw: ?Fixnum) -> Fixnum', typecheck: :now
+        def _kw_mapping7(kw: 'forty-two')
+          kw
+        end
+      }
+    }
+
+    self.class.class_eval {
+      type '(kw1: Fixnum, kw2: Fixnum) -> Fixnum', typecheck: :now
+      def _kw_mapping8(kw1:, kw2:)
+        kw1
+      end
+    }
+
+    assert_raises(RDL::Typecheck::StaticTypeError) {
+      self.class.class_eval {
+        type '(kw1: Fixnum, kw2: Fixnum, kw3: Fixnum) -> Fixnum', typecheck: :now
+        def _kw_mapping9(kw2:)
+          kw1
+        end
+      }
+    }
+
+    self.class.class_eval {
+      type '(kw1: Fixnum, kw2: Fixnum, **String) -> String', typecheck: :now
+      def _kw_mapping10(kw1:, kw2:, **kws)
+        kws[:foo]
+      end
+    }
+
+    assert_raises(RDL::Typecheck::StaticTypeError) {
+      self.class.class_eval {
+        type '(kw1: Fixnum, kw2: Fixnum) -> String', typecheck: :now
+        def _kw_mapping11(kw1:, kw2:, **kws)
+          kws[:foo]
+        end
+      }
+    }
+
+    assert_raises(RDL::Typecheck::StaticTypeError) {
+      self.class.class_eval {
+        type '(kw1: Fixnum, kw2: Fixnum, **String) -> Fixnum', typecheck: :now
+        def _kw_mapping12(kw1:, kw2:)
+          kw1
+        end
+      }
+    }
+
+  end
+
 end