rdl 2.1.0 → 2.2.0

data/rdl.gemspec

@@ -4,19 +4,20 @@
 
 Gem::Specification.new do |s|
   s.name        = 'rdl'
-  s.version     = '2.1.0'
-  s.date        = '2017-06-14'
+  s.version     = '2.2.0'
+  s.date        = '2019-06-09'
   s.summary     = 'Ruby type and contract system'
   s.description = <<-EOF
 RDL is a gem that adds types and contracts to Ruby. RDL includes extensive
 support for specifying method types, which can either be enforced as
 contracts or statically checked.
 EOF
-  s.authors     = ['Jeffrey S. Foster', 'Brianna M. Ren', 'T. Stephen Strickland', 'Alexander T. Yu', 'Milod Kazerounian']
+  s.authors     = ['Jeffrey S. Foster', 'Brianna M. Ren', 'T. Stephen Strickland', 'Alexander T. Yu', 'Milod Kazerounian', 'Sankha Narayan Guria']
   s.email       = ['rdl-users@googlegroups.com']
   s.files       = `git ls-files`.split($/)
   s.executables << 'rdl_query'
-  s.homepage    = 'https://github.com/plum-umd/rdl'
+  s.homepage    = 'https://github.com/tupl-tufts/rdl'
   s.license     = 'BSD-3-Clause'
   s.add_runtime_dependency 'parser', '~>2.3', '>= 2.3.1.4'
+  s.add_runtime_dependency 'sql-parser', '~>0.0.2'
 end

data/test/test_alias.rb

@@ -5,6 +5,10 @@ require 'rdl'
 class TestAlias < Minitest::Test
   extend RDL::Annotate
 
+  def setup
+    RDL.reset
+  end
+
   def test_alias_lookup
     self.class.class_eval {
       rdl_alias :foobar1, :foobar

data/test/test_array_types.rb

@@ -0,0 +1,244 @@
+require 'minitest/autorun'
+$LOAD_PATH << File.dirname(__FILE__) + "/../lib"
+require 'rdl'
+require 'types/core'
+
+class TestArrayTypes < Minitest::Test
+  extend RDL::Annotate
+
+  def setup
+    RDL.reset
+    RDL.readd_comp_types
+    RDL.type_params :Array, [:t], :all? unless RDL::Globals.type_params["Array"]
+    RDL.type_params(:Range, [:t], nil, variance: [:+]) { |t| t.member?(self.begin) && t.member?(self.end) } unless RDL::Globals.type_params["Range"]
+  end
+  
+  def test_array_methods
+    self.class.class_eval {
+      type '() -> 2', typecheck: :now
+      def access_test1()
+        x = [1, 2, 3]
+        x[1]
+      end
+
+      type '(Array<Integer>) -> Integer', typecheck: :now
+      def access_test2(x)
+        x[5]
+      end
+
+      type '([2, String, Float], Integer) -> Integer or String or Float', typecheck: :now
+      def access_test3(x, y)
+        x[y]
+      end
+
+      type '(Array) -> t', typecheck: :now
+      def access_test4(a)
+        a[3]
+      end
+
+      type '([1,2,3]) -> Array<3 or 2 or 1>', typecheck: :now
+      def access_test5(a)
+        a[1..4]
+      end
+
+      type '(Array<Integer>) -> Array<Integer>', typecheck: :now
+      def access_test6(a)
+        a[1..4]
+      end
+
+      type '([1,2,3]) -> [2,3]', typecheck: :now
+      def access_test7(a)
+        a[1, 9]
+      end
+
+      type '([1,2,3]) -> 2', typecheck: :now
+      def fetch_test1(a)
+        a[1]
+      end
+
+      type '([1,2,3]) -> 1', typecheck: :now
+      def first_test1(a)
+        a.first
+      end
+
+      type '([1,2,3], Integer) -> Array<3 or 2 or 1>', typecheck: :now
+      def first_test2(a, i)
+        a.first(i)
+      end
+
+      type '() -> [1,2,3,1,2,3]', typecheck: :now
+      def mult_test1
+        [1,2,3]*2
+      end
+
+      type '([1,2,3], Integer) -> Array<3 or 2 or 1>', typecheck: :now
+      def mult_test2(a, i)
+        a * i
+      end
+
+      type '([1,2,3]) -> 3', typecheck: :now
+      def count_test1(a)
+        a.count
+      end
+
+      type '(Array<Integer>) -> Integer', typecheck: :now
+      def count_test2(a)
+        a.count
+      end
+
+      type '([1,2,3]) -> [1,2,3,4]', typecheck: :now
+      def append_test1(a)
+        a << 4
+      end
+
+      type '(Array<Integer>) -> Array<Integer>', typecheck: :now
+      def append_test2(a)
+        a << 5
+      end
+
+      type '([1,2,3]) -> [1,2,3,4,5]', typecheck: :now
+      def push_test1(a)
+        a.push(4, 5)
+      end
+
+      type :append_callee, '([1,2,3]) -> %bool'
+
+      type '([1,2,3]) -> %bool', typecheck: :append_fail1
+      def append_fail_test1(a)
+        append_callee(a)
+        a << 4
+        true
+      end
+      
+      type '([1,2,3], [4,5,String]) -> [1,2,3,4,5,String]', typecheck: :now
+      def plus_test1(x, y)
+        x+y
+      end
+
+      type '([Integer,Integer,Integer], Array<String>) -> Array<Integer or String>', typecheck: :now
+      def plus_test2(x, y)
+        x+y
+      end
+
+      type '([1,2,3], Array) -> Array', typecheck: :now
+      def plus_test3(x, y)
+        x + y
+      end
+
+      type '(Array<String>, Array) -> Array', typecheck: :now
+      def plus_test4(x, y)
+        x + y
+      end
+
+      type '([1,2,3]) -> true', typecheck: :now
+      def include_test1(x)
+        x.include?(1)
+      end
+
+      type '([1,2,Integer]) -> %bool', typecheck: :now
+      def include_test2(x)
+        x.include?(4)
+      end
+
+      type '(Array<Integer>) -> %bool', typecheck: :now
+      def include_test3(x)
+        x.include?(42)
+      end
+
+      type '([1,2,3]) -> 2', typecheck: :now
+      def slice_test1(x)
+        x.slice(1)
+      end
+
+      type '([1,2,3]) -> [2,3]', typecheck: :now
+      def slice_test2(x)
+        x.slice(1,2)
+      end
+
+      type '([1,2,3]) -> [1,4 or 2,3]', typecheck: :now
+      def assign_test1(x)
+        x[1] = 4
+        x
+      end
+
+      type '(Integer, [1,2,3]) -> Array<1 or 2 or 3 or String>', typecheck: :now
+      def assign_test2(i, x)
+        x[i] = "hi"
+        x
+      end
+
+      type '(Array<Integer>) -> Array<Integer>', typecheck: :now
+      def assign_test3(x)
+        x[1] = 2
+        x
+      end
+
+      type :assign_callee, '([1,2,3]) -> %bool'
+
+      type '([1,2,3]) -> 2', typecheck: :now
+      def assign_test4(x)
+        assign_callee(x)
+        x[1] = 2
+      end
+
+      type '([1,2,3]) -> %any', typecheck: :assign_fail1
+      def assign_fail_test1(x)
+        assign_callee
+        x[1] = 100
+      end
+
+      type '(Array<Integer>) -> %any', typecheck: :assign_fail2
+      def assign_fail_test2(x)
+        x[1] = "hi"
+      end
+
+      type '([1,2,3]) -> false', typecheck: :now
+      def empty_test1(x)
+        x.empty?
+      end
+
+      type '(Array<Integer>) -> %bool', typecheck: :now
+      def empty_test2(x)
+        x.empty?
+      end
+
+      type '([1,2,3]) -> 1', typecheck: :now
+      def index_test1(x)
+        x.index(2)
+      end
+
+      type '([1,2,3], Integer) -> Integer', typecheck: :now
+      def index_test2(x, y)
+        x.index(y)
+      end
+
+      type '([1,Integer,3], 2) -> Integer', typecheck: :now
+      def index_test3(x, y)
+        x.index(y)
+      end
+
+      type '([1,2,3]) -> [3,2,1]', typecheck: :now
+      def reverse_test1(x)
+        x.reverse
+      end
+
+      type '([1,2,3]) -> [1,2,3]', typecheck: :now
+      def reverse_test2(x)
+        x.reverse
+        x
+      end
+
+      type '([1,2,3]) -> [3 or 1,2,1 or 3]', typecheck: :now
+      def reverse_test3(x)
+        x.reverse!
+        x
+      end
+    }
+
+    assert_raises(RDL::Typecheck::StaticTypeError) { RDL.do_typecheck :append_fail1 }
+    assert_raises(RDL::Typecheck::StaticTypeError) { RDL.do_typecheck :assign_fail1 }
+    assert_raises(RDL::Typecheck::StaticTypeError) { RDL.do_typecheck :assign_fail2 }
+  end
+
+end
+

data/test/test_bound_types.rb

@@ -0,0 +1,80 @@
+require 'minitest/autorun'
+$LOAD_PATH << File.dirname(__FILE__) + "/../lib"
+require 'rdl'
+require 'types/core'
+
+
+class TestBoundTypes < Minitest::Test
+  extend RDL::Annotate
+
+  def test_bound_types
+    self.class.class_eval {
+      type :uses_bound, "(t<::Integer) -> ``if t.is_a?(RDL::Type::SingletonType) then RDL::Globals.types[:integer] else RDL::Globals.types[:string] end``"
+
+      type :uses_bound_twice, "(t<::Integer, p<::Integer) -> ``if t==p then RDL::Globals.types[:integer] else RDL::Globals.types[:string] end``"
+
+      type :uses_optional, "(?String, t<::Integer) -> ``if t.is_a?(RDL::Type::SingletonType) then RDL::Globals.types[:integer] else RDL::Globals.types[:string] end``"
+
+      type "(Integer) -> String", typecheck: :now
+      def calls_bound1(x)
+        uses_bound(x)
+      end
+
+      type "(1) -> Integer", typecheck: :now
+      def calls_bound2(x)
+        uses_bound(x)
+      end
+
+      type "(Integer) -> Integer", typecheck: :fail1
+      def calls_bound3(x)
+        uses_bound(x)
+      end
+
+      type "(1) -> String", typecheck: :fail2
+      def calls_bound4(x)
+        uses_bound(x)
+      end
+
+      type "(1, 1) -> Integer", typecheck: :now
+      def calls_bound5(x, y)
+        uses_bound_twice(x, y)
+      end
+
+      type "(1, 2) -> String", typecheck: :now
+      def calls_bound6(x, y)
+        uses_bound_twice(x, y)
+      end
+
+      type "(1, 2) -> Integer", typecheck: :fail3
+      def calls_bound7(x, y)
+        uses_bound_twice(x, y)
+      end
+
+      type "(1) -> Integer", typecheck: :now
+      def calls_bound8(x)
+        uses_optional(x)
+      end
+
+      type "(1) -> Integer", typecheck: :now
+      def calls_bound9(x)
+        uses_optional('x', x)
+      end
+
+      type "(1) -> String", typecheck: :fail4
+      def calls_bound10(x)
+        uses_optional('x', x)
+      end
+
+      type "(1) -> String", typecheck: :fail5
+      def calls_bound11(x)
+        uses_optional(x)
+      end
+    }
+    assert_raises(RDL::Typecheck::StaticTypeError) { RDL.do_typecheck :fail1 }
+    assert_raises(RDL::Typecheck::StaticTypeError) { RDL.do_typecheck :fail2 }
+    assert_raises(RDL::Typecheck::StaticTypeError) { RDL.do_typecheck :fail3 }
+    assert_raises(RDL::Typecheck::StaticTypeError) { RDL.do_typecheck :fail4 }
+    assert_raises(RDL::Typecheck::StaticTypeError) { RDL.do_typecheck :fail5 }
+  end
+  
+end

data/test/test_contract.rb

@@ -5,6 +5,10 @@ require 'rdl'
 class TestContract < Minitest::Test
   include RDL::Contract
 
+  def setup
+    RDL.reset
+  end
+  
   def test_flat
     pos = FlatContract.new("Positive") { |x| x > 0 }
     assert_equal "Positive", pos.to_s

data/test/test_dsl.rb

@@ -4,6 +4,11 @@ require 'rdl'
 
 class TestDsl < Minitest::Test
 
+  def setup
+    RDL.reset
+  end
+
+
   class Pair
 
     # dsl {

data/test/test_dyn_comptype_checks.rb

@@ -0,0 +1,206 @@
+require 'minitest/autorun'
+$LOAD_PATH << File.dirname(__FILE__) + "/../lib"
+require 'rdl'
+require 'types/core'
+
+class TestDynChecks < Minitest::Test
+  extend RDL::Annotate
+
+  RDL::Config.instance.check_comp_types = true
+  RDL::Config.instance.rerun_comp_types = true
+
+  type :bar1, "(Integer) -> ``RDL::Type::SingletonType.new(2)``", wrap: false
+  
+  type "(Integer) -> Integer", typecheck: :now, wrap: false
+  def foo1(x)
+    bar1(x)
+  end
+
+  ## First, a silly example. `bar1` (defined below) always returns 1, but its comp type says it always returns 2.
+  ## `foo1` will type check properly, but the `bar1` error won't be caught until `foo` is called after type checking.
+  def test_foo1_fail
+    RDL::Util.silent_warnings { self.class.class_eval("def bar1(x) 1; end") } 
+    assert_raises(RDL::Type::TypeError) { self.class.new(nil).foo1(1) }
+  end
+
+  ## If we redefine `bar1`, it should work.
+
+  def test_foo1_pass
+    RDL::Util.silent_warnings { self.class.class_eval("def bar1(x) 2; end") }
+    assert self.class.new(nil).foo1(1)
+  end
+
+
+  ## Let's try again, with arrays.
+
+  type :return_array, "() -> ``RDL::Type::TupleType.new(RDL::Type::SingletonType.new(0), RDL::Type::SingletonType.new(0), RDL::Type::SingletonType.new(0))``", wrap: false
+
+  type "() -> Integer", typecheck: :now ## this type check should pass
+  def calls_array
+    a = return_array
+    a[1]
+  end
+
+  def test_array_fail
+    RDL::Util.silent_warnings{ self.class.class_eval("def return_array() [1,2,3]; end") }
+    assert_raises(RDL::Type::TypeError) { self.class.new(nil).calls_array }
+  end
+
+  def test_array_pass
+    RDL::Util.silent_warnings { self.class.class_eval("def return_array() [0,0,0]; end") }
+    assert self.class.new(nil).calls_array
+  end
+
+  # Now for a slightly-but-not-really more realistic example, with a mock (very small) DB schema.
+
+  class People
+    extend RDL::Annotate
+    @people_schema = RDL::Globals.parser.scan_str "#T { name: String, age: Integer }"
+    type 'self.where', "(``raise 'Expected schema' unless @people_schema; @people_schema``) -> Integer", wrap: false
+    def self.where(record)
+      1 ## not actually looking anything up, so just return a dummy int
+    end
+
+    type :person_to_look_up, '() -> {name: String, age: 30}', wrap: false
+    
+    type "() -> Integer", wrap: false, typecheck: :now ## type checking will succeed the first time
+    def calls_where
+      self.class.where(person_to_look_up)
+    end
+
+    
+  end
+
+  def test_where_fail
+    RDL::Util.silent_warnings{ People.class_eval("def person_to_look_up() {name: 'alice', age: '30'}; end") }
+    assert_raises(RDL::Type::TypeError) { People.new.calls_where }
+  end
+    
+  def test_where_pass
+    RDL::Util.silent_warnings { People.class_eval("def person_to_look_up() {name: 'alice', age: 30}; end") }
+    assert People.new.calls_where
+  end
+
+
+  # A test where the same method returns different types in different calls:
+
+  def self.called_thrice_output(trec, targs)
+    if targs[0].is_a?(RDL::Type::NominalType)
+      RDL::Globals.types[:integer]
+    elsif targs[0].is_a?(RDL::Type::SingletonType)
+      RDL::Type::SingletonType.new(targs[0].val + 1)
+    end
+  end
+  
+  type :called_thrice, "(Integer) -> ``called_thrice_output(trec, targs)``", wrap: false
+
+
+  type "(Integer) -> Integer", wrap: false, typecheck: :now
+  def multi_caller(x)
+    called_thrice(x) ## should have type Integer
+    called_thrice(1) ## Should have type 2
+    called_thrice(2) ## Should have type 3
+  end
+
+  def test_multi_pass
+    RDL::Util.silent_warnings { self.class.class_eval "def called_thrice(x) x+1; end" } ## this will satisfy all call return types
+    assert self.class.new(nil).multi_caller(0)
+  end
+
+  def test_multi_fail
+    RDL::Util.silent_warnings { self.class.class_eval "def called_thrice(x) if (x==2) then x+2 else x+1 end; end" } ## silly
+    assert_raises(RDL::Type::TypeError) { multi_caller(0) }
+  end
+
+
+  # Now to test op_asgn.
+
+  type "(Integer) -> Integer", typecheck: :now, wrap: false
+  def op_asgn_test(x)
+    x += 1
+  end
+
+  def test_op_asgn
+    assert self.class.new(nil).op_asgn_test(1)
+    assert_raises(RDL::Type::TypeError) { self.class.new(nil).op_asgn_test(1.5) } ## Because `op_asgn_test` isn't wrapped, this should only raise error once :+ is called    
+  end
+
+  type "([1,2,3]) -> Integer", typecheck: :now, wrap: false
+  def op_asgn_arr(arr)
+    arr[1] += 1
+  end
+
+  def test_op_asgn_arr
+    assert self.class.new(nil).op_asgn_arr([1,2,3])
+    assert_raises(RDL::Type::TypeError) { self.class.new(nil).op_asgn_arr([1,42, 3]) } ## same issue as above
+  end
+
+
+  # Now, we'll test the re-running of computed types; this has been tested in all the examples above, but here we'll test that it fails correctly.
+
+  class CompFail
+    extend RDL::Annotate
+    #@@compfail = 1
+=begin
+    def self.get_val()
+      @@compfail
+    end
+
+    def self.set_val(v)
+      @@compfail = v
+    end
+
+    type "(``if (get_val == 1) then RDL::Globals.types[:integer] else RDL::Type::UnionType.new(RDL::Globals.types[:integer], RDL::Globals.types[:string]) end``) -> Integer", wrap: false ## pathological type depending on @@compfail
+    def bar(x)
+      x
+    end
+
+    type "(Integer) -> Integer", typecheck: :now, wrap: false ## will type check fine
+    def foo(x)
+      bar(x)
+    end
+=end
+  end
+
+  def test_rerun_comp_type
+    CompFail.class_eval {
+      #RDL::Config.instance.check_comp_types = true
+      #RDL::Config.instance.rerun_comp_types = true
+
+      @@compfail = 1
+      def self.get_val()
+        @@compfail
+      end
+
+      def self.set_val(v)
+        @@compfail = v
+      end
+
+      type "(``if (get_val == 1) then RDL::Globals.types[:integer] else RDL::Type::UnionType.new(RDL::Globals.types[:integer], RDL::Globals.types[:string]) end``) -> Integer", wrap: false ## pathological type depending on @@compfail
+      def bar(x)
+        x
+      end
+
+      RDL::Config.instance.check_comp_types = true
+      RDL::Config.instance.rerun_comp_types = true
+      
+      type "(Integer) -> Integer", typecheck: :now, wrap: false ## will type check fine
+      def foo2(x)
+        bar(x)
+      end
+    }
+
+    ## These are needed out here too due to weird orderings involving RDL.reset.
+    assert CompFail.new.foo2(1) ## will run fine
+    CompFail.set_val(2) ## change heap
+    assert_raises(RDL::Type::TypeError) { CompFail.new.foo2(1) }
+
+    RDL::Config.instance.check_comp_types = false
+    RDL::Config.instance.rerun_comp_types = false
+  end
+
+  RDL::Config.instance.check_comp_types = false
+  RDL::Config.instance.rerun_comp_types = false
+  
+  
+end