rdl 2.1.0 → 2.2.0

data/test/test_member.rb

@@ -1,6 +1,7 @@
 require 'minitest/autorun'
 $LOAD_PATH << File.dirname(__FILE__) + "/../lib"
 require 'rdl'
+RDL.reset
 
 class TestMember < Minitest::Test
   include RDL::Type
@@ -15,6 +16,7 @@ class TestMember < Minitest::Test
   end
 
   def setup
+    RDL.reset
     @tbasicobject = NominalType.new "BasicObject"
     @tsymfoo = SingletonType.new :foo
     @tarraystring = GenericType.new(RDL::Globals.types[:array], RDL::Globals.types[:string])
@@ -84,7 +86,7 @@ class TestMember < Minitest::Test
     assert (@tsymfoo.member? :foo)
     assert (not (@tsymfoo.member? :bar))
     assert (not (@tsymfoo.member? "foo"))
-    assert (not(@tsymfoo.member? nil)) # nil no longer subtype of other singletons
+    #assert (not(@tsymfoo.member? nil)) # nil no longer subtype of other singletons
   end
 
   def test_union_intersection

data/test/test_parser.rb

@@ -10,6 +10,7 @@ class TestParser < Minitest::Test
   class C; end
 
   def setup
+    RDL.reset
     @tintegeropt = OptionalType.new RDL::Globals.types[:integer]
     @tintegervararg = VarargType.new RDL::Globals.types[:integer]
     @tstringopt = OptionalType.new RDL::Globals.types[:string]
@@ -170,6 +171,10 @@ class TestParser < Minitest::Test
     tm1 = MethodType.new [], nil, RDL::Globals.types[:string]
     ts1 = StructuralType.new(to_str: tm1)
     assert_equal ts1, t1
+    t2 = tt "[[]: (String) -> %any]"
+    tm2 = MethodType.new [RDL::Globals.types[:string]], nil, RDL::Globals.special_types['%any']
+    ts2 = StructuralType.new(:[] => tm2)
+    assert_equal ts2, t2
   end
 
   def test_finite_hash

data/test/test_query.rb

@@ -6,6 +6,7 @@ class TestQuery < Minitest::Test
   include RDL::Type
 
   def setup
+    RDL.reset
     @p = Parser.new
     @tinteger = NominalType.new Integer
     @tarray = NominalType.new Array

data/test/test_rdl.rb

@@ -5,6 +5,10 @@ require 'rdl'
 class TestRDL < Minitest::Test
   extend RDL::Annotate
 
+  def setup
+    RDL.reset
+  end
+
   # Test wrapping with no types or contracts
   def test_wrap
     def m1(x) return x; end
@@ -239,27 +243,27 @@ RUBY
   end
 
   def test_wrap_new
-    self.class.class_eval "class B; def initialize(x); @x = x end; def get(); return @x end end"
-    RDL.pre("TestRDL::B", "self.new") { |x| x > 0 }
-    assert_equal 3, TestRDL::B.new(3).get
-    assert_raises(RDL::Contract::ContractError) { TestRDL::B.new(-3) }
+    self.class.class_eval "class WrapB; def initialize(x); @x = x end; def get(); return @x end end"
+    RDL.pre("TestRDL::WrapB", "self.new") { |x| x > 0 }
+    assert_equal 3, TestRDL::WrapB.new(3).get
+    assert_raises(RDL::Contract::ContractError) { TestRDL::WrapB.new(-3) }
 
-    self.class.class_eval "class C; extend RDL::Annotate; pre { |x| x > 0 }; def initialize(x); @x = x end; def get(); return @x end end"
-    assert_equal 3, TestRDL::C.new(3).get
-    assert_raises(RDL::Contract::ContractError) { TestRDL::C.new(-3) }
+    self.class.class_eval "class WrapC; extend RDL::Annotate; pre { |x| x > 0 }; def initialize(x); @x = x end; def get(); return @x end end"
+    assert_equal 3, TestRDL::WrapC.new(3).get
+    assert_raises(RDL::Contract::ContractError) { TestRDL::WrapC.new(-3) }
 
-    self.class.class_eval "class D; def get(); return @x end end"
-    RDL.pre("TestRDL::D", "self.new") { |x| x > 0 }
-    self.class.class_eval "class D; def initialize(x); @x = x end end"
-    assert_equal 3, TestRDL::D.new(3).get
-    assert_raises(RDL::Contract::ContractError) { TestRDL::D.new(-3) }
+    self.class.class_eval "class WrapD; def get(); return @x end end"
+    RDL.pre("TestRDL::WrapD", "self.new") { |x| x > 0 }
+    self.class.class_eval "class WrapD; def initialize(x); @x = x end end"
+    assert_equal 3, TestRDL::WrapD.new(3).get
+    assert_raises(RDL::Contract::ContractError) { TestRDL::WrapD.new(-3) }
 
     skip "Can't defer contracts on new yet"
     RDL.
-    pre("TestRDL::E", "self.new") { |x| x > 0 }
-    self.class.class_eval "class E; def initialize(x); @x = x end end"
-    assert (TestRDL::E.new(3))
-    assert_raises(RDL::Contract::ContractError) { TestRDL::E.new(-3) }
+    pre("TestRDL::WrapE", "self.new") { |x| x > 0 }
+    self.class.class_eval "class WrapE; def initialize(x); @x = x end end"
+    assert (TestRDL::WrapE.new(3))
+    assert_raises(RDL::Contract::ContractError) { TestRDL::WrapE.new(-3) }
   end
 
   def test_class_method
@@ -388,25 +392,56 @@ RUBY
     assert !(RDL::Globals.info.has? "TestRDL::TestVersion", "m4", :post)
   end
 
-  class TestRDLAnnotate
-    extend RDL::RDLAnnotate
-
-    rdl_pre { |x| x > 0 }
-    def m1(x) return x; end
-
-    rdl_post { |x| x < 0 }
-    def m2(x) return 3; end
+  def test_pre_rdl_annotate_contract
+    self.class.class_eval <<-RUBY, __FILE__, __LINE__
+      class TestRDLAnnotate
+        extend RDL::RDLAnnotate
 
-    rdl_type '(Integer) -> Integer'
-    def m3(x) return x; end
+        rdl_pre { |x| x > 0 }
+        def m1(x) return x; end
 
-  end
+        rdl_post { |x| x < 0 }
+        def m2(x) return 3; end
 
-  def test_pre_rdl_annotate_contract
+        rdl_type '(Integer) -> Integer'
+        def m3(x) return x; end
+    end
+RUBY
     assert_equal 3, TestRDLAnnotate.new.m1(3)
     assert_raises(RDL::Contract::ContractError) { TestRDLAnnotate.new.m1(-1) }
     assert_raises(RDL::Contract::ContractError) { TestRDLAnnotate.new.m2(42) }
     assert_raises(RDL::Type::TypeError) { TestRDLAnnotate.new.m3('one') }
   end
 
+  class TC0
+    def foo
+      's'
+    end
+
+    def bar
+      0
+    end
+  end
+
+  class TC1 < TC0
+    def foo
+      's'
+    end
+
+    def bar
+      0
+    end
+  end
+
+  def test_wrap_inheritance
+    RDL.type TC0, :foo, '() -> Integer', typecheck: :call
+    RDL.type TC0, :bar, '() -> Integer', typecheck: :call
+    RDL.type TC1, :foo, '() -> String', typecheck: :call
+    RDL.type TC1, :bar, '() -> String', typecheck: :call
+    assert_raises(RDL::Typecheck::StaticTypeError) { TC0.new.foo }
+    assert_equal 0, TC0.new.bar
+    assert_equal 's', TC1.new.foo
+    assert_raises(RDL::Typecheck::StaticTypeError) { TC1.new.bar }
+  end
+
 end

data/test/test_rdl_type.rb

@@ -5,6 +5,10 @@ require 'rdl'
 class TestRDLType < Minitest::Test
   extend RDL::Annotate
 
+  def setup
+    RDL.reset
+  end
+
   def test_single_type_contract
     def m1(x) return x; end
     RDL.type TestRDLType, :m1, "(Integer) -> Integer"

data/test/test_string_types.rb

@@ -0,0 +1,102 @@
+require 'minitest/autorun'
+$LOAD_PATH << File.dirname(__FILE__) + "/../lib"
+require 'rdl'
+require 'types/core'
+
+
+class TestStringTypes < Minitest::Test
+  extend RDL::Annotate
+
+  def setup
+    RDL.reset
+    RDL.readd_comp_types
+  end  
+
+  def test_string_methods
+    self.class.class_eval {
+
+      type '(String) -> "hello"', typecheck: :append_fail1
+      def append_fail_test1(x)
+        "he" << x
+      end
+
+      type '("hello") -> Integer', typecheck: :append_fail2
+      def append_fail_test2(x)
+        takes_hello(x)
+        x << 'blah'
+        1
+      end
+
+      
+      type "('he') -> 'hello'", typecheck: :now
+      def append_test1(x)
+        x << "llo"
+      end
+
+      type '(String) -> String', typecheck: :now
+      def append_test2(x)
+        "he" << x
+      end
+
+      type '("llo") -> String', typecheck: :now
+      def append_test3(x)
+        "he" << x
+      end
+
+      type :takes_hello, "('hello') -> Integer"
+
+      type '("he") -> Integer', typecheck: :now
+      def append_test4(y)
+        takes_hello(y << "llo")
+      end
+
+      type '("hello") -> "Hello"', typecheck: :now
+      def capitalize_test1(x)
+        x.capitalize
+      end
+
+      type '("hello") -> "Hello"', typecheck: :now
+      def capitalize_test2(x)
+        x.capitalize!
+      end
+
+      type '("hello") -> "o"', typecheck: :now
+      def access_test1(x)
+        x[4]
+      end
+
+      type '("he") -> "hello"', typecheck: :now
+      def concat_test1(x)
+        x + "llo"
+      end
+
+      type '("hello") -> 5', typecheck: :now
+      def size_test1(x)
+        x.size
+      end
+
+      type '(String) -> Integer', typecheck: :now
+      def size_test2(x)
+        x.size
+      end
+
+      type '(:world) -> "hello, world!"', typecheck: :now
+      def interp_test1(y)
+        "hello, #{y}!"
+      end
+
+      type '(Symbol) -> String', typecheck: :now
+      def interp_test2(y)
+        "hello, #{y}!"
+      end
+
+      type '("hi") -> "bye"', typecheck: :now
+      def replace_test1(x)
+        x.replace "bye"
+        x
+      end
+    }
+    assert_raises(RDL::Typecheck::StaticTypeError) { RDL.do_typecheck :append_fail1 }
+    assert_raises(RDL::Typecheck::StaticTypeError) { RDL.do_typecheck :append_fail2 }
+  end
+end

data/test/test_type_contract.rb

@@ -8,6 +8,7 @@ class TestTypeContract < Minitest::Test
   extend RDL::Annotate
 
   def setup
+    RDL.reset
     @p = Parser.new
   end
 
@@ -23,6 +24,28 @@ class TestTypeContract < Minitest::Test
   end
 
   def test_proc
+    self.class.class_eval <<-RUBY, __FILE__, __LINE__
+      type '(Integer) { (Integer) -> Integer } -> Integer'
+      def block_contract_test1(x)
+        x+yield(5)
+      end
+
+      type '(Integer) { (Integer) -> Integer } -> Float'
+      def block_contract_test2(x)
+        x+yield(4.5)
+      end
+
+      type '(Integer) -> Integer'
+      def block_contract_test3(x)
+        42
+      end
+
+      type '(Integer) ?{(Integer) -> Integer} -> Integer'
+      def block_contract_test4(x,&blk)
+        return yield(x) if blk
+        return x
+      end
+RUBY
     t1 = @p.scan_str "(nil) -> nil"
     p1 = t1.to_contract.wrap(self) { |x| nil }
     assert_nil p1.call(nil)
@@ -187,29 +210,6 @@ class TestTypeContract < Minitest::Test
     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 '(Integer) { (Integer) -> Integer } -> Integer'
-  def block_contract_test1(x)
-    x+yield(5)
-  end
-
-  type '(Integer) { (Integer) -> Integer } -> Float'
-  def block_contract_test2(x)
-    x+yield(4.5)
-  end
-
-  type '(Integer) -> Integer'
-  def block_contract_test3(x)
-    42
-  end
-
-  type '(Integer) ?{(Integer) -> Integer} -> Integer'
-  def block_contract_test4(x,&blk)
-    return yield(x) if blk
-    return x
   end
 
   def test_proc_names
@@ -298,23 +298,45 @@ class TestTypeContract < Minitest::Test
     assert_raises(TypeError) { p9.call(43, x: "foo", y: 44, pi: 3.14, e: 3) }
   end
 
-  type '() { () -> nil } -> nil'
-  def _test_with_block
-    nil
-  end
-
-  type '() -> nil'
-  def _test_without_block
-    nil
-  end
-
-  type '() -> nil'
-  type '() { () -> nil } -> nil'
-  def _test_with_without_block
-    nil
+  def test_initialize
+    self.class.class_eval <<-RUBY, __FILE__, __LINE__
+      class TestTypeContract_A
+        extend RDL::Annotate
+        type "(Integer) -> self"
+        def initialize(x)
+          x
+        end
+      end
+      class TestTypeContract_B
+        extend RDL::Annotate
+        type "(Integer) -> Integer"
+        def initialize(x)
+          x
+        end
+      end
+RUBY
+    assert TestTypeContract_A.new(1)
+    assert_raises(ArgumentError) { TestTypeContract_B.new(1) }
   end
 
   def test_block
+    self.class.class_eval <<-RUBY, __FILE__, __LINE__
+      type '() { () -> nil } -> nil'
+      def _test_with_block
+        nil
+      end
+
+      type '() -> nil'
+      def _test_without_block
+        nil
+      end
+
+      type '() -> nil'
+      type '() { () -> nil } -> nil'
+      def _test_with_without_block
+        nil
+      end
+RUBY
     assert_nil(_test_with_block { nil })
     assert_raises(TypeError) { _test_with_block }
 

data/test/test_typecheck.rb

@@ -67,10 +67,6 @@ end
 
 class TestTypecheckC
   extend RDL::Annotate
-  type 'self.bar', '() -> Integer or String ret'
-  type 'self.foo', '() -> :A'
-  type 'foo', '() -> Integer'
-  type '(Integer) -> self'
   def initialize(x); end
 end
 
@@ -79,7 +75,6 @@ end
 
 class TestTypecheckE
   extend RDL::Annotate
-  type '(Integer) -> self', typecheck: :einit
   def initialize(x)
     x
   end
@@ -87,7 +82,6 @@ end
 
 class TestTypecheckF
   extend RDL::Annotate
-  type '(Integer) -> F', typecheck: :finit
   def initialize(x)
     x
   end
@@ -95,7 +89,6 @@ end
 
 module TestTypecheckM
   extend RDL::Annotate
-  type 'self.foo', '() -> :B'
 end
 
 class TestTypecheckOuter
@@ -140,12 +133,67 @@ class MethodMissing2
   end
 end
 
+class SingletonInheritA
+  extend RDL::Annotate
+end
+
+class SingletonInheritB < SingletonInheritA; end
+
 
 class TestTypecheck < Minitest::Test
   extend RDL::Annotate
-  type :_any_object, "() -> Object" # a method that could return true or false
 
   def setup
+    RDL.reset
+    RDL.type TestTypecheck, :_any_object, '() -> Object', wrap: false # a method that could return true or false
+    RDL.readd_comp_types
+    RDL.type_params :Hash, [:k, :v], :all? unless RDL::Globals.type_params["Hash"]
+    RDL.type_params :Array, [:t], :all? unless RDL::Globals.type_params["Array"]
+    RDL.rdl_alias :Array, :size, :length 
+    RDL.type_params 'RDL::Type::SingletonType', [:t], :satisfies? unless RDL::Globals.type_params["RDL::Type::SingletonType"]
+=begin
+    RDL.type_params :Array, [:t], :all?
+    RDL.type :Array, :[]=, '(Integer, t) -> t', wrap: false
+    RDL.type :Array, :[]=, '(Integer, Integer, t) -> t', wrap: false
+    RDL.type :Array, :[]=, '(Range<Integer>, t) -> t', wrap: false
+    RDL.type :Array, :each, '() -> Enumerator<t>', wrap: false
+    RDL.type :Array, :each, '() { (t) -> %any } -> Array<t>', wrap: false
+    RDL.type :Array, :length, '() -> Integer', wrap: false
+    RDL.type :Array, :index, '(u) -> Integer', wrap: false
+    RDL.type :Array, :index, '() { (t) -> %bool } -> Integer', wrap: false
+    RDL.type :Array, :index, '() -> Enumerator<t>', wrap: false
+    RDL.type :Array, :map, '() {(t) -> u} -> Array<u>', wrap: false
+    RDL.type :Array, :map, '() -> Enumerator<t>', wrap: false
+    RDL.type_params :Hash, [:k, :v], :all?
+    RDL.type :Hash, :length, '() -> Integer', wrap: false
+    RDL.rdl_alias :Array, :size, :length
+    RDL.type :Hash, :[], '(k) -> v', wrap: false
+    RDL.type :Hash, :[]=, '(k, v) -> v', wrap: false
+=end
+    RDL.type_params(:Range, [:t], nil, variance: [:+]) { |t| t.member?(self.begin) && t.member?(self.end) } unless RDL::Globals.type_params["Range"]
+    RDL.type :Range, :each, '() { (t) -> %any } -> self'
+    RDL.type :Range, :each, '() -> Enumerator<t>'
+=begin
+    RDL.type :Integer, :<, '(Integer) -> %bool', wrap: false
+    RDL.type :Integer, :>, '(Integer) -> %bool', wrap: false
+    RDL.type :Integer, :>=, '(Integer) -> %bool', wrap: false
+    RDL.type :Integer, :+, '(Integer) -> Integer', wrap: false
+    RDL.type :Integer, :&, '(Integer) -> Integer', wrap: false
+    RDL.type :Integer, :*, '(Integer) -> Integer', wrap: false
+=end
+    RDL.type :Integer, :to_s, '() -> String', wrap: false
+    RDL.type :Kernel, 'self.puts', '(*[to_s : () -> String]) -> nil', wrap: false
+    RDL.type :Kernel, :raise, '() -> %bot', wrap: false
+    RDL.type :Kernel, :raise, '(String) -> %bot', wrap: false
+    RDL.type :Kernel, :raise, '(Class, ?String, ?Array<String>) -> %bot', wrap: false
+    RDL.type :Kernel, :raise, '(Exception, ?String, ?Array<String>) -> %bot', wrap: false
+    RDL.type :Object, :===, '(%any other) -> %bool', wrap: false
+    RDL.type :Object, :clone, '() -> self', wrap: false
+#    RDL.type :String, :*, '(Integer) -> String', wrap: false
+#    RDL.type :String, :+, '(String) -> String', wrap: false
+#    RDL.type :String, :===, '(%any) -> %bool', wrap: false
+#    RDL.type :String, :length, '() -> Integer', wrap: false
+    RDL.type :NilClass, :&, '(%any obj) -> false', wrap: false
     @t3 = RDL::Type::SingletonType.new 3
     @t4 = RDL::Type::SingletonType.new 4
     @t5 = RDL::Type::SingletonType.new 5
@@ -161,6 +209,8 @@ class TestTypecheck < Minitest::Test
     @scopef = { tret: RDL::Globals.types[:integer] }
     @tfs = RDL::Type::UnionType.new(RDL::Globals.types[:integer], RDL::Globals.types[:string])
     @scopefs = { tret: @tfs, tblock: nil }
+    ### Uncomment below to see test names. Useful for hanging tests.
+    #puts "Start #{@NAME}"
   end
 
   # [+ a +] is the environment, a map from symbols to types; empty if omitted
@@ -400,6 +450,20 @@ class TestTypecheck < Minitest::Test
     assert_equal t, do_tc("TestTypecheckOuter::A", env: @env)
     t = RDL::Type::SingletonType.new(TestTypecheckOuter::A::B::C)
     assert_equal t, do_tc("TestTypecheckOuter::A::B::C", env: @env)
+
+    self.class.class_eval {
+      const_set(:CONST_STRING, 'string')
+
+      type '() -> String', typecheck: :now
+      def const1() CONST_STRING; end
+    }
+
+    assert_raises(RDL::Typecheck::StaticTypeError) {
+      self.class.class_eval {
+        type '() -> Integer', typecheck: :now
+        def const2() CONST_STRING; end
+      }
+    }
   end
 
   def test_defined
@@ -505,33 +569,14 @@ class TestTypecheck < Minitest::Test
   end
 
   class A
-    extend RDL::Annotate
-    type :_send_inherit1, "() -> Integer"
   end
   class B < A
   end
 
-  class A1
-    extend RDL::Annotate
-    type "() -> nil"
-    def _send_inherit2; end
-  end
-  class A2 < A1
-    def _send_inherit2; end
-  end
-  class A3 < A2
-  end
-
-  def test_send_inherit
-    assert do_tc("B.new._send_inherit1", env: @env) <= RDL::Globals.types[:integer]
-    assert_raises(RDL::Typecheck::StaticTypeError) { do_tc("A3.new._send_inherit2", env: @env) }
-  end
-
   def test_send_inter
-    self.class.class_eval {
-      type :_send_inter1, "(Integer) -> Integer"
-      type :_send_inter1, "(String) -> String"
-    }
+    RDL.type A, :_send_inherit1, "() -> Integer", wrap: false
+    RDL.type TestTypecheck, :_send_inter1, "(Integer) -> Integer", wrap: false
+    RDL.type TestTypecheck, :_send_inter1, "(String) -> String", wrap: false
     assert do_tc("_send_inter1(42)", env: @env) <= RDL::Globals.types[:integer]
     assert do_tc("_send_inter1('42')", env: @env) <= RDL::Globals.types[:string]
 
@@ -540,15 +585,13 @@ class TestTypecheck < Minitest::Test
 
   def test_send_opt_varargs
     # from test_type_contract.rb
-    self.class.class_eval {
-      type :_send_opt_varargs1, "(Integer, ?Integer) -> Integer"
-      type :_send_opt_varargs2, "(Integer, *Integer) -> Integer"
-      type :_send_opt_varargs3, "(Integer, ?Integer, ?Integer, *Integer) -> Integer"
-      type :_send_opt_varargs4, "(?Integer) -> Integer"
-      type :_send_opt_varargs5, "(*Integer) -> Integer"
-      type :_send_opt_varargs6, "(?Integer, String) -> Integer"
-      type :_send_opt_varargs7, "(Integer, *String, Integer) -> Integer"
-    }
+    RDL.type TestTypecheck, :_send_opt_varargs1, "(Integer, ?Integer) -> Integer", wrap: false
+    RDL.type TestTypecheck, :_send_opt_varargs2, "(Integer, *Integer) -> Integer", wrap: false
+    RDL.type TestTypecheck, :_send_opt_varargs3, "(Integer, ?Integer, ?Integer, *Integer) -> Integer", wrap: false
+    RDL.type TestTypecheck, :_send_opt_varargs4, "(?Integer) -> Integer", wrap: false
+    RDL.type TestTypecheck, :_send_opt_varargs5, "(*Integer) -> Integer", wrap: false
+    RDL.type TestTypecheck, :_send_opt_varargs6, "(?Integer, String) -> Integer", wrap: false
+    RDL.type TestTypecheck, :_send_opt_varargs7, "(Integer, *String, Integer) -> Integer", wrap: false
     assert do_tc("_send_opt_varargs1(42)", env: @env) <= RDL::Globals.types[:integer]
     assert do_tc("_send_opt_varargs1(42, 43)", env: @env) <= RDL::Globals.types[:integer]
     assert_raises(RDL::Typecheck::StaticTypeError) { assert do_tc("_send_opt_varargs1()", env: @env) }
@@ -679,7 +722,7 @@ class TestTypecheck < Minitest::Test
   end
 
   def test_send_singleton
-    RDL.type Integer, :_send_singleton, "() -> String"
+    RDL.type Integer, :_send_singleton, "() -> String", wrap: false
     assert do_tc("3._send_singleton", env: @env) <= RDL::Globals.types[:string]
     assert_raises(RDL::Typecheck::StaticTypeError) { do_tc("3._send_singleton_nexists", env: @env) }
   end
@@ -696,10 +739,8 @@ class TestTypecheck < Minitest::Test
   end
 
   def test_send_block
-    self.class.class_eval {
-      type :_send_block1, "(Integer) { (Integer) -> Integer } -> Integer"
-      type :_send_block2, "(Integer) -> Integer"
-    }
+    RDL.type TestTypecheck, :_send_block1, "(Integer) { (Integer) -> Integer } -> Integer"
+    RDL.type TestTypecheck, :_send_block2, "(Integer) -> Integer"
     assert_raises(RDL::Typecheck::StaticTypeError) { do_tc("_send_block1(42)", env: @env) }
     assert_raises(RDL::Typecheck::StaticTypeError) { do_tc("_send_block2(42) { |x| x + 1 }", env: @env) }
     assert_raises(RDL::Typecheck::StaticTypeError) { do_tc("_send_block1(42) { |x, y| x + y }", env: @env) }
@@ -733,7 +774,7 @@ class TestTypecheck < Minitest::Test
       type :_send_method_generic4, '(t) { (t) -> t } -> t'
       type :_send_method_generic5, '() { (u) -> u } -> u'
       type :_send_method_generic6, '() { (Integer) -> u } -> u'
-    }
+    }    
     assert do_tc('_send_method_generic1 3', env: @env) <= @t3
     assert do_tc('_send_method_generic1 "foo"', env: @env) <= RDL::Globals.types[:string]
     assert do_tc('_send_method_generic2 3, "foo"', env: @env) <= tt("3 or String")
@@ -912,7 +953,7 @@ class TestTypecheck < Minitest::Test
   # end
 
   def test_new
-    assert do_tc("B.new", env: @env) <= RDL::Type::NominalType.new(B)
+    assert do_tc("B.new", env: @env) <= RDL::Type::NominalType.new(TestTypecheck::B)
     assert_raises(RDL::Typecheck::StaticTypeError) { do_tc("B.new(3)", env: @env) }
   end
 
@@ -961,16 +1002,14 @@ class TestTypecheck < Minitest::Test
   end
 
   class C
-    extend RDL::Annotate
-    type :===, "(Object) -> %bool"
   end
 
   class D
-    extend RDL::Annotate
-    type :===, "(String) -> %bool"
   end
 
   def test_when
+    RDL.type C, :===, "(Object) -> %bool"
+    RDL.type D, :===, "(String) -> %bool"
     assert do_tc("case when C.new then 3 end", env: @env) <= @t3
     assert do_tc("x = 4; case when _any_object then x = 3 end; x", env: @env) <= @t34
     assert do_tc("case when _any_object then 3 else 'foo' end", env: @env) <= @ts3
@@ -998,6 +1037,7 @@ class TestTypecheck < Minitest::Test
     assert do_tc("until false do end") <= RDL::Globals.types[:nil]
     assert do_tc("begin end while true") <= RDL::Globals.types[:nil]
     assert do_tc("begin end until false") <= RDL::Globals.types[:nil]
+
     assert do_tc("i = 0; while i < 5 do i = 1 + i end; i") <= RDL::Globals.types[:integer]
     assert do_tc("i = 0; while i < 5 do i = i + 1 end; i") <= RDL::Globals.types[:integer]
     assert do_tc("i = 0; until i >= 5 do i = 1 + i end; i") <= RDL::Globals.types[:integer]
@@ -1008,10 +1048,10 @@ class TestTypecheck < Minitest::Test
     assert do_tc("i = 0; begin i = i + 1 end until i >= 5; i") <= RDL::Globals.types[:integer]
 
     # break, redo, next, no args
-    assert do_tc("i = 0; while i < 5 do if i > 2 then break end; i = 1 + i end; i") <= RDL::Globals.types[:integer]
-    assert do_tc("i = 0; while i < 5 do break end; i") <= tt("0")
-    assert do_tc("i = 0; while i < 5 do redo end; i") # infinite loop, ok for typing <= tt("0")
-    assert do_tc("i = 0; while i < 5 do next end; i") # infinite loop, ok for typing <= tt("0")
+#    assert do_tc("i = 0; while i < 5 do if i > 2 then break end; i = 1 + i end; i") <= RDL::Globals.types[:integer]
+#    assert do_tc("i = 0; while i < 5 do break end; i") <= tt("0")
+#    assert do_tc("i = 0; while i < 5 do redo end; i") # infinite loop, ok for typing <= tt("0")
+#     assert do_tc("i = 0; while i < 5 do next end; i") # infinite loop, ok for typing <= tt("0")
     assert_raises(RDL::Typecheck::StaticTypeError) { do_tc("i = 0; while i < 5 do retry end; i") }
     assert do_tc("i = 0; begin i = i + 1; break if i > 2; end while i < 5; i") <= RDL::Globals.types[:integer]
     assert do_tc("i = 0; begin i = i + 1; redo if i > 2; end while i < 5; i") <= RDL::Globals.types[:integer]
@@ -1023,16 +1063,21 @@ class TestTypecheck < Minitest::Test
     assert_raises(RDL::Typecheck::StaticTypeError) { do_tc("while _any_object do next 3 end", env: @env) }
     assert do_tc("begin break 3 end while _any_object", env: @env) <= @t3n
     assert_raises(RDL::Typecheck::StaticTypeError) { do_tc("begin next 3 end while _any_object", env: @env) }
+
   end
 
   def test_for
     assert do_tc("for i in 1..5 do end; i") <= RDL::Globals.types[:integer]
     assert do_tc("for i in [1,2,3,4,5] do end; i") <= tt("1 or 2 or 3 or 4 or 5")
+    ## TODO: figure out why above fails to terminate
     assert do_tc("for i in 1..5 do break end", env: @env) <= tt("Range<Integer>")
     assert do_tc("for i in 1..5 do next end", env: @env) <= tt("Range<Integer>")
     assert do_tc("for i in 1..5 do redo end", env: @env) <= tt("Range<Integer>") #infinite loop, ok for typing
     assert do_tc("for i in 1..5 do break 3 end", env: @env) <= tt("Range<Integer> or 3")
-    assert do_tc("for i in 1..5 do next 'three' end; i", env: @env) <= @tfs
+    #assert do_tc("for i in 1..5 do next 'three' end; i", env: @env) <= @tfs
+    ## Commented out above after implementing PreciseStringType. It no longer holds because 'three'
+    ## gets upper bound(s) of 'three', but then is promote!-ed to be compared to String, and because
+    ## String is not <= 'three', the previous bounds do not hold and this case fails.
   end
 
   def test_return
@@ -1060,12 +1105,11 @@ class TestTypecheck < Minitest::Test
   end
 
   class E
-    extend RDL::Annotate
-    type :f, '() -> Integer'
-    type :f=, '(Integer) -> nil'
   end
 
   def test_op_asgn
+    RDL.type E, :f, '() -> Integer', wrap: false
+    RDL.type E, :f=, '(Integer) -> nil', wrap: false
     assert RDL::Globals.types[:integer], do_tc("x = 0; x += 1")
     assert_raises(RDL::Typecheck::StaticTypeError) { do_tc("x += 1") }
     assert_raises(RDL::Typecheck::StaticTypeError) { do_tc("x = Object.new; x += 1", env: @env) }
@@ -1075,9 +1119,12 @@ class TestTypecheck < Minitest::Test
   end
 
   def test_and_or_asgn
+    RDL.type E, :f, '() -> Integer', wrap: false
+    RDL.type E, :f=, '(Integer) -> nil', wrap: false
     self.class.class_eval {
       var_type :@f_and_or_asgn, "Integer"
     }
+    RDL.type TestTypecheckE, :initialize, '(Integer) -> self', wrap: false, typecheck: :einit
     assert do_tc("x ||= 3") <= @t3 # weird
     assert do_tc("x &&= 3") <= RDL::Globals.types[:nil] # weirder
     assert do_tc("@f_and_or_asgn &&= 4", env: @env) <= RDL::Globals.types[:integer]
@@ -1088,6 +1135,8 @@ class TestTypecheck < Minitest::Test
   end
 
   def test_masgn
+    RDL.type E, :f, '() -> Integer', wrap: false
+    RDL.type E, :f=, '(Integer) -> nil', wrap: false
     self.class.class_eval {
       var_type :@f_masgn, "Array<Integer>"
     }
@@ -1101,7 +1150,8 @@ class TestTypecheck < Minitest::Test
     assert do_tc("a, b = 3, 'two'; b") <= RDL::Globals.types[:string]
     assert do_tc("a = [3, 'two']; x, y = a; x") <= @t3
     assert do_tc("a = [3, 'two']; x, y = a; y") <= RDL::Globals.types[:string]
-    assert_raises(RDL::Typecheck::StaticTypeError) { do_tc("a = [3, 'two']; x, y = a; a.length", env: @env) }
+    #assert_raises(RDL::Typecheck::StaticTypeError) { do_tc("a = [3, 'two']; x, y = a; a.length", env: @env) }
+    ## the above works after computational type changes
 
     # w/send
     assert do_tc("e = E.new; e.f, b = 1, 2; b", env: @env) <= tt("2")
@@ -1154,9 +1204,14 @@ class TestTypecheck < Minitest::Test
     assert do_tc("RDL.type_cast(1 + 2, 'Integer', force: :blah)", env: @env) <= RDL::Globals.types[:integer]
     assert_raises(RDL::Typecheck::StaticTypeError) { do_tc("RDL.type_cast(1 + 2, 'Integer', forc: true)", env: @env) }
     assert_raises(RDL::Typecheck::StaticTypeError) { do_tc("RDL.type_cast(1 + 2, 'Fluffy Bunny')") }
+    assert_raises(RDL::Typecheck::StaticTypeError) { do_tc("RDL.type_cast(:nonsense + 2, 'Integer')") }
+    assert do_tc("RDL.type_cast(RDL.type_cast(:nonsense, 'Integer') + 2, 'Integer')")
   end
 
   def test_instantiate
+    RDL.type :Array, :initialize, '() -> self', wrap: false
+    RDL.type :Array, :initialize, '(Integer) -> self', wrap: false
+    RDL.type :Array, :initialize, '(Integer, t) -> self<t>', wrap: false
     assert_raises(RDL::Typecheck::StaticTypeError) {
       self.class.class_eval {
         type "(Integer, Integer) -> Array<Integer>", typecheck: :now
@@ -1169,18 +1224,26 @@ class TestTypecheck < Minitest::Test
         def def_inst_pass(x, y) a = Array.new(x,y); RDL.instantiate!(a, "Integer"); a; end
       }
     )
-    assert_raises(RDL::Typecheck::StaticTypeError) {
+
+    # below works with computational types
+    #assert_raises(RDL::Typecheck::StaticTypeError) {
+    assert (
       self.class.class_eval {
         type "(Integer) -> Integer", typecheck: :now
         def def_inst_hash_fail(x) hash = {}; hash["test"] = x; hash["test"]; end
       }
-    }
+    )
+#     }
+
+=begin
+   # below works with computational types
     assert_raises(RDL::Typecheck::StaticTypeError) {
       self.class.class_eval {
         type "(Integer) -> Integer", typecheck: :now
         def def_inst_hash_fail2(x) hash = {}; hash.instantiate("Integer", "String") ; hash["test"] = x; hash["test"]; end
       }
     }
+=end
     assert(
       self.class.class_eval {
         type "(Integer) -> Integer", typecheck: :now
@@ -1203,11 +1266,11 @@ class TestTypecheck < Minitest::Test
   end
 
   def test_rescue_ensure
+
     assert do_tc("begin 3; rescue; 4; end") <= @t3 # rescue clause can never be executed
     assert do_tc("begin puts 'foo'; 3; rescue; 4; end", env: @env) <= @t34
     assert do_tc("begin puts 'foo'; 3; rescue => e; e; end", env: @env) <= tt("StandardError or 3")
     assert do_tc("begin puts 'foo'; 3; rescue RuntimeError => e; e; end", env: @env) <= tt("RuntimeError or 3")
-    assert do_tc("begin puts 'foo'; 3; else; 4; end", env: @env) <= tt("4") # parser discards else clause!
     assert do_tc("begin puts 'foo'; 3; rescue RuntimeError => e; e; rescue ArgumentError => x; x; end", env: @env) <= tt("RuntimeError or ArgumentError or 3")
     assert do_tc("begin puts 'foo'; 3; rescue RuntimeError => e; e; rescue ArgumentError => x; x; else 42; end", env: @env) <= tt("RuntimeError or ArgumentError or 42 or 3")
     assert do_tc("begin puts 'foo'; 3; rescue RuntimeError, ArgumentError => e; e; end", env: @env) <= tt("RuntimeError or ArgumentError or 3")
@@ -1216,6 +1279,7 @@ class TestTypecheck < Minitest::Test
     assert do_tc("begin x = 3; ensure x = 4; end; x", env: @env) <= @t4
     assert do_tc("begin puts 'foo'; x = 3; rescue; x = 4; ensure x = 5; end; x", env: @env) <= @t5
     assert do_tc("begin puts 'foo'; 3; rescue; 4; ensure 5; end", env: @env) <= @t34
+
   end
 
   class SubArray < Array
@@ -1225,11 +1289,9 @@ class TestTypecheck < Minitest::Test
   end
 
   def test_array_splat
-    self.class.class_eval {
-      type :_splataf, "() -> Array<Integer>"
-      type :_splatas, "() -> Array<String>"
-      type :_splathsf, "() -> Hash<Symbol, Integer>"
-    }
+    RDL.type TestTypecheck, :_splataf, "() -> Array<Integer>", wrap: false
+    RDL.type TestTypecheck, :_splatas, "() -> Array<String>", wrap: false
+    RDL.type TestTypecheck, :_splathsf, "() -> Hash<Symbol, Integer>", wrap: false
     assert do_tc("x = *1") <= tt("[1]")
     assert do_tc("x = [1, *2, 3]") <= tt("[1, 2, 3]")
     assert_raises(RDL::Typecheck::StaticTypeError) { do_tc("x = [1, *Object.new, 3]", env: @env) } # the Object might or might not be an array...
@@ -1248,9 +1310,11 @@ class TestTypecheck < Minitest::Test
     assert do_tc("x = *{a: 1, b: 2, c: 3}") <= tt("[[:a, 1], [:b, 2], [:c, 3]]")
     assert do_tc("x = [1, *{a: 2}, 3]") <= tt("[1, [:a, 2], 3]")
     assert do_tc("y = [2]; x = [1, *y, 3]; ") <= tt("[1, 2, 3]")
-    assert_raises(RDL::Typecheck::StaticTypeError) { do_tc("y = [2]; x = [1, *y, 3]; y.length") }
+    #assert_raises(RDL::Typecheck::StaticTypeError) { do_tc("y = [2]; x = [1, *y, 3]; y.length") }
+    # the above works after computational type changes
     assert do_tc("y = {a: 2}; x = [1, *y, 3]") <= tt("[1, [:a, 2], 3]")
-    assert_raises(RDL::Typecheck::StaticTypeError) { do_tc("y = {a: 2}; x = [1, *y, 3]; y.length") }
+    #assert_raises(RDL::Typecheck::StaticTypeError) { do_tc("y = {a: 2}; x = [1, *y, 3]; y.length") }
+    # the above works after computational type changes
 
     assert do_tc("x = *_splataf", env: @env) <= tt("Array<Integer>")
     assert do_tc("x = [1, *_splataf, 2]", env: @env) <= tt("Array<Integer>")
@@ -1275,7 +1339,8 @@ class TestTypecheck < Minitest::Test
     assert do_tc("x = {**{a: 1}, b: 2, **{c: 3}}") <= tt("{a: 1, b: 2, c: 3}")
     assert_raises(RDL::Typecheck::StaticTypeError) { do_tc("x = {a: 1, **Object.new}", env: @env) } # may or may not be hash
     assert_raises(RDL::Typecheck::StaticTypeError) { do_tc("x = {a: 1, **SubHash.new}", env: @env) } # is a how, but unclear how to splat
-    assert_raises(RDL::Typecheck::StaticTypeError) { do_tc("y = {b: 2}; x = {a: 1, **y}; y.length") }
+    #assert_raises(RDL::Typecheck::StaticTypeError) { do_tc("y = {b: 2}; x = {a: 1, **y}; y.length") }
+    # the above works after computational type changes
 
     assert do_tc("x = {**_kwsplathsf}", env: @env) <= tt("Hash<Symbol, Integer>")
     assert do_tc("x = {**_kwsplathsf, **_kwsplathos}", env: @env) <= tt("Hash<Symbol or Float, Integer or String>")
@@ -1403,6 +1468,22 @@ class TestTypecheck < Minitest::Test
       end
     }
 
+    self.class.class_eval {
+      type '(?Integer x) -> Integer', typecheck: :now
+      def _optional_varargs_mapping9(x=42)
+        x
+      end
+    }
+
+    assert_raises(RDL::Typecheck::StaticTypeError) {
+      self.class.class_eval {
+        type '(?Integer x) -> Integer', typecheck: :now
+        def _optional_varargs_mapping10(x='hi')
+          x
+        end
+      }
+    }
+
   end
 
   def test_kw_mapping
@@ -1508,6 +1589,7 @@ class TestTypecheck < Minitest::Test
 
   def test_class_call
     TestTypecheckE.class_eval {
+      type :initialize, '(Integer) -> self', wrap: false
       type '(Integer) -> Class', typecheck: :now
       def call_class1(x)
         x.class
@@ -1526,19 +1608,32 @@ class TestTypecheck < Minitest::Test
   end
 
   def test_singleton
+    TestTypecheckC.class_eval {
+      type :'self.foo', '() -> :A'
+    }
+    TestTypecheckM.class_eval {
+      type :'self.foo', '() -> :B'
+    }
     assert_equal ':A', do_tc("TestTypecheckC.foo", env: @env).to_s
     assert_equal ':B', do_tc("TestTypecheckM.foo", env: @env).to_s
   end
 
   def test_annotated_ret
+    TestTypecheckC.class_eval {
+      type 'self.bar', '() -> Integer or String ret'
+    }
     assert do_tc("TestTypecheckC.bar", env: @env) <= tt('Integer or String')
   end
 
   def test_constructor
+    RDL.type TestTypecheckC, :'self.bar', '() -> Integer or String ret'
+    RDL.type TestTypecheckC, :'self.foo', '() -> :A'
+    RDL.type TestTypecheckC, :foo, '() -> Integer'
+    RDL.type TestTypecheckC, :initialize, '(Integer) -> self'
+    RDL.type TestTypecheckF, :initialize, '(Integer) -> F', typecheck: :finit
     t = do_tc("TestTypecheckC.new(1)", env: @env)
     assert_equal 'TestTypecheckC', t.to_s
 
-
     assert_raises(RDL::Typecheck::StaticTypeError) {
       self.class.class_eval {
         type '(Integer) -> Integer', typecheck: :now
@@ -1583,6 +1678,80 @@ class TestTypecheck < Minitest::Test
     }
   end
 
+  def test_dyn
+    # any method call on %dyn type return %dyn
+    self.class.class_eval {
+      type "(%dyn) -> %dyn", typecheck: :now
+      def self.do_add(x); x + 1; end
+    }
+
+    # any method can return a %dyn type
+    self.class.class_eval {
+      type "() -> %dyn", typecheck: :now
+      def self.ret_dyn; "blah"; end
+    }
+
+    # somewhat larger program
+    self.class.class_eval {
+      def inc(x); x + 1; end
+      def use_val; v = get_val; inc(v); end
+      def get_val; return "blah"; end
+
+      type :inc, '(Integer) -> Integer', typecheck: :dyntest
+      type :use_val, '() -> Integer', typecheck: :dyntest
+      type :get_val, '() -> %dyn', typecheck: :dyntest
+
+      RDL.do_typecheck :dyntest
+    }
+  end
+
+  def test_assume_dynamic
+    RDL.config { |config| config.assume_dyn_type = true }
+
+    dynamic = do_tc('unknown', env: @env)
+    assert dynamic <= tt('Integer')
+    assert tt('Integer') <= dynamic
+    assert dynamic <= tt('Array<Integer>')
+    assert tt('Array<Integer>') <= dynamic
+
+    tuple_of_dynamic = do_tc('[unknown]', env: @env)
+    refute tuple_of_dynamic <= tt('Integer')
+    assert tuple_of_dynamic <= tt('[Integer]')
+    refute tt('Integer') <= tuple_of_dynamic
+    assert tt('[Integer]') <= tuple_of_dynamic
+
+    assert_equal(dynamic, do_tc('unknown.unknown', env: @env))
+    assert_equal(dynamic, do_tc('a,b = unknown', env: @env))
+    assert_equal(dynamic, do_tc('(a,b = unknown).unknown', env: @env))
+    assert_equal(dynamic, do_tc('unknown[1]', env: @env))
+
+    self.class.class_eval {
+      type "() -> String", typecheck: :now
+      def dynamic_1()
+        unknown
+      end
+      type "() -> Array<Integer>", typecheck: :now
+      def dynamic_2()
+        unknown(unknown)
+      end
+      type "() -> %bot", typecheck: :now
+      def dynamic_3()
+        unknown(3)
+      end
+    }
+
+    RDL.config { |config| config.assume_dyn_type = false }
+
+    assert_raises(RDL::Typecheck::StaticTypeError) {
+      self.class.class_eval {
+        type "() -> String", typecheck: :now
+        def dynamic_4()
+          unknown
+        end
+      }
+    }
+  end
+
   def test_method_missing
     skip "method_missing not supported yet"
     RDL.do_typecheck :later_mm1
@@ -1616,8 +1785,8 @@ class TestTypecheck < Minitest::Test
       def bar(x); 1 + x; end
       def baz(x); 1 + x; end
       type 'self.foo', '() -> :a0'
-      type 'bar', '(Fixnum) -> Fixnum'
-      type 'baz', '(Fixnum) -> Fixnum'
+      type 'bar', '(Integer) -> Integer'
+      type 'baz', '(Integer) -> Integer'
     end
     TestTypecheck::SA1.class_eval do
       extend RDL::Annotate
@@ -1625,8 +1794,8 @@ class TestTypecheck < Minitest::Test
       def bar(x); super(x); end
       def baz(x); super; end
       type 'self.foo', '() -> :a0', typecheck: :call
-      type :bar, '(Fixnum) -> Fixnum', typecheck: :call
-      type :baz, '(Fixnum) -> Fixnum', typecheck: :call
+      type :bar, '(Integer) -> Integer', typecheck: :call
+      type :baz, '(Integer) -> Integer', typecheck: :call
     end
 
     r = TestTypecheck::SA1.foo
@@ -1655,4 +1824,240 @@ class TestTypecheck < Minitest::Test
 
     assert_nil TestTypecheck::A5.new.foo(:a)
   end
+
+  module ModuleNesting
+    module Foo
+      extend RDL::Annotate
+      MYFOO = 'foo'
+      type '() -> String', :typecheck => :call
+      def self.foo
+        MYFOO
+      end
+    end
+    module Bar
+      extend RDL::Annotate
+      type '() -> NilClass', :typecheck => :call
+      def self.bar
+        TestTypecheck::ModuleNesting::Foo.foo
+        Foo.foo
+        Foo::MYFOO
+        nil
+      end
+    end
+    class Baz
+      extend RDL::Annotate
+      type '() -> NilClass', :typecheck => :call
+      def self.baz
+        TestTypecheck::ModuleNesting::Foo.foo
+        Foo.foo
+        Foo::MYFOO
+        nil
+      end
+      type '() -> NilClass', :typecheck => :call
+      def baz
+        TestTypecheck::ModuleNesting::Foo.foo
+        Foo.foo
+        Foo::MYFOO
+        nil
+      end
+    end
+
+    class Parent
+      MY_CONST = 'foo'
+    end
+    module Mixin
+      MY_MIXIN_CONST = 'bar'
+    end
+    class Child < Parent
+      include Mixin
+      extend RDL::Annotate
+      type '() -> String', :typecheck => :call
+      def self.no_context
+        MY_CONST
+      end
+      type '() -> String', :typecheck => :call
+      def self.parent_context
+        Parent::MY_CONST
+      end
+      type '() -> String', :typecheck => :call
+      def self.mixin
+        MY_MIXIN_CONST
+      end
+    end
+  end
+
+  def test_module_nesting
+    assert_nil ModuleNesting::Bar.bar
+    assert_nil ModuleNesting::Baz.baz
+    assert_nil ModuleNesting::Baz.new.baz
+    assert_equal 'foo', ModuleNesting::Child.no_context
+    assert_equal 'foo', ModuleNesting::Child.parent_context
+    assert_equal 'bar', ModuleNesting::Child.mixin
+  end
+
+  def test_module_fully_qualfieds_calls
+    self.class.class_eval "module FullyQualfied; end"
+    FullyQualfied.class_eval do
+      extend RDL::Annotate
+      type '() -> nil', :typecheck => :call
+      def self.foo
+        TestTypecheck::FullyQualfied.bar
+      end
+      type '() -> nil', :typecheck => :call
+      def self.bar
+      end
+    end
+
+    assert_nil FullyQualfied.foo
+  end
+
+  def test_grandparent_with_type
+    self.class.class_eval "class GrandParentWithType; end"
+    self.class.class_eval "class ParentWithoutType < GrandParentWithType; end"
+    self.class.class_eval "class ChildWithoutType < ParentWithoutType; end"
+    GrandParentWithType.class_eval do
+      extend RDL::Annotate
+      type '(Integer) -> nil', typecheck: :call
+      def foo(x); end
+    end
+
+    ParentWithoutType.class_eval do
+      def foo(x); end
+    end
+
+    ChildWithoutType.class_eval do
+      def foo(x); end
+    end
+
+    assert_nil ChildWithoutType.new.foo(1)
+  end
+
+  def test_object_sing_method
+    assert_raises(RDL::Typecheck::StaticTypeError) {
+      Object.class_eval do
+        extend RDL::Annotate
+        type '(Integer) -> String', typecheck: :now
+        def self.add_one(x)
+          x+1
+        end
+      end
+    }
+  end
+
+  def test_raise_typechecks
+    self.class.class_eval "module RaiseTypechecks; end"
+    RaiseTypechecks.class_eval do
+      extend RDL::Annotate
+      type '() -> nil', :typecheck => :call
+      def self.foo
+        raise "strings are good"
+      end
+
+      type '() -> nil', :typecheck => :call
+      def self.bar
+        raise RuntimeError.new, "so are two-args"
+      end
+
+      type '() -> nil', :typecheck => :call
+      def self.baz
+        raise RuntimeError, "and just class is ok"
+      end
+    end
+
+    assert_raises(RuntimeError) do
+      RaiseTypechecks.foo
+    end
+    assert_raises(RuntimeError) do
+      RaiseTypechecks.bar
+    end
+    assert_raises(RuntimeError) do
+      RaiseTypechecks.baz
+    end
+  end
+
+  
+  def test_sing_method_inheritence
+    RDL.type SingletonInheritA, 'self.foo', '(Integer) -> Integer'
+    self.class.class_eval do
+      type '(Integer) -> Integer', typecheck: :now
+      def calls_inherited_sing_meth(x)
+        SingletonInheritB.foo(x)
+      end
+    end
+  end
+
+
+  def test_comp_types
+    self.class.class_eval "class CompTypes; end"
+    CompTypes.class_eval do
+      ### Tests where return type is computed
+      extend RDL::Annotate
+      type :bar, '(Integer or String) -> ``gen_return_type(targs)``'
+      def self.gen_return_type(targs)
+        raise RDL::Typecheck::StaticTypeError, "Unexpected number of arguments to bar." unless targs.size == 1
+        if targs[0] == RDL::Globals.types[:integer]
+          return RDL::Globals.types[:string]
+        elsif targs[0] == RDL::Globals.types[:string]
+          return RDL::Globals.types[:integer]
+        else
+          raise RDL::Typecheck::StaticTypeError, "Unexpected input type."
+        end
+      end
+
+      type '(Integer) -> String', typecheck: :now
+      def uses_bar1(x)
+        bar(x)
+      end
+
+      type '(String) -> Integer', typecheck: :now
+      def uses_bar2(x)
+        bar(x)
+      end
+    end
+
+    assert_raises(RDL::Typecheck::StaticTypeError) {
+      CompTypes.class_eval do
+          type '(String) -> String', typecheck: :now
+          def uses_bar3(x)
+            bar(x)
+          end
+      end
+    }
+
+    CompTypes.class_eval do
+      ### Tests where input type is computed
+      type :baz, '(Integer or String, ``gen_input_type(targs)``) -> Integer'
+
+      def self.gen_input_type(targs)
+        raise RDL::Typecheck::StaticTypeError, "Unexpected number of arguments to bar." unless targs.size == 2
+        if targs[0] == RDL::Globals.types[:integer]
+          return RDL::Globals.types[:string]
+        elsif targs[0] == RDL::Globals.types[:string]
+          return RDL::Globals.types[:integer]
+        else
+          raise RDL::Typecheck::StaticTypeError, "Unexpected input type."
+        end    
+      end
+
+      type '(Integer, String) -> Integer', typecheck: :now
+      def uses_baz1(x, y)
+        baz(x, y)
+      end
+
+      type '(String, Integer) -> Integer', typecheck: :now
+      def uses_baz2(x, y)
+        baz(x, y)
+      end
+    end
+
+    assert_raises(RDL::Typecheck::StaticTypeError) {
+      CompTypes.class_eval do
+        type '(Integer, Integer) -> Integer', typecheck: :now
+        def uses_baz3(x, y)
+          baz(x, y)
+        end
+      end
+    }
+
+  end
 end