typed.rb 0.0.11

data/spec/lib/types/polymorphism/generic_comparisons_spec.rb

@@ -0,0 +1,492 @@
+require_relative '../../../spec_helper'
+
+describe TypedRb::Types::Polymorphism::GenericComparisons do
+
+  let(:language) { TypedRb::Language.new }
+
+  let(:int_bound) do
+    TypedRb::Types::TySingletonObject.new(Integer)
+  end
+
+  let(:numeric_bound) do
+    TypedRb::Types::TySingletonObject.new(Numeric)
+  end
+
+  let(:object_bound) do
+    TypedRb::Types::TySingletonObject.new(Object)
+  end
+
+  # Array[? < Integer]
+  let(:array_extends_integer) do
+    type_arg = TypedRb::Types::Polymorphism::TypeVariable.new('Array:T:1:?',
+                                                              :gen_name => false,
+                                                              :upper_bound => int_bound)
+    TypedRb::Types::TyGenericSingletonObject.new(Array, [type_arg])
+  end
+
+  # Array[? > Numeric]
+  let(:array_super_numeric) do
+    type_arg = TypedRb::Types::Polymorphism::TypeVariable.new('Array:T:1:?',
+                                                              :gen_name => false,
+                                                              :lower_bound => numeric_bound)
+#    type_arg.bind(numeric_bound)
+    TypedRb::Types::TyGenericSingletonObject.new(Array, [type_arg])
+  end
+
+  # Array[?]
+  let(:arg0) do
+    type_arg = TypedRb::Types::Polymorphism::TypeVariable.new('?', :gen_name => false)
+    TypedRb::Types::TyGenericSingletonObject.new(Array, [type_arg])
+  end
+
+  # Array[Integer]
+  let(:arg1) do
+    type_arg = TypedRb::Types::Polymorphism::TypeVariable.new('Array:T', :gen_name => false,
+                                                              :upper_bound => int_bound,
+                                                              :lower_bound => int_bound)
+    type_arg.bind(int_bound)
+    TypedRb::Types::TyGenericSingletonObject.new(Array, [type_arg])
+  end
+
+  # Array[Numeric]
+  let(:arg2) do
+    type_arg = TypedRb::Types::Polymorphism::TypeVariable.new('Array:T', :gen_name => false,
+                                                              :upper_bound => numeric_bound,
+                                                              :lower_bound => numeric_bound)
+    type_arg.bind(numeric_bound)
+    TypedRb::Types::TyGenericSingletonObject.new(Array, [type_arg])
+  end
+
+  # Array[? < Numeric]
+  let(:arg3) do
+    type_arg = TypedRb::Types::Polymorphism::TypeVariable.new('Array:T:1:?',
+                                                              :gen_name => false,
+                                                              :upper_bound => numeric_bound)
+#    type_arg.bind(numeric_bound)
+    TypedRb::Types::TyGenericSingletonObject.new(Array, [type_arg])
+  end
+
+  # Array[? > Integer]
+  let(:arg4) do
+    type_arg = TypedRb::Types::Polymorphism::TypeVariable.new('Array:T:1:?',
+                                                              :gen_name => false,
+                                                              :lower_bound => int_bound)
+ #   type_arg.bind(int_bound)
+    TypedRb::Types::TyGenericSingletonObject.new(Array, [type_arg])
+  end
+
+  # Array[? > Object]
+  let(:arg5) do
+    type_arg = TypedRb::Types::Polymorphism::TypeVariable.new('Array:T:1:?',
+                                                              :gen_name => false,
+                                                              :lower_bound => object_bound)
+#    type_arg.bind(object_bound)
+    TypedRb::Types::TyGenericSingletonObject.new(Array, [type_arg])
+  end
+
+  context 'base of :lt comparison is a generic type with an upper_bound' do
+    it 'checks correctly: Array<?> :lt Array<? extends Integer> => [?, ?] /< [?, Integer] => FALSE' do
+      code = <<__CODE
+         ts '#tgcoll2 / Array[? < Integer] -> unit'
+         def tgcoll2(gc); end
+
+         arg = Array.('[?]').new
+
+         tgcoll2(arg)
+__CODE
+      expect {
+        language.check(code)
+      }.to raise_error(TypedRb::TypeCheckError)
+    end
+
+    it 'checks correctly: Array<?> :lt Array<? extends Integer> => [?, ?] /< [?, Integer] => FALSE' do
+      expect(arg0.compatible?(array_extends_integer, :lt)).to be_falsey
+    end
+
+
+    it 'checks correctly: Array<? extends Integer> :lt  correctly: Array<?> => [?, Integer] < [?, ?] => TRUE' do
+      code = <<__CODE
+         ts '#tgcoll3 / Array[?] -> unit'
+         def tgcoll3(gc); end
+
+         arg = Array.('[? < Integer]').new
+
+         tgcoll3(arg)
+__CODE
+
+      result = language.check(code)
+      expect(result.ruby_type).to eq(NilClass)
+    end
+
+    it 'checks correctly: Array<? extends Integer> :lt  correctly: Array<?> => [?, Integer] < [?, ?] => TRUE' do
+      expect(array_extends_integer.compatible?(arg0, :lt)).to be_truthy
+    end
+
+
+    it 'checks correctly: Array<Integer> :lt Array<? extends Integer> => [Integer, Integer] < [?, Integer] => TRUE' do
+      code = <<__CODE
+         ts '#tgcoll4 / Array[? < Integer] -> unit'
+         def tgcoll4(gc); end
+
+         arg = Array.(Integer).new
+
+         tgcoll4(arg)
+__CODE
+
+      result = language.check(code)
+      expect(result.ruby_type).to eq(NilClass)
+    end
+
+    it 'checks correctly: Array<Integer> :lt Array<? extends Integer> => [Integer, Integer] < [?, Integer] => TRUE' do
+      expect(arg1.compatible?(array_extends_integer, :lt)).to be_truthy
+    end
+
+
+    it 'checks correctly: Array<? extends Integer> :lt Array<Integer> => [?, Integer] /< [Integer, Integer] => FALSE' do
+      code = <<__CODE
+         ts '#tgcoll5 / Array[Integer] -> unit'
+         def tgcoll5(gc); end
+
+         arg = Array.('[? < Integer]').new
+         tgcoll5(arg)
+__CODE
+      expect {
+        language.check(code)
+      }.to raise_error(TypedRb::TypeCheckError)
+    end
+
+    it 'checks correctly: Array<? extends Integer> :lt Array<Integer> => [?, Integer] /< [Integer, Integer] => FALSE' do
+      expect(array_extends_integer.compatible?(arg1, :lt)).to be_falsey
+    end
+
+
+
+    it 'checks correctly: Array<Numeric> :lt Array<? extends Integer> => [Numeric, Numeric] /< [?, Integer] => FALSE' do
+      code = <<__CODE
+         ts '#tgcoll6 / Array[? < Integer] -> unit'
+         def tgcoll6(gc); end
+
+         arg = Array.(Numeric).new
+         tgcoll6(arg)
+__CODE
+      expect {
+        language.check(code)
+      }.to raise_error(TypedRb::TypeCheckError)
+    end
+
+    it 'checks correctly: Array<Numeric> :lt Array<? extends Integer> => [Numeric, Numeric] /< [?, Integer] => FALSE' do
+      expect(arg2.compatible?(array_extends_integer, :lt)).to be_falsey
+    end
+
+
+    it 'checks correctly: Array<? extends Integer> :lt Array<Numeric> => [?, Integer] /< [Numeric, Numeric] => FALSE' do
+      code = <<__CODE
+         ts '#tgcoll7 / Array[Numeric] -> unit'
+         def tgcoll7(gc); end
+
+         arg = Array.('[? < Integer]').new
+         tgcoll7(arg)
+__CODE
+      expect {
+        language.check(code)
+      }.to raise_error(TypedRb::TypeCheckError)
+    end
+
+    it 'checks correctly: Array<? extends Integer> :lt Array<Numeric> => [?, Integer] /< [Numeric, Numeric] => FALSE' do
+      expect(array_extends_integer.compatible?(arg2, :lt)).to be_falsey
+    end
+
+
+
+    it 'checks correctly: Array<? extends Integer> :lt Array<? extends Integer> => [?, Integer] < [?, Integer] => TRUE' do
+      code = <<__CODE
+         ts '#tgcoll9 / Array[? < Integer] -> unit'
+         def tgcoll9(gc); end
+
+         arg = Array.('[? < Integer]').new
+
+         tgcoll9(arg)
+__CODE
+
+      result = language.check(code)
+      expect(result.ruby_type).to eq(NilClass)
+    end
+
+    it 'checks correctly: Array<? extends Integer> :lt Array<? extends Integer> => [?, Integer] < [?, Integer] => TRUE' do
+      expect(array_extends_integer.compatible?(array_extends_integer, :lt)).to be_truthy
+    end
+
+
+    it 'checks correctly: Array<? extends Numeric> :lt Array<? extends Integer> => [?, Numeric] /< [?, Integer] => FALSE' do
+      code = <<__CODE
+         ts '#tgcoll10 / Array[? < Integer] -> unit'
+         def tgcoll10(gc); end
+
+         arg = Array.('[? < Numeric]').new
+         tgcoll10(arg)
+__CODE
+      expect {
+        language.check(code)
+      }.to raise_error(TypedRb::TypeCheckError)
+    end
+
+    it 'checks correctly: Array<? extends Numeric> :lt Array<? extends Integer> => [?, Numeric] /< [?, Integer] => FALSE' do
+      expect(arg3.compatible?(array_extends_integer, :lt)).to be_falsey
+    end
+
+
+    it 'checks correctly: Array<? extends Integer> :lt Array<? extends Numeric> => [?, Integer] < [?, Numeric] => TRUE' do
+      code = <<__CODE
+         ts '#tgcoll11 / Array[? < Numeric] -> unit'
+         def tgcoll11(gc); end
+
+         arg = Array.('[? < Integer]').new
+
+         tgcoll11(arg)
+__CODE
+
+      result = language.check(code)
+      expect(result.ruby_type).to eq(NilClass)
+    end
+
+    it 'checks correctly: Array<? extends Integer> :lt Array<? extends Numeric> => [?, Integer] < [?, Numeric] => TRUE' do
+      expect(array_extends_integer.compatible?(arg3, :lt)).to be_truthy
+    end
+
+
+    it 'checks correctly: Array<? super Integer> :lt Array<? extends Integer> => [Integer, ?] /< [?, Integer] => FALSE' do
+      code = <<__CODE
+         ts '#tgcoll12 / Array[? < Integer] -> unit'
+         def tgcoll12(gc); end
+
+         arg = Array.('[? > Integer]').new
+         tgcoll12(arg)
+__CODE
+      expect {
+        language.check(code)
+      }.to raise_error(TypedRb::TypeCheckError)
+    end
+
+    it 'checks correctly: Array<? super Integer> :lt Array<? extends Integer> => [Integer, ?] /< [?, Integer] => FALSE' do
+      expect(arg4.compatible?(array_extends_integer, :lt)).to be_falsey
+    end
+
+
+    it 'checks correctly: Array<? extends Integer> :lt Array<? super Integer> => [?, Integer] /< [Integer, ?] => FALSE' do
+      code = <<__CODE
+         ts '#tgcoll13 / Array[? > Integer] -> unit'
+         def tgcoll13(gc); end
+
+         arg = Array.('[? < Integer]').new
+         tgcoll13(arg)
+__CODE
+      expect {
+        language.check(code)
+      }.to raise_error(TypedRb::TypeCheckError)
+    end
+
+    it 'checks correctly: Array<? extends Integer> :lt Array<? super Integer> => [?, Integer] /< [Integer, ?] => FALSE' do
+      expect(array_extends_integer.compatible?(arg4, :lt)).to be_falsey
+    end
+
+
+    it 'checks correctly: Array<? super Numeric> :lt Array<? extends Integer> => [Numeric, ?] /< [?, Integer] => FALSE' do
+      code = <<__CODE
+         ts '#tgcoll14 / Array[? < Integer] -> unit'
+         def tgcoll14(gc); end
+
+         arg = Array.('[? > Numeric]').new
+         tgcoll14(arg)
+__CODE
+      expect {
+        language.check(code)
+      }.to raise_error(TypedRb::TypeCheckError)
+    end
+
+    it 'checks correctly: Array<? super Numeric> :lt Array<? extends Integer> => [Numeric, ?] /< [?, Integer] => FALSE' do
+      expect(array_super_numeric.compatible?(array_extends_integer, :lt)).to be_falsey
+    end
+
+
+    it 'checks correctly: Array<? extends Integer> :lt Array<? super Numeric> => [?, Integer] /< [Numeric, ?] => FALSE' do
+      code = <<__CODE
+         ts '#tgcoll15 / Array[? > Numeric] -> unit'
+         def tgcoll15(gc); end
+
+         arg = Array.('[? < Integer]').new
+         tgcoll15(arg)
+__CODE
+      expect {
+        language.check(code)
+      }.to raise_error(TypedRb::TypeCheckError)
+    end
+
+    it 'checks correctly: Array<? extends Integer> :lt Array<? super Numeric> => [?, Integer] /< [Numeric, ?] => FALSE' do
+      expect(array_extends_integer.compatible?(array_super_numeric, :lt)).to be_falsey
+    end
+  end
+
+  context 'base of :lt comparison is a generic type with a lower_bound' do
+
+    it 'checks compatible? Array<?> :lt Array<? super Numeric> => [?, ?] /< [Numeric, ?] => FALSE' do
+      expect(arg0.compatible?(array_super_numeric, :lt)).to be_falsey
+    end
+
+    it 'checks compatible? Array<? super Numeric> :lt Array<?> => [Numeric, ?] /< [?, ?] => TRUE' do
+      expect(array_super_numeric.compatible?(arg0, :lt)).to be_truthy
+    end
+
+    it 'checks correctly: Array<Integer> :lt Array<? super Numeric> => [Integer, Integer] /< [Numeric, ?] => FALSE' do
+      expect(arg1.compatible?(array_super_numeric, :lt)).to be_falsey
+    end
+
+    it 'checks correctly: Array<? super Numeric> :lt Array<Integer> =>  [Numeric, ?] /< [Integer, Integer] => FALSE' do
+      expect(array_super_numeric.compatible?(arg1, :lt)).to be_falsey
+    end
+
+    it 'checks correctly: Array<Numeric> :lt Array<? super Numeric> => [Numeric, Numeric] < [Numeric, ?] => TRUE' do
+      expect(arg2.compatible?(array_super_numeric, :lt)).to be_truthy
+    end
+
+    it 'checks correctly: Array<? super Numeric> :lt Array<Numeric> =>  [Numeric, ?] < [Numeric, Numeric] => FALSE' do
+      expect(array_super_numeric.compatible?(arg2, :lt)).to be_falsey
+    end
+
+    it 'checks correctly: Array<? extends Numeric> :lt Array<? super Numeric> => [?, Numeric] /< [Numeric, ?] => FALSE' do
+      expect(arg3.compatible?(array_super_numeric, :lt)).to be_falsey
+    end
+
+    it 'checks correctly: Array<? super Numeric> :lt Array<? extends Numeric> => [Numeric,?] /< [?, Numeric] => FALSE' do
+      expect(array_super_numeric.compatible?(arg3, :lt)).to be_falsey
+    end
+
+    it 'checks correctly: Array<? super Integer> :lt Array<? super Numeric> => [Integer, ?] /< [Numeric, ?] => FALSE' do
+      expect(arg4.compatible?(array_super_numeric, :lt)).to be_falsey
+    end
+
+    it 'checks correctly: Array<? super Numeric> :lt Array<? super Integer> => [Numeric, ?] < [Integer, ?] => TRUE' do
+      expect(array_super_numeric.compatible?(arg4, :lt)).to be_truthy
+    end
+
+    it 'checks correctly: Array<? super Numeric> :lt Array<? super Numeric> => [Numeric, ?] < [Numeric, ?] => TRUE' do
+      expect(array_super_numeric.compatible?(array_super_numeric, :lt)).to be_truthy
+    end
+
+    it 'checks correctly: Array<? super Object> :lt Array<? super Numeric> => [Object, ?] < [Numeric, ?] => TRUE' do
+      expect(arg5.compatible?(array_super_numeric, :lt)).to be_truthy
+    end
+
+    it 'checks correctly: Array<? super Numeric> :lt Array<? super Object> => [Numeric, ?] /< [Object, ?] => FALSE' do
+      expect(array_super_numeric.compatible?(arg5, :lt)).to be_falsey
+    end
+  end
+
+  context 'base of :gt comparison is a generic type with an upper_bound' do
+    it 'checks correctly: Array<?> :gt Array<? extends Integer> => [?, ?] > [?, Integer] => TRUE' do
+      expect(arg0.compatible?(array_extends_integer, :gt)).to be_truthy
+    end
+
+    it 'checks correctly: Array<? extends Integer> :gt  correctly: Array<?> => [?, Integer] /> [?, ?] => FALSE' do
+      expect(array_extends_integer.compatible?(arg0, :gt)).to be_falsey
+    end
+
+    it 'checks correctly: Array<Integer> :gt Array<? extends Integer> => [Integer, Integer] /> [?, Integer] => FALSE' do
+      expect(arg1.compatible?(array_extends_integer, :gt)).to be_falsey
+    end
+
+    it 'checks correctly: Array<? extends Integer> :gt Array<Integer> => [?, Integer] > [Integer, Integer] => TRUE' do
+      expect(array_extends_integer.compatible?(arg1, :gt)).to be_truthy
+    end
+
+    it 'checks correctly: Array<Numeric> :gt Array<? extends Integer> => [Numeric, Numeric] /> [?, Integer] => FALSE' do
+      expect(arg2.compatible?(array_extends_integer, :gt)).to be_falsey
+    end
+
+    it 'checks correctly: Array<? extends Integer> :gt Array<Numeric> => [?, Integer] /> [Numeric, Numeric] => FALSE' do
+      expect(array_extends_integer.compatible?(arg2, :gt)).to be_falsey
+    end
+
+    it 'checks correctly: Array<? extends Integer> :gt Array<? extends Integer> => [?, Integer] > [?, Integer] => TRUE' do
+      expect(array_extends_integer.compatible?(array_extends_integer, :gt)).to be_truthy
+    end
+
+    it 'checks correctly: Array<? extends Numeric> :gt Array<? extends Integer> => [?, Numeric] > [?, Integer] => TRUE' do
+      expect(arg3.compatible?(array_extends_integer, :gt)).to be_truthy
+    end
+
+    it 'checks correctly: Array<? extends Integer> :gt Array<? extends Numeric> => [?, Integer] > [?, Numeric] => FALSE' do
+      expect(array_extends_integer.compatible?(arg3, :gt)).to be_falsey
+    end
+
+    it 'checks correctly: Array<? super Integer> :gt Array<? extends Integer> => [Integer, ?] /> [?, Integer] => FALSE' do
+      expect(arg4.compatible?(array_extends_integer, :gt)).to be_falsey
+    end
+
+    it 'checks correctly: Array<? extends Integer> :gt Array<? super Integer> => [?, Integer] /> [Integer, ?] => FALSE' do
+      expect(array_extends_integer.compatible?(arg4, :gt)).to be_falsey
+    end
+
+    it 'checks correctly: Array<? super Numeric> :gt Array<? extends Integer> => [Numeric, ?] /> [?, Integer] => FALSE' do
+      expect(array_super_numeric.compatible?(array_extends_integer, :gt)).to be_falsey
+    end
+
+    it 'checks correctly: Array<? extends Integer> :gt Array<? super Numeric> => [?, Integer] /> [Numeric, ?] => FALSE' do
+      expect(array_extends_integer.compatible?(array_super_numeric, :gt)).to be_falsey
+    end
+  end
+
+  context 'base of :gt comparison is a generic type with a lower_bound' do
+
+    it 'checks compatible? Array<?> :gt Array<? super Numeric> => [?, ?] > [Numeric, ?] => TRUE' do
+      expect(arg0.compatible?(array_super_numeric, :gt)).to be_truthy
+    end
+
+    it 'checks compatible? Array<? super Numeric> :gt Array<?> => [Numeric, ?] /> [?, ?] => FALSE' do
+      expect(array_super_numeric.compatible?(arg0, :gt)).to be_falsey
+    end
+
+    it 'checks correctly: Array<Integer> :gt Array<? super Numeric> => [Integer, Integer] /> [Numeric, ?] => FALSE' do
+      expect(arg1.compatible?(array_super_numeric, :gt)).to be_falsey
+    end
+
+    it 'checks correctly: Array<? super Numeric> :gt Array<Integer> =>  [Numeric, ?] /> [Integer, Integer] => FALSE' do
+      expect(array_super_numeric.compatible?(arg1, :gt)).to be_falsey
+    end
+
+    it 'checks correctly: Array<Numeric> :gt Array<? super Numeric> => [Numeric, Numeric] /> [Numeric, ?] => FALSE' do
+      expect(arg2.compatible?(array_super_numeric, :gt)).to be_falsey
+    end
+
+    it 'checks correctly: Array<? super Numeric> :gt Array<Numeric> =>  [Numeric, ?] > [Numeric, Numeric] => TRUE' do
+      expect(array_super_numeric.compatible?(arg2, :gt)).to be_truthy
+    end
+
+    it 'checks correctly: Array<? extends Numeric> :gt Array<? super Numeric> => [?, Numeric] /> [Numeric, ?] => FALSE' do
+      expect(arg3.compatible?(array_super_numeric, :gt)).to be_falsey
+    end
+
+    it 'checks correctly: Array<? super Numeric> :gt Array<? extends Numeric> => [Numeric,?] /> [?, Numeric] => FALSE' do
+      expect(array_super_numeric.compatible?(arg3, :gt)).to be_falsey
+    end
+
+    it 'checks correctly: Array<? super Integer> :gt Array<? super Numeric> => [Integer, ?] > [Numeric, ?] => TRUE' do
+      expect(arg4.compatible?(array_super_numeric, :gt)).to be_truthy
+    end
+
+    it 'checks correctly: Array<? super Numeric> :gt Array<? super Integer> => [Numeric, ?] > [Integer, ?] => FALSE' do
+      expect(array_super_numeric.compatible?(arg4, :gt)).to be_falsey
+    end
+
+    it 'checks correctly: Array<? super Numeric> :gt Array<? super Numeric> => [Numeric, ?] > [Numeric, ?] => TRUE' do
+      expect(array_super_numeric.compatible?(array_super_numeric, :gt)).to be_truthy
+    end
+
+    it 'checks correctly: Array<? super Object> :gt Array<? super Numeric> => [Object, ?] /> [Numeric, ?] => FALSE' do
+      expect(arg5.compatible?(array_super_numeric, :gt)).to be_falsey
+    end
+
+    it 'checks correctly: Array<? super Numeric> :gt Array<? super Object> => [Numeric, ?] > [Object, ?] => TRUE' do
+      expect(array_super_numeric.compatible?(arg5, :gt)).to be_truthy
+    end
+  end
+end

data/spec/lib/types/polymorphism/type_variable_register_spec.rb

@@ -0,0 +1,128 @@
+require_relative '../../../spec_helper'
+
+describe TypedRb::Types::Polymorphism::TypeVariableRegister do
+  describe '#initialize' do
+    it 'should be possible to create a register without parent' do
+      subject = described_class.new(nil,:top_level)
+      expect(subject.parent).to be_nil
+    end
+
+    it 'should be possible to create a nested register' do
+      parent = described_class.new(nil,:top_level)
+      child = described_class.new(parent, :lambda)
+      expect(parent.children).to include(child)
+      expect(child.parent).to eq(parent)
+    end
+  end
+
+  describe '#type_variable_for' do
+    it 'finds a type variable for a single register' do
+      register = described_class.new(nil,:top_level)
+      type_variable_one = register.type_variable_for(:instance_variable, '@a', String.ancestors)
+      type_variable_two = register.type_variable_for(:instance_variable, '@a', String.ancestors)
+      expect(type_variable_one).to eq(type_variable_two)
+    end
+
+    it 'finds a type_variable in a nested register' do
+      parent = described_class.new(nil,:top_level)
+      child = described_class.new(parent, :lambda)
+      type_variable_one = parent.type_variable_for(:instance_variable, '@a', String.ancestors)
+      type_variable_two = child.type_variable_for(:instance_variable, '@a', String.ancestors)
+      expect(type_variable_one).to eq(type_variable_two)
+    end
+
+   it 'finds a type variable in the hierarchy' do
+     parent = described_class.new(nil,:top_level)
+     child = described_class.new(parent, :lambda)
+     type_variable_one = parent.type_variable_for(:instance_variable, '@a', Object.ancestors)
+     type_variable_two = child.type_variable_for(:instance_variable, '@a', String.ancestors)
+     expect(type_variable_one).to eq(type_variable_two)
+   end
+  end
+
+  describe '#type_variable_for_message' do
+    it 'finds a type variable for a single register' do
+      register = described_class.new(nil,:top_level)
+      type_variable_one = register.type_variable_for_message('x', 'msg')
+      type_variable_two = register.type_variable_for_message('x', 'msg')
+      expect(type_variable_one).to eq(type_variable_two)
+    end
+
+    it 'finds a type_variable in a nested register' do
+      parent = described_class.new(nil,:top_level)
+      child = described_class.new(parent, :lambda)
+      type_variable_one = parent.type_variable_for_message('x', 'msg')
+      type_variable_two = child.type_variable_for_message('x', 'msg')
+      expect(type_variable_one).to eq(type_variable_two)
+    end
+  end
+
+  describe '#apply_type' do
+    it 'applies a type to a send constraint' do
+      TypedRb::Types::TypingContext.type_variables_register = described_class.new(nil,:top_level)
+      register = TypedRb::Types::TypingContext.type_variables_register
+      xvar = register.type_variable_for_abstraction(:lambda,'x',top_level_typing_context)
+      ret_type = xvar.add_message_constraint('id', [xvar])
+
+      renamed_x = tyvariable('renamed_x')
+      renamed_return_id_x = tyvariable('renamed_ret_id_x')
+      renamed_register = register.send(:apply_type,nil, {xvar.variable => renamed_x, ret_type.variable => renamed_return_id_x})
+
+      constraints = renamed_register.all_constraints
+      expect(constraints.size).to eq(1)
+      variable, type, info = constraints.first
+      expect(type).to eq :send
+      expect(variable).to eq renamed_x
+      expect(info[:return]).to eq renamed_return_id_x
+      expect(info[:args].size).to eq 1
+      expect(info[:args].first).to eq renamed_x
+
+      constraints = register.all_constraints
+      expect(constraints.size).to eq(1)
+      variable, type, info = constraints.first
+      expect(type).to eq :send
+      expect(variable).to eq xvar
+      expect(info[:return]).to eq ret_type
+      expect(info[:args].size).to eq 1
+      expect(info[:args].first).to eq xvar
+    end
+
+    it 'creates a new register with the right subsitutions in the type_variable' do
+      TypedRb::Types::TypingContext.type_variables_register = described_class.new(nil,:top_level)
+      parent = TypedRb::Types::TypingContext.type_variables_register
+      ata = parent.type_variable_for(:instance_variable, '@a', String.ancestors)
+      argy = parent.type_variable_for_abstraction(:lambda, 'y', top_level_typing_context)
+
+      child = described_class.new(parent, :lambda)
+      TypedRb::Types::TypingContext.type_variables_register = child
+
+      argx = child.type_variable_for_abstraction(:lambda, 'x', top_level_typing_context)
+
+      argx.compatible?(ata)
+      argy.compatible?(argx)
+
+      substitution = tyvariable('substitution')
+      result = parent.send(:apply_type, nil, argx.variable => substitution)
+      constraints = result.all_constraints
+      var, type, info = constraints[0]
+      expect(var).to eq(argy)
+      expect(type).to eq(:lt)
+      expect(info).to eq(substitution)
+      var, type, info = constraints[1]
+      expect(var).to eq(substitution)
+      expect(type).to eq(:lt)
+      expect(info).to eq(ata)
+
+      TypedRb::Types::TypingContext.type_variables_register = parent
+      constraints = TypedRb::Types::TypingContext.all_constraints
+      var, type, info = constraints[0]
+      expect(var).to eq(argy)
+      expect(type).to eq(:lt)
+      expect(info).to eq(argx)
+      var, type, info = constraints[1]
+      expect(var).to eq(argx)
+      expect(type).to eq(:lt)
+      expect(info).to eq(ata)
+    end
+  end
+end