rdl 1.1.0 → 1.1.1.rc1

data/lib/rdl/types/tuple.rb

@@ -61,7 +61,7 @@ module RDL::Type
     end
 
     def hash
-      h = 73 * @params.hash
+      73 * @params.hash
     end
   end
 end

data/lib/rdl/types/type_inferencer.rb

@@ -20,14 +20,14 @@ module RDL
     end
 
     private
-    
+
     def self.extract_types(param_type)
       param_type.instance_of?(RDL::Type::UnionType) ? param_type.types.to_a : [param_type]
     end
-    
+
     # Unifies i.e. #<Set: {Array<String>, Array<Array<String>>}> into
     # Array<(Array<String> or String)>
-    # If this step is not called, then infer_type for 
+    # If this step is not called, then infer_type for
     # [["a", "b"], [["c"]]].rdl_type would return
     # (Array<Array<String>> or Array<String>) instead of
     # (Array<(Array<String> or String)>)
@@ -49,7 +49,7 @@ module RDL
           type_parameters = cls.instance_variable_get :@__cls_params
           ((0..(type_parameters.size - 1)).map {|tparam_index|
              extract_types(member_type.params[tparam_index])
-           }).each_with_index {|type_parameter,index|            
+           }).each_with_index {|type_parameter,index|
             tparam_set[index]+=type_parameter
           }
 
@@ -59,12 +59,12 @@ module RDL
         end
       }
 
-      parameterized_classes.each {|nominal, type_set|
-        t = type_set.map {|unioned_type_parameter|
+      parameterized_classes.each {|nominal, ts|
+        nt = ts.map {|unioned_type_parameter|
           RDL::Type::UnionType.new(*unify_param_types(unioned_type_parameter))
         }
 
-        non_param_classes << RDL::Type::GenericType.new(nominal, *t)
+        non_param_classes << RDL::Type::GenericType.new(nominal, *nt)
       }
 
       non_param_classes

data/lib/rdl/wrap.rb

@@ -70,10 +70,13 @@ class RDL::Wrap
         def #{meth}(*args, &blk)
           klass = "#{klass_str}"
           meth = types = matches = nil
+	        bind = binding
           inst = nil
+
           $__rdl_wrap_switch.off {
             $__rdl_wrapped_calls["#{full_method_name}"] += 1 if RDL::Config.instance.gather_stats
-            inst = @__rdl_inst
+            inst = nil
+            inst = @__rdl_inst if defined? @__rdl_inst
             inst = Hash[$__rdl_type_params[klass][0].zip []] if (not(inst) && $__rdl_type_params[klass])
             inst = {} if not inst
             #{if not(is_singleton_method) then "inst[:self] = RDL::Type::SingletonType.new(self)" end}
@@ -85,17 +88,17 @@ class RDL::Wrap
             end
             if RDL::Wrap.has_contracts?(klass, meth, :type)
               types = RDL::Wrap.get_contracts(klass, meth, :type)
-              matches = RDL::Type::MethodType.check_arg_types("#{full_method_name}", types, inst, *args, &blk)
+              matches,args,blk,bind = RDL::Type::MethodType.check_arg_types("#{full_method_name}", self, bind, types, inst, *args, &blk)
             end
           }
-          ret = send(#{meth_old.inspect}, *args, &blk)
+	  ret = send(#{meth_old.inspect}, *args, &blk)
           $__rdl_wrap_switch.off {
             if RDL::Wrap.has_contracts?(klass, meth, :post)
               posts = RDL::Wrap.get_contracts(klass, meth, :post)
               RDL::Contract::AndContract.check_array(posts, self, ret, *args, &blk)
             end
             if matches
-              RDL::Type::MethodType.check_ret_types("#{full_method_name}", types, inst, matches, ret, *args, &blk)
+              ret = RDL::Type::MethodType.check_ret_types(self, "#{full_method_name}", types, inst, matches, ret, bind, *args, &blk)
             end
           }
           return ret
@@ -414,21 +417,21 @@ class Object
     $__rdl_contract_switch.off {
       klass = self.class.to_s
       klass = "Object" if (klass.is_a? Object) && (klass.to_s == "main")
-      formals, variance, all = $__rdl_type_params[klass]
+      formals, _, all = $__rdl_type_params[klass]
       raise RuntimeError, "Receiver is of class #{klass}, which is not parameterized" unless formals
       raise RuntimeError, "Expecting #{params.size} type parameters, got #{typs.size}" unless formals.size == typs.size
-      raise RuntimeError, "Instance already has type instantiation" if @__rdl_type
+      raise RuntimeError, "Instance already has type instantiation" if (defined? @__rdl_type) && @rdl_type
       new_typs = typs.map { |t| if t.is_a? RDL::Type::Type then t else $__rdl_parser.scan_str "#T #{t}" end }
       t = RDL::Type::GenericType.new(RDL::Type::NominalType.new(klass), *new_typs)
       if all.instance_of? Symbol
         self.send(all) { |*objs|
-          new_typs.zip(objs).each { |t, obj|
-            if t.instance_of? RDL::Type::GenericType # require obj to be instantiated
+          new_typs.zip(objs).each { |nt, obj|
+            if nt.instance_of? RDL::Type::GenericType # require obj to be instantiated
               t_obj = RDL::Util.rdl_type(obj)
-              raise RDL::Type::TypeError, "Expecting element of type #{t.to_s}, but got uninstantiated object #{obj.inspect}" unless t_obj
-              raise RDL::Type::TypeError, "Expecting type #{t.to_s}, got type #{t_obj.to_s}" unless t_obj <= t
+              raise RDL::Type::TypeError, "Expecting element of type #{nt.to_s}, but got uninstantiated object #{obj.inspect}" unless t_obj
+              raise RDL::Type::TypeError, "Expecting type #{nt.to_s}, got type #{t_obj.to_s}" unless t_obj <= nt
             else
-              raise RDL::Type::TypeError, "Expecting type #{t.to_s}, got #{obj.inspect}" unless t.member? obj
+              raise RDL::Type::TypeError, "Expecting type #{nt.to_s}, got #{obj.inspect}" unless nt.member? obj
             end
           }
         }
@@ -476,4 +479,6 @@ class Object
       end
     }
   end
+
+
 end

data/rdl.gemspec

@@ -4,8 +4,8 @@
 
 Gem::Specification.new do |s|
   s.name        = 'rdl'
-  s.version     = '1.1.0'
-  s.date        = '2016-01-03'
+  s.version     = '1.1.1.rc1'
+  s.date        = '2016-05-21'
   s.summary     = 'Ruby type and contract system'
   s.description = <<-EOF
 RDL is a gem that allows contracts (pre- and postconditions) to be added to methods.
@@ -14,7 +14,7 @@ postconditions are checked at run time when the method returns.
 RDL also includes extensive support for type contracts, which check the types of arguments and returns
 when the method is called and when it returns, respectively.
 EOF
-  s.authors     = ['Jeffrey S. Foster', 'Brianna M. Ren', 'T. Stephen Strickland', 'Alexander T. Yu']
+  s.authors     = ['Jeffrey S. Foster', 'Brianna M. Ren', 'T. Stephen Strickland', 'Alexander T. Yu', 'Milod Kazerounian']
   s.email       = ['rdl-users@googlegroups.com']
   s.files       = `git ls-files`.split($/)
   s.executables << 'rdl_query'

data/test/test_dsl.rb

@@ -61,16 +61,16 @@ class TestDsl < Minitest::Test
       [@val, l, r]
     end
   end
-  
-  def test_pair 
-    p = Pair.new.entry {
+
+  def test_pair
+    _ = Pair.new.entry {
       left 3
       right 4
     }
   end
 
   def test_tree
-    t = Tree.new.entry(2) {
+    _ = Tree.new.entry(2) {
       left(3)
       right(4) {
         left(5) {
@@ -82,4 +82,3 @@ class TestDsl < Minitest::Test
     }
   end
 end
-  

data/test/test_le.rb

@@ -12,7 +12,7 @@ class TestLe < Minitest::Test
 
   class C < B
   end
-  
+
   def setup
     @tnil = NilType.new
     @ttop = TopType.new
@@ -26,7 +26,7 @@ class TestLe < Minitest::Test
     @tc = NominalType.new C
     @tfixnum = NominalType.new "Fixnum"
   end
-  
+
   def test_nil
     assert (@tnil <= @ttop)
     assert (@tnil <= @tstring)
@@ -85,7 +85,7 @@ class TestLe < Minitest::Test
   def test_union
     tstring_or_sym = UnionType.new(@tstring, @tsym)
     assert (tstring_or_sym <= @tobject)
-    assert (not (@tobject <= @tstring_or_sym))
+    assert (not (@tobject <= tstring_or_sym))
   end
 
   def test_tuple
@@ -182,12 +182,12 @@ class TestLe < Minitest::Test
     assert (tnom <= ts4) # types don't matter, only methods
     assert (not (tnomt <= ts4))
   end
-  
+
   # def test_intersection
   #   skip "<= not defined on intersection"
   #   tobject_and_basicobject = IntersectionType.new(@tobject, @tbasicobject)
   #   assert (not (tobject_and_basicobject <= @tobject))
   #   assert (@tobject <= tobject_and_basicobject)
   # end
-  
+
 end

data/test/test_lib_types.rb

@@ -22,26 +22,26 @@ class TestStdlibTypes < Minitest::Test
 
   def test_abbrev
     skip "Skip when nowrap is enabled"
-    assert_raises(RDL::Type::TypeError) { s0 = Abbrev.abbrev 5}
+    assert_raises(RDL::Type::TypeError) { Abbrev.abbrev 5}
     # From the Ruby stdlib documentation
     s1 = Abbrev.abbrev(['ruby']) # -> {"ruby"=>"ruby", "rub"=>"ruby", "ru"=>"ruby", "r"=>"ruby"}
     ev = {"ruby"=>"ruby", "rub"=>"ruby", "ru"=>"ruby", "r"=>"ruby"}
-    assert_equal(s1,ev)
+    assert_equal(s1, ev)
     # Other tests
-    assert_raises(RDL::Type::TypeError) { s2 = Abbrev.abbrev Dummy.new }
+    assert_raises(RDL::Type::TypeError) { Abbrev.abbrev Dummy.new }
   end
 
   def test_base64
     skip "Skip when nowrap is enabled"
     # From the Ruby stdlib documentation
     e0 = Base64.encode64('Send reinforcements') # -> "U2VuZCByZWluZm9yY2VtZW50cw==\n"
-    d0 = Base64.decode64(e0) # -> "Send reinforcements"
+    Base64.decode64(e0) # -> "Send reinforcements"
     #assert_equal(e0,d0)
     e1 = Base64.strict_encode64('Send reinforcements')
-    d1 = Base64.strict_decode64(e1)
+    Base64.strict_decode64(e1)
     #assert_equal(e1,d1)
     e2 = Base64.urlsafe_encode64('Send reinforcements')
-    d2 = Base64.urlsafe_decode64(e2)
+    Base64.urlsafe_decode64(e2)
     #assert_equal(e2,d2)
   end
 
@@ -51,24 +51,24 @@ class TestStdlibTypes < Minitest::Test
     Benchmark.measure { "a"*1_000_000_000 }
     n = 5000000
     Benchmark.bm do |x|
-      x.report { for i in 1..n; a = "1"; end }
-      x.report { n.times do   ; a = "1"; end }
-      x.report { 1.upto(n) do ; a = "1"; end }
+      x.report { for i in 1..n; a = i; a; end }
+      x.report { n.times do   ; a = "1"; a; end }
+      x.report { 1.upto(n) do ; a = "1"; a; end }
     end
     Benchmark.bm(7) do |x|
-      x.report("for:")   { for i in 1..n; a = "1"; end }
-      x.report("times:") { n.times do   ; a = "1"; end }
-      x.report("upto:")  { 1.upto(n) do ; a = "1"; end }
+      x.report("for:")   { for i in 1..n; a = i; a; end }
+      x.report("times:") { n.times do   ; a = "1"; a; end }
+      x.report("upto:")  { 1.upto(n) do ; a = "1"; a; end }
     end
-    array = (1..1000000).map { rand }
+    _ = (1..1000000).map { rand }
     Benchmark.bmbm do |x|
       #x.report("sort!") { array.dup.sort! } # TODO this causes a hang
       #x.report("sort")  { array.dup.sort  }
     end
     Benchmark.benchmark(Benchmark::CAPTION, 7, Benchmark::FORMAT, ">total:", ">avg:") do |x|
-      tf = x.report("for:")   { for i in 1..n; a = "1"; end }
-      tt = x.report("times:") { n.times do   ; a = "1"; end }
-      tu = x.report("upto:")  { 1.upto(n) do ; a = "1"; end }
+      tf = x.report("for:")   { for i in 1..n; a = i; a; end }
+      tt = x.report("times:") { n.times do   ; a = "1"; a; end }
+      tu = x.report("upto:")  { 1.upto(n) do ; a = "1"; a; end }
       [tf+tt+tu, (tf+tt+tu)/3]
     end
   end
@@ -97,7 +97,7 @@ class TestStdlibTypes < Minitest::Test
     BigDecimal.mode(BigDecimal::EXCEPTION_NaN, false)
     BigDecimal.mode(BigDecimal::EXCEPTION_NaN)
     BigDecimal.ver
-    
+
     # TODO
   end
 
@@ -110,7 +110,7 @@ class TestStdlibTypes < Minitest::Test
     BigMath.sin(BigMath.PI(5)/4, 5)
     BigMath.sqrt(BigDecimal.new('2'), 16)
   end
-  
+
   def test_class
     Dummy.allocate
     Dummy.new
@@ -123,10 +123,10 @@ class TestStdlibTypes < Minitest::Test
     Coverage.result
     #Coverage.result # TODO This cannot be typechecked
   end
-  
+
   def test_exception
     e1 = Exception.new
-    e1 == 5
+    _ = (e1 == 5)
     tmp = e1.backtrace
     e1.backtrace_locations
     e1.cause
@@ -136,14 +136,14 @@ class TestStdlibTypes < Minitest::Test
     e1.set_backtrace(tmp)
     e1.to_s
   end
-  
+
   def test_set
     skip "Skip when nowrap is enabled"
-    assert_raises(RDL::Type::TypeError) { s6 = Set.new(1,2) }
+    assert_raises(RDL::Type::TypeError) { _ = Set.new(1,2) }
     # From the Ruby stdlib documentation
     s1 = Set.new [1, 2]                   # -> #<Set: {1, 2}>
     s2 = [1, 2].to_set                    # -> #<Set: {1, 2}>
-    s1 == s2                              # -> true
+    _ = (s1 == s2)                        # -> true
     s1.add("foo")                         # -> #<Set: {1, 2, "foo"}>
     s1.merge([2, 6])                      # -> #<Set: {1, 2, "foo", 6}>
     s1.subset? s2                         # -> false
@@ -151,18 +151,18 @@ class TestStdlibTypes < Minitest::Test
     Set[1, 2, 3].disjoint? Set[3, 4] # => false
     Set[1, 2, 3].disjoint? Set[4, 5] # => true
     numbers = Set[1, 3, 4, 6, 9, 10, 11]
-    set = numbers.divide { |i,j| (i - j).abs == 1 }
+    _ = numbers.divide { |i,j| (i - j).abs == 1 }
     Set[1, 2, 3].intersect? Set[4, 5] # => false
     Set[1, 2, 3].intersect? Set[3, 4] # => true
     # Some more tests, just to make sure type checking doesn't cause crashes
-    s3 = s1 - s2
+    _ = s1 - s2
     s1.proper_subset? s2
     s1.superset? s2
-    s1 ^ s2
+    _ = s1 ^ s2
     s1.add?("bar")
-    h = s1.classify { |x| x.size }
+    _ = s1.classify { |x| x.size }
     s2.clear
-    s4 = s1.map { |x| 42 }
+    _ = s1.map { |x| 42 }
     s1.delete "foo"
     s1.delete? "bar"
     s1.delete_if { |x| false }
@@ -174,21 +174,21 @@ class TestStdlibTypes < Minitest::Test
     s1.size
     s1.difference [1,2,3]
     s1.to_a
-    s5 = s1 + s2
+    _ = s1 + s2
   end
-  
+
   def test_uri
     URI.decode_www_form("a=1&a=2&b=3")
     URI.encode_www_form([["q", "ruby"], ["lang", "en"]]) # Internally uses _component
     URI.encode_www_form("q" => "ruby", "lang" => "en")
     URI.encode_www_form("q" => ["ruby", "perl"], "lang" => "en")
     URI.encode_www_form([["q", "ruby"], ["q", "perl"], ["lang", "en"]])
-    URI.extract("text here http://foo.example.org/bla and here mailto:test@example.com and here also.")
+#    URI.extract("text here http://foo.example.org/bla and here mailto:test@example.com and here also.")
     URI.join("http://example.com/","main.rbx")
     URI.parse("http://www.ruby-lang.org/")
     URI.scheme_list
     URI.split("http://www.ruby-lang.org/")
-    enc_uri = URI.escape("http://example.com/?a=\11\15")
-    URI.unescape(enc_uri)
+#    enc_uri = URI.escape("http://example.com/?a=\11\15")
+#    URI.unescape(enc_uri)
   end
-end
+end

data/test/test_member.rb

@@ -12,7 +12,7 @@ class TestMember < Minitest::Test
 
   class C < B
   end
-  
+
   def setup
     @tnil = NilType.new
     @ttop = TopType.new
@@ -72,7 +72,7 @@ class TestMember < Minitest::Test
     assert (@tkernel.member? "Foo")
     assert (@tkernel.member? :Foo)
     assert (@tkernel.member? o)
-    
+
     a = A.new
     b = B.new
     c = C.new
@@ -88,7 +88,7 @@ class TestMember < Minitest::Test
 
     assert (@tstring.member? nil)
     assert (@tobject.member? nil)
-end
+  end
 
   def test_symbol
     assert (@tsym.member? :foo)

data/test/test_type_contract.rb

@@ -107,6 +107,68 @@ class TestTypeContract < Minitest::Test
     assert_equal 42, p10.call(43, "44")
     assert_raises(TypeError) { p10.call() }
     assert_raises(TypeError) { p10.call(43, "44", 45) }
+
+    t11 = @p.scan_str "(Fixnum x {{ x > 42 }}) -> Fixnum"
+    p11 = t11.to_contract.wrap(self) { |x| x }
+    assert_equal 43, p11.call(43)
+    assert_raises(TypeError) { p11.call(42) }
+
+    t12 = @p.scan_str "(Fixnum x {{ x>10 }}, Fixnum y {{ y > x }}) -> Fixnum z {{z > (x+y) }}"
+    p12 = t12.to_contract.wrap(self) { |x,y| x+y+1 }
+    assert_equal 30, p12.call(14, 15)
+    assert_equal 50, p12.call(24, 25)
+    assert_raises(TypeError) { p12.call(9,10) }
+    assert_raises(TypeError) { p12.call(20,19) }
+    p12b = t12.to_contract.wrap(self) { |x,y| x+y }
+    assert_raises(TypeError) { p12b.call(42, 43) }
+    assert_raises(TypeError) { p12b.call(11, 10) }
+    assert_raises(TypeError) { p12b.call(9, 10) }
+
+    t13 = @p.scan_str "(Fixnum, {(Fixnum x {{x>10}}) -> Fixnum}) -> Float"
+    p13 = t13.to_higher_contract(self) { |x,y| x+y.call(11)+0.5 } 
+    assert_equal 53.5, p13.call(42, Proc.new { |x| x })
+    assert_raises(TypeError) { p13.call(42.5, Proc.new { |x| x} ) }
+    assert_raises(TypeError) { p13.call(42, Proc.new { |x| 0.5 } ) }
+    p13b = t13.to_higher_contract(self) { |x,y| x+y.call(10)+0.5 } 
+    assert_raises(TypeError) { p13b.call(42, Proc.new { |x| x } ) }
+    p13c = t13.to_higher_contract(self) { |x,y| x+y.call(11.5)+0.5 }
+    assert_raises(TypeError) { p13c.call(42, Proc.new { |x| x } ) }
+    p13d = t13.to_higher_contract(self) { |x,y| x+y.call(42) }
+    assert_raises(TypeError) { p13d.call(42, Proc.new { |x| x } ) }
+
+    t14 = @p.scan_str "(Fixnum, Fixnum) -> {(Fixnum) -> Fixnum}"
+    p14 = t14.to_higher_contract(self) { |x,y| Proc.new {|z| x+y+z} }
+    assert_raises(TypeError) { p14.call(42.5, 42) }
+    p14b = p14.call(42,42)
+    assert_equal 126, p14b.call(42)
+    assert_raises(TypeError) { p14b.call(42.5) }
+    p14c = t14.to_higher_contract(self) { |x,y| Proc.new {|z| x+y+z+0.5} }
+    p14d = p14c.call(42,42)
+    assert_raises(TypeError) { p14d.call(42) }
+
+    assert_equal 47, block_contract_test1(42) {|z| z}
+    assert_raises(TypeError) { block_contract_test1(42) {|z| 0.5} } 
+    assert_raises(TypeError) { block_contract_test2(42) {|z| z} }
+
+
+    t15 = @p.scan_str "(Fixnum x {{x>y}}, Fixnum y) -> Fixnum"
+    p15 = t15.to_contract.wrap(self) { |x, y| x+y } 
+    assert_equal 21, p15.call(11, 10)
+    assert_raises(TypeError) { p15.call(10, 11) }
+
+    t16 = @p.scan_str "(Fixnum x {{x > undefvar}}, Fixnum) -> Fixnum"
+    p16 = t16.to_contract.wrap(self) { |x,y| x }
+    assert_raises(NameError) { p16.call(10,10) } 
+  end
+
+  type '(Fixnum) { (Fixnum) -> Fixnum } -> Fixnum'
+  def block_contract_test1(x)
+    x+yield(5)
+  end
+  
+  type '(Fixnum) { (Fixnum) -> Fixnum } -> Float'
+  def block_contract_test2(x)
+    x+yield(4.5)
   end
 
   def test_proc_names
@@ -184,4 +246,4 @@ class TestTypeContract < Minitest::Test
     assert_raises(TypeError) { p8.call(43, x: "foo", y: "foo") }
     assert_raises(TypeError) { p8.call(43, x: :foo, y: "foo", z: 44) }
   end
-end
+end