typed.rb 0.0.11

data/spec/lib/model/tm_abs_spec.rb

@@ -0,0 +1,66 @@
+require_relative '../../spec_helper'
+
+describe TypedRb::Model::TmAbs do
+
+  it 'parses a lambda function with multiple args' do
+    parsed = parse('->(x,y) { x + y }')
+
+    expect(parsed).to be_instance_of(described_class)
+    expect(parsed.arity).to eq(2)
+    expect(parsed.abs_type).to eq(:lambda)
+
+    result = parsed.check_type(top_level_typing_context)
+
+    expect(result.from[0]).to be_instance_of(TypedRb::Types::Polymorphism::TypeVariable)
+    expect(result.from[1]).to be_instance_of(TypedRb::Types::Polymorphism::TypeVariable)
+    expect(result.from.size).to eq(2)
+    expect(result.from[0].variable.index("lambda:#{parsed.term.receiver.val}")).to_not be_nil
+    expect(result.from[1].variable.index("lambda:#{parsed.term.args[0].val}")).to_not be_nil
+  end
+
+  it 'check types creating the right constraints for the type variables' do
+    parsed = parse('->(x,y) { x + y }')
+    expect(parsed.arity).to eq(2)
+    expect(parsed.abs_type).to eq(:lambda)
+
+    result = parsed.check_type(top_level_typing_context)
+
+    TypedRb::Types::TypingContext.with_context(result.local_typing_context) do
+      expect(result.from.size).to eq(2)
+      expect(result.from[0]).to be_a(TypedRb::Types::Polymorphism::TypeVariable)
+      expect(result.from[0].constraints[0][1]).to eq(:send)
+      expect(result.from[1]).to be_a(TypedRb::Types::Polymorphism::TypeVariable)
+      expect(result.to).to be_a(TypedRb::Types::Polymorphism::TypeVariable)
+    end
+  end
+
+  it 'parses a Proc with multiple args' do
+    parsed = parse('Proc.new{ |x,y| x + y }')
+
+    expect(parsed).to be_instance_of(described_class)
+    expect(parsed.arity).to eq(2)
+    expect(parsed.abs_type).to eq(:proc)
+
+    result = parsed.check_type(top_level_typing_context)
+
+    expect(result.from[0]).to be_instance_of(TypedRb::Types::Polymorphism::TypeVariable)
+    expect(result.from[1]).to be_instance_of(TypedRb::Types::Polymorphism::TypeVariable)
+    expect(result.from.size).to eq(2)
+    expect(result.from[0].variable.index("lambda:#{parsed.term.receiver.val}")).to_not be_nil
+    expect(result.from[1].variable.index("lambda:#{parsed.term.args[0].val}")).to_not be_nil
+  end
+
+  it 'check types creating the right constraints for the type variables' do
+    parsed = parse('Proc.new { |x,y| x + y }')
+    expect(parsed.arity).to eq(2)
+    expect(parsed.abs_type).to eq(:proc)
+    result = parsed.check_type(top_level_typing_context)
+    TypedRb::Types::TypingContext.with_context(result.local_typing_context) do
+      expect(result.from.size).to eq(2)
+      expect(result.from[0]).to be_a(TypedRb::Types::Polymorphism::TypeVariable)
+      expect(result.from[0].constraints[0][1]).to eq(:send)
+      expect(result.from[1]).to be_a(TypedRb::Types::Polymorphism::TypeVariable)
+      expect(result.to).to be_a(TypedRb::Types::Polymorphism::TypeVariable)
+    end
+  end
+end

data/spec/lib/model/tm_array_literal_spec.rb

@@ -0,0 +1,36 @@
+require_relative '../../spec_helper'
+
+describe TypedRb::Model::TmArrayLiteral do
+
+  it 'parses array literals with the same type' do
+    code = '[1, 2, 3]'
+
+    parsed = TypedRb::Language.new.check(code)
+    expect(parsed.ruby_type).to eq(Array)
+    expect(parsed.type_vars.first.bound.ruby_type).to eq(Integer)
+  end
+
+  it 'parses array literals with compatible types' do
+    code = '[1, Numeric.new, 3]'
+
+    parsed = TypedRb::Language.new.check(code)
+    expect(parsed.ruby_type).to eq(Array)
+    expect(parsed.type_vars.first.bound.ruby_type).to eq(Numeric)
+  end
+
+  it 'parses array literals with nil values' do
+    code = '[1, Numeric.new, nil]'
+
+    parsed = TypedRb::Language.new.check(code)
+    expect(parsed.ruby_type).to eq(Array)
+    expect(parsed.type_vars.first.bound.ruby_type).to eq(Numeric)
+  end
+
+  it 'parses array literals with incompatible values' do
+    code = '[1, "string"]'
+
+    parsed = TypedRb::Language.new.check(code)
+    expect(parsed.ruby_type).to eq(Array)
+    expect(parsed.type_vars.first.bound.ruby_type).to eq(Object)
+  end
+end

data/spec/lib/model/tm_case_when_spec.rb

@@ -0,0 +1,39 @@
+require_relative '../../spec_helper'
+
+describe TypedRb::Model::TmCaseWhen do
+  let(:language) { TypedRb::Language.new }
+
+  it 'type checks a simple case/when statement' do
+    code = <<__CODE
+      a = 'a'
+      case a
+      when 'a'
+        a
+      when 'b'
+        a
+      else
+        'other'
+      end
+__CODE
+
+    parsed = language.check(code)
+    expect(parsed.ruby_type).to eq(String)
+  end
+
+  it 'Promotes types to union type in case/when expressions' do
+    code = <<__CODE
+      a = 'a'
+      case a
+      when 'a'
+        a
+      when 'b'
+        0
+      else
+        'other'
+      end
+__CODE
+
+    parsed = language.check(code)
+    expect(parsed.ruby_type).to eq(Object)
+  end
+end

data/spec/lib/model/tm_class_spec.rb

@@ -0,0 +1,67 @@
+require_relative '../../spec_helper'
+
+describe TypedRb::Model::TmClass do
+  let(:language) { TypedRb::Language.new }
+
+  it 'parses a generic type' do
+    code = <<__CODE
+       ts 'type Pod[X<Numeric]'
+       class Pod
+
+         ts '#put / [X] -> unit'
+         def put(n)
+           @value = n
+         end
+
+         ts '#take / -> [X]'
+         def take
+           @value
+         end
+       end
+
+       Pod
+__CODE
+
+    parsed = language.check(code)
+
+    expect(parsed).to be_instance_of(TypedRb::Types::TyGenericSingletonObject)
+    value_instance_var = parsed.local_typing_context.type_variables_register[[:instance_variable, Pod, :@value]]
+    expect(value_instance_var).to_not be_nil
+    expect(value_instance_var.variable.index('Pod:@value')).to_not be_nil
+    value_instance_var_constraints = parsed.local_typing_context.constraints[value_instance_var.variable]
+    expect(value_instance_var_constraints.size).to eq(2)
+  end
+
+  it 'handles nested classes' do
+    code = <<__CODE
+       module TCNS
+         class TC
+           ts '#test / -> Integer'
+           def test; 1; end
+         end
+       end
+
+       TCNS::TC.new.test
+__CODE
+
+    result = language.check(code)
+    expect(result.ruby_type).to eq(Integer)
+  end
+
+  it 'handles nested classes in return arguments' do
+    code = <<__CODE
+       module TCNS
+         class TC2; end
+         class TC3
+           ts '#test / -> Class'
+           def test; TC2; end
+         end
+       end
+
+       TCNS::TC3.new.test
+__CODE
+
+    result = language.check(code)
+    expect(result.ruby_type).to eq(Class)
+  end
+end

data/spec/lib/model/tm_defined_spec.rb

@@ -0,0 +1,10 @@
+require_relative '../../spec_helper'
+
+describe TypedRb::Model::TmDefined do
+
+  it 'parses a defined invocation' do
+    parsed = parse('defined? 2')
+    expect(parsed).to be_instance_of(described_class)
+    expect(parsed.expression).to be_instance_of(TypedRb::Model::TmInt)
+  end
+end

data/spec/lib/model/tm_for_spec.rb

@@ -0,0 +1,150 @@
+require_relative '../../spec_helper'
+
+describe TypedRb::Model::TmFor 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); x + 1; end
+
+       for i in 0..3
+         test_i_fn(i)
+       end
+__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_s_fn / String -> Integer'
+       def test_s_fn(x); 0; end
+
+       for i in 0..3
+         test_s_fn(i)
+       end
+__CODE
+
+      expect {
+        language.check(code)
+      }.to raise_error(TypedRb::Types::UncomparableTypes)
+    end
+  end
+
+  describe 'Simple for loop, break' do
+    let(:language) { TypedRb::Language.new }
+
+    it 'type checks a for statement' do
+      code = <<__CODE
+       ts '#test_i_fn / Integer -> Integer'
+       def test_i_fn(x); x + 1; end
+
+       for i in 0..3
+         break 7
+         ""
+       end
+__CODE
+
+      parsed = language.check(code)
+      expect(parsed.ruby_type).to eq(Integer)
+    end
+
+    it 'type checks a for statement, no value' do
+      code = <<__CODE
+       ts '#test_i_fn / Integer -> Integer'
+       def test_i_fn(x); x + 1; end
+
+       for i in 0..3
+         break
+         ""
+       end
+__CODE
+
+      parsed = language.check(code)
+      expect(parsed.ruby_type).to eq(NilClass)
+    end
+
+    it 'type checks a for statement returning an array' do
+      code = <<__CODE
+       for i in 0..3
+         break 7,3
+         ""
+       end
+__CODE
+
+      parsed = language.check(code)
+      expect(parsed.to_s).to eq('Array[Integer]')
+    end
+  end
+
+  describe 'Simple for loop, next' do
+    let(:language) { TypedRb::Language.new }
+
+    it 'type checks a for statement' do
+      code = <<__CODE
+       a = for i in 0..3
+             next(3)
+             nil
+           end
+       a
+__CODE
+
+      parsed = language.check(code)
+      expect(parsed.ruby_type).to eq(Integer)
+    end
+
+    it 'type checks a for statement, no value' do
+      code = <<__CODE
+       a = for i in 0..3
+             next
+             nil
+           end
+       a
+__CODE
+
+      parsed = language.check(code)
+      expect(parsed.ruby_type).to eq(NilClass)
+    end
+  end
+
+  describe 'Simple for loop, next array' do
+    let(:language) { TypedRb::Language.new }
+
+    it 'type checks a for statement' do
+      code = <<__CODE
+       a = for i in 0..3
+             next 3,4
+             nil
+           end
+       a
+__CODE
+
+      parsed = language.check(code)
+      expect(parsed.to_s).to eq('Array[Integer]')
+    end
+  end
+
+  describe 'Simple for loop, either' do
+    let(:language) { TypedRb::Language.new }
+
+    it 'type checks a for statement' do
+      code = <<__CODE
+       a = for i in 0..3
+             if i == 0
+               next(3)
+              else
+                i
+              end
+           end
+       a
+__CODE
+
+      parsed = language.check(code)
+      expect(parsed.ruby_type).to eq(Integer)
+    end
+  end
+end

data/spec/lib/model/tm_fun_spec.rb

@@ -0,0 +1,11 @@
+require_relative '../../spec_helper'
+
+describe TypedRb::Model::TmFun do
+  it 'parses a function with rest args' do
+    parsed = parse('def f(a,*rest); end')
+    expect(parsed).to be_instance_of(described_class)
+    expect(parsed.args.size).to eq(2)
+    expect(parsed.args.last.first).to eq(:restarg)
+    parsed.check_type(TypedRb::Types::TypingContext.top_level)
+  end
+end

data/spec/lib/model/tm_hash_literal_spec.rb

@@ -0,0 +1,40 @@
+require_relative '../../spec_helper'
+
+describe TypedRb::Model::TmHashLiteral do
+
+  it 'parses hash literals with the same type' do
+    code = '{:a => 1, :b => 2}'
+
+    parsed = TypedRb::Language.new.check(code)
+    expect(parsed.ruby_type).to eq(Hash)
+    expect(parsed.type_vars.first.bound.ruby_type).to eq(Symbol)
+    expect(parsed.type_vars.last.bound.ruby_type).to eq(Integer)
+  end
+
+  it 'parses hash literals with compatible types' do
+    code = '{2 => 1, 3 => Numeric.new, Numeric.new => 4}'
+
+    parsed = TypedRb::Language.new.check(code)
+    expect(parsed.ruby_type).to eq(Hash)
+    expect(parsed.type_vars.first.bound.ruby_type).to eq(Numeric)
+    expect(parsed.type_vars.last.bound.ruby_type).to eq(Numeric)
+  end
+
+  it 'parses array literals with nil values' do
+    code = '{:x => 1, nil => Numeric.new, :z => nil}'
+
+    parsed = TypedRb::Language.new.check(code)
+    expect(parsed.ruby_type).to eq(Hash)
+    expect(parsed.type_vars.first.bound.ruby_type).to eq(Symbol)
+    expect(parsed.type_vars.last.bound.ruby_type).to eq(Numeric)
+  end
+
+  it 'parses array literals with incompatible values' do
+    code = '{:x => 1, 2 => "string"}'
+
+    parsed = TypedRb::Language.new.check(code)
+    expect(parsed.ruby_type).to eq(Hash)
+    expect(parsed.type_vars.first.bound.ruby_type).to eq(Object)
+    expect(parsed.type_vars.last.bound.ruby_type).to eq(Object)
+  end
+end

data/spec/lib/model/tm_mass_asgn_spec.rb

@@ -0,0 +1,104 @@
+require_relative '../../spec_helper'
+
+describe TypedRb::Model::TmMassAsgn do
+
+  it 'parses mass assignment' do
+    code = <<__CODE
+       ts '#fma1 / -> Array[Integer]'
+       def fma1; Array.(Integer).new; end
+
+       a,b = fma1
+__CODE
+
+    parsed = TypedRb::Language.new.check(code)
+    expect(parsed.ruby_type).to eq(Array)
+
+    code = <<__CODE
+       ts '#fma1 / -> Array[Integer]'
+       def fma1; Array.(Integer).new; end
+
+       a,b = fma1
+       a
+__CODE
+
+    parsed = TypedRb::Language.new.check(code)
+    expect(parsed.bound.ruby_type).to eq(Integer)
+
+
+    code = <<__CODE
+       ts '#fma1 / -> Array[Integer]'
+       def fma1; Array.(Integer).new; end
+
+       a,b = fma1
+       b
+__CODE
+
+    parsed = TypedRb::Language.new.check(code)
+    expect(parsed.bound.ruby_type).to eq(Integer)
+
+    code = <<__CODE
+       ts '#fma1 / -> Array[Integer]'
+       def fma1; Array.(Integer).new; end
+
+       ts '#fmai1 / -> Integer'
+       def fmai1
+         a,b = fma1
+         a
+       end
+
+      fmai1
+__CODE
+    parsed = TypedRb::Language.new.check(code)
+    expect(parsed.ruby_type).to eq(Integer)
+  end
+
+it 'parses mass assignment when returning scalar types' do
+    code = <<__CODE
+       ts '#fma2 / -> String'
+       def fma2; 'string'; end
+
+       a,b = fma2
+__CODE
+
+    parsed = TypedRb::Language.new.check(code)
+    expect(parsed.ruby_type).to eq(String)
+
+    code = <<__CODE
+       ts '#fma2 / -> String'
+       def fma2; 'string'; end
+
+       a,b = fma2
+       a
+__CODE
+
+    parsed = TypedRb::Language.new.check(code)
+    expect(parsed.ruby_type).to eq(String)
+
+
+    code = <<__CODE
+       ts '#fma2 / -> String'
+       def fma2; 'string'; end
+
+       a,b = fma2
+       b
+__CODE
+
+    parsed = TypedRb::Language.new.check(code)
+    expect(parsed).to eq(tyunit)
+
+    code = <<__CODE
+       ts '#fma2 / -> String'
+       def fma2; 'string'; end
+
+       ts '#fmai2 / -> String'
+       def fmai2
+         a,b = fma2
+         a
+       end
+
+      fmai2
+__CODE
+    parsed = TypedRb::Language.new.check(code)
+    expect(parsed.ruby_type).to eq(String)
+  end
+end

data/spec/lib/model/tm_module_spec.rb

@@ -0,0 +1,42 @@
+require_relative '../../spec_helper'
+
+describe TypedRb::Model::TmModule do
+
+  it 'parses ruby modules' do
+    code = <<__CODE
+        module TMod1
+           ts '#x / -> unit'
+           def x; 'test'; end
+        end
+__CODE
+
+    parsed = TypedRb::Language.new.check(code)
+    expect(parsed.is_a?(TypedRb::Types::TyExistentialType)).to eq(true)
+    expect(parsed.ruby_type).to eq(TMod1)
+  end
+
+  it 'parses nested modules' do
+    code = <<__CODE
+        module TMod1
+          module TMod2
+           module TMod3
+             module TMod4
+               class TMod4C1
+                 ts '#x / -> Integer'
+                 def x
+                   0
+                 end
+               end
+             end
+           end
+           class TMod4C2; end
+          end
+        end
+
+       TMod1::TMod2::TMod3::TMod4::TMod4C1.new.x
+__CODE
+
+    parsed = TypedRb::Language.new.check(code)
+    expect(parsed.ruby_type).to eq(Integer)
+  end
+end

data/spec/lib/model/tm_regexp_spec.rb

@@ -0,0 +1,9 @@
+require_relative '../../spec_helper'
+
+describe TypedRb::Model::TmRegexp do
+
+  it 'parses a regular expression' do
+    parsed = parse('/[Rr]eg[Ee]xp/')
+    expect(parsed).to be_instance_of(described_class)
+  end
+end

data/spec/lib/model/tm_return_spec.rb

@@ -0,0 +1,47 @@
+require_relative '../../spec_helper'
+
+describe TypedRb::Model::TmArrayLiteral do
+  it 'parses return instructions with single types' do
+    code = <<__CODE
+        ts '#fret1 / -> Integer'
+        def fret1
+          return 1
+        end
+
+        fret1
+__CODE
+
+    parsed = TypedRb::Language.new.check(code)
+    expect(parsed.ruby_type).to eq(Integer)
+  end
+
+  it 'parses return instructions with multiple compatible types' do
+    code = <<__CODE
+        ts '#fret2 / -> Array[Integer]'
+        def fret2
+          return 1, 2
+        end
+
+        fret2
+__CODE
+
+    parsed = TypedRb::Language.new.check(code)
+    expect(parsed.ruby_type).to eq(Array)
+    expect(parsed.type_vars.first.bound.ruby_type).to eq(Integer)
+  end
+
+  it 'parses return instructions with multiple incompatible types' do
+    code = <<__CODE
+        ts '#fret3 / -> Array[Object]'
+        def fret3
+          return 1, 'string'
+        end
+
+        fret3
+__CODE
+
+    parsed = TypedRb::Language.new.check(code)
+    expect(parsed.ruby_type).to eq(Array)
+    expect(parsed.type_vars.first.bound.ruby_type).to eq(Object)
+  end
+end

data/spec/lib/model/tm_s_class_spec.rb

@@ -0,0 +1,27 @@
+require_relative '../../spec_helper'
+
+describe TypedRb::Model::TmSClass do
+
+  it 'parses a singleton class' do
+    code = <<__CODE
+       ts 'type Pod1[X<Numeric]'
+       class Pod1
+
+         ts '.put / [X] -> unit'
+         def self.put(n)
+           @value = n
+         end
+
+         class << self
+           ts '.take / -> [X]'
+           def take
+             @value
+           end
+         end
+       end
+__CODE
+
+    TypedRb::Language.new.check(code)
+    expect(BasicObject::TypeRegistry.send(:registry)[[:class,Pod1]].keys).to eq(['put', 'take'])
+  end
+end

data/spec/lib/model/tm_self_spec.rb

@@ -0,0 +1,19 @@
+require_relative '../../spec_helper'
+
+describe TypedRb::Model::TmSelf do
+  it 'returns the self reference type' do
+    code = <<__CODE
+      class TSelfRef1
+         ts '#test / -> TSelfRef1'
+         def test
+           self
+         end
+      end
+
+     TSelfRef1.new.test
+__CODE
+
+    parsed = TypedRb::Language.new.check(code)
+    expect(parsed.ruby_type).to eq(TSelfRef1)
+  end
+end

data/spec/lib/model/tm_string_interpolation_spec.rb

@@ -0,0 +1,10 @@
+require_relative '../../spec_helper'
+
+describe TypedRb::Model::TmStringInterpolation do
+
+  it 'parses interpolation of strings' do
+    parsed = parse('"this #{is} an #{interpolation}"')
+    expect(parsed).to be_instance_of(described_class)
+    expect(parsed.units.size).to eq(4)
+  end
+end

data/spec/lib/model/tm_symbol_interpolation_spec.rb

@@ -0,0 +1,10 @@
+require_relative '../../spec_helper'
+
+describe TypedRb::Model::TmSymbolInterpolation do
+
+  it 'parses interpolation of strings' do
+    parsed = parse(':"this #{is} an #{interpolation}"')
+    expect(parsed).to be_instance_of(described_class)
+    expect(parsed.units.size).to eq(4)
+  end
+end