rdl 1.0.0.rc3 → 1.0.0.rc4

data/test/test_types.rb

@@ -0,0 +1,221 @@
+require 'minitest/autorun'
+require_relative '../lib/rdl.rb'
+
+class TestTypes < Minitest::Test
+  include RDL::Type
+
+  def test_nil_top
+    tnil = NilType.new
+    tnil2 = NilType.new
+    assert(tnil.equal? tnil2)
+    tnil3 = NominalType.new :NilClass
+    assert(tnil.equal? tnil3)
+    ttop = TopType.new
+    ttop2 = TopType.new
+    assert_same ttop, ttop2
+    assert (tnil != ttop)
+  end
+
+  def test_nominal
+    ta = NominalType.new :A
+    ta2 = NominalType.new :A
+    ta3 = NominalType.new "A"
+    tb = NominalType.new :B
+    assert_same ta, ta2
+    assert_same ta, ta3
+    assert (ta != tb)
+    assert_equal "A", ta.name
+  end
+
+  def test_symbol
+    ta = SingletonType.new :A
+    ta2 = SingletonType.new :A
+    tb = SingletonType.new :B
+    tan = NominalType.new :A
+    assert_same ta, ta2
+    assert (ta != tb)
+    assert_equal :A, ta.val
+    assert (ta != tan)
+  end
+
+  def test_var
+    ta = VarType.new :A
+    ta2 = VarType.new :A
+    ta3 = VarType.new "A"
+    tb = VarType.new :B
+    tan = NominalType.new :A
+    assert_same ta, ta2
+    assert_same ta, ta3
+    assert (ta != tb)
+    assert_equal :A, ta.name
+    assert (ta != tan)
+  end
+
+  def u_or_i(c)
+    tnil = NilType.new
+    ttop = TopType.new
+    ta = NominalType.new :A
+    tb = NominalType.new :B
+    tc = NominalType.new :C
+    t1 = c.new ta, tb
+    assert_equal 2, t1.types.length
+    t2 = c.new tb, ta
+    assert_same t1, t2
+    t3 = c.new ttop, ttop
+    assert_same t3, ttop
+    t4 = c.new ttop, tnil, ttop, tnil
+    assert_same t4, ttop
+    t5 = c.new tnil, tnil
+    assert_same t5, tnil
+    t6 = c.new ta, tb, tc
+    assert_equal 3, t6.types.length
+    t7 = c.new ta, (c.new tb, tc)
+    assert_same t6, t7
+    t8 = c.new (c.new tc, tb), (c.new ta)
+    assert_same t6, t8
+    assert (t1 != tnil)
+  end
+
+  def test_union_intersection
+    u_or_i UnionType
+    u_or_i IntersectionType
+  end
+
+  def test_optional
+    tnil = NilType.new
+    ta = NominalType.new :A
+    t1 = OptionalType.new tnil
+    assert_equal tnil, t1.type
+    t2 = OptionalType.new tnil
+    assert_same t1, t2
+    t3 = OptionalType.new ta
+    assert (t1 != t3)
+  end
+
+  def test_vararg
+    tnil = NilType.new
+    ta = NominalType.new :A
+    t1 = VarargType.new tnil
+    assert_equal tnil, t1.type
+    t2 = VarargType.new tnil
+    assert_same t1, t2
+    t3 = VarargType.new ta
+    assert (t1 != t3)
+  end
+
+  def test_method
+    tnil = NilType.new
+    ta = NominalType.new :A
+    tb = NominalType.new :B
+    tc = NominalType.new :C
+    t1 = MethodType.new [ta, tb, tc], nil, tnil
+    assert_equal [ta, tb, tc], t1.args
+    assert_nil t1.block
+    assert_equal tnil, t1.ret
+    t2 = MethodType.new [tnil], t1, tnil
+    assert_equal t1, t2.block
+  end
+
+  def test_generic
+    thash = NominalType.new :Hash
+    ta = NominalType.new :A
+    tb = NominalType.new :B
+    t1 = GenericType.new thash, ta, tb
+    assert_equal thash, t1.base
+    assert_equal [ta, tb], t1.params
+    t2 = GenericType.new thash, ta, tb
+    assert_same t1, t2
+    t3 = GenericType.new thash, tb, ta
+    assert (t1 != t3)
+    tavar = VarType.new :a
+    tbvar = VarType.new :b
+    t4 = GenericType.new thash, tavar, tbvar
+    assert_equal "Hash<a, b>", t4.to_s
+  end
+
+  def test_structural
+    tnil = NilType.new
+    ta = NominalType.new :A
+    tb = NominalType.new :B
+    tc = NominalType.new :C
+    tm1 = MethodType.new [ta, tb, tc], nil, tnil
+    tm2 = MethodType.new [ta], tm1, tb
+    t1 = StructuralType.new(m1: tm1, m2: tm2)
+    assert_equal tm1, t1.methods[:m1]
+    assert_equal tm2, t1.methods[:m2]
+    t2 = StructuralType.new(m1: tm1, m2: tm2)
+    assert_equal t1, t2
+  end
+
+  def test_singleton_caching
+    s = Set.new
+    r = Set.new
+    t1 = SingletonType.new(s)
+    t2 = SingletonType.new(r)
+    assert (t1 != t2) # shouldn't be the same since they're different
+                      # objects! e.g., mutating one won't change the
+                      # other
+  end
+
+  def test_instantiate
+    tnil = NilType.new
+    ttop = TopType.new
+    tA = NominalType.new :A
+    tB = NominalType.new :B
+    toptionalA = OptionalType.new tA
+    tvarargA = VarargType.new tA
+    tannotatedA = AnnotatedArgType.new("arg", tA)
+    tunionAB = UnionType.new(tA, tB)
+    tinterAB = IntersectionType.new(tA, tB)
+    tsyma = SingletonType.new(:a)
+    tstring = NominalType.new :String
+    tfixnum = NominalType.new :Fixnum
+    ta = VarType.new :a
+    tb = VarType.new :b
+    tc = VarType.new :c
+    thash = NominalType.new :Hash
+    thashAB = GenericType.new(thash, tA, tB)
+    thashab = GenericType.new(thash, ta, tb)
+    thashstringfixnum = GenericType.new(thash, tstring, tfixnum)
+    inst = {a: tstring, b: tfixnum}
+    ttupleAB = TupleType.new(tA, tB)
+    ttupleab = TupleType.new(ta, tb)
+    ttuplestringfixnum = TupleType.new(tstring, tfixnum)
+    tfinitehashaAbB = FiniteHashType.new(a: tA, b: tB)
+    tfinitehashaabb = FiniteHashType.new(a: ta, b: tb)
+    tfinitehashastringbfixnum = FiniteHashType.new(a: tstring, b: tfixnum)
+    tmethAAB = MethodType.new([tA, tA], nil, tB)
+    tmethaab = MethodType.new([ta, ta], nil, tb)
+    tmethstringstringfixnum = MethodType.new([tstring, tstring], nil, tfixnum)
+    tmethbAABn = MethodType.new([], tmethAAB, tnil)
+    tmethbaabn = MethodType.new([], tmethaab, tnil)
+    tmethbssfn = MethodType.new([], tmethstringstringfixnum, tnil)
+    tstructorig = StructuralType.new(m1: tmethAAB, m2: tmethaab,
+                                     m3: tmethbAABn, m4: tmethbaabn)
+    tstructinst = StructuralType.new(m1: tmethAAB, m2: tmethstringstringfixnum,
+                                     m3: tmethbAABn, m4: tmethbssfn)
+    assert_equal tnil, tnil.instantiate(inst)
+    assert_equal ttop, ttop.instantiate(inst)
+    assert_equal tA, tA.instantiate(inst)
+    assert_equal toptionalA, toptionalA.instantiate(inst)
+    assert_equal tvarargA, tvarargA.instantiate(inst)
+    assert_equal tannotatedA, tannotatedA.instantiate(inst)
+    assert_equal tunionAB, tunionAB.instantiate(inst)
+    assert_equal tinterAB, tinterAB.instantiate(inst)
+    assert_equal tsyma, tsyma.instantiate(inst)
+    assert_equal tstring, ta.instantiate(inst)
+    assert_equal tfixnum, tb.instantiate(inst)
+    assert_equal tc, tc.instantiate(inst)
+    assert_equal thashAB, thashAB.instantiate(inst)
+    assert_equal thashstringfixnum, thashab.instantiate(inst)
+    assert_equal ttupleAB, ttupleAB.instantiate(inst)
+    assert_equal ttuplestringfixnum, ttupleab.instantiate(inst)
+    assert_equal tfinitehashaAbB, tfinitehashaAbB.instantiate(inst)
+    assert_equal tfinitehashastringbfixnum, tfinitehashaabb.instantiate(inst)
+    assert_equal tmethAAB, tmethAAB.instantiate(inst)
+    assert_equal tmethstringstringfixnum, tmethaab.instantiate(inst)
+    assert_equal tmethbAABn, tmethbAABn.instantiate(inst)
+    assert_equal tmethbssfn, tmethbaabn.instantiate(inst)
+    assert_equal tstructinst, tstructorig.instantiate(inst)
+  end
+end

data/test/test_wrap.rb

@@ -0,0 +1,46 @@
+require 'minitest/autorun'
+require_relative '../lib/rdl.rb'
+
+class TestWrap < Minitest::Test
+  class C
+    def foo_public(x)
+      foo(x)
+    end
+
+    private
+
+    def foo(x)
+      x + 1
+    end
+  end
+
+  def test_private_wrap
+    type C, :foo, '(Fixnum) -> Fixnum'
+    c = C.new
+
+    assert_raises RDL::Type::TypeError do
+      c.foo_public("1")
+    end
+  end
+
+  class D
+    def foo_public(x)
+      foo(x)
+    end
+
+    protected
+
+    def foo(x)
+      x + 1
+    end
+  end
+
+  def test_protected_wrap
+    type D, :foo, '(Fixnum) -> Fixnum'
+    d = D.new
+
+    assert_raises RDL::Type::TypeError do
+      d.foo_public("1")
+    end
+  end
+end

data/types/{ruby-2.2.0 → ruby-2.x}/abbrev.rb

@@ -1,5 +1,5 @@
 module Abbrev
-  nowrap
+  rdl_nowrap
 
   type 'self.abbrev', '(Array<String>) -> Hash<String,String>'
-end
+end

data/types/{ruby-2.2.0 → ruby-2.x}/array.rb

@@ -1,8 +1,8 @@
 class Array
-  nowrap
+  rdl_nowrap
 
   type_params [:t], :all?
-  
+
   type :<<, '(t) -> Array<t>'
   type :[], '(Range<Fixnum>) -> Array<t>'
   type :[], '(Fixnum or Float) -> t'

data/types/{ruby-2.2.0 → ruby-2.x}/base64.rb

@@ -1,5 +1,5 @@
 module Base64
-  nowrap
+  rdl_nowrap
 
   type 'self.decode64', '(String) -> String'
   type 'self.encode64', '(String) -> String'
@@ -7,4 +7,4 @@ module Base64
   type 'self.strict_encode64', '(String) -> String'
   type 'self.urlsafe_decode64', '(String) -> String'
   type 'self.urlsafe_encode64', '(String) -> String'
-end
+end

data/types/{ruby-2.2.0 → ruby-2.x}/basic_object.rb

@@ -1,5 +1,6 @@
 class BasicObject
-  nowrap
+  rdl_nowrap
+  
   type :==, '(%any other) -> %bool'
   type :equal?, '(%any other) -> %bool'
   type :!, '() -> %bool'

data/types/{ruby-2.2.0 → ruby-2.x}/benchmark.rb

@@ -1,5 +1,5 @@
 module Benchmark
-  nowrap
+  rdl_nowrap
 
   type 'self.benchmark', '(String, ?Fixnum, ?String, *String) -> Array<Benchmark::Tms>'
   type 'self.bm', '(?Fixnum, *String) { (Benchmark::Process) -> nil} -> Array<Benchmark::Tms>'
@@ -8,4 +8,4 @@ module Benchmark
   type 'self.bmbm', '(?Fixnum label_width) { (Benchmark::Process) -> nil} -> Array<Benchmark::Tms>'
   type 'self.measure', '(?String label) -> Benchmark::Tms'
   type 'self.realtime', '() {(*%any) -> %any} -> Fixnum'
-end
+end

data/types/{ruby-2.2.0 → ruby-2.x}/bigdecimal.rb

@@ -1,6 +1,6 @@
 class BigDecimal
-  nowrap
-  
+  rdl_nowrap
+
   #type 'self._load', '()'
   type 'self.double_fig', '() -> Fixnum'
   type 'self.limit', '(Fixnum) -> Fixnum'
@@ -10,6 +10,6 @@ class BigDecimal
   type 'self.save_limit', '() { (*%any) -> %any } -> %any'
   type 'self.save_rounding_mode', '() { (*%any) -> %any } -> %any'
   type 'self.ver', '() -> String'
-  
+
   # TODO
-end
+end

data/types/{ruby-2.2.0 → ruby-2.x}/bigmath.rb

@@ -1,5 +1,5 @@
 module BigMath
-  nowrap
+  rdl_nowrap
 
   type 'self.exp', '(Fixnum, Fixnum) -> BigDecimal'
   type 'self.log', '(Fixnum, Fixnum) -> BigDecimal'
@@ -9,4 +9,4 @@ module BigMath
   type :cos, '(Fixnum, Fixnum) -> BigDecimal'
   type :sin, '(Fixnum, Fixnum) -> BigDecimal'
   type :sqrt, '(Fixnum, Fixnum) -> BigDecimal'
-end
+end

data/types/{ruby-2.2.0 → ruby-2.x}/class.rb

@@ -1,12 +1,12 @@
 class Class
-  nowrap
-  
+  rdl_nowrap
+
   type 'allocate', '() -> %any' # Instance of class self
   type 'inherited', '(Class) -> %any'
   #type 'initialize', '() -> '
   #type 'new', '(*%any) -> %any' #Causes two other test cases to fail
   type 'superclass', '() -> Class or nil'
-  
+
   #  type :class_eval, '() {() -> %any} -> %any'
   #  type :method_defined?, '(String or Symbol) -> %bool'
   #  type :define_method, '(String or Symbol) {(*%any) -> %any} -> Proc'

data/types/{ruby-2.2.0 → ruby-2.x}/complex.rb

@@ -1,5 +1,5 @@
 class Complex
-  nowrap
+  rdl_nowrap
 
   type 'self.polar', '(%real abs, ?%real arg) -> Complex'
   type 'self.rect', '(%real real, ?%real imag) -> Complex'
@@ -39,4 +39,4 @@ class Complex
   type :to_i, '() -> Integer'
   type :to_r, '() -> Rational'
   type :to_s, '() -> String'
-end
+end

data/types/{ruby-2.2.0 → ruby-2.x}/coverage.rb

@@ -1,6 +1,6 @@
 module Coverage
-  nowrap
+  rdl_nowrap
 
   type 'self.start', '() -> nil'
   type 'self.result', '() -> Hash<String,Array<Fixnum or nil>>'
-end
+end

data/types/{ruby-2.2.0 → ruby-2.x}/csv.rb

@@ -1,5 +1,5 @@
 class CSV
-  nowrap
+  rdl_nowrap
 
   type 'self.foreach', '(String or File, ?Hash<Symbol, %any>) {(Array<String>) -> %any} -> NilClass'
-end
+end

data/types/{ruby-2.2.0 → ruby-2.x}/date.rb

@@ -1,6 +1,6 @@
 class Date
-  nowrap
-  
+  rdl_nowrap
+
   type('self.now', "() -> DateTime")
   type(:strftime, "(String) -> String")
 end

data/types/{ruby-2.2.0 → ruby-2.x}/dir.rb

@@ -1,6 +1,6 @@
 class Dir
-  nowrap
-  
+  rdl_nowrap
+
   rdl_alias :[], :glob
   type 'self.chdir', '(?(String or Pathname)) -> 0'
   type 'self.chdir', '(?(String or Pathname)) { (String) -> u } -> u'
@@ -35,4 +35,4 @@ class Dir
   type :seek, '(Fixnum) -> self'
   type :tell, '() -> Fixnum'
   type :to_path, '() -> String or nil'
-end
+end

data/types/{ruby-2.2.0 → ruby-2.x}/encoding.rb

@@ -1,5 +1,5 @@
 class Encoding
-  nowrap
+  rdl_nowrap
 
   type 'self.aliases', '() -> Hash<String, String>'
   type 'self.compatible?', '(%any obj1, %any obj2) -> Encoding or nil'
@@ -20,4 +20,4 @@ class Encoding
   type :names, '() -> Array<String>'
   type :replicate, '(String name) -> Encoding'
   rdl_alias :to_s, :name
-end
+end

data/types/{ruby-2.2.0 → ruby-2.x}/enumerable.rb

@@ -1,8 +1,8 @@
 module Enumerable
-  nowrap
+  rdl_nowrap
 
   type_params [:t], :all?
-  
+
   type :all?, '() -> %bool'
   type :all?, '() { (t) -> %bool } -> %bool'
   type :any?, '() -> %bool'