typed.rb 0.0.11

data/spec/lib/types/ty_generic_singleton_object_spec.rb

@@ -0,0 +1,288 @@
+require_relative '../../spec_helper'
+
+describe TypedRb::Types::TyGenericSingletonObject do
+  let(:language) { TypedRb::Language.new }
+
+  it 'materializes a correctly typed generic type' do
+
+    expr = <<__CODE
+      ts 'type GW1[T]'
+      class GW1
+
+        ts '#f / -> [T]'
+        def f
+         2
+        end
+      end
+
+      GW1.(Integer)
+__CODE
+
+    result = language.check(expr)
+    expect(result.type_vars.first.lower_bound.ruby_type).to eq(Integer)
+    expect(result.type_vars.first.upper_bound.ruby_type).to eq(Integer)
+  end
+
+  it 'materializes a correctly typed generic type and subtype' do
+
+    expr = <<__CODE
+      ts 'type GW2[T]'
+      class GW2
+
+        ts '#f / -> [T]'
+        def f
+         2
+        end
+      end
+
+      GW2.(Numeric)
+__CODE
+
+    result = language.check(expr)
+    expect(result.type_vars.first.lower_bound.ruby_type).to eq(Numeric)
+    expect(result.type_vars.first.upper_bound.ruby_type).to eq(Numeric)
+  end
+
+  it 'catches inconsistencies in the type application' do
+
+    expr = <<__CODE
+      ts 'type GW3[T]'
+      class GW3
+
+        ts '#f / -> [T]'
+        def f
+         2
+        end
+      end
+
+      GW3.(String)
+__CODE
+
+    expect {
+      language.check(expr)
+    }.to raise_error(TypedRb::Types::Polymorphism::UnificationError)
+  end
+
+  context 'with complex bounds in the argument type' do
+
+    it 'parses the type correctly upper bound' do
+      expr = <<__CODE
+      ts 'type GColl1[T]'
+      class GColl1
+
+        ts '#add / [T] -> unit'
+        def add(x)
+          @val = x
+        end
+
+        ts '#pop / -> [T]'
+        def pop
+          @val
+        end
+      end
+
+      GColl1.('[? < Numeric]')
+__CODE
+      result = language.check(expr)
+      expect(result.type_vars.first.upper_bound.ruby_type).to eq(Numeric) # -> we can assign -> X = pop() -> X ALWAYS Numeric or greater
+      expect(result.type_vars.first.lower_bound).to be_nil # -> we cannot add -> add(X) : X lt NIL -> error
+    end
+
+    it 'parses the type correctly with lower bound' do
+      expr = <<__CODE
+      ts 'type GColl2[T]'
+      class GColl2
+
+        ts '#add / [T] -> unit'
+        def add(x)
+          @val = x
+        end
+
+        ts '#pop / -> [T]'
+        def pop
+          @val
+        end
+      end
+
+      GColl2.('[? > Numeric]')
+__CODE
+      result = language.check(expr)
+      expect(result.type_vars.first.upper_bound).to be_nil # -> we cannot assign -> X = pop() -> X gt NIL -> error
+      expect(result.type_vars.first.lower_bound.ruby_type).to eq(Numeric)  # -> we can add -> add(X) :  X ALWAYS Numeric or smaller
+    end
+
+    it 'detects type errors with upper bounds' do
+      expr = <<__CODE
+      class AG1
+         ts '#ag1 / -> unit'
+         def ag1;
+         end
+      end
+
+      class AG2 < AG1
+          ts '#ag2 / -> unit'
+          def ag2
+          end
+      end
+
+      class AG3 < AG2; end
+
+      ts 'type GW6[T]'
+      class GW6
+
+        ts '#ag2_thing / AG2 -> unit'
+        def ag2_thing(ag2); end
+
+        ts '#f / [T] -> [T]'
+        def f(x)
+          AG2.new
+        end
+      end
+
+      GW6.('[? < AG3]')
+__CODE
+      expect {
+        language.check(expr)
+      }.to raise_error(TypedRb::Types::Polymorphism::UnificationError)
+    end
+
+    it 'materializes a correctly typed generic type and subtype with different bounds' do
+
+      expr = <<__CODE
+      ts 'type GColl3[T]'
+      class GColl3
+
+        ts '#add / [T] -> unit'
+        def add(x)
+          @val = x
+        end
+
+        ts '#pop / -> [T]'
+        def pop
+          2
+        end
+      end
+
+      GColl3.('[? < Numeric]')
+__CODE
+
+      result = language.check(expr)
+      expect(result.type_vars.first.upper_bound.ruby_type).to eq(Numeric) # -> X pop() -> X > Numeric
+      expect(result.type_vars.first.lower_bound.ruby_type).to eq(Integer) # -> add(X) -> X < Integer
+
+      expr = <<__CODE
+      ts 'type GW8[T]'
+      class GW8
+
+        ts '#f / -> [T]'
+        def f
+         2
+        end
+      end
+
+      GW8.('[? > Numeric]')
+__CODE
+
+      result = language.check(expr)
+      expect(result.type_vars.first.upper_bound).to be_nil
+      expect(result.type_vars.first.lower_bound.ruby_type).to eq(Numeric)
+
+      expr = <<__CODE
+      ts 'type GW9[T]'
+      class GW9
+
+        ts '#f / -> [T]'
+        def f
+         2
+        end
+
+        ts '#id / [T] -> [T]'
+        def id(x); x; end
+      end
+
+      GW9.('[? < Numeric]')
+__CODE
+
+      result = language.check(expr)
+      expect(result.type_vars.first.upper_bound.ruby_type).to eq(Numeric)
+      expect(result.type_vars.first.lower_bound.ruby_type).to eq(Integer)
+    end
+  end
+
+  context 'mixing generic type definition constraints and instantiation constraints' do
+
+    it 'materializes generic types when passed as arguments' do
+
+      expr = <<__CODE
+      ts 'type GColl4[T]'
+      class GColl4
+
+        ts '#add / [T] -> unit'
+        def add(x)
+          @val = x
+        end
+
+        ts '#pop / -> [T]'
+        def pop
+          Numeric.new
+        end
+      end
+
+      ts '#test_fun / GColl4[? < Integer] -> unit'
+      def test_fun(x)
+        x.add(1)
+      end
+__CODE
+      expect {
+        language.check(expr)
+      }.to raise_error(TypedRb::Types::Polymorphism::UnificationError,
+                       /Numeric is not a subtype of Integer/)
+    end
+
+    it 'materializes generic types when found in arguments sent with a message' do
+
+      expr = <<__CODE
+      ts 'type GColl5[T]'
+      class GColl5
+
+        ts '#add / [T] -> unit'
+        def add(x)
+          @val = x
+        end
+
+        ts '#pop / -> [T]'
+        def pop
+          Numeric.new
+        end
+      end
+
+      ts '#test_fun2 / Object -> unit'
+      def test_fun2(x)
+        x
+      end
+
+      test_fun2(GColl5.('[? < Integer]').new)
+__CODE
+      expect {
+        language.check(expr)
+      }.to raise_error(TypedRb::Types::Polymorphism::UnificationError,
+                       /Numeric is not a subtype of Integer/)
+    end
+
+    it 'supports nested type parameters' do
+
+      expr = <<__CODE
+      ts 'type GColl6[T]'
+      class GColl6
+         ts '#id / [T] -> [T]'
+         def id(x); x; end
+      end
+
+      GColl6.('Array[Array[Integer]]')
+__CODE
+
+      result = language.check(expr)
+      expect(result.to_s).to eq('GColl6[Array[Array[Integer]]]')
+    end
+  end
+end

data/spec/lib/types/typing_context_spec.rb

@@ -0,0 +1,86 @@
+require_relative '../../spec_helper'
+
+describe TypedRb::Types::TypingContext do
+
+  describe '.type_variable_for' do
+    before do
+      described_class.type_variables_register.clear
+    end
+
+    it 'should register and find an instance variable for a ruby type' do
+      result = described_class.type_variable_for(:instance_variable, '@a', tyobject(Integer).hierarchy)
+      expect(result).to be_a(TypedRb::Types::Polymorphism::TypeVariable)
+      result2 = described_class.type_variable_for(:instance_variable, '@a', tyobject(Integer).hierarchy)
+      expect(result).to eq(result2)
+    end
+
+    it 'should find instance variables in the class hierarchy' do
+      result = described_class.type_variable_for(:instance_variable, '@a', tyobject(Numeric).hierarchy)
+      result2 = described_class.type_variable_for(:instance_variable, '@a', tyobject(Integer).hierarchy)
+      expect(result).to eq(result2)
+    end
+
+    it 'should not mix instance variables with the same name for different classes' do
+      result = described_class.type_variable_for(:instance_variable, '@a', tyobject(Integer).hierarchy)
+      result2 = described_class.type_variable_for(:instance_variable, '@a', tyobject(String).hierarchy)
+      expect(result).to_not eq(result2)
+    end
+  end
+
+  describe 'namespaces' do
+    eval('module TCNS1; AC=0; module TCNS2; class A; end; class B; BC=1; end; end; end;')
+
+    before do
+      described_class.namespace.clear
+    end
+
+    it 'works like a stack' do
+      expect(described_class.namespace.count).to eq(0)
+      described_class.namespace_push('TCNS1')
+      described_class.namespace_push('TCNS2')
+      described_class.namespace_push('A')
+
+      expect(described_class.namespace).to eq(['TCNS1', 'TCNS2', 'A'])
+
+      described_class.namespace_pop
+      described_class.namespace_pop
+      described_class.namespace_pop
+      expect(described_class.namespace.count).to eq(0)
+    end
+
+    it 'handles compound class names' do
+      expect(described_class.namespace.count).to eq(0)
+      described_class.namespace_push('TCNS1')
+      described_class.namespace_push('TCNS2::A')
+
+      expect(described_class.namespace).to eq(['TCNS1', 'TCNS2', 'A'])
+    end
+
+    it 'is able to find nested classes' do
+      expect(described_class.namespace.count).to eq(0)
+      described_class.namespace_push('TCNS1')
+      described_class.namespace_push('TCNS2')
+
+      result = described_class.find_namespace('A')
+      expect(result).to eq(TCNS1::TCNS2::A)
+
+      result = described_class.find_namespace('AC')
+      expect(result).to eq(TCNS1::AC)
+
+      result = described_class.find_namespace('B::BC')
+      expect(result).to eq(TCNS1::TCNS2::B::BC)
+
+      result = described_class.find_namespace('TCNS2::B::BC')
+      expect(result).to eq(TCNS1::TCNS2::B::BC)
+
+      result = described_class.find_namespace('::String')
+      expect(result).to eq(String)
+
+      result = described_class.find_namespace('TCNS1::TCNS2::B::BC')
+      expect(result).to eq(TCNS1::TCNS2::B::BC)
+
+      result = described_class.find_namespace('::TCNS1::TCNS2::B::BC')
+      expect(result).to eq(TCNS1::TCNS2::B::BC)
+    end
+  end
+end

data/spec/lib/types_spec.rb

@@ -0,0 +1,174 @@
+require_relative '../spec_helper'
+
+describe TypedRb::Types::TyObject do
+  let(:ty_object) { TypedRb::Types::TyObject.new(Object) }
+  let(:ty_numeric) { TypedRb::Types::TyObject.new(Numeric) }
+  let(:ty_integer) { TypedRb::Types::TyObject.new(Integer) }
+  let(:ty_string) { tyobject(String) }
+
+  it 'is possible to compare TyObjects' do
+
+    expect(ty_object > ty_numeric).to be_truthy
+    expect(ty_numeric > ty_integer).to be_truthy
+    expect(ty_object > ty_integer).to be_truthy
+
+    expect(ty_object >= ty_numeric).to be_truthy
+    expect(ty_object >= ty_object).to be_truthy
+    expect(ty_numeric >= ty_integer).to be_truthy
+    expect(ty_numeric >= ty_numeric).to be_truthy
+    expect(ty_object >= ty_integer).to be_truthy
+    expect(ty_object >= ty_object).to be_truthy
+
+    expect(ty_numeric < ty_object).to be_truthy
+    expect(ty_integer < ty_numeric).to be_truthy
+    expect(ty_integer < ty_object).to be_truthy
+
+    expect{ ty_string < ty_integer }.to raise_error ArgumentError
+    expect{ ty_integer < ty_string }.to raise_error ArgumentError
+    expect{ ty_string > ty_integer }.to raise_error ArgumentError
+    expect{ ty_integer > ty_string }.to raise_error ArgumentError
+
+
+    expect(ty_numeric <= ty_numeric).to be_truthy
+    expect(ty_integer <= ty_integer).to be_truthy
+    expect(ty_object <= ty_object).to be_truthy
+
+    expect(ty_numeric >= ty_numeric).to be_truthy
+    expect(ty_integer >= ty_integer).to be_truthy
+    expect(ty_object >= ty_object).to be_truthy
+
+
+    expect([ty_numeric, ty_integer, ty_object].sort).to  eq([ty_integer, ty_numeric, ty_object])
+  end
+
+  it 'is possible to compare if two objects are compatible' do
+    expect(ty_object.compatible?(ty_numeric, :gt)).to be_truthy
+    expect(ty_object.compatible?(ty_numeric, :lt)).to be_falsey
+    expect(ty_object.compatible?(ty_numeric, :lt)).to be_falsey
+    expect(ty_object.compatible?(ty_numeric, :gt)).to be_truthy
+  end
+
+  describe '#find_function_type' do
+    before :each do
+      ::BasicObject::TypeRegistry.clear
+    end
+
+    it 'it can find methods in the base and super classes' do
+      $TYPECHECK = true
+      code = <<__CODE
+
+         class A1
+            ts 'A1#a / String -> unit'
+            def a(s); puts 'a'; end
+         end
+
+         class B1 < A1
+            ts 'B1#b / Numeric -> unit'
+            def b(n); puts 'a'; end
+         end
+__CODE
+
+      eval(code)
+      ::BasicObject::TypeRegistry.normalize_types!
+
+      ty_b = described_class.new(B1)
+
+      klass, method = ty_b.find_function_type(:a, 1, false)
+      expect(method.to_s).to eq('(String -> NilClass)')
+      expect(klass).to eq(A1)
+
+      klass, method = ty_b.find_function_type(:b, 1, false)
+      expect(method.to_s).to eq('(Numeric -> NilClass)')
+      expect(klass).to eq(B1)
+    end
+
+    it 'can find methods with functions as arguments' do
+      $TYPECHECK = true
+      code = <<__CODE
+
+         class A1
+            ts '#a / String -> (String -> String) -> unit'
+            def a(s,f); f(s); end
+         end
+__CODE
+
+      eval(code)
+      ::BasicObject::TypeRegistry.normalize_types!
+
+      ty_b = described_class.new(B1)
+
+      klass, method = ty_b.find_function_type(:a, 2, false)
+      function = method.from[1]
+      expect(function).to be_instance_of(TypedRb::Types::TyFunction)
+      expect(function.from.size).to eq(1)
+      expect(function.from[0]).to eq(ty_string)
+      expect(function.to).to eq(ty_string)
+      expect(klass).to eq(A1)
+    end
+
+    context 'with multiple signatures including block types' do
+      it 'find both versions with and without block type' do
+        $TYPECHECK = false
+        eval 'class A2; def t(x); end; end'
+        $TYPECHECK = true
+        code = <<__CODE
+        class A2
+           ts '#t / Integer -> Integer'
+           ts '#t / Integer -> &(Integer -> String) -> String'
+        end
+__CODE
+
+        eval(code)
+        ::BasicObject::TypeRegistry.normalize_types!
+
+        ty_b = described_class.new(A2)
+
+        _, method = ty_b.find_function_type(:t, 1, false)
+        expect(method.from.count).to eq(1)
+        expect(method.block_type).to be_nil
+        expect(method.to.ruby_type).to eq(Integer)
+
+        _, method = ty_b.find_function_type(:t, 1, true)
+        expect(method.from.count).to eq(1)
+        expect(method.block_type).to_not be_nil
+        expect(method.to.ruby_type).to eq(String)
+      end
+    end
+  end
+
+  describe('#parse') do
+    before :each do
+      ::BasicObject::TypeRegistry.clear
+    end
+
+    context 'with a generic type' do
+
+      it 'should parse a generic singleton class if it the var is not bound' do
+        $TYPECHECK = true
+        code = <<__CODE
+
+         ts 'type A2[T]'
+         class A2
+            ts '#a / [T]... -> unit'
+            def a(*xs); end
+         end
+__CODE
+
+        eval(code)
+        ::BasicObject::TypeRegistry.normalize_types!
+
+        result = TypedRb::Runtime::TypeParser.parse({:type       => 'Array',
+                                                     :parameters =>  [{:type=>"T", :bound=>"BasicObject", :kind=>:type_var}],
+                                                     :kind       => :rest}, A2)
+        expect(result).to be_instance_of(TypedRb::Types::TyGenericSingletonObject)
+        expect(result.type_vars[0].bound).to be_nil
+
+        result = TypedRb::Runtime::TypeParser.parse({:type       => 'Array',
+                                                     :parameters =>  ['Integer'],
+                                                     :kind       => :rest}, A2)
+        expect(result).to be_instance_of(TypedRb::Types::TyGenericObject)
+        expect(result.type_vars[0].bound.ruby_type).to eq(Integer)
+      end
+    end
+  end
+end

data/spec/lib/typing/boolean_asgn_spec.rb

@@ -0,0 +1,134 @@
+require_relative '../../spec_helper'
+
+describe 'boolean assign operations' do
+  let(:language) { TypedRb::Language.new }
+
+  context 'with instance level variables' do
+    it 'type-checks boolean assignment operations' do
+      expr = <<__END
+        class BAsgn1
+          ts '#test / -> Integer'
+          def test
+            @test ||= 1
+          end
+        end
+
+        BAsgn1.new.test
+__END
+
+      result = language.check(expr)
+      expect(result.ruby_type).to eq(Integer)
+    end
+
+    it 'detects type errors' do
+
+      expr = <<__END
+        class BAsgn1
+          ts '#test / -> String'
+          def test
+            @test = 1
+            @test ||= 'string'
+          end
+        end
+
+        BAsgn1.new.test
+__END
+
+      expect {
+        language.check(expr)
+      }.to raise_error(TypedRb::Types::Polymorphism::UnificationError)
+    end
+  end
+
+  context 'with global variables' do
+    it 'type-checks boolean assignment operations' do
+      expr = <<__END
+        $VAR_BASGN ||= 3
+        $VAR_BASGN
+__END
+
+      result = language.check(expr)
+      expect(result.bound.ruby_type).to eq(Integer)
+    end
+
+    it 'type-checks boolean && assignment operations' do
+
+      expr = <<__END
+        $VAR_BASGN = 3
+        $VAR_BASGN &&= Numeric.new
+__END
+
+      result = language.check(expr)
+      expect(result.bound.ruby_type).to eq(Numeric)
+    end
+  end
+
+  context 'with local variables' do
+    it 'type-checks boolean assignment operations' do
+      expr = <<__END
+        var ||= 3
+        var
+__END
+      result = language.check(expr)
+      expect(result.ruby_type).to eq(Integer)
+    end
+
+    it 'detects type errors' do
+      expr = <<__END
+        var ||= 3
+        var = Numeric.new
+        var
+__END
+      expect {
+        language.check(expr)
+      }.to raise_error(TypedRb::Types::UncomparableTypes)
+    end
+  end
+
+  context 'with attr_readers/attr_writers' do
+    it 'type-checks boolean assignment operations' do
+      expr = <<__END
+        class BAsgn2
+          ts '#t / -> Integer'
+          def t
+           @t
+          end
+
+          ts '#t= / Integer -> Integer'
+          def t=(t)
+           @t = t
+          end
+        end
+
+        ba2 = BAsgn2.new
+
+        ba2.t ||= 3
+__END
+      result = language.check(expr)
+      expect(result.ruby_type).to eq(Integer)
+    end
+
+    it 'detects type errors' do
+      expr = <<__END
+        class BAsgn3
+          ts '#t / -> String'
+          def t
+           @t
+          end
+
+          ts '#t= / Integer -> Integer'
+          def t=(t)
+           @t = t
+          end
+        end
+
+        ba3 = BAsgn3.new
+
+        ba3.t ||= 3
+__END
+      expect {
+        language.check(expr)
+      }.to raise_error(TypedRb::Types::UncomparableTypes)
+    end
+  end
+end