typed.rb 0.0.11

data/spec/lib/typing/tm_boolean_operator_spec.rb

@@ -0,0 +1,100 @@
+require_relative '../../spec_helper'
+
+describe TypedRb::Model::TmBooleanOperator do
+  let(:language) { TypedRb::Language.new }
+
+  it 'type checks boolean operations of the same type' do
+    expr = 'true && false'
+
+    result = language.check(expr)
+    expect(result.ruby_type).to eq(TrueClass)
+
+    expr = 'true || false'
+
+    result = language.check(expr)
+    expect(result.ruby_type).to eq(TrueClass)
+
+    expr = 'true or false'
+
+    result = language.check(expr)
+    expect(result.ruby_type).to eq(TrueClass)
+
+    expr = 'true and false'
+
+    result = language.check(expr)
+    expect(result.ruby_type).to eq(TrueClass)
+  end
+
+  it 'type checks boolean operations with different types' do
+    expr = '1 && 0'
+
+    result = language.check(expr)
+    expect(result.ruby_type).to eq(Integer)
+
+    expr = '1 || Numeric.new'
+
+    result = language.check(expr)
+    expect(result.ruby_type).to eq(Numeric)
+
+    expr = '"string" or Numeric.new'
+
+    result = language.check(expr)
+    expect(result.ruby_type).to eq(Object)
+  end
+
+
+  it 'type checks boolean operations with nil values' do
+    expr = '1 && nil'
+
+    result = language.check(expr)
+    expect(result.ruby_type).to eq(Integer)
+
+    expr = 'nil || Numeric.new'
+
+    result = language.check(expr)
+    expect(result.ruby_type).to eq(Numeric)
+
+    expr = '"string" or nil'
+
+    result = language.check(expr)
+    expect(result.ruby_type).to eq(String)
+  end
+
+  it 'type checks operations with type variables' do
+
+    code = <<__CODE
+      class TBOp1
+        ts '#test / -> Boolean'
+        def test
+          @b || false
+        end
+
+        ts '#b / -> Boolean'
+        def b; @b; end
+      end
+
+      TBOp1.new.b
+__CODE
+
+    result = language.check(code)
+    expect(result.ruby_type).to eq(TrueClass)
+
+
+    code = <<__CODE
+      class TBOp2
+        ts '#test / -> Boolean'
+        def test
+          @b || @c
+        end
+
+        ts '#b / -> Boolean'
+        def b; @b; end
+      end
+
+      TBOp2.new.b
+__CODE
+
+    result = language.check(code)
+    expect(result.ruby_type).to eq(TrueClass)
+  end
+end

data/spec/lib/typing/tm_boolean_spec.rb

@@ -0,0 +1,61 @@
+require_relative '../../spec_helper'
+
+describe TypedRb::Model::TmBoolean 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 validly typed code' do
+    let(:code) {
+      <<__CODE
+       ts '#f / Boolean -> Boolean'
+       def f(b)
+          b
+       end
+
+       f(true)
+       f(false)
+__CODE
+    }
+
+    it 'should be possible to type check a method and method application' do
+      expect {
+        ast.check_type(TypedRb::Types::TypingContext.top_level)
+      }.to_not raise_error
+    end
+  end
+
+  context 'when used as a subtype' do
+    let(:code) {
+      <<__CODE
+       ts '#f / Object -> Object'
+       def f(b)
+          b
+       end
+
+       f(true)
+       f(false)
+__CODE
+    }
+
+    it 'should be possible to type check method application' do
+      expect {
+        ast.check_type(TypedRb::Types::TypingContext.top_level)
+      }.to_not raise_error
+    end
+  end
+end

data/spec/lib/typing/tm_const_spec.rb

@@ -0,0 +1,28 @@
+require_relative '../../spec_helper'
+
+describe TypedRb::Model::TmConst do
+
+  let(:language) { TypedRb::Language.new }
+
+  it 'type checks class constants' do
+    result = language.check('class TmConstTest1; end; TmConstTest1')
+    expect(result.ruby_type).to eq(TmConstTest1)
+  end
+
+  it 'type checks module constants' do
+    result = language.check('module TmConstTest2; end; TmConstTest2')
+    expect(result.ruby_type).to eq(TmConstTest2)
+  end
+
+  it 'type checks user defined constants' do
+    code = <<__END
+       module TestConstTest3
+         MY_CONSTANT = 2
+       end
+
+       TestConstTest3::MY_CONSTANT
+__END
+    result = language.check(code)
+    expect(result.ruby_type).to eq(Fixnum)
+  end
+end

data/spec/lib/typing/tm_defined_spec.rb

@@ -0,0 +1,12 @@
+require_relative '../../spec_helper'
+
+describe TypedRb::Model::TmDefined do
+  let(:language) { TypedRb::Language.new }
+
+  it 'defined invocations' do
+      expr = 'defined? 2'
+
+      result = language.check(expr)
+      expect(result.ruby_type).to eq(String)
+  end
+end

data/spec/lib/typing/tm_fun_spec.rb

@@ -0,0 +1,347 @@
+require_relative '../../spec_helper'
+
+describe TypedRb::Model::TmFun do
+  before :each do
+    ::BasicObject::TypeRegistry.clear
+  end
+
+  let(:code) do
+    text = <<__CODE
+      class A
+        ts '#f1 / Integer -> String'
+        def f1(num)
+          'String'
+        end
+
+        ts '#f2 / Integer -> String'
+        def f2(num=2)
+          f1(num)
+        end
+      end
+__CODE
+    text
+  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 validly typed code' do
+    it 'is possible to type check a method and method application' do
+      expect do
+        ast.check_type(TypedRb::Types::TypingContext.new)
+      end.to_not raise_error
+    end
+  end
+
+  context 'with not matching arg type in function definition' do
+    let(:code) do
+      text = <<__CODE
+      class A
+        ts '#f1 / Integer -> String'
+        def f1(num='text')
+          'String'
+        end
+
+        ts '#f2 / Integer -> String'
+        def f2(num)
+          f1(num)
+        end
+      end
+__CODE
+      text
+    end
+
+    it 'raises a type error' do
+      expect do
+        ast.check_type(TypedRb::Types::TypingContext.new)
+      end.to raise_error(TypedRb::Types::UncomparableTypes)
+    end
+  end
+
+  context 'with not matching return type in function definition' do
+    let(:code) do
+      text =<<__CODE
+      class A
+        ts '#f1 / Integer -> String'
+        def f1(num)
+          2
+        end
+
+        ts '#f2 / Integer -> String'
+        def f2(num)
+          f1(num)
+        end
+      end
+__CODE
+      text
+    end
+
+    it 'raises a type error' do
+      expect do
+        ast.check_type(TypedRb::Types::TypingContext.new)
+      end.to raise_error(TypedRb::Types::UncomparableTypes)
+    end
+  end
+
+  context 'with application without optional arguments' do
+    let(:code) do
+      text = <<__CODE
+       ts '#f / Integer -> Integer -> String'
+       def f(a,b=1)
+         'string'
+       end
+
+       f(2)
+
+       f(2,3)
+__CODE
+      text
+    end
+
+    it 'does not raise a type error' do
+      expect do
+        ast.check_type(TypedRb::Types::TypingContext.top_level)
+      end.not_to raise_error
+    end
+  end
+
+  context 'with application without erroneus optional arguments' do
+    let(:code) do
+      text = <<__CODE
+       ts '#f / Integer -> Integer -> String'
+       def f(a,b='string')
+         'string'
+       end
+
+       f(2)
+
+       f(2,3)
+__CODE
+      text
+    end
+
+    it 'does not raise a type error' do
+      expect do
+        ast.check_type(TypedRb::Types::TypingContext.top_level)
+      end.to raise_error(TypedRb::Types::UncomparableTypes)
+    end
+  end
+
+  context 'with application with rest args' do
+
+    context 'with correct types' do
+      let(:code) do
+        text = <<__CODE
+       ts 'type Array[T]'
+
+       ts '#f / Integer -> Integer... -> String'
+       def f(a, *b)
+         'string'
+       end
+
+       f(2, 3, 4, 5)
+__CODE
+        text
+      end
+
+      it 'doest not raise a type error' do
+
+        expect do
+          res = ast.check_type(TypedRb::Types::TypingContext.top_level)
+          expect(res.ruby_type).to eq(String)
+        end.not_to raise_error
+      end
+    end
+
+    context 'with erroneous types' do
+      let(:code) do
+        text = <<__CODE
+       ts 'type Array[T]'
+
+       ts '#f / Integer -> Integer... -> String'
+       def f(a, *b)
+         'string'
+       end
+
+       f(2, 'a', 'b')
+__CODE
+        text
+      end
+
+      it 'raises a type error' do
+
+        expect do
+          ast.check_type(TypedRb::Types::TypingContext.top_level)
+        end.to raise_error(TypedRb::TypeCheckError)
+      end
+    end
+
+    context 'with missing rest args' do
+      let(:code) do
+        text = <<__CODE
+       ts 'type Array[T]'
+
+       ts '#f / Integer -> Integer... -> String'
+       def f(a, *b)
+         'string'
+       end
+
+       f(2)
+__CODE
+        text
+      end
+
+      it 'does not raise a type error' do
+
+        expect do
+          res = ast.check_type(TypedRb::Types::TypingContext.top_level)
+          expect(res.ruby_type).to eq(String)
+        end.not_to raise_error
+      end
+    end
+
+    context 'with a correctly typed class function' do
+      let(:code) do
+        text = <<__CODE
+     class CFA
+       ts '.a / String -> Integer'
+       def self.a(x); 1; end
+     end
+
+     CFA.a('string')
+__CODE
+      end
+
+      it 'does not raise a type error' do
+        res = ast.check_type(TypedRb::Types::TypingContext.top_level)
+        expect(res.ruby_type).to eq(Integer)
+      end
+    end
+
+    context 'with a correctly typed class function added to the class object' do
+      let(:code) do
+        text = <<__CODE
+     class CFB; end
+
+     ts 'CFB.b / String -> Integer'
+     def CFB.b(x); 1; end
+
+
+     CFB.b('string')
+__CODE
+      end
+
+      it 'does not raise a type error' do
+        res = ast.check_type(TypedRb::Types::TypingContext.top_level)
+        expect(res.ruby_type).to eq(Integer)
+      end
+    end
+
+    context 'with a mistmacth in the arg types' do
+      context 'with an untyped function' do
+        let(:code) do
+          text = <<__CODE
+             class CFC1
+               ts '#t / String -> Integer'
+               def t(x); 1; end
+             end
+
+             class CFC2 < CFC1
+               def t; 1; end
+             end
+            CFC2.new.t
+__CODE
+        end
+        it 'does not raise an error' do
+          expect do
+            ast.check_type(TypedRb::Types::TypingContext.top_level)
+          end.not_to raise_error
+        end
+      end
+
+      context 'with a typed function' do
+        let(:code) do
+          text = <<__CODE
+             class CFD
+               ts '#t / String -> Integer'
+               def t(x); 1; end
+             end
+__CODE
+        end
+        it 'does raises an error' do
+          expect do
+            ast.check_type(TypedRb::Types::TypingContext.top_level)
+          end.not_to raise_error
+        end
+      end
+
+      context 'with a missing block arg' do
+        let(:code) do
+          text = <<__CODE
+             class CFE
+               ts '#t / String -> Integer'
+               def t(x, &b); 1; end
+             end
+__CODE
+        end
+        it 'does raises an error' do
+          expect do
+            ast.check_type(TypedRb::Types::TypingContext.top_level)
+          end.to raise_error(TypedRb::TypeCheckError)
+        end
+      end
+    end
+  end
+
+  context 'with a either conditional return, positive case' do
+    let(:code) do
+      <<__CODE
+      ts '#t / String -> Integer'
+      def t(s)
+        if s == 'foo'
+          0
+        else
+          return 1
+        end
+      end
+      t('bar')
+__CODE
+    end
+
+    it 'does not raise an error' do
+      result = ast.check_type(TypedRb::Types::TypingContext.top_level)
+      expect(result.ruby_type).to eq(Integer)
+    end
+  end
+
+  context 'with a either conditional return, negative case' do
+    let(:code) do
+      <<__CODE
+      ts '#t / String -> Integer'
+      def t(s)
+        if s == 'foo'
+          0
+        else
+          return 'bar'
+        end
+      end
+__CODE
+    end
+
+    it 'does not raise an error' do
+      expect {
+        ast.check_type(TypedRb::Types::TypingContext.top_level)
+      }.to raise_error(TypedRb::Types::UncomparableTypes)
+    end
+  end
+end

data/spec/lib/typing/tm_global_var_spec.rb

@@ -0,0 +1,33 @@
+require_relative '../../spec_helper'
+
+describe TypedRb::Model::TmGlobalVar do
+  let(:language) { TypedRb::Language.new }
+
+  context 'with a valid global var' do
+    it 'is possible to type-check the global var' do
+      expr = <<__END
+        $test = 1
+        $test
+__END
+
+      result = language.check(expr)
+      expect(result.bound.ruby_type).to eq(Integer)
+    end
+
+    it 'is possible to type-check errors in global var typing' do
+      expr = <<__END
+        $test = 1
+        $test = 'test'
+
+        ts '#x / Integer -> unit'
+        def x(n); end
+
+        x($test)
+__END
+
+      expect {
+        language.check(expr)
+      }.to raise_error(TypedRb::Types::UncomparableTypes)
+    end
+  end
+end

data/spec/lib/typing/tm_if_else_spec.rb

@@ -0,0 +1,104 @@
+require_relative '../../spec_helper'
+
+describe TypedRb::Model::TmIfElse do
+  let(:language) { TypedRb::Language.new }
+
+  it 'types correctly if/then/else branches' do
+    expr = <<__CODE
+      if true
+       1
+      else
+       2
+      end
+__CODE
+
+    result = language.check(expr)
+    expect(result).to eq(tyinteger)
+  end
+
+  it 'types correctly if/then' do
+    expr = <<__CODE
+     1 if true
+__CODE
+
+    result = language.check(expr)
+    expect(result).to eq(tyinteger)
+  end
+
+  it 'types correctly if/else' do
+    expr = <<__CODE
+     1 unless true
+__CODE
+    result = language.check(expr)
+    expect(result).to eq(tyinteger)
+  end
+
+  it 'types correctly return statements in if/then/else branches' do
+    expr = <<__CODE
+      ts '#fbite1 / -> Integer'
+      def fbite1
+        return  1 if true
+      end
+      fbite1
+__CODE
+
+    result = language.check(expr)
+    expect(result).to eq(tyinteger)
+  end
+
+  it 'types correctly return statements in if/then branches' do
+    expr = <<__CODE
+      ts '#fbite2 / -> Integer'
+      def fbite2
+       return 2 unless true
+      end
+      fbite2
+__CODE
+
+    result = language.check(expr)
+    expect(result).to eq(tyinteger)
+  end
+
+  it 'types correctly return statements in if/else branches' do
+    expr = <<__CODE
+      ts '#fbite3 / -> Integer'
+      def fbite3
+        if true
+         return  1
+        else
+         return 2
+        end
+      end
+      fbite3
+__CODE
+
+    result = language.check(expr)
+    expect(result).to eq(tyinteger)
+  end
+
+  it 'types correctly if/then/else statements with errors in the then branch' do
+    expr = <<__CODE
+     if false
+      fail StandardError, 'error'
+     else
+       1
+     end
+__CODE
+
+    result = language.check(expr)
+    expect(result.ruby_type).to eq(Integer)
+  end
+
+  it 'types correctly if/then/else statements with errors in the else branch' do
+    expr = <<__CODE
+     if true
+       1
+     else
+       fail StandardError, 'error'
+     end
+__CODE
+
+    result = language.check(expr)
+    expect(result.ruby_type).to eq(Integer)
+  end
+end

data/spec/lib/typing/tm_ignore_spec.rb

@@ -0,0 +1,24 @@
+require_relative '../../spec_helper'
+
+describe BasicObject do
+  let(:language) { TypedRb::Language.new }
+
+  it 'Ignores functions marked with #ts_ignore' do
+    expr = <<__CODE
+      class TypeA
+
+        ts '#fa / -> String'
+        ts_ignore
+        def fa
+          2.0
+        end
+
+      end
+
+      TypeA.new.fa
+__CODE
+
+    result = language.check(expr)
+    expect(result.to_s).to eq('String')
+  end
+end