typed.rb 0.0.11

data/spec/lib/typing/tm_instance_vars_spec.rb

@@ -0,0 +1,117 @@
+require_relative '../../spec_helper'
+
+describe TypedRb::Model::TmInstanceVar do
+
+  before :each do
+    ::BasicObject::TypeRegistry.clear
+  end
+
+  let(:code) do
+    text =<<__CODE
+      class A
+        ts '\#@a / Integer'
+        ts '#initialize / -> unit'
+        def initialize
+          @a = 'error'
+        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 invalid type assignment' do
+    it 'should raise a type error' do
+      expect {
+        ast.check_type(TypedRb::Types::TypingContext.new)
+      }.to raise_error(TypedRb::Types::UncomparableTypes)
+    end
+  end
+
+  context 'with valid type assignment' do
+    let(:code) do
+      text =<<__CODE
+      class A
+        ts '\#@a / Integer'
+
+        ts '#initialize / -> unit'
+        def initialize
+          @a = 10
+          a(@a)
+        end
+
+        ts '#a / Integer -> Integer'
+        def a(x)
+          x
+        end
+      end
+__CODE
+      text
+    end
+
+    it 'should not raise a type error' do
+      expect {
+        ast.check_type(TypedRb::Types::TypingContext.new)
+      }.to_not raise_error
+    end
+  end
+
+  context 'with a valid singleton class instance variable' do
+    let(:code) do
+      <<__CODE
+        class A
+          ts '.@a / Integer'
+
+          ts 'A.a / -> Integer'
+          def self.a
+            @a
+          end
+        end
+
+        A.a
+__CODE
+    end
+
+    it 'should not raise a type error' do
+      expect {
+        result = ast.check_type(TypedRb::Types::TypingContext.new)
+        expect(result.to_s).to eq('Integer')
+      }.to_not raise_error
+    end
+  end
+
+  context 'with an invalid type annotation' do
+    let(:code) do
+      <<__CODE
+        class A
+          ts '.@a / Integer'
+
+          ts 'A.a / -> String'
+          def self.a
+            @a
+          end
+        end
+
+        A.a
+__CODE
+    end
+
+    it 'should raise a type error' do
+      expect {
+        result = ast.check_type(TypedRb::Types::TypingContext.new)
+      }.to raise_error(TypedRb::Types::UncomparableTypes)
+    end
+  end
+end

data/spec/lib/typing/tm_local_var_asgn_spec.rb

@@ -0,0 +1,134 @@
+require_relative '../../spec_helper'
+
+describe TypedRb::Model::TmLocalVarAsgn do
+  before :each do
+    ::BasicObject::TypeRegistry.clear
+  end
+
+  let(:code) do
+    text =<<__CODE
+     a = 3
+     a
+__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 simple assignment' do
+    it 'should be possible to get the right type' do
+      type = ast.check_type(TypedRb::Types::TypingContext.top_level)
+      expect(type.to_s).to eq('Integer')
+    end
+  end
+
+
+  context 'with variable assignment' do
+    let(:code) do
+      text =<<__CODE
+     a = 3
+     b = a
+     b
+__CODE
+      text
+    end
+
+    it 'should be possible to get the right type' do
+      type = ast.check_type(TypedRb::Types::TypingContext.top_level)
+      expect(type.to_s).to eq('Integer')
+    end
+  end
+
+
+  context 'with multiple variable assignment' do
+    let(:code) do
+      text =<<__CODE
+     a = 3
+     b = "blah"
+     a = b
+     a
+__CODE
+      text
+    end
+
+    it 'should be possible to get the right type' do
+      expect {
+        ast.check_type(TypedRb::Types::TypingContext.top_level)
+      }.to raise_error(TypedRb::Types::UncomparableTypes)
+    end
+  end
+
+  context 'in function application' do
+    context 'with correctly typed code' do
+      let(:code) do
+        <<__CODE
+        ts '#f / Integer -> String'
+        def f(x)
+          a = 'hola'
+          a
+        end
+
+        ts '#g / Integer -> String'
+        def g(y)
+          a = y
+          f(a)
+        end
+__CODE
+      end
+
+      it 'should be possible to be passed as an argument to a function' do
+        expect {
+          ast.check_type(TypedRb::Types::TypingContext.top_level)
+        }.to_not raise_error
+      end
+    end
+
+    context 'with incorrectly typed code' do
+      let(:code) do
+        <<__CODE
+        ts '#f / String -> String'
+        def f(x)
+          x
+        end
+
+        ts '#g / Integer -> String'
+        def g(y)
+          a = y
+          f(a)
+        end
+__CODE
+      end
+
+      it 'should be possible to check the error' do
+        expect {
+          ast.check_type(TypedRb::Types::TypingContext.top_level)
+        }.to raise_error(TypedRb::Types::UncomparableTypes)
+      end
+    end
+
+    context 'with variable assignment using casting' do
+      let(:code) do
+        <<__CODE
+           a = cast(1,Numeric)
+           a = 2.5
+__CODE
+      end
+
+      it 'should be possible to be passed as an argument to a function using casting' do
+        result = ast.check_type(TypedRb::Types::TypingContext.top_level)
+        expect(result.ruby_type).to eq(Numeric)
+      end
+    end
+  end
+end

data/spec/lib/typing/tm_mlhs_spec.rb

@@ -0,0 +1,164 @@
+require_relative '../../spec_helper'
+
+describe TypedRb::Model::TmMlhs do
+  let(:language) { TypedRb::Language.new }
+
+  it 'type checks array args, positive case' do
+    code = <<__CODE
+      ts '#mlhsaddition / Integer -> Integer -> Integer'
+      def mlhsaddition(a,b); a + b; end
+
+      ts '#mlhstest1 / Array[Integer] -> Integer'
+      def mlhstest1((a,b))
+        mlhsaddition(a,b)
+      end
+
+      mlhstest1([1,2])
+__CODE
+
+    result = language.check(code)
+    expect(result.ruby_type).to eq(Integer)
+  end
+
+  it 'type checks array args, negative case' do
+    code = <<__CODE
+      ts '#mlhsaddition2 / String -> Integer'
+      def mlhsaddition2(a); 0; end
+
+      ts '#mlhstest2 / Array[Integer] -> Integer'
+      def mlhstest2((a,b))
+        mlhsaddition2(a)
+      end
+
+      mlhstest2([1,2])
+__CODE
+
+    expect {
+      language.check(code)
+    }.to raise_error(TypedRb::Types::UncomparableTypes)
+  end
+
+  it 'type checks array Pair arg, positive case' do
+    code = <<__CODE
+      ts '#mlhstestpair1 / Pair[String][Integer] -> Integer'
+      def mlhstestpair1((a,b)); b; end
+__CODE
+
+    expect {
+      language.check(code)
+    }.to_not raise_error
+  end
+
+  it 'type checks array Pair arg, negative case' do
+    code = <<__CODE
+      ts '#mlhstestpair1 / Pair[String][Integer] -> Integer'
+      def mlhstestpair1((a,b,c)); a; end
+__CODE
+
+    expect {
+      language.check(code)
+    }.to raise_error(TypedRb::Types::UncomparableTypes)
+  end
+
+  it 'raises an error if the type of the argument is not an array or tuple' do
+    code = <<__CODE
+      ts '#mlhstest_error / Integer -> Integer'
+      def mlhstest_error((a,b))
+        a + b
+      end
+__CODE
+
+    expect {
+      language.check(code)
+    }.to raise_error(TypedRb::TypeCheckError)
+  end
+
+  it 'type checks array args for blocks, positive case' do
+    code = <<__CODE
+      ts '#mlhsaddition3 / Integer -> Integer -> Integer'
+      def mlhsaddition3(a,b); a + b; end
+
+      ts '#mlhstest3 / Array[Integer] -> &(Array[Integer] -> Integer) -> Integer'
+      def mlhstest3(a)
+        yield a
+      end
+
+      mlhstest3([1,2]) { |(a,b)| mlhsaddition3(a,b) }
+__CODE
+
+    result = language.check(code)
+    expect(result.ruby_type).to eq(Integer)
+  end
+
+  it 'type checks array args for blocks, negative case' do
+    code = <<__CODE
+      ts '#mlhsaddition4 / Integer -> Integer -> Integer'
+      def mlhsaddition4(a,b); a + b; end
+
+      ts '#mlhstest4 / Array[String] -> &(Array[String] -> String) -> Integer'
+      def mlhstest4(a)
+        yield a
+      end
+
+      mlhstest4(['a','b']) { |(a,b)| mlhsaddition4(a,b) }
+__CODE
+
+    expect {
+      language.check(code)
+    }.to raise_error(TypedRb::Types::UncomparableTypes)
+  end
+
+  it 'type checks pair args for blocks, positive case' do
+    code = <<__CODE
+      ts '#mlhstestpair3 / Pair[String][Integer] -> &(Pair[String][Integer] -> Integer) -> Integer'
+      def mlhstestpair3(p)
+        yield p
+      end
+
+      mlhstestpair3(cast(['a',1],'Pair[String][Integer]')) { |(a,b)| b }
+__CODE
+
+    result = language.check(code)
+    expect(result.ruby_type).to eq(Integer)
+  end
+
+  it 'type checks pair args for blocks, negative case' do
+    code = <<__CODE
+      ts '#mlhstestpair3 / Pair[String][Integer] -> &(Pair[String][Integer] -> Integer) -> Integer'
+      def mlhstestpair3(p)
+        yield p
+      end
+
+      mlhstestpair3(cast(['a',1],'Pair[String][Integer]')) { |(a,b)| a }
+__CODE
+    expect {
+    language.check(code)
+    }.to raise_error(TypedRb::Types::UncomparableTypes)
+  end
+
+  it 'type checks assignation of pairs, positive case' do
+    code = <<__CODE
+    ts '#x / Pair[String][Integer] -> String'
+    def x(p)
+      a,b = p
+      a
+    end
+__CODE
+    expect {
+      language.check(code)
+    }.to_not raise_error
+  end
+
+  it 'type checks assignation of pairs, negative case' do
+    code = <<__CODE
+    ts '#x / Pair[String][Integer] -> String'
+    def x(p)
+      a,b = p
+      b
+    end
+__CODE
+    expect {
+      language.check(code)
+    }.to raise_error(TypedRb::Types::UncomparableTypes)
+  end
+end

data/spec/lib/typing/tm_module_spec.rb

@@ -0,0 +1,89 @@
+require_relative '../../spec_helper'
+
+describe TypedRb::Model::TmModule do
+  let(:language) { TypedRb::Language.new }
+
+  it 'includes a module in a class' do
+    code = <<__CODE
+       module TMod2
+        ts '#x / -> String'
+        def x; 'test'; end
+       end
+
+       include TMod2
+__CODE
+
+    expect do
+      language.check(code)
+    end.to_not raise_error
+  end
+
+  it 'detects errors in the mixed in type' do
+    code = <<__CODE
+      module TMod3
+        ts '#x / -> String'
+        def x
+          return_string
+        end
+      end
+
+      class TMod3C1
+        include TMod3
+        ts '#return_string / -> Integer'
+        def return_string; 2; end
+      end
+__CODE
+
+    expect {
+      language.check(code)
+    }.to raise_error(TypedRb::Types::UncomparableTypes,
+                     'Cannot compare types Integer <=> String')
+  end
+
+  it 'includes a module referencing instance variables in a class' do
+    code = <<__CODE
+       module TMod4
+        ts '#x / Integer -> unit'
+        def x(i); @a = i; end
+       end
+
+       class TMod4C1
+         include TMod4
+
+         ts '#a / -> Integer'
+         def a; @a; end
+       end
+
+       TMod4C1.new.a
+__CODE
+
+    result = language.check(code)
+    expect(result.ruby_type).to eq(Integer)
+  end
+
+  it 'typechecks the inclusion of a module in multiple classes' do
+    code = <<__CODE
+       module TMod4
+        ts '#x / Integer -> unit'
+        def x(i); @a = i; end
+       end
+
+       class TMod4C1
+         include TMod4
+
+         ts '#a / -> Integer'
+         def a; @a; end
+       end
+
+       class TMod4C2
+         include TMod4
+       end
+
+       TMod4C2.new.x(3)
+       TMod4C1.new.a
+__CODE
+
+    result = language.check(code)
+    expect(result.ruby_type).to eq(Integer)
+  end
+end

data/spec/lib/typing/tm_raise_spec.rb

@@ -0,0 +1,31 @@
+require_relative '../../spec_helper'
+
+describe TypedRb::Model::TmError do
+
+  let(:language) { TypedRb::Language.new }
+
+  context 'with raise, one error' do
+    it 'type-checks it correctly' do
+      code = <<__END
+      1 || raise(StandardError)
+__END
+      result = language.check(code)
+      expect(result.to_s).to eq('Integer')
+    end
+  end
+
+  context 'with raise, only errors' do
+    it 'type-checks it correctly' do
+      code = <<__END
+      ts '#x / -> Integer'
+      def x
+        raise(StandardError) || raise(StandardError)
+      end
+__END
+      expect {
+        language.check(code)
+      }.not_to raise_error(TypedRb::Types::UncomparableTypes)
+    end
+  end
+
+end

data/spec/lib/typing/tm_range_literal_spec.rb

@@ -0,0 +1,25 @@
+require_relative '../../spec_helper'
+
+describe TypedRb::Model::TmRangeLiteral do
+
+  let(:language) { TypedRb::Language.new }
+
+  it 'parses ranges with the same type' do
+    code = '0..10'
+    result = language.check(code)
+    expect(result.ruby_type).to eq(Range)
+    expect(result.type_vars.first.bound.ruby_type).to eq(Integer)
+
+    code = '"a"..."z"'
+    result = language.check(code)
+    expect(result.ruby_type).to eq(Range)
+    expect(result.type_vars.first.bound.ruby_type).to eq(String)
+  end
+
+  it 'fails for incompatible types' do
+    code = '0..10.0'
+    expect {
+      language.check(code)
+    }.to raise_error
+  end
+end

data/spec/lib/typing/tm_regexp_spec.rb

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

data/spec/lib/typing/tm_return_spec.rb

@@ -0,0 +1,45 @@
+require_relative '../../spec_helper'
+
+describe TypedRb::Model::TmReturn do
+
+  describe 'Simple for loop' do
+    let(:language) { TypedRb::Language.new }
+
+    it 'type checks a for statement, positive case' do
+      code = <<__CODE
+       ts '#test_i_fn / Integer -> Integer'
+       def test_i_fn(x); return 1; end
+
+       test_i_fn(1)
+__CODE
+
+      parsed = language.check(code)
+      expect(parsed.ruby_type).to eq(Integer)
+    end
+
+    it 'type checks a for statement, no return value' do
+      code = <<__CODE
+       ts '#test_i_fn / Integer -> Integer'
+       def test_i_fn(x); return; end
+
+       test_i_fn(1)
+__CODE
+
+      parsed = language.check(code)
+      expect(parsed.ruby_type).to eq(Integer)
+    end
+
+    it 'type checks a for statement, negative case' do
+      code = <<__CODE
+       ts '#test_i_fn / Integer -> Integer'
+       def test_i_fn(x); return '1'; end
+
+       test_i_fn(1)
+__CODE
+
+      expect {
+        language.check(code)
+      }.to raise_error(TypedRb::Types::UncomparableTypes)
+    end
+  end
+end

data/spec/lib/typing/tm_send_casting_spec.rb

@@ -0,0 +1,26 @@
+require_relative '../../spec_helper'
+
+describe TypedRb::Model::TmSend do
+  let(:language) { TypedRb::Language.new }
+
+  it 'casts any value to the provided type' do
+    expr = 'cast(\'string\', Integer)'
+
+    result = language.check(expr)
+    expect(result).to eq(tyinteger)
+  end
+
+  it 'casts values when provided as strings' do
+    expr = 'cast(\'string\', \'Integer\')'
+
+    result = language.check(expr)
+    expect(result).to eq(tyinteger)
+  end
+
+  it 'casts values when provided as a generic type' do
+    expr = 'cast(\'string\', \'Array[Integer]\')'
+
+    result = language.check(expr)
+    expect(result.to_s).to eq('Array[Integer]')
+  end
+end

data/spec/lib/typing/tm_send_class_methods_spec.rb

@@ -0,0 +1,42 @@
+require_relative '../../spec_helper'
+
+describe TypedRb::Model::TmSend do
+  let(:language) { TypedRb::Language.new }
+
+  context 'with class methods' do
+    it 'is possible to send messages to the class objects' do
+      expr = <<__END
+       class Integer
+         ts '#+ / Integer -> Integer'
+       end
+
+       class TypeCM1
+
+         ts '.a / -> Integer'
+         def self.a
+           1
+         end
+
+         class << self
+           ts '.b / -> Integer'
+           def b
+             2
+           end
+         end
+
+         class << TypeCM1
+           ts '.c / -> Integer'
+           def c
+             3
+           end
+         end
+       end
+
+       TypeCM1.a + TypeCM1.c  + TypeCM1.c
+__END
+
+      result = language.check(expr)
+      expect(result.ruby_type).to eq(Integer)
+    end
+  end
+end