typed.rb 0.0.11

data/spec/lib/typing/tm_send_yield_block_spec.rb

@@ -0,0 +1,308 @@
+require_relative '../../spec_helper'
+
+describe TypedRb::Model::TmSend do
+  let(:language) { TypedRb::Language.new }
+
+  context 'with a yield blocking function' do
+    it 'type-checks correctly the block yielding and the block passing' do
+      expr = <<__END
+     ts '#wblock1 / Integer -> &(Integer -> Integer) -> Integer'
+     def wblock1(x)
+       yield x
+     end
+
+     wblock1(2) { |n| n + 1 }
+__END
+
+      result = language.check(expr)
+      expect(result).to eq(tyinteger)
+    end
+
+    it 'type-checks correctly errors in the block arguments application' do
+      expr = <<__END
+     ts '#wblock2 / Integer -> &(Integer -> Integer) -> Integer'
+     def wblock2(x)
+       yield x
+     end
+     lambda {
+       wblock2('2') { |n| n + 1 }
+     }
+__END
+
+      expect {
+        language.check(expr)
+      }.to raise_error(TypedRb::TypeCheckError)
+    end
+
+    it 'type-checks correctly errors in the block arguments type' do
+      expr = <<__END
+     class Integer
+       ts '#+ / Integer -> Integer'
+     end
+
+     ts '#wblock3 / Integer -> &(Integer -> Integer) -> Integer'
+     def wblock3(x)
+       yield x
+     end
+     lambda {
+       wblock3(2) { |n| n + '1' }
+     }
+__END
+
+      expect {
+        language.check(expr)
+      }.to raise_error(TypedRb::TypeCheckError)
+    end
+
+    it 'type-checks correctly errors in the block return type' do
+      expr = <<__END
+     ts '#wblock4 / Integer -> &(Integer -> Integer) -> Integer'
+     def wblock4(x)
+       yield x
+     end
+
+     wblock4(2) { |n| '1' }
+__END
+
+      expect {
+        language.check(expr)
+      }.to raise_error(TypedRb::TypeCheckError)
+    end
+
+    it 'type-checks block-passing args' do
+      expr = <<__CODE
+
+        ts '#f / &(Integer -> String) -> String'
+        def f(&b)
+          b[1]
+        end
+
+        p = Proc.new { |arg| 'string' }
+
+        f(&p)
+__CODE
+
+      result = language.check(expr)
+
+      expect(result.ruby_type).to eq(String)
+    end
+
+    it 'captures errors type-checking block-passing args' do
+
+      expr = <<__CODE
+
+        ts '#f / &(Integer -> String) -> String'
+        def f(&b)
+          b[1]
+        end
+
+        p = Proc.new { |arg| 0 }
+
+        f(&p)
+__CODE
+
+      expect {
+        language.check(expr)
+      }.to raise_error(TypedRb::Types::UncomparableTypes)
+
+    end
+
+    it 'captures errors type-checking block-passing args' do
+
+      expr = <<__CODE
+
+        ts '#f / &(Integer -> String) -> Integer'
+        def f(&b)
+          b[1]
+        end
+
+        p = Proc.new { |arg| 'string' }
+
+        f(&p)
+__CODE
+
+      expect {
+        language.check(expr)
+      }.to raise_error(TypedRb::Types::UncomparableTypes)
+
+    end
+
+    it 'type-checks yielded block-passing args' do
+      expr = <<__CODE
+
+        ts '#f / &(Integer -> String) -> String'
+        def f(&b)
+          yield 1
+        end
+
+        p = Proc.new { |arg| 'string' }
+
+        f(&p)
+__CODE
+
+      result = language.check(expr)
+
+      expect(result.ruby_type).to eq(String)
+    end
+
+    it 'type-checks yielded blocks' do
+      expr = <<__CODE
+
+        ts '#f / &(Integer -> String) -> String'
+        def f(&b)
+          yield 1
+        end
+
+        f { |arg| 'string' }
+__CODE
+
+      result = language.check(expr)
+
+      expect(result.ruby_type).to eq(String)
+    end
+
+    it 'captures errors in yielded type-checking block-passing args' do
+
+      expr = <<__CODE
+
+        ts '#f / &(Integer -> String) -> String'
+        def f(&b)
+          yield 1
+        end
+
+        p = Proc.new { |arg| 0 }
+
+        f(&p)
+__CODE
+
+      expect {
+        language.check(expr)
+      }.to raise_error(TypedRb::Types::UncomparableTypes)
+
+    end
+
+    it 'captures errors in yielded type-checking blocks' do
+
+      expr = <<__CODE
+
+        ts '#f / &(Integer -> String) -> String'
+        def f(&b)
+          yield 1
+        end
+
+        f { |arg| 0 }
+__CODE
+
+      expect {
+        language.check(expr)
+      }.to raise_error(TypedRb::Types::UncomparableTypes)
+
+    end
+
+    it 'captures errors yielded type-checking block-passing args' do
+
+      expr = <<__CODE
+
+        ts '#f / &(Integer -> String) -> Integer'
+        def f(&b)
+          yield 1
+        end
+
+        p = Proc.new { |arg| 'string' }
+
+        f(&p)
+__CODE
+
+      expect {
+        language.check(expr)
+      }.to raise_error(TypedRb::Types::UncomparableTypes)
+
+    end
+
+    it 'type-checks symbol.to_proc converted arguments' do
+      expr = <<__CODE
+        class TStP1
+          ts '#test / -> String'
+          def test
+            'string'
+          end
+        end
+
+        ts '#ftstp1 / TStP1 -> &(TStP1 -> String) -> String'
+        def ftstp1(obj, &b)
+          yield obj
+        end
+
+        ftstp1(TStP1.new, &:test)
+__CODE
+
+      result = language.check(expr)
+      expect(result.ruby_type).to eq(String)
+    end
+
+    it 'type-checks symbol.to_proc converted arguments for generic functions' do
+      expr = <<__CODE
+        class TStP1g
+          ts '#test / -> String'
+          def test
+            'string'
+          end
+        end
+
+        ts '#ftstp1g[T] / [T] -> &([T] -> String) -> String'
+        def ftstp1g(obj, &b)
+          yield obj
+        end
+
+        ftstp1g(TStP1g.new, &:test)
+__CODE
+
+      result = language.check(expr)
+      expect(result.ruby_type).to eq(String)
+    end
+
+    it 'type-checks symbol.to_proc converted arguments for generic functions, negative case' do
+      expr = <<__CODE
+        class TStP1gn
+          ts '#test / -> Integer'
+          def test
+            1
+          end
+        end
+
+        ts '#ftstp1gn[T] / [T] -> &([T] -> String) -> String'
+        def ftstp1gn(obj, &b)
+          yield obj
+        end
+
+        ftstp1gn(TStP1gn.new, &:test)
+__CODE
+
+      expect {
+        language.check(expr)
+      }.to raise_error(TypedRb::Types::UncomparableTypes)
+    end
+
+    it 'captures errors in the application of  symbol.to_proc converted arguments' do
+      expr = <<__CODE
+        class TStP2
+          ts '#test / -> String'
+          def test
+            'string'
+          end
+        end
+
+        ts '#ftstp2 / TStP2 -> &(TStP2 -> Integer) -> Integer'
+        def ftstp2(obj, &b)
+          yield obj
+        end
+
+        ftstp2(TStP2.new, &:test)
+__CODE
+
+      expect {
+        language.check(expr)
+      }.to raise_error(TypedRb::Types::UncomparableTypes)
+    end
+  end
+end

data/spec/lib/typing/tm_sequencing_spec.rb

@@ -0,0 +1,174 @@
+require_relative '../../spec_helper'
+
+describe TypedRb::Model::TmSequencing do
+  it 'parses sequencing instructions without return type' do
+    code = <<__CODE
+       1
+       2
+       'string'
+__CODE
+
+    parsed = TypedRb::Language.new.check(code)
+    expect(parsed.ruby_type).to eq(String)
+  end
+
+  it 'parses sequencing instructions with return type' do
+    code = <<__CODE
+       ts '#st1 / -> String'
+       def st1
+        return 'string'
+        nil
+       end
+
+       st1
+__CODE
+
+    parsed = TypedRb::Language.new.check(code)
+    expect(parsed.ruby_type).to eq(String)
+  end
+
+  it 'parses sequencing instructions with multiple return types' do
+    code = <<__CODE
+       ts '#st2 / -> Numeric'
+       def st2
+        return 1
+        return Numeric.new
+        nil
+       end
+
+       st2
+__CODE
+
+    parsed = TypedRb::Language.new.check(code)
+    expect(parsed.ruby_type).to eq(Numeric)
+  end
+
+  it 'parses sequencing instructions with multiple return types and dynamic objects' do
+    code = <<__CODE
+       ts '#st2 / -> Numeric'
+       def st2
+        return 1
+        return dynamic
+        nil
+       end
+
+       st2
+__CODE
+
+    parsed = TypedRb::Language.new.check(code)
+    expect(parsed.ruby_type).to eq(Numeric)
+  end
+
+  it 'parses sequencing instructions with nested nodes' do
+    code = <<__CODE
+       ts '#st3 / -> Boolean'
+       def st3
+         if true
+           1
+           true
+         else
+           'string'
+           false
+         end
+         0
+         return true
+         nil
+       end
+
+       st3
+__CODE
+
+    parsed = TypedRb::Language.new.check(code)
+    expect(parsed.class).to eq(TypedRb::Types::TyBoolean)
+  end
+
+  it 'parses sequencing instructions with either types, positive case' do
+    code = <<__CODE
+       ts '#st3 / -> Boolean'
+       def st3
+         if true
+           1
+           return true
+         else
+           'string'
+           false
+         end
+         0
+         true
+         nil
+       end
+
+       st3
+__CODE
+
+    parsed = TypedRb::Language.new.check(code)
+    expect(parsed.class).to eq(TypedRb::Types::TyBoolean)
+  end
+
+  it 'parses sequencing instructions with either types, negative case' do
+    code = <<__CODE
+       ts '#st3 / -> Boolean'
+       def st3
+         if true
+           1
+           return 2.0
+         else
+           'string'
+           false
+         end
+         0
+         true
+         nil
+       end
+
+       st3
+__CODE
+
+    expect {
+      TypedRb::Language.new.check(code)
+    }.to raise_error(TypedRb::Types::UncomparableTypes)
+  end
+
+  it 'parses sequencing instructions with either types, negative case2' do
+    code = <<__CODE
+       ts '#st3 / -> Boolean'
+       def st3
+         if true
+           1
+           return 2.0
+         else
+           'string'
+           false
+         end
+         0
+         return true
+         nil
+       end
+
+       st3
+__CODE
+
+    expect {
+      TypedRb::Language.new.check(code)
+    }.to raise_error(TypedRb::Types::UncomparableTypes)
+  end
+
+  it 'parses sequencing instructions with either types, negative case 3' do
+    code = <<__CODE
+       ts '#st3 / -> Boolean'
+       def st3
+         if true
+           1
+           2.0
+         else
+           'string'
+           return false
+         end
+       end
+__CODE
+
+    expect {
+      TypedRb::Language.new.check(code)
+    }.to raise_error(TypedRb::Types::UncomparableTypes)
+  end
+end

data/spec/lib/typing/tm_string_interpolation_spec.rb

@@ -0,0 +1,19 @@
+require_relative '../../spec_helper'
+
+describe TypedRb::Model::TmStringInterpolation do
+
+  let(:language) { TypedRb::Language.new }
+
+  context 'with a interpolated string' do
+
+    it 'type-checks it correctly' do
+      code = <<__END
+        a = 1
+        b = 'interpolated'
+        "This is \#{a} string \#{b}"
+__END
+      result = language.check(code)
+      expect(result).to eq(tystring)
+    end
+  end
+end

data/spec/lib/typing/tm_super_spec.rb

@@ -0,0 +1,63 @@
+require_relative '../../spec_helper'
+
+describe TypedRb::Model::TmSuper do
+  let(:language) { TypedRb::Language.new }
+
+  it 'type checks invocations of the super keyword' do
+    expr = <<__CODE
+      class TSA
+        ts '#t / Integer -> Integer'
+        def t(x); x; end
+      end
+
+      class TSB < TSA
+       ts '#t / Integer -> Integer'
+       def t(x); super; end
+      end
+
+      TSB.new.t(1)
+__CODE
+
+    result = language.check(expr)
+    expect(result.ruby_type).to eq(Integer)
+  end
+
+  it 'type checks invocations of the super keyword and arguments' do
+    expr = <<__CODE
+      class TSA
+        ts '#t / Integer -> Integer -> Integer'
+        def t(x,y); x+y; end
+      end
+
+      class TSB < TSA
+       ts '#t / Integer -> Integer'
+       def t(x); super(0,x); end
+      end
+
+      TSB.new.t(1)
+__CODE
+
+    result = language.check(expr)
+    expect(result.ruby_type).to eq(Integer)
+  end
+
+  it 'type checks invocations of the super keyword and arguments, negative case' do
+    expr = <<__CODE
+      class TSA
+        ts '#t / Integer -> Integer -> Integer'
+        def t(x,y); x.to_i+y.to_i; end
+      end
+
+      class TSB < TSA
+       ts '#t / String -> String'
+       def t(x); super(0,x); end
+      end
+
+      TSB.new.t('string')
+__CODE
+
+    expect {
+      language.check(expr)
+    }.to raise_error(TypedRb::Types::UncomparableTypes)
+  end
+end

data/spec/lib/typing/tm_symbol_interpolation_spec.rb

@@ -0,0 +1,19 @@
+require_relative '../../spec_helper'
+
+describe TypedRb::Model::TmSymbolInterpolation do
+
+  let(:language) { TypedRb::Language.new }
+
+  context 'with a interpolated string' do
+
+    it 'type-checks it correctly' do
+      code = <<__END
+        a = 1
+        b = 'interpolated'
+        :"This is \#{a} string \#{b}"
+__END
+      result = language.check(code)
+      expect(result).to eq(tysymbol)
+    end
+  end
+end

data/spec/lib/typing/tm_symbol_spec.rb

@@ -0,0 +1,14 @@
+require_relative '../../spec_helper'
+
+describe TypedRb::Model::TmSymbol do
+
+  let(:language) { TypedRb::Language.new }
+
+  context 'with a ruby symbol' do
+
+    it 'parsed the symbol type correctly' do
+      result = language.check(':test')
+      expect(result).to eq(tysymbol)
+    end
+  end
+end

data/spec/lib/typing/tm_try_spec.rb

@@ -0,0 +1,73 @@
+require_relative '../../spec_helper'
+
+describe TypedRb::Model::TmTry do
+
+  let(:language) { TypedRb::Language.new }
+
+  context 'with no rescue term' do
+    it 'type-checks it correctly' do
+      code = <<__END
+        begin
+           2 + 2
+        end
+__END
+      result = language.check(code)
+      expect(result.to_s).to eq('Integer')
+    end
+  end
+  context 'with rescue term' do
+    it 'type-checks it correctly, positive case' do
+      code = <<__END
+        begin
+           2 + 2
+        rescue StandardError => e
+           0
+        end
+__END
+      result = language.check(code)
+      expect(result.to_s).to eq('Integer')
+    end
+
+    it 'type-checks it correctly, negative case' do
+      code = <<__END
+        begin
+           2 + 2
+        rescue
+           'string'
+        end
+__END
+      expect {
+        language.check(code)
+      }.to raise_error(TypedRb::Types::UncomparableTypes)
+    end
+  end
+
+  context 'with multiple rescue clauses' do
+    it 'type-checks it correctly' do
+      code = <<__END
+        begin
+           2 + 2
+        rescue StandardError => e
+        rescue
+           0
+        end
+__END
+      result = language.check(code)
+      expect(result.to_s).to eq('Integer')
+    end
+  end
+
+  context 'with a error return type' do
+    it 'type-checks it correctly' do
+      code = <<__END
+        begin
+           Object.new
+        rescue StandardError, Object => e
+           e
+        end
+__END
+      result = language.check(code)
+      expect(result.to_s).to eq('Object')
+    end
+  end
+end