rdl 2.0.1 → 2.1.0

data/lib/types/rails/active_record/base.rb

@@ -0,0 +1,2 @@
+RDL.nowrap :'ActiveRecord::Base'
+RDL.type :'ActiveRecord::Base', :logger, '() -> ActiveSupport::Logger'

data/lib/types/rails/active_record/core.rb

@@ -0,0 +1,2 @@
+RDL.nowrap :'ActiveRecord::Core'
+RDL.type :'ActiveRecord::Core', :==, '(%any) -> %bool'

data/lib/types/rails/active_record/finder_methods.rb

@@ -0,0 +1,2 @@
+RDL.nowrap :'ActiveRecord::FinderMethods'
+RDL.type :'ActiveRecord::FinderMethods', :exists?, '(?String or Fixnum or Array<String> or Hash<String or Symbol, %any>) -> %bool'

data/lib/types/rails/active_record/model_schema.rb

@@ -0,0 +1,37 @@
+module ActiveRecord::ModelSchema::ClassMethods
+  extend RDL::RDLAnnotate
+
+  rdl_post(:load_schema!) { |ret| # load_schema! doesn't return anything interesting
+    columns_hash.each { |name, col|
+      t = RDL::Rails.column_to_rdl(col.type)
+      if col.null
+        # may be null; show nullability in return type
+        rdl_type name,       "() -> #{t} or nil"     # getter
+        rdl_type "#{name}=", "(#{t}) -> #{t} or nil" # setter
+        rdl_type "write_attribute", "(:#{name}, #{t}) -> %bool"
+        rdl_type "update_attribute", "(:#{name}, #{t}) -> %bool"
+        rdl_type "update_column", "(:#{name}, #{t}) -> %bool"
+      else
+        # not null; can't truly check in type system but hint via the name
+        rdl_type name,       "() -> !#{t}"                 # getter
+        rdl_type "#{name}=", "(!#{t}) -> !#{t}" # setter
+        rdl_type "write_attribute", "(:#{name}, !#{t}) -> %bool"
+        rdl_type "update_attribute", "(:#{name}, #{t}) -> %bool"
+        rdl_type "update_column", "(:#{name}, #{t}) -> %bool"
+      end
+    }
+
+    attribute_types = RDL::Rails.attribute_types(self)
+    rdl_type 'self.find_by', '(' + attribute_types + ") -> #{self} or nil"
+    rdl_type 'self.find_by!', '(' + attribute_types + ") -> #{self}"
+    rdl_type 'update', '(' + attribute_types + ') -> %bool'
+    rdl_type 'update_columns', '(' + attribute_types + ') -> %bool'
+    rdl_type 'attributes=', '(' + attribute_types + ') -> %bool'
+
+    # If called with String arguments, can't check types as precisely
+    rdl_type 'write_attribute', '(String, %any) -> %bool'
+    rdl_type 'update_attribute', '(String, %any) -> %bool'
+    rdl_type 'update_column', '(String, %any) -> %bool'
+    true
+  }
+end

data/lib/types/rails/active_record/relation.rb

@@ -0,0 +1,11 @@
+RDL.nowrap :'ActiveRecord::Relation'
+
+RDL.type_params :'ActiveRecord::Relation', [:t], :all?
+
+RDL.type :'ActiveRecord::Relation', :[], '(Fixnum) -> t'
+RDL.type :'ActiveRecord::Relation', :empty?, '() -> %bool'
+RDL.type :'ActiveRecord::Relation', :first, '() -> t'
+RDL.type :'ActiveRecord::Relation', :length, '() -> Fixnum'
+RDL.type :'ActiveRecord::Relation', :sort, '() {(t, t) -> Fixnum} -> Array<t>'
+RDL.type :'ActiveRecord::Relation', :each, '() -> Enumerator<t>'
+RDL.type :'ActiveRecord::Relation', :each, '() { (t) -> %any } -> Array<t>'

data/lib/types/rails/active_record/schema_types.rb

@@ -0,0 +1,51 @@
+class ActiveRecord::Base
+  extend RDL::RDLAnnotate
+
+  def self.add_schema_types
+  end
+
+  rdl_post('self.add_schema_types') { |ret| # load_schema! doesn't return anything interesting
+    type 'self.where', "(*%any) -> ActiveRecord::Relation<#{self}>"
+
+    columns_hash.each { |name, col|
+      t = RDL::Rails.column_to_rdl(col.type)
+      if col.null
+        # may be null; show nullability in return type
+        rdl_type name,       "() -> #{t} or nil"     # getter
+        rdl_type "#{name}_id",       "() -> #{t} or nil"     # getter
+        rdl_type "#{name}=", "(#{t}) -> #{t} or nil" # setter
+        rdl_type "write_attribute", "(:#{name}, #{t}) -> %bool"
+        rdl_type "update_attribute", "(:#{name}, #{t}) -> %bool"
+        rdl_type "update_column", "(:#{name}, #{t}) -> %bool"
+      else
+        # not null; can't truly check in type system but hint via the name
+        rdl_type name,       "() -> !#{t}"                 # getter
+        rdl_type "#{name}_id",       "() -> !#{t}"                 # getter
+        rdl_type "#{name}=", "(!#{t}) -> !#{t}" # setter
+        rdl_type "write_attribute", "(:#{name}, !#{t}) -> %bool"
+        rdl_type "update_attribute", "(:#{name}, #{t}) -> %bool"
+        rdl_type "update_column", "(:#{name}, #{t}) -> %bool"
+      end
+    }
+
+    attribute_types = RDL::Rails.attribute_types(self)
+
+    rdl_type 'self.find', "(Fixnum) -> #{self}"
+    rdl_type 'self.find', "(String) -> #{self}"
+    rdl_type 'self.find', '({' + attribute_types + "}) -> #{self}"
+
+=begin
+    type 'self.find_by', '(' + attribute_types + ") -> #{self} or nil"
+    type 'self.find_by!', '(' + attribute_types + ") -> #{self}"
+    type 'update', '(' + attribute_types + ') -> %bool'
+    type 'update_columns', '(' + attribute_types + ') -> %bool'
+    type 'attributes=', '(' + attribute_types + ') -> %bool'
+
+    # If called with String arguments, can't check types as precisely
+    type 'write_attribute', '(String, %any) -> %bool'
+    type 'update_attribute', '(String, %any) -> %bool'
+    type 'update_column', '(String, %any) -> %bool'
+=end
+    true
+  }
+end

data/lib/types/rails/active_record/validations.rb

@@ -0,0 +1,2 @@
+RDL.nowrap :'ActiveRecord::Validations'
+RDL.type :'ActiveRecord::Validations', :valid?, '(?:create or :update or :on or NilClass) -> %bool'

data/lib/types/rails/active_support/base.rb

@@ -0,0 +1,2 @@
+RDL.nowrap :'ActiveRecord::Base'
+RDL.type :'ActiveRecord::Base', :logger, '() -> ActiveSupport::Logger'

data/lib/types/rails/active_support/logger.rb

@@ -0,0 +1,3 @@
+RDL.nowrap :'ActiveSupport::Logger'
+RDL.type :'ActiveSupport::Logger', :error, '(String) -> %bool'
+RDL.type :'ActiveSupport::Logger', :debug, '(String) -> %bool'

data/lib/types/rails/active_support/tagged_logging.rb

@@ -0,0 +1,2 @@
+RDL.nowrap :'ActiveSupport::TaggedLogging'
+RDL.type :'ActiveSupport::TaggedLogging', :info, '(String) -> %bool'

data/lib/types/rails/active_support/time_with_zone.rb

@@ -0,0 +1,13 @@
+RDL.nowrap :'ActiveSupport::TimeWithZone'
+RDL.type :'ActiveSupport::TimeWithZone', :beginning_of_day, '() -> ActiveSupport::TimeWithZone'
+RDL.type :'ActiveSupport::TimeWithZone', :end_of_day, '() -> ActiveSupport::TimeWithZone'
+RDL.type :'ActiveSupport::TimeWithZone', :beginning_of_week, '() -> ActiveSupport::TimeWithZone'
+RDL.type :'ActiveSupport::TimeWithZone', :end_of_week, '() -> ActiveSupport::TimeWithZone'
+RDL.type :'ActiveSupport::TimeWithZone', :to_date, '() -> Date'
+RDL.type :'ActiveSupport::TimeWithZone', :strftime, '(String) -> String'
+RDL.type :'ActiveSupport::TimeWithZone', :+, '(ActiveSupport::Duration) -> ActiveSupport::TimeWithZone'
+RDL.type :'ActiveSupport::TimeWithZone', :-, '(ActiveSupport::Duration) -> ActiveSupport::TimeWithZone'
+RDL.type :'ActiveSupport::TimeWithZone', :<, '(ActiveSupport::TimeWithZone or Time) -> %bool'
+RDL.type :'ActiveSupport::TimeWithZone', :>, '(ActiveSupport::TimeWithZone or Time) -> %bool'
+RDL.type :'ActiveSupport::TimeWithZone', :<=, '(ActiveSupport::TimeWithZone or Time) -> %bool'
+RDL.type :'ActiveSupport::TimeWithZone', :>=, '(ActiveSupport::TimeWithZone or Time) -> %bool'

data/lib/types/rails/active_support/time_zone.rb

@@ -0,0 +1,2 @@
+RDL.nowrap :'ActiveSupport::TimeZone'
+RDL.type :'ActiveSupport::TimeZone', :now, '() -> ActiveSupport::TimeWithZone'

data/lib/types/rails/fixnum.rb

@@ -0,0 +1,2 @@
+RDL.type :Fixnum, :*, '(ActiveSupport::Duration) -> ActiveSupport::Duration', version: RDL::Globals::FIXBIG_VERSIONS
+RDL.type :Fixnum, :day, '() -> ActiveSupport::Duration', version: RDL::Globals::FIXBIG_VERSIONS

data/lib/types/rails/integer.rb

@@ -0,0 +1,2 @@
+RDL.type :Integer, :*, '(ActiveSupport::Duration) -> ActiveSupport::Duration'
+RDL.type :Integer, :day, '() -> ActiveSupport::Duration'

data/lib/types/rails/rack/request.rb

@@ -0,0 +1,2 @@
+RDL.nowrap :'Rack::Request'
+RDL.type :'Rack::Request', :env, '() -> Hash<String, %any>'

data/lib/types/rails/string.rb

@@ -0,0 +1,3 @@
+RDL.type :String, :truncate, '(Fixnum) -> String'
+RDL.type :String, :strftime, '(String) -> String'
+RDL.type :String, :sanitize, '() -> String'

data/lib/types/rails/time.rb

@@ -0,0 +1 @@
+RDL.type :Time, 'self.zone', '() -> ActiveSupport::TimeZone'

data/rdl.gemspec

@@ -4,8 +4,8 @@
 
 Gem::Specification.new do |s|
   s.name        = 'rdl'
-  s.version     = '2.0.1'
-  s.date        = '2016-11-11'
+  s.version     = '2.1.0'
+  s.date        = '2017-06-14'
   s.summary     = 'Ruby type and contract system'
   s.description = <<-EOF
 RDL is a gem that adds types and contracts to Ruby. RDL includes extensive

data/test/disabled_test_rdoc.rb

@@ -14,9 +14,9 @@ class RdocTest < MiniTest::Test
 
   class TestClass
     extend RDL
-    
-    typesig :size, "()->Fixnum"
-    typesig :bytesize, "()->Fixnum"
+
+    typesig :size, "()->Integer"
+    typesig :bytesize, "()->Integer"
   end
 
   def test_rdoc_gen
@@ -35,25 +35,25 @@ class TestRDLRDoc
     @rdoc = RDoc::RDoc.new
     @rdoc.store = @store
     @rdoc.options = RDoc::Options.new
-    
+
     g = Object.new
     def g.class_dir() end
     def g.file_dir() end
     @rdoc.generator = g
-    
+
     @lib_dir = "#{@pwd}/lib"
     $LOAD_PATH.unshift @lib_dir # ensure we load from this RDoc
-    
+
     @options = RDoc::Options.new
     @options.option_parser = OptionParser.new
-    
+
     p Dir.tmpdir
     @tmpdir = File.join Dir.tmpdir, "test_rdoc_generator_darkfish_#{$$}"
     FileUtils.mkdir_p @tmpdir
     Dir.chdir @tmpdir
     @options.op_dir = @tmpdir
     @options.generator = RDoc::Generator::Darkfish
-    
+
     $LOAD_PATH.each do |path|
     darkfish_dir = File.join path, 'rdoc/generator/template/darkfish/'
         next unless File.directory? darkfish_dir

data/test/test_alias.rb

@@ -3,6 +3,7 @@ $LOAD_PATH << File.dirname(__FILE__) + "/../lib"
 require 'rdl'
 
 class TestAlias < Minitest::Test
+  extend RDL::Annotate
 
   def test_alias_lookup
     self.class.class_eval {

data/test/test_dsl.rb

@@ -7,8 +7,8 @@ class TestDsl < Minitest::Test
   class Pair
 
     # dsl {
-    #   type :left, '(Fixnum) -> Fixnum'
-    #   type :right, '(Fixnum) -> Fixnum'
+    #   type :left, '(Integer) -> Integer'
+    #   type :right, '(Integer) -> Integer'
     # }
     def entry(&blk)
       instance_eval(&blk)
@@ -30,9 +30,9 @@ class TestDsl < Minitest::Test
   class Tree
 
     # dsl :tree { # recursive DSL
-    #   type :left, '(Fixnum) -> Fixnum'
+    #   type :left, '(Integer) -> Integer'
     #   dsl :left, :tree
-    #   type :right, '(Fixnum) -> Fixnum'
+    #   type :right, '(Integer) -> Integer'
     #   dsl :right, :tree
     # }
     def entry(val, &blk)

data/test/test_generic.rb

@@ -3,10 +3,12 @@ $LOAD_PATH << File.dirname(__FILE__) + "/../lib"
 require 'rdl'
 
 class TestGeneric < Minitest::Test
+  extend RDL::Annotate
 
   # 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)
@@ -15,6 +17,7 @@ class TestGeneric < Minitest::Test
   end
 
   class H
+    extend RDL::Annotate
     type_params [:k, :v], :all?
     def initialize(h); @h = h end
     def all?(&blk)
@@ -23,6 +26,7 @@ class TestGeneric < Minitest::Test
   end
 
   class B
+    extend RDL::Annotate
     # class for checking other variance annotations
     type_params [:a, :b], nil, variance: [:+, :-] { |a, b| true }
     type "(a) -> nil"
@@ -37,13 +41,13 @@ class TestGeneric < Minitest::Test
   def setup
     @ta = RDL::Type::NominalType.new "TestGeneric::A"
     @th = RDL::Type::NominalType.new "TestGeneric::H"
-    @tas = RDL::Type::GenericType.new(@ta, $__rdl_string_type)
-    @tao = RDL::Type::GenericType.new(@ta, $__rdl_object_type)
+    @tas = RDL::Type::GenericType.new(@ta, RDL::Globals.types[:string])
+    @tao = RDL::Type::GenericType.new(@ta, RDL::Globals.types[:object])
     @taas = RDL::Type::GenericType.new(@ta, @tas)
     @taao = RDL::Type::GenericType.new(@ta, @tao)
-    @thss = RDL::Type::GenericType.new(@th, $__rdl_string_type, $__rdl_string_type)
-    @thoo = RDL::Type::GenericType.new(@th, $__rdl_object_type, $__rdl_object_type)
-    @thsf = RDL::Type::GenericType.new(@th, $__rdl_string_type, $__rdl_fixnum_type)
+    @thss = RDL::Type::GenericType.new(@th, RDL::Globals.types[:string], RDL::Globals.types[:string])
+    @thoo = RDL::Type::GenericType.new(@th, RDL::Globals.types[:object], RDL::Globals.types[:object])
+    @thsf = RDL::Type::GenericType.new(@th, RDL::Globals.types[:string], RDL::Globals.types[:integer])
     @tb = RDL::Type::NominalType.new "TestGeneric::B"
   end
 
@@ -68,10 +72,10 @@ class TestGeneric < Minitest::Test
     assert (not (@thss <= @th))
 
     # Check co- and contravariance using B
-    tbss = RDL::Type::GenericType.new(@tb, $__rdl_string_type, $__rdl_string_type)
-    tbso = RDL::Type::GenericType.new(@tb, $__rdl_string_type, $__rdl_object_type)
-    tbos = RDL::Type::GenericType.new(@tb, $__rdl_object_type, $__rdl_string_type)
-    tboo = RDL::Type::GenericType.new(@tb, $__rdl_object_type, $__rdl_object_type)
+    tbss = RDL::Type::GenericType.new(@tb, RDL::Globals.types[:string], RDL::Globals.types[:string])
+    tbso = RDL::Type::GenericType.new(@tb, RDL::Globals.types[:string], RDL::Globals.types[:object])
+    tbos = RDL::Type::GenericType.new(@tb, RDL::Globals.types[:object], RDL::Globals.types[:string])
+    tboo = RDL::Type::GenericType.new(@tb, RDL::Globals.types[:object], RDL::Globals.types[:object])
     assert (tbss <= tbss)
     assert (not (tbss <= tbso))
     assert (tbss <= tbos)
@@ -91,10 +95,10 @@ class TestGeneric < Minitest::Test
   end
 
   def test_le_structural
-    tbss = RDL::Type::GenericType.new(@tb, $__rdl_string_type, $__rdl_string_type)
-    tma = RDL::Type::MethodType.new([], nil, $__rdl_nil_type)
-    tmb = RDL::Type::MethodType.new([$__rdl_string_type], nil, $__rdl_nil_type)
-    tmc = RDL::Type::MethodType.new([$__rdl_fixnum_type], nil, $__rdl_nil_type)
+    tbss = RDL::Type::GenericType.new(@tb, RDL::Globals.types[:string], RDL::Globals.types[:string])
+    tma = RDL::Type::MethodType.new([], nil, RDL::Globals.types[:nil])
+    tmb = RDL::Type::MethodType.new([RDL::Globals.types[:string]], nil, RDL::Globals.types[:nil])
+    tmc = RDL::Type::MethodType.new([RDL::Globals.types[:integer]], nil, RDL::Globals.types[:nil])
     ts1 = RDL::Type::StructuralType.new(m2: tma)
     assert (tbss <= ts1)
     ts2 = RDL::Type::StructuralType.new(m1: tmb)
@@ -108,6 +112,7 @@ class TestGeneric < Minitest::Test
   end
 
   class C
+    extend RDL::Annotate
     type "() -> self"
     def m1() return self; end
     type "() -> self"
@@ -141,51 +146,53 @@ class TestGeneric < Minitest::Test
   end
 
   def test_instantiate
-    assert_raises(RuntimeError) { Object.new.instantiate!($__rdl_string_type) }
+    assert_raises(RuntimeError) { RDL.instantiate!(Object.new, RDL::Globals.types[:string]) }
 
     # Array<String>
-    assert (A.new([]).instantiate!('String'))
-    assert (A.new(["a", "b", "c"]).instantiate!($__rdl_string_type))
-    assert (A.new(["a", "b", "c"]).instantiate!('String'))
-    assert_raises(RDL::Type::TypeError) { A.new([1, 2, 3]).instantiate!('String') }
+    assert (RDL.instantiate!(A.new([]), 'String'))
+    assert (RDL.instantiate!(A.new(["a", "b", "c"]), RDL::Globals.types[:string], check: true))
+    assert (RDL.instantiate!(A.new(["a", "b", "c"]), 'String', check: true))
+    assert_raises(RDL::Type::TypeError) { RDL.instantiate!(A.new([1, 2, 3]), 'String', check: true) }
+    assert (RDL.instantiate!(A.new([1, 2, 3]), 'String', check: false))
 
     # Array<Object>
-    assert (A.new([])).instantiate!('Object')
-    assert (A.new(["a", "b", "c"]).instantiate!($__rdl_object_type))
-    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 (RDL.instantiate!(A.new([]), 'Object', check: true))
+    assert (RDL.instantiate!(A.new(["a", "b", "c"]), RDL::Globals.types[:object], check: true))
+    assert (RDL.instantiate!(A.new(["a", "b", "c"]), 'Object', check: true))
+    assert (RDL.instantiate!(A.new([1, 2, 3]), 'Object', check: true))
+
+    # Hash<String, Integer>
+    assert (RDL.instantiate!(H.new({}), 'String', 'Integer', check: true))
+    assert (RDL.instantiate!(H.new({"one"=>1, "two"=>2}), 'String', 'Integer', check: true))
     assert_raises(RDL::Type::TypeError) {
-      H.new(one: 1, two: 2).instantiate!('String', 'Fixnum')
+      RDL.instantiate!(H.new(one: 1, two: 2), 'String', 'Integer', check: true)
     }
+    assert (RDL.instantiate!(H.new(one: 1, two: 2), 'String', 'Integer', check: false))
     assert_raises(RDL::Type::TypeError){
-      H.new({"one"=>:one, "two"=>:two}).instantiate!('String', 'Fixnum')
+      RDL.instantiate!(H.new({"one"=>:one, "two"=>:two}), 'String', 'Integer', check: true)
     }
 
     # 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'))
+    assert (RDL.instantiate!(H.new({}), 'Object', 'Object', check: true))
+    assert (RDL.instantiate!(H.new({"one"=>1, "two"=>2}), 'Object', 'Object', check: true))
+    assert (RDL.instantiate!(H.new(one: 1, two: 2), 'Object', 'Object', check: true))
+    assert (RDL.instantiate!(H.new({"one"=>:one, "two"=>:two}), 'Object', 'Object', check: true))
 
     # A<A<String>>
-    assert (A.new([A.new(["a", "b"]).instantiate!('String'),
-                   A.new(["c"]).instantiate!('String')]).instantiate!('TestGeneric::A<String>'))
+    assert (RDL.instantiate!(A.new([RDL.instantiate!(A.new(["a", "b"]), 'String', check: true),
+                                    RDL.instantiate!(A.new(["c"]), 'String', check: true)]), 'TestGeneric::A<String>', check: true))
     assert_raises(RDL::Type::TypeError) {
       # Must instantiate all members
-      A.new([A.new(["a", "b"]).instantiate!('String'), A.new([])]).instantiate!('TestGeneric::A<String>')
+      RDL.instantiate!(A.new([RDL.instantiate!(A.new(["a", "b"]), 'String', check: true), A.new([])]), 'TestGeneric::A<String>', check: true)
     }
     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>')
+      RDL.instantiate!(A.new([RDL.instantiate!(A.new(["a", "b"]), 'String', check: true), "A"]), 'TestGeneric::A<String>', check: true)
     }
     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>')
+      RDL.instantiate!(A.new([RDL.instantiate!(A.new(["a", "b"]), 'String', check: true),
+                              RDL.instantiate!(H.new({a: 1, b: 2}), 'Object', 'Object', check: true)]), 'TestGeneric::A<String>', check: true)
     }
   end
 

data/test/test_intersection.rb

@@ -8,7 +8,7 @@ class TestIntersection < Minitest::Test
   def setup
     @parser = RDL::Type::Parser.new
 
-    @fixnum = NominalType.new(Fixnum)
+    @integer = NominalType.new(Integer)
     @string = NominalType.new(String)
     @array = NominalType.new(Array)
     @hash = NominalType.new(Hash)
@@ -16,24 +16,24 @@ class TestIntersection < Minitest::Test
 
     @tparam_t = VarType.new(:t)
 
-    @f_or_s = UnionType.new(@fixnum, @string)
+    @f_or_s = UnionType.new(@integer, @string)
     @string_or_true = UnionType.new(@string, @true_n)
 
-    @array_of_fixnum = GenericType.new(@array, @fixnum)
+    @array_of_integer = GenericType.new(@array, @integer)
     @array_of_true = GenericType.new(@array, @true_n)
-    @array_of_fixnum_string = GenericType.new(@array, @f_or_s)
+    @array_of_integer_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)
+    @hash_of_string_integer = GenericType.new(@hash, @string, @integer)
+    @hash_of_string_true_integer = GenericType.new(@hash, @string_or_true, @integer)
+    @a_a_f = GenericType.new(@array, @array_of_integer)
     @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"
+    t1 = @parser.scan_str "(Integer) -> Integer"
+    t2 = @parser.scan_str "(Integer) -> Integer"
+    t3 = @parser.scan_str "(Integer) -> Integer"
     i = IntersectionType.new(t1, t2, t3)
 
     assert_equal(t1, i)