typed.rb 0.0.11

data/spec/lib/prelude/hash_spec.rb

@@ -0,0 +1,361 @@
+require_relative '../../spec_helper'
+
+describe Hash do
+  let(:language) { TypedRb::Language.new }
+
+  describe '#initialize' do
+    it 'type checks / -> Hash[S][T]' do
+      result = language.check('Hash.(String,Integer).new')
+      expect(result.to_s).to eq('Hash[String][Integer]')
+    end
+
+    it 'type checks / -> Hash[S][T] with a literal type annotation' do
+      result = language.check("Hash.('[String][Integer]').new")
+      expect(result.to_s).to eq('Hash[String][Integer]')
+    end
+
+    it 'type checks / -> [T] -> Hash[S][T]' do
+      result = language.check("Hash.(String,Integer).new(1)")
+      expect(result.to_s).to eq('Hash[String][Integer]')
+
+      expect {
+        language.check("Hash.(String,Integer).new('string')")
+      }.to raise_error(TypedRb::Types::UncomparableTypes)
+    end
+
+    it 'type checks / &(Hash[S][T] -> [S] -> unit) -> Hash[S][T]' do
+      result = language.check("Hash.(String,Integer).new { |acc,k| acc[k] = 0 }")
+      expect(result.to_s).to eq('Hash[String][Integer]')
+
+      expect {
+        language.check("Hash.(String,Integer).new { |acc,k| acc[k] = 'string'}")
+      }.to raise_error(TypedRb::Types::UncomparableTypes)
+    end
+  end
+
+  describe '#any?' do
+    it 'type checks / &(T -> S -> Boolean) -> Boolean' do
+      code = <<__CODE
+
+         ts "#randomBool / String -> Integer -> Boolean"
+         def randomBool(s,i); true; end
+
+         Hash.(String,Integer).new.any? { |s,t| randomBool(s,t) }
+__CODE
+
+      result = language.check(code)
+      expect(result.to_s).to eq('Boolean')
+
+      expect {
+        code = <<__CODE
+
+         ts "#randomBool / String -> Integer -> Boolean"
+         def randomBool(s,i); true; end
+
+         Hash.(String,Integer).new.any? { |s,t| randomBool(t,s) }
+__CODE
+
+        language.check("Hash.(String,Integer).new { |acc,k| acc[k] = 'string'}")
+      }.to raise_error(TypedRb::Types::UncomparableTypes)
+    end
+  end
+
+  describe '#assoc' do
+    it 'type checks / [S] -> Pair[S][T]' do
+      code = <<__CODE
+         h = Hash.(String,Integer).new
+         h['key'] = 0
+         result = h.assoc('key')
+         result.second
+__CODE
+
+      result = language.check(code)
+      expect(result.to_s).to eq('Integer')
+
+       expect {
+         code = <<__CODE
+          Hash.(String,Integer).new.assoc(2)
+__CODE
+
+         language.check("Hash.(String,Integer).new { |acc,k| acc[k] = 'string'}")
+       }.to raise_error(TypedRb::Types::UncomparableTypes)
+    end
+  end
+
+  # describe '#default_proc' do
+  #   xit 'type checks / -> (Hash[S][T] -> [S] -> [T])' do
+  #     code = 'Hash.(String,Integer).new.default_proc'
+  #     #result = language.check(code)
+  #   end
+  # end
+
+  describe '#delete' do
+    it 'type checks / [S] -> [T]' do
+      code = <<__CODE
+        Hash.(String,Integer).new.delete('str')
+__CODE
+      result = language.check(code)
+      expect(result.ruby_type).to eq(Integer)
+
+      expect {
+        language.check('Hash.(String,Integer).new.delete(1)')
+      }.to raise_error(TypedRb::Types::UncomparableTypes)
+    end
+
+    it 'type checks / [S] -> &([S] -> [T]) -> [T]' do
+      code = <<__CODE
+        Hash.(String,Integer).new.delete('str') { |k| 0 }
+__CODE
+      result = language.check(code)
+      expect(result.ruby_type).to eq(Integer)
+
+      expect {
+        code = <<__CODE
+        Hash.(String,Integer).new.delete('str') { |k| k }
+__CODE
+        language.check(code)
+      }.to raise_error(TypedRb::Types::UncomparableTypes)
+    end
+  end
+
+  describe '#delete_if' do
+    it 'type checks / [S] -> &([S] -> [T] -> Boolean) -> [T]' do
+      code = <<__CODE
+        ts '#str_int_bool / String -> Integer -> Boolean'
+        def str_int_bool(s,i); true; end
+        Hash.(String,Integer).new.delete_if { |k,v| str_int_bool(k,v) }
+__CODE
+      result = language.check(code)
+      expect(result.to_s).to eq('Hash[String][Integer]')
+
+      expect {
+        code = <<__CODE
+        ts '#str_int_bool / String -> Integer -> Boolean'
+        def str_int_bool(s,i); true; end
+        Hash.(String,Integer).new.delete_if { |k,v| str_int_bool(v,k) }
+__CODE
+
+        language.check(code)
+      }.to raise_error(TypedRb::Types::UncomparableTypes)
+    end
+  end
+
+  describe '#each' do
+    it 'type checks / &([S] -> [T] -> unit) -> Hash[S][T]' do
+      code = <<__CODE
+        ts '#str_int_bool / String -> Integer -> Boolean'
+        def str_int_bool(s,i); true; end
+
+        Hash.(String,Integer).new.each { |s,t| str_int_bool(s,t) }
+__CODE
+
+      result = language.check(code)
+      expect(result.to_s).to eq('Hash[String][Integer]')
+
+
+      code = <<__CODE
+        ts '#str_int_bool / String -> Integer -> Boolean'
+        def str_int_bool(s,i); true; end
+
+        Hash.(String,Integer).new.each { |(s,t)| str_int_bool(s,t) }
+__CODE
+
+      result = language.check(code)
+      expect(result.to_s).to eq('Hash[String][Integer]')
+
+      expect {
+        code = <<__CODE
+        ts '#str_int_bool / String -> Integer -> Boolean'
+        def str_int_bool(s,i); true; end
+        Hash.(String,Integer).new.delete_if { |k,v| str_int_bool(v,v) }
+__CODE
+
+        language.check(code)
+      }.to raise_error(TypedRb::Types::UncomparableTypes)
+
+      expect {
+        code = <<__CODE
+        ts '#str_int_bool / String -> Integer -> Boolean'
+        def str_int_bool(s,i); true; end
+        Hash.(String,Integer).new.delete_if { |(k,v)| str_int_bool(v,v) }
+__CODE
+
+        language.check(code)
+      }.to raise_error(TypedRb::Types::UncomparableTypes)
+    end
+  end
+
+  describe '#each_key' do
+    it 'type checks / -> Enumerator' do
+      result = language.check('Hash.(String,Integer).new.each_key')
+      expect(result.ruby_type).to eq(Enumerator)
+    end
+
+    it 'type checks / &([S] -> unit) -> Hash[S][T]' do
+      code = <<__CODE
+        ts '#str_bool / String -> Boolean'
+        def str_bool(s); true; end
+
+        Hash.(String,Integer).new.each_key { |s| str_bool(s,t) }
+__CODE
+
+      result = language.check(code)
+      expect(result.to_s).to eq('Hash[String][Integer]')
+
+      expect {
+        code = <<__CODE
+          ts '#int_bool / Integer -> Boolean'
+          def int_bool(s); true; end
+
+          Hash.(String,Integer).new.each_key { |s| int_bool(s) }
+__CODE
+
+        language.check(code)
+      }.to raise_error(TypedRb::Types::UncomparableTypes)
+    end
+  end
+
+  describe '#eql?' do
+    it 'type checks / Hash[?][?] -> Boolean' do
+      result = language.check('Hash.(String,Integer).new.eql?(Hash.(String,String).new)')
+      expect(result.to_s).to eq('Boolean')
+
+      result = language.check('Hash.(String,Integer).new.eql?(Array.(String).new)')
+      expect(result.to_s).to eq('Boolean')
+    end
+  end
+
+  describe '#fetch' do
+    it 'type checks / [S] -> &([S] -> [T]) -> [T]' do
+
+      code = <<__CODE
+        h = Hash.(String,Integer).new
+        h['str'] = 0
+        h.fetch('str')
+__CODE
+      result = language.check(code)
+      expect(result.ruby_type).to eq(Integer)
+
+      code = <<__CODE
+        ts '#str / String -> unit'
+        def str(k); end
+
+        h = Hash.(String,Integer).new
+        h['str'] = 0
+        h.fetch('str') { |k| str(k) }
+__CODE
+      result = language.check(code)
+      expect(result.ruby_type).to eq(Integer)
+
+      expect {
+        code = <<__CODE
+        h = Hash.(String,Integer).new
+        h['str'] = 0
+        begin
+           h.fetch(0)
+        rescue; end
+__CODE
+        language.check(code)
+      }.to raise_error(TypedRb::Types::UncomparableTypes)
+
+      expect {
+        code = <<__CODE
+        ts '#intf / Integer -> unit'
+        def intf(k); end
+
+        h = Hash.(String,Integer).new
+        h['str'] = 0
+        h.fetch('str') { |k| intf(k) }
+__CODE
+        language.check(code)
+      }.to raise_error(TypedRb::Types::UncomparableTypes)
+    end
+
+    it 'type checks / [S] -> [T] -> [T]' do
+      result = language.check('Hash.(String,Integer).new.fetch("str",0)')
+      expect(result.ruby_type).to eq(Integer)
+
+      expect {
+        language.check('Hash.(String,Integer).new.fetch("str","default")')
+      }.to raise_error(TypedRb::Types::UncomparableTypes)
+    end
+  end
+
+  describe '#invert' do
+    it 'type checks / -> Hash[T][S]' do
+      result = language.check('Hash.(String,Integer).new.invert')
+      expect(result.to_s).to eq('Hash[Integer][String]')
+    end
+  end
+
+  describe '#merge' do
+    it 'type checks / Hash[S][T] -> Hash[S][T]' do
+      result = language.check('a = Hash.(String,Integer).new; Hash.(String,Integer).new.merge(a)')
+      expect(result.to_s).to eq('Hash[String][Integer]')
+
+      expect {
+        language.check('a = Hash.(Integer,Integer).new; Hash.(String,Integer).new.merge(a)')
+      }.to raise_error(TypedRb::Types::UncomparableTypes)
+    end
+
+    context 'with a given block' do
+      it 'type checks / Hash[S][T] -> &([S] -> [T] -> [T] -> [S]) -> Hash[S][T]' do
+        code = <<__CODE
+               ts '#str_int_int_fn / String -> Integer -> Integer -> Integer'
+               def str_int_int_fn(k,v1,v2); v1 + v2; end
+
+               a = Hash.(String,Integer).new
+               Hash.(String,Integer).new.merge(a) { |k,v1,v2| str_int_int_fn(k, v1, v2) }
+__CODE
+        result = language.check(code)
+        expect(result.to_s).to eq('Hash[String][Integer]')
+
+        expect {
+          code = <<__CODE
+               ts '#str_str_int_fn / String -> String -> Integer -> Integer'
+               def str_str_int_fn(k,v1,v2); 0; end
+
+               a = Hash.(String,Integer).new
+               Hash.(String,Integer).new.merge(a) { |k,v1,v2| str_str_int_fn(k, v1, v2) }
+__CODE
+          language.check(code)
+        }.to raise_error(TypedRb::Types::UncomparableTypes)
+      end
+    end
+  end
+
+  describe '#rassoc' do
+    it 'type checks / [T] -> Pair[S][T]' do
+      result = language.check('Hash.(String,Integer).new.rassoc(2)')
+      expect(result.to_s).to eq('Pair[String][Integer]')
+    end
+  end
+
+  describe '#shift' do
+    it 'type checks / -> Pair[S][T]' do
+      result = language.check('Hash.(String,Integer).new.shift')
+      expect(result.to_s).to eq('Pair[String][Integer]')
+    end
+  end
+
+  describe '#to_a' do
+    it 'type checks / -> Array[Pair[S][T]]' do
+      result = language.check('Hash.(String,Integer).new.to_a')
+      expect(result.to_s).to eq('Array[Pair[String][Integer]]')
+    end
+  end
+
+  describe '#values' do
+    it 'type checks / -> Array[S]' do
+      result = language.check('Hash.(String,Integer).new.values')
+      expect(result.to_s).to eq('Array[Integer]')
+    end
+  end
+
+  describe '#values_at' do
+    it 'type checks / -> Array[S]' do
+      result = language.check('Hash.(String,Integer).new.values_at("a","b","d")')
+      expect(result.to_s).to eq('Array[Integer]')
+    end
+  end
+end

data/spec/lib/prelude/kernel_spec.rb

@@ -0,0 +1,23 @@
+require_relative '../../spec_helper'
+
+describe Kernel do
+  let(:language) { TypedRb::Language.new }
+
+  describe '#Array[E]' do
+    it 'type checks / Range[E] -> Array[E]' do
+      result = language.check('Array(Range.(Integer).new(0, 10))')
+      expect(result.ruby_type).to eq(Array)
+      expect(result.type_vars.first.bound.ruby_type).to eq(Integer)
+    end
+  end
+
+  describe '#rand' do
+    it 'type checks #rand[E < Numeric] / [E] -> [E]' do
+      result = language.check('rand(2.0)')
+      expect(result.ruby_type).to eq(Float)
+
+      result = language.check('rand(1)')
+      expect(result.ruby_type).to eq(Integer)
+    end
+  end
+end

data/spec/lib/prelude/object_spec.rb

@@ -0,0 +1,22 @@
+require_relative '../../spec_helper'
+
+describe Object do
+  let(:language) { TypedRb::Language.new }
+
+  describe '#instance_variable_defined' do
+    it 'type checks / Showable -> Boolean' do
+      result = language.check('Object.new.instance_variable_defined?("@a")')
+      expect(result.ruby_type).to eq(TrueClass)
+
+      result = language.check('Object.new.instance_variable_defined?(:@a)')
+      expect(result.ruby_type).to eq(TrueClass)
+    end
+  end
+
+  describe '#instance_of?' do
+    it 'type checks / Class -> Boolean' do
+      result = language.check('Object.new.instance_of?(Object)')
+      expect(result.ruby_type).to eq(TrueClass)
+    end
+  end
+end

data/spec/lib/prelude/pair_spec.rb

@@ -0,0 +1,16 @@
+require_relative '../../spec_helper'
+require_relative '../../../lib/typed/prelude'
+
+describe Pair do
+  let(:language) { TypedRb::Language.new }
+
+  describe '#instance_variable_defined' do
+    it 'type checks / Showable -> Boolean' do
+      result = language.check('Pair.of(1,"foo").second')
+      expect(result.ruby_type).to eq(String)
+
+      result = language.check('Pair.of(1,"foo").first')
+      expect(result.ruby_type).to eq(Integer)
+    end
+  end
+end

data/spec/lib/prelude/showable_spec.rb

@@ -0,0 +1,31 @@
+require_relative '../../spec_helper'
+
+describe Object do
+  let(:language) { TypedRb::Language.new }
+
+  describe 'Strings' do
+    it 'is a Showable' do
+      code = <<__CODE
+        ts '#st1 / Showable -> Showable'
+        def st1(s); s; end
+
+        st1('hey')
+__CODE
+      result = language.check(code)
+      expect(result.ruby_type).to eq(Showable)
+    end
+  end
+
+  describe 'Symbols' do
+    it 'is a Showable' do
+      code = <<__CODE
+        ts '#st1 / Showable -> Showable'
+        def st1(s); s; end
+
+        st1(:hey)
+__CODE
+      result = language.check(code)
+      expect(result.ruby_type).to eq(Showable)
+    end
+  end
+end

data/spec/lib/prelude/string_spec.rb

@@ -0,0 +1,98 @@
+require_relative '../../spec_helper'
+
+describe String do
+  let(:language) { TypedRb::Language.new }
+
+  describe '#each_line' do
+    describe '/ &(String -> unit) -> String' do
+      it 'type checks , positive case' do
+        code = <<__CODE
+        ts '#str_fn / String -> unit'
+        def str_fn(s); end
+
+        "".each_line{ |s| str_fn(s) }
+__CODE
+        result = language.check(code)
+        expect(result.to_s).to eq('String')
+      end
+
+      it 'type checks / &(String -> unit) -> String, negative case' do
+        code = <<__CODE
+        ts '#int_fn / Integer -> unit'
+        def int_fn(i); end
+
+        "".each_line{ |s| int_fn(s) }
+__CODE
+        expect {
+          language.check(code)
+        }.to raise_error(TypedRb::Types::UncomparableTypes)
+      end
+    end
+
+    describe '-> Enumerator[String]' do
+      it 'type checks' do
+        result = language.check('"".each_line')
+        expect(result.to_s).to eq('Enumerator[String]')
+      end
+    end
+
+    describe '/ String -> &(String -> unit) -> String' do
+      it 'type checks , positive case' do
+        code = <<__CODE
+        ts '#str_fn / String -> unit'
+        def str_fn(s); end
+
+        "".each_line(''){ |s| str_fn(s) }
+__CODE
+        result = language.check(code)
+        expect(result.to_s).to eq('String')
+      end
+
+      it 'type checks / &(String -> unit) -> String, negative case' do
+        code = <<__CODE
+        ts '#int_fn / Integer -> unit'
+        def int_fn(i); end
+
+        "".each_line(''){ |s| int_fn(s) }
+__CODE
+        expect {
+          language.check(code)
+        }.to raise_error(TypedRb::Types::UncomparableTypes)
+      end
+    end
+
+    describe 'String -> Enumerator[String]' do
+      it 'type checks' do
+        result = language.check('"".each_line("")')
+        expect(result.to_s).to eq('Enumerator[String]')
+      end
+    end
+  end
+
+  describe '#scan' do
+    describe 'Regexp -> &(String... -> unit) -> String' do
+      it 'type checks, positive case' do
+        code = <<__CODE
+         ts '#str_array_fn / Array[String] -> unit'
+         def str_array_fn(ss); end
+
+         "".scan(/\n/) { |ss| str_array_fn(ss) }
+__CODE
+        result = language.check(code)
+        expect(result.to_s).to eq('String')
+      end
+
+      it 'type checks, negative case' do
+        code = <<__CODE
+         ts '#int_array_fn / Array[Integer] -> unit'
+         def int_array_fn(is); end
+
+         "".scan(/\n/) { |ss| int_array_fn(ss) }
+__CODE
+        expect {
+          language.check(code)
+        }.to raise_error(TypedRb::Types::UncomparableTypes)
+      end
+    end
+  end
+end

data/spec/lib/runtime/normalization_spec.rb

@@ -0,0 +1,29 @@
+require_relative '../../spec_helper'
+
+describe TypedRb::Runtime::Normalization do
+  let(:language) { TypedRb::Language.new }
+  it 'normalizes generic types with super types annotations' do
+    code = <<__END
+    ts 'type TestPair[S][T] super Array[Object]'
+    class TestPair < Array
+      ts '#first / -> [S]'
+    end
+    TestPair
+__END
+    result = language.check(code)
+    expect(result.ruby_type).to eq(TestPair)
+    expect(result.super_type.ruby_type).to eq(Array)
+    expect(result.super_type.type_vars.first.bound.ruby_type).to eq(Object)
+  end
+
+  it 'raises an exception if the super type is not a super class of the current type' do
+    code = <<__END
+    ts 'type TestPair2[S][T] super Array[Object]'
+    class TestPair2
+    end
+__END
+    expect {
+      language.check(code)
+    }.to raise_error(StandardError)
+  end
+end

data/spec/lib/runtime/validations_spec.rb

@@ -0,0 +1,56 @@
+require_relative '../../spec_helper'
+
+describe TypedRb::Runtime::Normalization::Validations do
+
+  let(:language) { TypedRb::Language.new }
+
+  include described_class
+
+  describe '#validate_signature' do
+    it 'is valid if the type is a variable' do
+      expect {
+        validate_signature(:class_variable, nil)
+      }.to_not raise_error
+      expect {
+        validate_signature(:instance_variable, nil)
+      }.to_not raise_error
+      expect {
+        validate_signature(:invalid, nil)
+      }.to raise_error(::TypedRb::Types::TypeParsingError)
+    end
+  end
+
+  describe '#validate_signatures' do
+    it 'raises an exception if there is a duplicated arity' do
+      code = <<__END
+      class TA
+        ts '#x / Integer -> Integer -> Integer'
+        ts '#x / String -> String -> String'
+        def x(a,b); a + b; end
+      end
+__END
+      expect {
+        language.check(code)
+      }.to raise_error(::TypedRb::Types::TypeParsingError)
+    end
+  end
+
+  describe '#validate_method' do
+    it 'fails if the class method info passed does not include the method validated' do
+      expect {
+        validate_method({instance_methods: []}, :class, :test, :instance)
+      }.to raise_error(::TypedRb::Types::TypeParsingError)
+      expect {
+        validate_method({all_methods: []}, :class, :test, :class)
+      }.to raise_error(::TypedRb::Types::TypeParsingError)
+    end
+  end
+
+  describe '#validate_function_signature' do
+    it 'fails if a hash is passed' do
+      expect {
+        validate_function_signature(nil, nil, {}, nil)
+      }.to raise_error(::TypedRb::Types::TypeParsingError)
+    end
+  end
+end