rdl 2.1.0 → 2.2.0

data/test/test_generic.rb

@@ -1,6 +1,7 @@
 require 'minitest/autorun'
 $LOAD_PATH << File.dirname(__FILE__) + "/../lib"
 require 'rdl'
+RDL.reset
 
 class TestGeneric < Minitest::Test
   extend RDL::Annotate
@@ -8,8 +9,6 @@ class TestGeneric < Minitest::Test
   # Make two classes that wrap Array and Hash, so we don't mess with their
   # implementations in test case evaluation.
   class A
-    extend RDL::Annotate
-    type_params [:t], :all?
     def initialize(a); @a = a end
     def all?(&blk)
       @a.all?(&blk)
@@ -17,8 +16,6 @@ class TestGeneric < Minitest::Test
   end
 
   class H
-    extend RDL::Annotate
-    type_params [:k, :v], :all?
     def initialize(h); @h = h end
     def all?(&blk)
       @h.all? { |x, y| blk.call(x, y) } # have to do extra wrap to avoid splat issues
@@ -28,9 +25,7 @@ class TestGeneric < Minitest::Test
   class B
     extend RDL::Annotate
     # class for checking other variance annotations
-    type_params [:a, :b], nil, variance: [:+, :-] { |a, b| true }
-    type "(a) -> nil"
-    def m1(x)
+    def m1(x) # type annotation
       nil
     end
     def m2(x) # no type annotation
@@ -38,7 +33,26 @@ class TestGeneric < Minitest::Test
     end
   end
 
+  class C
+    def m1() return self; end
+    def m2() return C.new; end
+    def m3() return Object.new; end
+  end
+
+  class D < C
+  end
+
+
+
   def setup
+    RDL.reset
+    RDL.type_params A, [:t], :all?
+    RDL.type_params H, [:k, :v], :all?
+    RDL.type_params(B, [:a, :b], nil, variance: [:+, :-]) { |a, b| true }
+    RDL.type B, :m1, "(a) -> nil"
+    RDL.type C, :m1, "() -> self"
+    RDL.type C, :m2, "() -> self"
+    RDL.type C, :m3, "() -> self"
     @ta = RDL::Type::NominalType.new "TestGeneric::A"
     @th = RDL::Type::NominalType.new "TestGeneric::H"
     @tas = RDL::Type::GenericType.new(@ta, RDL::Globals.types[:string])
@@ -111,19 +125,6 @@ class TestGeneric < Minitest::Test
     assert (tbss <= ts5)
   end
 
-  class C
-    extend RDL::Annotate
-    type "() -> self"
-    def m1() return self; end
-    type "() -> self"
-    def m2() return C.new; end
-    type "() -> self"
-    def m3() return Object.new; end
-  end
-
-  class D < C
-  end
-
   def test_self_type
     c = C.new
     assert(c.m1)

data/test/test_hash_types.rb

@@ -0,0 +1,322 @@
+require 'minitest/autorun'
+$LOAD_PATH << File.dirname(__FILE__) + "/../lib"
+require 'rdl'
+require 'types/core'
+
+
+class TestHashTypes < Minitest::Test
+  extend RDL::Annotate
+
+  def setup
+    require 'types/core'
+    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"]
+  end
+
+  def test_hash_methods
+    self.class.class_eval {
+      type '({bar: Integer, baz: String}) -> String', typecheck: :now
+      def access_test1(x)
+        x[:baz]
+      end
+      
+      type '({bar: Integer, baz: String}) -> {bar: Integer, baz: String}', typecheck: :now
+      def access_test2(x)
+        x[:baz]
+        x
+      end
+
+      type '(Symbol, {bar: Integer, baz: String}) -> String or Integer', typecheck: :now
+      def access_test3(y, x)
+        x[y]
+      end
+
+      type '(Hash) -> v', typecheck: :now
+      def access_test4(x)
+        x[:blah]
+      end
+
+      type '(Hash<Symbol, Integer or String>) -> Integer or String', typecheck: :now
+      def access_test5(x)
+        x[:baz]
+      end
+
+      type '({ foo: 1, Symbol: String }) -> 1 or String', typecheck: :now
+      def access_test6(x)
+        x[:blah]
+      end
+
+      type '({bar: Integer, baz: String}) -> Integer', typecheck: :access_fail1
+      def access_fail_test1(x)
+        x[:baz]
+      end
+      
+      type '(Hash<Symbol, Integer or String>) -> Integer', typecheck: :access_fail2
+      def access_fail_test2(x)
+        x[:baz]
+      end
+
+      type '({ bar: 1, baz: 2 }) -> :bar', typecheck: :now
+      def key_test1(x)
+        x.key(1)
+      end
+
+      type '({ bar: Integer, baz: String }) -> Symbol', typecheck: :now
+      def key_test2(x)
+        x.key(1)
+      end
+
+      type '(Hash<Symbol, Integer>) -> Symbol', typecheck: :now
+      def key_test3(x)
+        x.key(1)
+      end
+
+      type '({ bar: Integer, baz: String }) -> { bar: Integer, baz: String, foo: Integer }', typecheck: :now
+      def merge_test1(x)
+        x.merge({ foo: 1 })
+      end
+
+      type '({ bar: Integer, baz: String }) -> { bar: String, baz: String }', typecheck: :now
+      def merge_test2(x)
+        x.merge({ bar: 'hi' })
+      end
+
+      type '(Hash<Integer, String>, { bar: Integer, baz: String }) -> Hash<Integer or Symbol, Integer or String>', typecheck: :now
+      def merge_test3(x, y)
+        x.merge(y)
+      end
+
+      type '(Hash<Integer, String>, { bar: Integer, baz: String }) -> Hash<Integer or Symbol, Integer or String>', typecheck: :now
+      def merge_test4(x, y)
+        y.merge(x)
+      end
+
+      type '(Hash<Integer, String>, Hash<Symbol, Integer>) -> Hash<Integer or Symbol, String or Integer>', typecheck: :now
+      def merge_test5(x, y)
+        x.merge(y)
+      end
+
+      type '(Hash<Integer, String>, Hash<Symbol, Integer>) -> Hash<Integer or Symbol, String or Integer>', typecheck: :now
+      def merge_test6(x, y)
+        y.merge(x)
+      end
+      
+      type '(Hash, { bar: Integer, baz: String }) -> Hash', typecheck: :now
+      def merge_test7(x, y)
+        x.merge(y)
+      end
+
+      type '(Hash, { bar: Integer, baz: String }) -> Hash', typecheck: :now
+      def merge_test8(x, y)
+        y.merge(x)
+      end
+
+      type '(Hash, Hash<Integer, String>) -> Hash', typecheck: :now
+      def merge_test9(x, y)
+        x.merge(y)
+      end
+
+      type '(Hash, Hash<Integer, String>) -> Hash', typecheck: :now
+      def merge_test10(x, y)
+        y.merge(x)
+      end
+
+      type '({ bar: Integer, baz: String}) -> 2', typecheck: :now
+      def length_test1(x)
+        x.length
+      end
+
+      type '(Hash<Integer, String>) -> Integer', typecheck: :now
+      def length_test2(x)
+        x.length
+      end
+
+      type '({ hi: 1}) -> false', typecheck: :now
+      def empty_test1(x)
+        x.empty?
+      end
+
+      type '() -> true', typecheck: :now
+      def empty_test2()
+        x = {}
+        x.empty?
+      end
+
+      type '(Hash) -> %bool', typecheck: :now
+      def empty_test3(x)
+        x.empty?
+      end
+
+      type '(Hash<Symbol, String>) -> %bool', typecheck: :now
+      def empty_test4(x)
+        x.empty?
+      end
+
+      type '({ baz: Integer, 1 => 2 }) -> [:baz, 1]', typecheck: :now
+      def keys_test1(x)
+        x.keys
+      end
+
+      type '(Hash<Symbol, Integer>) -> Array<Symbol>', typecheck: :now
+      def keys_test2(x)
+        x.keys
+      end
+
+
+      type '({ foo: Integer }) -> { foo: Integer, bar: String }', typecheck: :now
+      def assign_test1(x)
+        x[:bar] = "2"
+        x
+      end
+
+      type '(Hash<Symbol, Integer>) -> Integer', typecheck: :now
+      def assign_test2(x)
+        x[:blah] = 42
+        x[:foo]
+      end
+
+      type '() -> Integer', typecheck: :now
+      def assign_test3()
+        x = {foo: 1, bar: 2, baz: 3}
+        x[:bar] = 3
+      end
+
+      type '({foo: Integer}) -> 42', typecheck: :now
+      def assign_test4(x)
+        x[:bar] = 42
+        x[:bar]
+      end
+
+      type '(Integer, { foo: String }) -> Hash<Symbol or Integer, String or Integer>', typecheck: :now
+      def assign_test5(i, x)
+        x[i] = i
+        x
+      end
+
+      type '({ foo: 1 }) -> { foo: 1 or 2 }', typecheck: :now
+      def assign_test6(x)
+        x[:foo] = 2
+        x
+      end
+
+      type :hash_callee, '({ foo: 1 or 2 }) -> %bool'
+
+      type '({ foo: 1 }) -> { foo: 1 or 2 }', typecheck: :now
+      def assign_test7(x)
+        hash_callee(x)
+        x[:foo] = 2
+        x
+      end
+
+      type '({ foo: 1 }) -> String', typecheck: :assign_fail1
+      def assign_fail_test1(x)
+        hash_callee(x)
+        x[:foo] = "2"
+      end
+
+      type '(Hash<Symbol, Integer>) -> %any', typecheck: :assign_fail2
+      def assign_fail_test2(x)
+        x[:blah] = 'hi'
+      end
+
+      type '(Hash<Symbol, Integer>) -> %any', typecheck: :assign_fail3
+      def assign_fail_test3(x)
+        x['string'] = 2
+      end
+
+      type '({ foo: 1, bar: String }) -> [:bar, String]', typecheck: :now
+      def assoc_test1(x)
+        x.assoc(:bar)
+      end
+
+      type '(Symbol, { foo: 1, bar: String }) -> [Symbol, Integer or String]', typecheck: :now
+      def assoc_test2(y, x)
+        x.assoc(y)
+      end
+
+      type '(Hash<Symbol, Integer>) -> [Symbol, Integer]'
+      def assoc_test3(x)
+        x.assoc(42)
+      end
+
+      type '({ foo: 1 }) -> true', typecheck: :now
+      def has_key_test1(x)
+        x.has_key?(:foo)
+      end
+
+      type '({ foo: 1 }) -> false', typecheck: :now
+      def has_key_test2(x)
+        x.has_key?(:bar)
+      end
+
+      type '(Symbol, { foo: 1 }) -> %bool', typecheck: :now
+      def has_key_test3(y, x)
+        x.has_key?(y)
+      end
+
+      type '(Symbol, Hash<Symbol, Integer>) -> %bool', typecheck: :now
+      def has_key_test4(y, x)
+        x.has_key?(y)
+      end
+
+      type '(String) -> { a: 1, b: String }', typecheck: :now
+      def create_test1(x)
+        Hash[:a, 1, :b, x]
+      end
+
+      type '() -> %any', typecheck: :create_fail1
+      def create_fail_test1
+        Hash[1, 2, 3]
+      end
+
+      type '({ foo: 1, bar: 2 }) -> 1', typecheck: :now
+      def delete_test1(x)
+        x.delete(:foo)
+      end
+
+      type '({ foo: 1, bar: 2 }) -> { foo: 1, bar: 2 }', typecheck: :now
+      def delete_test2(x)
+        x.delete(:foo)
+        x
+      end
+
+      type '(Symbol, {foo: 1, bar: 2}) -> 1 or 2', typecheck: :now
+      def delete_test3(s, x)
+        x.delete(s)
+      end
+
+      type '(Symbol, Hash<Symbol, Integer>) -> Integer', typecheck: :now
+      def delete_test4(s, x)
+        x.delete(s)
+      end
+
+      type '(Symbol, { foo: 1 }) -> Integer or String'
+      def delete_test5(s, x)
+        x.delete(s) { |i| "hi" }
+      end
+
+      type '({ foo: 1, bar: String, baz: Integer }) -> [1, String]', typecheck: :now
+      def values_at_test1(x)
+        x.values_at(:foo, :bar)
+      end
+
+      type '(Symbol, { foo: 1, bar: String, baz: Integer }) -> Array<Integer or String>', typecheck: :now
+      def values_at_test2(s, x)
+        x.values_at(:foo, s)
+      end
+
+      type '({ foo: 1, Symbol: String, baz: Integer }) -> Array<Integer or String>', typecheck: :now
+      def values_at_test3(x)
+        x.values_at(:foo, :blah)
+      end
+    }
+    assert_raises(RDL::Typecheck::StaticTypeError) { RDL.do_typecheck :access_fail1 }
+    assert_raises(RDL::Typecheck::StaticTypeError) { RDL.do_typecheck :access_fail2 }
+    assert_raises(RDL::Typecheck::StaticTypeError) { RDL.do_typecheck :assign_fail1 }
+    assert_raises(RDL::Typecheck::StaticTypeError) { RDL.do_typecheck :assign_fail2 }
+    assert_raises(RDL::Typecheck::StaticTypeError) { RDL.do_typecheck :assign_fail3 }
+    assert_raises(RDL::Typecheck::StaticTypeError) { RDL.do_typecheck :create_fail1 }      
+  end
+
+end

data/test/test_intersection.rb

@@ -6,6 +6,7 @@ class TestIntersection < Minitest::Test
   include RDL::Type
 
   def setup
+    RDL.reset
     @parser = RDL::Type::Parser.new
 
     @integer = NominalType.new(Integer)

data/test/test_le.rb

@@ -1,7 +1,6 @@
 require 'minitest/autorun'
 $LOAD_PATH << File.dirname(__FILE__) + "/../lib"
 require 'rdl'
-require 'types/core'
 
 class TestLe < Minitest::Test
   include RDL::Type
@@ -21,6 +20,7 @@ class TestLe < Minitest::Test
   end
 
   def setup
+    RDL.reset
     @tbasicobject = NominalType.new "BasicObject"
     @tsymfoo = SingletonType.new :foo
     @ta = NominalType.new A
@@ -54,6 +54,24 @@ class TestLe < Minitest::Test
     assert (@tsymfoo <= RDL::Globals.types[:top])
   end
 
+  def test_dyn
+    assert (RDL::Globals.types[:dyn] <= RDL::Globals.types[:nil])
+    assert (RDL::Globals.types[:nil] <= RDL::Globals.types[:dyn])
+    assert (RDL::Globals.types[:dyn] <= RDL::Globals.types[:top])
+    assert (RDL::Globals.types[:top] <= RDL::Globals.types[:dyn])
+    assert (RDL::Globals.types[:dyn] <= RDL::Globals.types[:bot])
+    assert (RDL::Globals.types[:bot] <= RDL::Globals.types[:dyn])
+    assert (RDL::Globals.types[:dyn] <= RDL::Globals.types[:dyn])
+    assert (RDL::Globals.types[:dyn] <= RDL::Globals.types[:string])
+    assert (RDL::Globals.types[:string] <= RDL::Globals.types[:dyn])
+    assert (RDL::Globals.types[:dyn] <= RDL::Globals.types[:object])
+    assert (RDL::Globals.types[:object] <= RDL::Globals.types[:dyn])
+    assert (RDL::Globals.types[:dyn] <= @tbasicobject)
+    assert (@tbasicobject <= RDL::Globals.types[:dyn])
+    assert (RDL::Globals.types[:dyn] <= @tsymfoo)
+    assert (@tsymfoo <= RDL::Globals.types[:dyn])
+  end
+
   def test_sym
     assert (RDL::Globals.types[:symbol] <= RDL::Globals.types[:symbol])
     assert (@tsymfoo <= @tsymfoo)
@@ -90,6 +108,8 @@ class TestLe < Minitest::Test
   end
 
   def test_tuple
+    RDL.type_params :Array, [:t], :all?
+
     t1 = TupleType.new(RDL::Globals.types[:symbol], RDL::Globals.types[:string])
     t2 = TupleType.new(RDL::Globals.types[:object], RDL::Globals.types[:object])
     tarray = NominalType.new("Array")
@@ -131,6 +151,8 @@ class TestLe < Minitest::Test
   end
 
   def test_finite_hash
+    RDL.type_params :Hash, [:k, :v], :all?
+
     t12 = tt "{a: 1, b: 2}"
     tfs = tt "{a: Integer, b: Integer}"
     too = tt "{a: Object, b: Object}"
@@ -248,18 +270,18 @@ class TestLe < Minitest::Test
   end
 
   class NomT
-    extend RDL::Annotate
-    type "() -> nil"
     def m1()
       nil
     end
-    type "() -> nil"
     def m2()
       nil
     end
   end
 
   def test_nominal_structural
+    RDL.type TestLe::NomT, :m1, "() -> nil", wrap: false
+    RDL.type TestLe::NomT, :m2, "() -> nil", wrap: false
+
     tnom = NominalType.new(Nom)
     tnomt = NominalType.new(NomT)
     tma = MethodType.new([], nil, RDL::Globals.types[:nil])
@@ -279,6 +301,9 @@ class TestLe < Minitest::Test
   end
 
   def test_leq_inst
+    RDL.type_params :Array, [:t], :all?
+    RDL.type_params :Hash, [:k, :v], :all?
+
     # when return of do_leq is false, ignore resulting inst, since that's very implementation dependent
     assert_equal [true, {t: @ta}], do_leq(tt("t"), @ta, true)
     assert_equal false, do_leq(tt("t"), @ta, false)[0]