rdl 1.0.0.rc3 → 1.0.0.rc4

data/test/test_dsl.rb

@@ -0,0 +1,85 @@
+require 'minitest/autorun'
+require_relative '../lib/rdl.rb'
+
+class TestDsl < Minitest::Test
+
+  class Pair
+
+    # dsl {
+    #   type :left, '(Fixnum) -> Fixnum'
+    #   type :right, '(Fixnum) -> Fixnum'
+    # }
+    def entry(&blk)
+      instance_eval(&blk)
+    end
+
+    def left(x)
+      @left = x
+    end
+
+    def right(x)
+      @right = x
+    end
+
+    def get
+      [@left, @right]
+    end
+  end
+
+  class Tree
+
+    # dsl :tree { # recursive DSL
+    #   type :left, '(Fixnum) -> Fixnum'
+    #   dsl :left, :tree
+    #   type :right, '(Fixnum) -> Fixnum'
+    #   dsl :right, :tree
+    # }
+    def entry(val, &blk)
+      @val = val
+      instance_eval(&blk)
+    end
+
+    def left(x, &blk)
+      if blk
+        @left = Tree.new.entry(x, &blk)
+      else
+        @left = x
+      end
+    end
+
+    def right(x, &blk)
+      if blk
+        @right = Tree.new.entry(x, &blk)
+      else
+        @right = x
+      end
+    end
+
+    def get
+      l = @left.instance_of?(Tree) ? @left.get : @left
+      r = @right.instance_of?(Tree) ? @right.get : @right
+      [@val, l, r]
+    end
+  end
+  
+  def test_pair 
+    p = Pair.new.entry {
+      left 3
+      right 4
+    }
+  end
+
+  def test_tree
+    t = Tree.new.entry(2) {
+      left(3)
+      right(4) {
+        left(5) {
+          left(6)
+          right(7)
+        }
+        right(8)
+      }
+    }
+  end
+end
+  

data/test/test_generic.rb

@@ -0,0 +1,188 @@
+require 'minitest/autorun'
+require_relative '../lib/rdl.rb'
+
+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
+    type_params [:t], :all?
+    def initialize(a); @a = a end
+    def all?(&blk)
+      @a.all?(&blk)
+    end
+  end
+
+  class H
+    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
+    end
+  end
+
+  class B
+    # class for checking other variance annotations
+    type_params [:a, :b], nil, variance: [:+, :-] { |a, b| true }
+    type "(a) -> nil"
+    def m1(x)
+      nil
+    end
+    def m2(x) # no type annotation
+      nil
+    end
+  end
+  
+  def setup
+    @ta = RDL::Type::NominalType.new "TestGeneric::A"
+    @th = RDL::Type::NominalType.new "TestGeneric::H"
+    @tstring = RDL::Type::NominalType.new "String"
+    @tobject = RDL::Type::NominalType.new "Object"
+    @tfixnum = RDL::Type::NominalType.new "Fixnum"
+    @tas = RDL::Type::GenericType.new(@ta, @tstring)
+    @tao = RDL::Type::GenericType.new(@ta, @tobject)
+    @taas = RDL::Type::GenericType.new(@ta, @tas)
+    @taao = RDL::Type::GenericType.new(@ta, @tao)
+    @thss = RDL::Type::GenericType.new(@th, @tstring, @tstring)
+    @thoo = RDL::Type::GenericType.new(@th, @tobject, @tobject)
+    @thsf = RDL::Type::GenericType.new(@th, @tstring, @tfixnum)
+    @tb = RDL::Type::NominalType.new "TestGeneric::B"
+    @tnil = RDL::Type::NilType.new
+  end
+
+  def test_le
+    # Check invariance for A and H
+    assert (@tas <= @tas)
+    assert (@tao <= @tao)
+    assert (@taas <= @taas)
+    assert (@thss <= @thss)
+    assert (@thoo <= @thoo)
+    assert (not (@tas <= @tao))
+    assert (not (@tao <= @tas))
+    assert (not (@thss <= @thoo))
+    assert (not (@thoo <= @thss))
+
+    # Check "raw" class subtyping is forbidden
+    assert (not (@ta <= @tas))
+    assert (not (@tas <= @ta))
+    assert (not (@ta <= @taas))
+    assert (not (@taas <= @ta))
+    assert (not (@th <= @thss))
+    assert (not (@thss <= @th))
+
+    # Check co- and contravariance using B
+    tbss = RDL::Type::GenericType.new(@tb, @tstring, @tstring)
+    tbso = RDL::Type::GenericType.new(@tb, @tstring, @tobject)
+    tbos = RDL::Type::GenericType.new(@tb, @tobject, @tstring)
+    tboo = RDL::Type::GenericType.new(@tb, @tobject, @tobject)
+    assert (tbss <= tbss)
+    assert (not (tbss <= tbso))
+    assert (tbss <= tbos)
+    assert (not (tbss <= tboo))
+    assert (tbso <= tbss)
+    assert (tbso <= tbso)
+    assert (tbso <= tbos)
+    assert (tbso <= tboo)
+    assert (not (tbos <= tbss))
+    assert (not (tbos <= tbso))
+    assert (tbos <= tbos)
+    assert (not (tbos <= tboo))
+    assert (not (tboo <= tbss))
+    assert (not (tboo <= tbso))
+    assert (tboo <= tbos)
+    assert (tboo <= tboo)
+  end
+
+  def test_le_structural
+    tbss = RDL::Type::GenericType.new(@tb, @tstring, @tstring)
+    tma = RDL::Type::MethodType.new([], nil, @tnil)
+    tmb = RDL::Type::MethodType.new([@tstring], nil, @tnil)
+    tmc = RDL::Type::MethodType.new([@tfixnum], nil, @tnil)
+    ts1 = RDL::Type::StructuralType.new(m2: tma)
+    assert (tbss <= ts1)
+    ts2 = RDL::Type::StructuralType.new(m1: tmb)
+    assert (tbss <= ts2)
+    ts3 = RDL::Type::StructuralType.new(m1: tmb, m2: tma)
+    assert (tbss <= ts3)
+    ts4 = RDL::Type::StructuralType.new(m1: tmc, m2: tma)
+    assert (not (tbss <= ts4))
+    ts5 = RDL::Type::StructuralType.new(m1: tmb, m2: tmc)
+    assert (tbss <= ts5)
+  end
+  
+  class C
+    type "() -> self"
+    def m1() return self; end
+    type "() -> self"
+    def m2() return C.new; end
+  end
+  
+  def test_self_type
+    c = C.new
+    assert(c.m1)
+    assert_raises(RDL::Type::TypeError) { c.m2 }
+  end
+
+  def test_member
+    # member? should only check the base types
+    assert (@ta.member?(A.new([1, 2, 3])))
+    assert (@ta.member?(A.new([])))
+    assert (@ta.member?(A.new(["a", "b", "c"])))
+    assert (@tas.member?(A.new([1, 2, 3])))
+    assert (@tas.member?(A.new([])))
+    assert (@tas.member?(A.new(["a", "b", "c"])))
+    assert (@taas.member?(A.new([1, 2, 3])))
+    assert (@taas.member?(A.new([])))
+    assert (@taas.member?(A.new(["a", "b", "c"])))
+  end
+
+  def test_instantiate
+    assert_raises(RuntimeError) { Object.new.instantiate!(@tstring) }
+    
+    # Array<String>
+    assert (A.new([]).instantiate!('String'))
+    assert (A.new(["a", "b", "c"]).instantiate!(@tstring))
+    assert (A.new(["a", "b", "c"]).instantiate!('String'))
+    assert_raises(RDL::Type::TypeError) { A.new([1, 2, 3]).instantiate!('String') }
+
+    # Array<Object>
+    assert (A.new([])).instantiate!('Object')
+    assert (A.new(["a", "b", "c"]).instantiate!(@tobject))
+    assert (A.new(["a", "b", "c"]).instantiate!('Object'))
+    assert (A.new([1, 2, 3]).instantiate!('Object'))
+
+    # Hash<String, Fixnum>
+    assert (H.new({}).instantiate!('String', 'Fixnum'))
+    assert (H.new({"one"=>1, "two"=>2}).instantiate!('String', 'Fixnum'))
+    assert_raises(RDL::Type::TypeError) {
+      H.new(one: 1, two: 2).instantiate!('String', 'Fixnum')
+    }
+    assert_raises(RDL::Type::TypeError){
+      H.new({"one"=>:one, "two"=>:two}).instantiate!('String', 'Fixnum')
+    }
+
+    # Hash<Object, Object>
+    assert (H.new({}).instantiate!('Object', 'Object'))
+    assert (H.new({"one"=>1, "two"=>2}).instantiate!('Object', 'Object'))
+    assert (H.new(one: 1, two: 2).instantiate!('Object', 'Object'))
+    assert (H.new({"one"=>:one, "two"=>:two}).instantiate!('Object', 'Object'))
+
+    # A<A<String>>
+    assert (A.new([A.new(["a", "b"]).instantiate!('String'),
+                   A.new(["c"]).instantiate!('String')]).instantiate!('TestGeneric::A<String>'))
+    assert_raises(RDL::Type::TypeError) {
+      # Must instantiate all members
+      A.new([A.new(["a", "b"]).instantiate!('String'), A.new([])]).instantiate!('TestGeneric::A<String>')
+    }
+    assert_raises(RDL::Type::TypeError) {
+      # All members must be of same type
+      A.new([A.new(["a", "b"]).instantiate!('String'), "A"]).instantiate!('TestGeneric::A<String>')
+    }
+    assert_raises(RDL::Type::TypeError) {
+      # All members must be instantiated and of same type
+      A.new([A.new(["a", "b"]).instantiate!('String'),
+             H.new({a: 1, b: 2}).instantiate!('Object', 'Object')]).instantiate!('TestGeneric::A<String>')
+    }
+  end
+
+end

data/test/test_intersection.rb

@@ -0,0 +1,41 @@
+require 'minitest/autorun'
+require_relative '../lib/rdl.rb'
+
+class TestIntersection < Minitest::Test
+  include RDL::Type
+
+  def setup
+    @parser = RDL::Type::Parser.new
+
+    @fixnum = NominalType.new(Fixnum)
+    @string = NominalType.new(String)
+    @array = NominalType.new(Array)
+    @hash = NominalType.new(Hash)
+    @true_n = NominalType.new(TrueClass)
+
+    @tparam_t = VarType.new(:t)
+    
+    @f_or_s = UnionType.new(@fixnum, @string)
+    @string_or_true = UnionType.new(@string, @true_n)
+
+    @array_of_fixnum = GenericType.new(@array, @fixnum)
+    @array_of_true = GenericType.new(@array, @true_n)
+    @array_of_fixnum_string = GenericType.new(@array, @f_or_s)
+    @array_of_true_string = GenericType.new(@array, @string_or_true)
+    @hash_of_string_fixnum = GenericType.new(@hash, @string, @fixnum)
+    @hash_of_string_true_fixnum = GenericType.new(@hash, @string_or_true, @fixnum)
+    @a_a_f = GenericType.new(@array, @array_of_fixnum)
+    @a_a_a_f = GenericType.new(@array, @a_a_f)
+    @a_a_a_a_f = GenericType.new(@array, @a_a_a_f)
+  end
+
+  def test_intersection_same
+    t1 = @parser.scan_str "(Fixnum) -> Fixnum"
+    t2 = @parser.scan_str "(Fixnum) -> Fixnum"
+    t3 = @parser.scan_str "(Fixnum) -> Fixnum"
+    i = IntersectionType.new(t1, t2, t3)
+
+    assert_equal(t1, i)
+  end
+end
+

data/test/test_le.rb

@@ -0,0 +1,193 @@
+require 'minitest/autorun'
+require_relative '../lib/rdl.rb'
+
+class TestLe < Minitest::Test
+  include RDL::Type
+
+  class A
+  end
+
+  class B < A
+  end
+
+  class C < B
+  end
+  
+  def setup
+    @tnil = NilType.new
+    @ttop = TopType.new
+    @tstring = NominalType.new "String"
+    @tobject = NominalType.new "Object"
+    @tbasicobject = NominalType.new "BasicObject"
+    @tsymfoo = SingletonType.new :foo
+    @tsym = NominalType.new Symbol
+    @ta = NominalType.new A
+    @tb = NominalType.new B
+    @tc = NominalType.new C
+    @tfixnum = NominalType.new "Fixnum"
+  end
+  
+  def test_nil
+    assert (@tnil <= @ttop)
+    assert (@tnil <= @tstring)
+    assert (@tnil <= @tobject)
+    assert (@tnil <= @tbasicobject)
+    assert (@tnil <= @tsymfoo)
+    assert (not (@ttop <= @tnil))
+    assert (not (@tstring <= @tnil))
+    assert (not (@tobject <= @tnil))
+    assert (not (@tbasicobject <= @tnil))
+    assert (not (@tsymfoo <= @tnil))
+  end
+
+  def test_top
+    assert (not (@ttop <= @tnil))
+    assert (not (@ttop <= @tstring))
+    assert (not (@ttop <= @tobject))
+    assert (not (@ttop <= @tbasicobject))
+    assert (not (@ttop <= @tsymfoo))
+    assert (@ttop <= @ttop)
+    assert (@tstring <= @ttop)
+    assert (@tobject <= @ttop)
+    assert (@tbasicobject <= @ttop)
+    assert (@tsymfoo <= @ttop)
+  end
+
+  def test_sym
+    assert (@tsym <= @tsym)
+    assert (@tsymfoo <= @tsymfoo)
+    assert (@tsymfoo <= @tsym)
+    assert (not (@tsym <= @tsymfoo))
+  end
+
+  def test_nominal
+    assert (@tstring <= @tstring)
+    assert (@tsym <= @tsym)
+    assert (not (@tstring <= @tsym))
+    assert (not (@tsym <= @tstring))
+    assert (@tstring <= @tobject)
+    assert (@tstring <= @tbasicobject)
+    assert (@tobject <= @tbasicobject)
+    assert (not (@tobject <= @tstring))
+    assert (not (@tbasicobject <= @tstring))
+    assert (not (@tbasicobject <= @tobject))
+    assert (@ta <= @ta)
+    assert (@tb <= @ta)
+    assert (@tc <= @ta)
+    assert (not (@ta <= @tb))
+    assert (@tb <= @tb)
+    assert (@tc <= @tb)
+    assert (not (@ta <= @tc))
+    assert (not (@tb <= @tc))
+    assert (@tc <= @tc)
+  end
+
+  def test_union
+    tstring_or_sym = UnionType.new(@tstring, @tsym)
+    assert (tstring_or_sym <= @tobject)
+    assert (not (@tobject <= @tstring_or_sym))
+  end
+
+  def test_tuple
+    t1 = TupleType.new(@tsym, @tstring)
+    t2 = TupleType.new(@tobject, @tobject)
+    tarray = NominalType.new("Array")
+    assert (t1 <= t1)
+    assert (t2 <= t2)
+    assert (not (t1 <= t2)) # invariant subtyping since tuples are mutable
+    assert (not (t2 <= t1))
+    assert (not (t1 <= tarray)) # no convertability to arrays due to mutability
+    assert (not (tarray <= t1))
+  end
+
+  def test_method
+    tss = MethodType.new([@tstring], nil, @tstring)
+    tso = MethodType.new([@tstring], nil, @tobject)
+    tos = MethodType.new([@tobject], nil, @tstring)
+    too = MethodType.new([@tobject], nil, @tobject)
+    assert (tss <= tss)
+    assert (tss <= tso)
+    assert (not (tss <= tos))
+    assert (not (tss <= too))
+    assert (not (tso <= tss))
+    assert (tso <= tso)
+    assert (not (tso <= tos))
+    assert (not (tso <= too))
+    assert (tos <= tss)
+    assert (tos <= tso)
+    assert (tos <= tos)
+    assert (tos <= too)
+    assert (not (too <= tss))
+    assert (too <= tso)
+    assert (not (too <= tos))
+    assert (too <= too)
+    tbos = MethodType.new([], tos, @tobject)
+    tbso = MethodType.new([], tso, @tobject)
+    assert (tbos <= tbos)
+    assert (not (tbos <= tbso))
+    assert (tbso <= tbso)
+    assert (tbso <= tbos)
+  end
+
+  def test_structural
+    tso = MethodType.new([@tstring], nil, @tobject)
+    tos = MethodType.new([@tobject], nil, @tstring)
+    ts1 = StructuralType.new(m1: tso)
+    ts2 = StructuralType.new(m1: tos)
+    assert (ts1 <= @ttop)
+    assert (ts1 <= ts1)
+    assert (ts2 <= ts2)
+    assert (ts2 <= ts1)
+    assert (not (ts1 <= ts2))
+    ts3 = StructuralType.new(m1: tso, m2: tso) # width subtyping
+    assert (ts3 <= ts1)
+    assert (not (ts1 <= ts3))
+  end
+
+  class Nom
+    def m1()
+      nil
+    end
+    def m2()
+      nil
+    end
+  end
+
+  class NomT
+    type "() -> nil"
+    def m1()
+      nil
+    end
+    type "() -> nil"
+    def m2()
+      nil
+    end
+  end
+
+  def test_nominal_structural
+    tnom = NominalType.new(Nom)
+    tnomt = NominalType.new(NomT)
+    tma = MethodType.new([], nil, @tnil)
+    tmb = MethodType.new([@tfixnum], nil, @tnil)
+    ts1 = StructuralType.new(m1: tma)
+    assert (tnom <= ts1)
+    assert (tnomt <= ts1)
+    ts2 = StructuralType.new(m1: tma, m2: tma)
+    assert (tnom <= ts2)
+    assert (tnomt <= ts2)
+    ts3 = StructuralType.new(m1: tma, m2: tma, m3: tma)
+    assert (not (tnom <= ts3))
+    assert (not (tnomt <= ts3))
+    ts4 = StructuralType.new(m1: tmb)
+    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