typed.rb 0.0.11

data/spec/lib/typing/break_spec.rb

@@ -0,0 +1,79 @@
+require_relative '../../spec_helper'
+
+describe ':break term' do
+  let(:language) { TypedRb::Language.new }
+
+  it 'is type checked correctly, positive case' do
+    code = <<__END
+     ts '#test_break / Integer -> &(Integer -> unit) -> Integer'
+     def test_break(x)
+       yield(x)
+     end
+
+     test_break(0) { |x| break(1) }
+__END
+
+    result = language.check(code)
+    expect(result.to_s).to eq('Integer')
+  end
+
+  it 'is type checked correctly, no break value, positive case' do
+    code = <<__END
+     ts '#test_break / Integer -> &(Integer -> unit) -> Integer'
+     def test_break(x)
+       yield(x)
+     end
+
+     test_break(0) { |x| break }
+__END
+
+    result = language.check(code)
+    expect(result.to_s).to eq('Integer')
+  end
+
+  it 'is type checked correctly, negative case' do
+    code = <<__END
+     ts '#test_break / Integer -> &(Integer -> unit) -> Integer'
+     def test_break(x)
+       yield(x)
+     end
+
+     test_break(0) { |x| break("") }
+__END
+
+    expect {
+      language.check(code)
+    }.to raise_error(TypedRb::Types::UncomparableTypes)
+  end
+
+  context 'with not matching return type' do
+    it 'is type checked correctly, positive case' do
+      code = <<__END
+     ts '#test_break / Integer -> &(Integer -> Integer) -> Integer'
+     def test_break(x)
+       yield(x)
+     end
+
+     test_break(0) { |x| break(1) }
+__END
+
+      result = language.check(code)
+      expect(result.to_s).to eq('Integer')
+    end
+
+    it 'is type checked correctly, negative case' do
+      code = <<__END
+     ts '#test_break / Integer -> &(String -> Integer) -> Integer'
+     def test_break(x)
+       yield(x)
+     end
+
+     test_break(0) { |x| break(1) }
+__END
+
+      expect {
+        language.check(code)
+      }.to raise_error(TypedRb::Types::UncomparableTypes)
+    end
+  end
+end

data/spec/lib/typing/generics_spec.rb

@@ -0,0 +1,191 @@
+require_relative '../../spec_helper'
+
+describe 'generics use caes' do
+  let(:language) { TypedRb::Language.new }
+
+  it 'applies arguments to generic types' do
+    code = <<__END
+      ts 'type TestGen1[T]'
+      class TestGen1
+        ts '#gm / [T] -> [T]'
+        def gm(t)
+          t
+        end
+      end
+
+      TestGen1.(String).new.gm('string')
+__END
+    result = language.check(code)
+    expect(result.ruby_type).to eq(String)
+
+    code = <<__END
+      ts 'type TestGen1[T]'
+      class TestGen1
+        ts '#gm / [T] -> &([T] -> [T]) -> [T]'
+        def gm(t)
+          yield t
+        end
+      end
+
+      TestGen1.(String).new.gm('string') { |t| 'string' }
+__END
+    result = language.check(code)
+    expect(result.ruby_type).to eq(String)
+
+    code = <<__END
+      ts 'type TestGen1[T]'
+      class TestGen1
+        ts '#gm / [T] -> &([T] -> [T]) -> [T]'
+        def gm(t)
+          yield t
+        end
+      end
+
+      TestGen1.(String).new.gm('string') { |t| 2 }
+__END
+
+    expect do
+      language.check(code)
+    end.to raise_error(TypedRb::TypeCheckError)
+  end
+
+
+  it 'applies arguments to generic types without implementation' do
+    code = <<__END
+      xs = Array.(String).new
+      xs << 'string'
+      xs.at(0)
+__END
+    result = language.check(code)
+    expect(result.ruby_type).to eq(String)
+
+    code = <<__END
+      xs = Array.(String).new
+      xs << 2
+      xs.at(0)
+__END
+
+    expect do
+      language.check(code)
+    end.to raise_error(TypedRb::TypeCheckError)
+  end
+
+  it 'materializes generic types using type variables' do
+    code = <<__END
+       ts 'type TestGen2[T]'
+       class TestGen2
+
+         ts '#gm / [T] -> Array[T]'
+         def gm(x)
+           xs = Array.('[T]').new
+           xs << x
+           xs
+         end
+       end
+
+       TestGen2.(String).new.gm('x')
+__END
+
+    result = language.check(code)
+    expect(result.to_s).to eq('Array[String]')
+  end
+
+  it 'detects errors materializing generic types using type variables' do
+    code = <<__END
+       ts 'type TestGen2[T][U]'
+       class TestGen2
+
+         ts '#gm / [T] -> [U] -> Array[T]'
+         def gm(x,y)
+           xs = Array.('[T]').new
+           xs << y
+           xs
+         end
+       end
+
+       TestGen2.(String,Integer).new.gm('x',2)
+__END
+
+    expect do
+      language.check(code)
+    end.to raise_error(TypedRb::TypeCheckError,
+                       /TestGen2\:T\:\:\[\?,\?\] expected, TestGen2\:U\:\:\[\?,\?\]/)
+  end
+
+  it 'type-checks correctly super type generics' do
+    code = <<__END
+    class Array
+      ts '#last / Integer... -> [T]'
+    end
+
+    ts 'type MyContainerG1[T] super Array[Object]'
+    class MyContainerG1 < Array
+      ts '#first / -> [T]'
+    end
+
+    MyContainerG1.(String).new.last
+__END
+
+    result = language.check(code)
+    expect(result.ruby_type).to eq(Object)
+  end
+
+  it 'type-checks correctly super type generics detecting type errors based on the super-type parameter' do
+    code = <<__END
+    ts 'type BaseGen1[T]'
+    class BaseGen1
+      ts '#getString / -> String'
+      def getString
+       'a string'
+      end
+
+      ts '#in_subclass / -> [T]'
+      def in_subclass
+        getString
+      end
+    end
+
+    ts 'type MyContainerG2[T] super BaseGen1[String]'
+    class MyContainerG2 < BaseGen1
+    end
+
+    ts 'type MyContainerG3[T] super BaseGen1[Integer]'
+    class MyContainerG3 < BaseGen1
+    end
+__END
+
+    expect do
+      language.check(code)
+    end.to raise_error(TypedRb::Types::UncomparableTypes,
+                       /Cannot compare types Object with.*Integer/)
+  end
+
+  it 'type-checks correctly super type generics detecting type errors based on the super-type parameter on type instantiation' do
+    code = <<__END
+    ts 'type BaseGen2[T]'
+    class BaseGen2
+      ts '#getString / -> String'
+      def getString
+       'a string'
+      end
+
+      ts '#in_subclass / -> [T]'
+      def in_subclass
+        getString
+      end
+    end
+
+    ts 'type MyContainerG4[T] super BaseGen2[T]'
+    class MyContainerG4 < BaseGen2
+    end
+    BaseGen2.(String).new
+    MyContainerG4.(Integer).new
+__END
+
+    expect do
+      language.check(code)
+    end.to raise_error(TypedRb::Types::UncomparableTypes,
+                       /Cannot compare types Object with.*Integer/)
+  end
+
+end

data/spec/lib/typing/instance_vars_spec.rb

@@ -0,0 +1,103 @@
+require_relative '../../spec_helper'
+
+describe 'instance vars' do
+  let(:language) { TypedRb::Language.new }
+
+  it 'types correctly instance vars, case 1' do
+    code = <<__END
+      class TestIVar
+
+        ts '#gm1 / -> Integer'
+        def gm1
+          @a = 1
+        end
+
+        ts '#gm2 / -> String'
+        def gm2
+          @a = 'hey'
+          'hey'
+        end
+
+        ts '#gm3 / -> Object'
+        def gm3
+          @a
+        end
+      end
+__END
+
+    language.check(code)
+  end
+
+  it 'types correctly instance vars, positive case 2' do
+    code = <<__END
+      class TestIVar
+
+        ts '#gm1 / -> Integer'
+        def gm1
+          @a = 1
+        end
+
+        ts '#gm2 / -> String'
+        def gm2
+          @a = 'hey'
+          'hey'
+        end
+
+        ts '#gm3 / -> Float'
+        def gm3
+          @a
+        end
+      end
+__END
+
+    expect {
+      language.check(code)
+    }.to raise_error(TypedRb::Types::Polymorphism::UnificationError)
+  end
+
+  it 'types correctly instance vars, positive case 3' do
+    code = <<__END
+      class TestIVar
+
+        ts '#gm1 / -> Integer'
+        def gm1
+          @a = 1
+        end
+
+        ts '#gm2 / -> String'
+        def gm2
+          @a = 'hey'
+          'hey'
+        end
+      end
+__END
+
+    expect {
+      language.check(code)
+    }.not_to raise_error
+  end
+
+
+  it 'types correctly instance vars, positive case 5' do
+    code = <<__END
+      class TestIVar5
+        ts '#gm1 / -> Integer'
+        def gm1
+          @a = 1
+        end
+      end
+
+      class TestIVar5
+        ts '#gm2 / -> String'
+        def gm2
+          @a = 'hey'
+          @a
+        end
+      end
+__END
+
+    expect {
+      language.check(code)
+    }.to raise_error
+  end
+end

data/spec/lib/typing/next_spec.rb

@@ -0,0 +1,29 @@
+require_relative '../../spec_helper'
+
+describe ':next term' do
+  let(:language) { TypedRb::Language.new }
+
+  it 'is type checked correctly, positive case' do
+    code = <<__END
+     [1,2,3,4].map { |i| next(i * 2) }
+__END
+
+    result = language.check(code)
+    expect(result.to_s).to eq('Array[Integer]')
+  end
+
+  it 'is type checked correctly, negative case' do
+    code = <<__END
+     ts '#test_break / Integer -> &(Integer -> Integer) -> Integer'
+     def test_break(x)
+       yield(x)
+     end
+
+     test_break(0) { |x| next("") }
+__END
+
+    expect {
+      language.check(code)
+    }.to raise_error(TypedRb::Types::UncomparableTypes)
+  end
+end

data/spec/lib/typing/op_asgn_spec.rb

@@ -0,0 +1,104 @@
+require_relative '../../spec_helper'
+
+describe 'operator assign operations' do
+  let(:language) { TypedRb::Language.new }
+
+  context 'with a local variable' do
+    it 'type checks assignment operations over local variables, positive case' do
+      expr = <<__CODE
+         a = 0
+         a += 1
+__CODE
+
+      result = language.check(expr)
+      expect(result.ruby_type).to eq(Integer)
+    end
+
+    it 'type checks assignment operations over local variables, negative case' do
+      expr = <<__CODE
+         class LocalVarTest
+           ts '#+ / LocalVarTest -> LocalVarTest'
+           def +(other)
+             self
+           end
+         end
+
+         ts '#x / -> LocalVarTest'
+         def x
+           a = LocalVarTest.new
+           a += 1
+         end
+__CODE
+
+      expect {
+        language.check(expr)
+      }.to raise_error(TypedRb::Types::UncomparableTypes)
+    end
+  end
+
+  context 'with an instance variable' do
+    it 'type checks assignment operations over instance variables, positive case' do
+      expr = <<__CODE
+         @a = 0
+         @a += 1
+__CODE
+      result = language.check(expr)
+      expect(result.bound.ruby_type).to eq(Integer)
+    end
+
+    it 'type checks assignment operations over instance variables, negative case' do
+      expr = <<__CODE
+         class LocalVarTest
+           ts '#+ / LocalVarTest -> LocalVarTest'
+           def +(other)
+             self
+           end
+         end
+
+         ts '#x / -> LocalVarTest'
+         def x
+           @a = LocalVarTest.new
+           @a += 1
+         end
+__CODE
+
+      expect {
+        language.check(expr)
+      }.to raise_error(TypedRb::Types::UncomparableTypes)
+    end
+  end
+
+  context 'with a global variable' do
+    it 'type checks assignment operations over global variables, positive case' do
+      expr = <<__CODE
+         $TEST_GLOBAL_OPS = 0
+         $TEST_GLOBAL_OPS += 1
+__CODE
+      result = language.check(expr)
+      expect(result.bound.ruby_type).to eq(Integer)
+    end
+  end
+
+  context 'with a constant' do
+    it 'type checks assignment operations over global variables, positive case' do
+      expr = <<__CODE
+         TEST_GLOBAL_OPS = 0
+         TEST_GLOBAL_OPS += 1
+__CODE
+      result = language.check(expr)
+      expect(result.ruby_type).to eq(Integer)
+    end
+  end
+
+  context 'with a message sent as the receiver' do
+    it 'type checks assignment operations over sending of messages, positive case' do
+      expr = <<__CODE
+        a = [1]
+        a[0] += 2
+__CODE
+
+      result = language.check(expr)
+      expect(result.ruby_type).to eq(Object)
+    end
+  end
+end

data/spec/lib/typing/overriden_methods_spec.rb

@@ -0,0 +1,31 @@
+require_relative '../../spec_helper'
+
+describe TypedRb::Model::TmSend do
+  let(:language) { TypedRb::Language.new }
+
+  context 'with a function with multiple type signatures' do
+    it 'type checks methods with multiple type signatures' do
+      eval('class TOM1; def f(a, *args, &b); end; end')
+
+      base =  <<__CODE
+      class TOM1
+        ts '#f / String -> Integer'
+        ts '#f / String -> Integer -> String'
+      end
+
+__CODE
+
+      expr1 = "#{base}TOM1.new.f('a')"
+      result = language.check(expr1)
+      expect(result).to eq(tyinteger)
+
+      expr2 = "#{base}TOM1.new.f('a', 2)"
+      result = language.check(expr2)
+      expect(result).to eq(tystring)
+
+      expr3 = "#{base}TOM1.new.f('a', 2, nil)"
+      result = language.check(expr3)
+      expect(result).to eq(tydynamic)
+    end
+  end
+end

data/spec/lib/typing/subtyping_spec.rb

@@ -0,0 +1,112 @@
+require_relative '../../spec_helper'
+
+describe TypedRb::Types::Type do
+  before :each do
+    ::BasicObject::TypeRegistry.clear
+  end
+
+  let(:typed_code) do
+    $TYPECHECK = true
+    eval(code, TOPLEVEL_BINDING)
+    ::BasicObject::TypeRegistry.normalize_types!
+    code
+  end
+
+  let(:ast) do
+    TypedRb::Model::GenSym.reset
+    parser = TypedRb::AstParser.new
+    parser.parse(typed_code)
+  end
+
+  context 'with valid exact type' do
+    let(:code) do
+      text = <<__CODE
+        ts '#test / Integer -> Integer'
+        def test(x)
+          x
+        end
+__CODE
+      text
+    end
+
+    it 'should not raise a type error' do
+      expect do
+        ast.check_type(TypedRb::Types::TypingContext.top_level)
+      end.to_not raise_error
+    end
+  end
+
+  context 'with  a super-type class' do
+    let(:code) do
+      text = <<__CODE
+        ts '#test / Integer -> Numeric'
+        def test(x)
+          x
+        end
+__CODE
+      text
+    end
+
+    it 'should not raise a type error' do
+      expect do
+        ast.check_type(TypedRb::Types::TypingContext.top_level)
+      end.to_not raise_error
+    end
+  end
+
+  context 'with  a super-type argument' do
+    let(:code) do
+      text = <<__CODE
+        ts '#test / Numeric -> Numeric'
+        def test(x)
+          x
+        end
+
+        test(1)
+__CODE
+      text
+    end
+
+    it 'should not raise a type error' do
+      expect {
+        ast.check_type(TypedRb::Types::TypingContext.top_level)
+      }.to_not raise_error
+    end
+  end
+
+  context 'with  a sub-type class' do
+    let(:code) do
+      text = <<__CODE
+        ts '#test / Numeric -> Integer'
+        def test(x)
+          x
+        end
+__CODE
+      text
+    end
+
+    it 'should raise a type error' do
+      expect {
+        ast.check_type(TypedRb::Types::TypingContext.top_level)
+      }.to raise_error(TypedRb::TypeCheckError)
+    end
+  end
+
+  context 'with  a sub-type optional argument' do
+    let(:code) do
+      text = <<__CODE
+        ts '#test / Numeric -> Numeric'
+        def test(x = 1)
+          x
+        end
+__CODE
+      text
+    end
+
+    it 'should not raise a type error' do
+      expect do
+        ast.check_type(TypedRb::Types::TypingContext.top_level)
+      end.to_not raise_error
+    end
+  end
+end