typed.rb 0.0.15 → 0.0.16

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: bb42b861c759a6aaa03b52fd351f5a1615d5232a
-  data.tar.gz: 1d76b7a85bdd7758d28b54a1506734c123e2384c
+  metadata.gz: ac43557e5bdf48bfa8082e5526b798e7a2fc3aca
+  data.tar.gz: ed3a52ee31070c01b9dff44e8decd67bbabac035
 SHA512:
-  metadata.gz: 133005549d678a09477e777dc944e6cc3300bd89fee267f529d92986e20757170d4005dfa0385b4ec4722507458f0b52d2315f6355dcbac2aea135c1ac09bd83
-  data.tar.gz: 6bcbbe9cb52ffd37a466fec62fae0a11d6e14c04f25e3c66e4b4918c283f4d70faed9eb2e43210cc7cec08fac76234c543989ade1933791eed743e47850fd331
+  metadata.gz: 06c43f6cc812fa5b98a53e4d5e556fce63492746241f618ead568a04bcb018ec83a239891484168b692927699eb4fc7fa8793bf514cb3bf2bbcce790ee902e3f
+  data.tar.gz: 9fa398a80e4c0e57807df2ae73538176e2ffb1d9b1c2387a3c4aba0a28e43898df5c82fc0ce715f9318c3f249fecffeab4529792981676b7c109cf2f06c56868

data/README.md

@@ -94,7 +94,7 @@ The method receives a string with the type signature and returns unit. At run-ti
 A type signature for a method is composed of the following parts:
 
 ```
-Type?(#/.)method[T]* / ArgumentType? (-> ArgumentType)* -> &BlockType? -> ReturnType
+Type?(#/.)method[T]* / ArgumentType? (-> ArgumentType)* (-> &BlockType)? -> ReturnType
 ```
 
 For example, the type signature of the ```#ts``` method itself is ```BasicObject#ts / String -> unit```.
@@ -148,6 +148,7 @@ Typed.rb will try to perform automatic type inference for the following language
 - instance variables
 - local variables
 - constants
+- lambda functions
 
 To know more about the type inferance mechanism, check the implementation of the unification algorithm used by the type checker in ```lib/typed/types/polymorphism/unification.rb```.
 

data/lib/typed/language.rb

@@ -142,10 +142,11 @@ module TypedRb
           puts "\n"
           puts error.message.red
         end
+        warnings_accum= {}
         warnings_for_file.each do |warning|
           hash = warning.to_s.hash
-          unless errors_accum[hash]
-            errors_accum[hash] = true
+          unless warnings_accum[hash]
+            warnings_accum[hash] = true
             puts "\n"
             puts warning.message.yellow
           end

data/lib/typed/runtime.rb

@@ -34,4 +34,20 @@ class Class
   def call(*_types)
     self
   end
+
+  ts_ignore
+  def meta_ancestors
+    singleton_class = class << self
+      self
+    end
+    singleton_class.ancestors
+  end
+end
+
+class Module
+
+  ts_ignore
+  def meta_ancestors
+    [self] + self.class.ancestors
+  end
 end

data/lib/typed/runtime/normalization.rb

@@ -28,7 +28,11 @@ module TypedRb
       ts '#check_super_type_annotations / -> unit'
       def check_super_type_annotations
         @generic_types_registry.values.each do |type|
-          type.super_type.self_materialize if type.super_type
+          if type.super_type
+            type.super_type.each do |super_type|
+              super_type.self_materialize
+            end
+          end
         end
       end
 
@@ -44,16 +48,15 @@ module TypedRb
 
       def check_generic_super_type(type_info)
         _, info = type_info
-        super_type = build_generic_super_type(info)
-        @generic_types_registry[info[:type]].super_type = super_type if super_type
+        @generic_types_registry[info[:type]].super_type = (info[:super_type] || []).map do |super_type_spec|
+          build_generic_super_type(info[:type], super_type_spec)
+        end
       end
 
-      def build_generic_super_type(info)
-        with_super_type = valid_super_type?(info[:type], info[:super_type])
-        if with_super_type
-          TypedRb.log(binding, :debug,  "Normalising generic super type: #{info[:super_type][:type]} for #{info[:type]}")
-          build_generic_singleton_object([info[:super_type][:type], info[:super_type]])
-        end
+      def build_generic_super_type(type, super_type)
+        valid_super_type?(type, super_type)
+        TypedRb.log(binding, :debug,  "Normalising generic super type: #{super_type[:type]} for #{type}")
+        build_generic_singleton_object([super_type[:type], super_type])
       end
 
       def valid_super_type?(base_class, super_type_info)

data/lib/typed/runtime/type_registry.rb

@@ -28,12 +28,12 @@ class BasicObject
       end
 
       ts '.register_generic_type_information / Hash[Object][Object] -> Hash[Object][Object] -> unit'
-      def register_generic_type_information(generic_type_information, generic_super_type_information)
+      def register_generic_type_information(generic_type_information, generic_super_types_information)
         unless generic_type_information.is_a?(String) # TODO: String when super annotations for non-generic types
-          generic_type_information[:super_type] = generic_super_type_information
+          generic_type_information[:super_type] = generic_super_types_information
           if generic_types_parser_registry[generic_type_information[:type]]
-            fail ::TypedRb::Types::TypeParsingError,
-            "Duplicated generic type definition for #{generic_type_information[:type]}"
+            super_type = (generic_types_parser_registry[generic_type_information[:type]][:super_type] || [])
+            generic_types_parser_registry[generic_type_information[:type]][:super_type]= super_type.concat(generic_type_information[:super_type])
           else
             generic_types_parser_registry[generic_type_information[:type]] = generic_type_information
           end

data/lib/typed/runtime/type_signature_processor.rb

@@ -10,14 +10,16 @@ module TypedRb
         def process(signature)
           type_signature = signature.split(PARAMETRIC_TYPE_PREFIX).last
 
-          type_signature, super_type_signature = parse_generic_supertype(type_signature)
+          type_signature, super_type_signatures = parse_generic_supertype(type_signature)
 
           generic_type = ::TypedRb::TypeSignature::Parser.parse(type_signature)
-          if super_type_signature
-            generic_super_type = ::TypedRb::TypeSignature::Parser.parse(super_type_signature)
+          if super_type_signatures
+            generic_super_types = super_type_signatures.split(/\s*,\s*/).map do |super_type_signature|
+              ::TypedRb::TypeSignature::Parser.parse(super_type_signature)
+            end
           end
 
-          BasicObject::TypeRegistry.register_generic_type_information(generic_type, generic_super_type)
+          BasicObject::TypeRegistry.register_generic_type_information(generic_type, generic_super_types)
         end
 
         private

data/lib/typed/types/polymorphism/generic_comparisons.rb

@@ -48,8 +48,10 @@ module TypedRb
             else
               false
             end
-          else
+          elsif other_type.is_a?(TyObject)
             check_generic_type_relation(other_type.ruby_type, relation)
+          else
+            other_type.compatible?(self, relation == :lt ? :gt : :lt)
           end
         rescue ArgumentError
           raise TypedRb::Types::UncomparableTypes.new(self, other_type)

data/lib/typed/types/ty_generic_object.rb

@@ -18,9 +18,9 @@ module TypedRb
       def find_function_type(message, num_args, block)
         function_klass_type, function_type = find_function_type_in_hierarchy(:instance, message, num_args, block)
         if function_klass_type != ruby_type && ancestor_of_super_type?(generic_singleton_object.super_type, function_klass_type)
-          TypedRb.log binding, :debug, "Found message '#{message}', generic function: #{function_type}, explicit super type #{generic_singleton_object.super_type}"
-          target_class = generic_singleton_object.super_type
-          target_type_vars = generic_singleton_object.super_type.type_vars
+          target_class = ancestor_of_super_type?(generic_singleton_object.super_type, function_klass_type)
+          TypedRb.log binding, :debug, "Found message '#{message}', generic function: #{function_type}, explicit super type #{target_class}"
+          target_type_vars = target_class.type_vars
           materialize_super_type_found_function(message, num_args, block, target_class, target_type_vars)
         elsif function_klass_type != ruby_type && BasicObject::TypeRegistry.find_generic_type(function_klass_type)
           TypedRb.log binding, :debug, "Found message '#{message}', generic function: #{function_type}, implict super type #{function_klass_type}"
@@ -99,9 +99,10 @@ module TypedRb
         end
       end
 
-      def ancestor_of_super_type?(super_type_klass, function_klass_type)
-        return false if super_type_klass.nil?
-        super_type_klass.ruby_type.ancestors.include?(function_klass_type)
+      def ancestor_of_super_type?(super_type_klasses, function_klass_type)
+        super_type_klasses.detect do |super_type_klass|
+            super_type_klass.ruby_type.ancestors.include?(function_klass_type)
+        end
       end
 
       def materialize_found_function_arg(arg)

data/lib/typed/types/ty_generic_singleton_object.rb

@@ -35,7 +35,9 @@ module TypedRb
 
       def self_materialize
         TypedRb.log binding, :debug, "Materialising self for generic singleton object '#{self}'"
-        BasicObject::TypeRegistry.find_generic_type(ruby_type).materialize(type_vars)
+        generic_type = BasicObject::TypeRegistry.find_generic_type(ruby_type)
+        fail TypeCheckError.new("Missing generic type annotation for #{ruby_type}", node) if generic_type.nil?
+        generic_type.materialize(type_vars)
       end
 
       # materialize will be invoked by the logic handling invocations like:

data/lib/typed/types/ty_object.rb

@@ -86,7 +86,7 @@ module TypedRb
           if generic_type.nil?
             return klass, function # generic method in non-generic class
           elsif generic_type.type_vars.size == 1
-            generic_type.materialize([self]).find_function_type(message, num_args, block)
+            generic_type.materialize([self]).as_object_type.find_function_type(message, num_args, block)
           else
             fail "Undeclared generic type variables for #{ruby_type} super class/mix-in #{klass.class} #{klass}##{message}, please add a 'super' type annotation"
           end

data/lib/typed/types/ty_singleton_object.rb

@@ -19,7 +19,7 @@ module TypedRb
       end
 
       def find_function_type_in_metaclass_hierarchy(message, num_args, block)
-        hierarchy = Class.ancestors
+        hierarchy = ruby_type.meta_ancestors
         initial_value = select_matching_function_in_class(hierarchy.first, :instance, message, num_args, block)
         hierarchy.drop(1).inject([hierarchy.first, initial_value]) do |(klass, acc), type|
           if acc.nil? || acc.is_a?(TyDynamicFunction)

data/lib/typed/version.rb

@@ -1,5 +1,5 @@
 module TypedRb
   unless defined?(VERSION)
-    VERSION = '0.0.15'
+    VERSION = '0.0.16'
   end
 end

data/spec/lib/examples/monoid2.rb

@@ -0,0 +1,34 @@
+require 'typed/runtime'
+
+module Monoid
+
+  ts 'type Monoid::Instance[T]'
+  module Instance
+    ts '#mappend / [T] -> [T]'
+    abstract(:mappend)
+  end
+
+  ts 'type Monoid::Class[T]'
+  module Class
+    ts '#mempty / -> [T]'
+    abstract(:mempty)
+  end
+end
+
+ts 'type Array[T] super Monoid::Instance[Array[T]]'
+class Array
+
+  extend Monoid::Class
+  include Monoid::Instance
+
+  def mappend(b)
+    concat(b)
+  end
+
+  def self.mempty
+    []
+  end
+
+end
+
+Array.(Integer).new.mappend([3])

data/spec/lib/language_spec.rb

@@ -109,4 +109,16 @@ describe TypedRb::Language do
       }.to raise_error(TypedRb::Types::Polymorphism::UnificationError)
     end
   end
+
+  context 'with monoid2 example, type checks correctly' do
+    let(:example) { 'monoid2.rb' }
+
+    it 'should be possible to type check the example correctly' do
+      expect {
+        silence_stream(STDOUT) do
+          language.check_file(file, true)
+        end
+      }.to_not raise_error
+    end
+  end
 end

data/spec/lib/prelude/array_spec.rb

@@ -62,12 +62,13 @@ describe Array do
 
   describe '#count' do
     it 'type checks / &([T] -> Boolean) -> Integer' do
+=begin
       result = language.check('Array.(Integer).new(10,0).count(0)')
       expect(result.ruby_type).to eq(Integer)
-
+=end
       result = language.check('Array.(Integer).new(10,0).count{ |x| x == 0 }')
       expect(result.ruby_type).to eq(Integer)
-
+=begin
       expect {
         code = <<__CODE
           ts '#testarrs / String -> Boolean'
@@ -77,6 +78,7 @@ describe Array do
 __CODE
         language.check(code)
       }.to raise_error(TypedRb::Types::UncomparableTypes)
+=end
     end
   end
 

data/spec/lib/runtime/normalization_spec.rb

@@ -12,8 +12,41 @@ describe TypedRb::Runtime::Normalization do
 __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)
+    expect(result.super_type[0].ruby_type).to eq(Array)
+    expect(result.super_type[0].type_vars.first.bound.ruby_type).to eq(Object)
+  end
+
+  it 'normalizes generic types with multiple super types annotations' do
+    code = <<__END
+    ts 'type TestModule[T]'
+    module TestModule; end
+
+    ts 'type TestPair[S][T] super Array[Object], TestModule[Object]'
+    class TestPair < Array
+      include TestModule
+      ts '#first / -> [S]'
+    end
+    TestPair
+__END
+    result = language.check(code)
+    expect(result.ruby_type).to eq(TestPair)
+    expect(result.super_type[0].ruby_type).to eq(Array)
+    expect(result.super_type[0].type_vars.first.bound.ruby_type).to eq(Object)
+    expect(result.super_type[1].ruby_type).to eq(TestModule)
+    expect(result.super_type[1].type_vars.first.bound.ruby_type).to eq(Object)
+  end
+
+  it 'raises a meaningful error if no generic type is found' do
+    code = <<__END
+    ts 'type TestPair[S][T] super Array[Object], Integer[Object]'
+    class TestPair < Array
+      ts '#first / -> [S]'
+    end
+    TestPair
+__END
+    expect {
+      language.check(code)
+    }.to raise_error(TypedRb::TypeCheckError)
   end
 
   it 'raises an exception if the super type is not a super class of the current type' do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: typed.rb
 version: !ruby/object:Gem::Version
-  version: 0.0.15
+  version: 0.0.16
 platform: ruby
 authors:
 - Antonio Garrote
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-01-25 00:00:00.000000000 Z
+date: 2016-01-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: parser
@@ -152,6 +152,7 @@ files:
 - spec/lib/examples/monoid/monoid_error2.rb
 - spec/lib/examples/monoid/monoid_error3.rb
 - spec/lib/examples/monoid/monoid_error4.rb
+- spec/lib/examples/monoid2.rb
 - spec/lib/language_spec.rb
 - spec/lib/model/tm_abs_spec.rb
 - spec/lib/model/tm_array_literal_spec.rb