typed.rb 0.0.11 → 0.0.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 12f994fd40b7d71db8aa86c0875aa723347a8edd
-  data.tar.gz: 13a8daf59012cddba4a106476f9609c901cd6f9b
+  metadata.gz: c111e1f20ab0b156bcead6d988eae88c0aabf660
+  data.tar.gz: 8103b73f4455913b46606a7e81d2c64bcac2f1e5
 SHA512:
-  metadata.gz: c9f9d208d55df978a5e1fa6f6014f955ffd3c10922970ce9d9801c9ed56bfd0775840f43978283b6ebd9139dfc0a3b595b81473b16823342a413c1e4fd0d37ea
-  data.tar.gz: aaa9b40826ca304563e4e5eb34e60f74efd3a5a47985bac003f2bd77c60f7ea25405bec24e4e3cffe5fa261a338370592cad42b68ebd25f52818a2192bc01abd
+  metadata.gz: bb9195b5d6411a04ae2fd223ce61db7b314ea4cb2a38ad661b48827fc8f50fdcec2827af10d0d09131dfae81fc438f51ea354f1ce1bab883edb46d49105f424c
+  data.tar.gz: b038edcf95e5551c70c544cf3e7e089d365b8069b5d6785d11d8dbe6de7c9a835ccca41bc323fa8ff96b452053f882e4cb72dfbbd9b15baa0d6a1ec1d8004ad9

data/bin/typed.rb

@@ -3,8 +3,34 @@
 require 'pry'
 require_relative '../lib/typed'
 require 'benchmark'
-
 require 'set'
+require 'optparse'
+
+class OptionsParser
+  class << self
+    def parse(options)
+      args = { :dynamic_warnings => false }
+
+
+      opt_parser = OptionParser.new do |opts|
+        opts.banner = 'Usage: typed.rb [options] [path]'
+
+        opts.on('-m', '--missing-type', 'Produce warnings when a missing type annotation has been detected') do |m|
+          args[:dynamic_warnings] = true
+        end
+
+        opts.on('-h', '--help', 'Prints this help') do
+          puts opts
+          exit
+        end
+      end
+
+      opt_parser.parse!(options)
+
+      args
+    end
+  end
+end
 
 class TargetFinder
   # Generate a list of target files by expanding globbing patterns
@@ -102,9 +128,21 @@ class TargetFinder
   end
 end
 
+TypedRb.options = OptionsParser.parse(ARGV)
+
+success = true
 time = Benchmark.realtime do
-  files_to_check = TargetFinder.new.find(ARGV).reject { |f| f == File.expand_path(__FILE__) }
-  TypedRb::Language.new.check_files(files_to_check)
+  begin
+    files_to_check = TargetFinder.new.find(ARGV).reject { |f| f == File.expand_path(__FILE__) }
+    TypedRb::Language.new.check_files(files_to_check, true)
+  rescue TypedRb::TypeCheckError => e
+    success = false
+  end
 end
 
-puts "Finished in #{time} seconds"
+puts "\nFinished in #{time} seconds"
+if success == false
+  exit(1)
+else
+  exit(0)
+end

data/lib/typed/language.rb

@@ -1,4 +1,5 @@
 require_relative './runtime/ast_parser'
+require 'colorize'
 
 module TypedRb
   class Language
@@ -67,7 +68,7 @@ module TypedRb
       end
     end
 
-    def check_files(files)
+    def check_files(files, raise_errors = false)
       ::BasicObject::TypeRegistry.clear
       $TYPECHECK = true
       prelude_path = File.join(File.dirname(__FILE__), 'prelude.rb')
@@ -85,27 +86,74 @@ module TypedRb
       ::BasicObject::TypeRegistry.normalize_types!
       TypingContext.clear(:top_level)
       check_result = nil
+      errors = {}
       ordered_files.each do |file|
-        puts "*** FILE #{file}"
         $TYPECHECK_FILE = file
         expr = File.open(file, 'r').read
-        #begin
+        begin
           check_result = check_type(parse(expr))
-        #rescue TypedRb::Types::UncomparableTypes => e
-        #  puts e.backtrace.join("\n")
-        #  puts e.message
-        #  exit(-1)
-        #rescue TypedRb::TypeCheckError => e
-        # puts e.message
-        #end
+          print '.'.green
+        rescue TypedRb::Types::UncomparableTypes, TypedRb::TypeCheckError => e
+          print 'E'.red
+          errors_for_file = errors[file] || []
+          errors_for_file << e
+          errors[file] = errors_for_file
+        end
       end
-      ::BasicObject::TypeRegistry.check_super_type_annotations
-      @unification_result = run_unification
+      top_level_errors = []
+      begin
+        ::BasicObject::TypeRegistry.check_super_type_annotations
+        @unification_result = run_unification
+      rescue TypedRb::Types::UncomparableTypes, TypedRb::TypeCheckError => e
+        print 'E'.red
+        top_level_errors << e
+      end
+      puts "\n"
+      total_errors = all_errors(top_level_errors, errors)
+      dynamic_warnings = TypedRb.dynamic_warnings
+      if total_errors.count > 0
+        puts "\nErrors:"
+        report_errors(top_level_errors, errors, {})
+      end
+      if dynamic_warnings.count > 0
+        puts "\nWarnings:"
+        report_errors([], {}, dynamic_warnings)
+      end
+      puts "\nProcessed #{files.size} files, #{total_errors.count} errors, #{dynamic_warnings.count} warnings\n"
+      check_errors(total_errors) if raise_errors
       check_result
     end
 
-    def check_file(path)
-      check_files([path])
+    def report_errors(top_level_errors, errors, warnings)
+      files = (errors.keys||[]) + (warnings.keys||[])
+      files.each do |file|
+        errors_for_file = errors[file] || []
+        warnings_for_file = warnings[file] || []
+        errors_for_file.each do |error|
+          puts "\n"
+          puts error.message.red
+        end
+        warnings_for_file.each do |warning|
+          puts "\n"
+          puts warning.message.yellow
+        end
+      end
+      top_level_errors.each do |error|
+        puts "\n"
+        puts error.message.red
+      end
+    end
+
+    def all_errors(top_level_errors, errors)
+      (top_level_errors||[]) + ((errors||{}).values.reduce(&:concat) || [])
+    end
+
+    def check_errors(total_errors)
+      raise total_errors.first if total_errors.count > 0
+    end
+
+    def check_file(path, raise_errors = false)
+      check_files([path], raise_errors)
     end
 
     def parse(expr)

data/lib/typed/model/tm_array_literal.rb

@@ -11,7 +11,7 @@ module TypedRb
 
       def check_type(context)
         element_types = elements.map { |element|  element.check_type(context) }
-        max_type = element_types.max rescue Types::TyObject.new(Object, node)
+        max_type = element_types.reduce(&:max)
         type_var = Types::Polymorphism::TypeVariable.new('Array:T',
                                                          :node => node,
                                                          :gen_name => false,

data/lib/typed/model/tm_boolean_operator.rb

@@ -23,7 +23,7 @@ module TypedRb
           var
         else
           types = [lhs_type, rhs_type].reject { |type| type.is_a?(Types::TyUnit) || type.is_a?(Types::TyError) }
-          type = types.max rescue Types::TyObject.new(Object, node)
+          type = types.reduce(&:max)
           type  = Types::TyUnit.new if type.nil?
           type.node = node
           type

data/lib/typed/model/tm_fun.rb

@@ -24,10 +24,10 @@ module TypedRb
 
         function_klass_type, function_type = owner_type.find_function_type(name, @arg_count, @has_block)
 
-        # fail TypeCheckError.new("Error type checking function #{owner}##{name}: Cannot find function type information for owner.", node)
-        # Missing type information stops the type checking process
-        # TODO: raise a warning here about the previous fact
-        return Types::TyUnit.new(node) if function_type.nil? || function_type.dynamic?
+        if function_type.nil? || function_type.dynamic?
+          TypedRb.log_dynamic_warning(node, owner_type, name)
+          return Types::TyUnit.new(node)
+        end
 
         context = setup_context(context, function_type)
         # check the body with the new bindings for the args

data/lib/typed/model/tm_hash_literal.rb

@@ -11,8 +11,8 @@ module TypedRb
 
       def check_type(context)
         pair_types = pairs.map { |key, element|  [key.check_type(context), element.check_type(context)] }
-        max_key_type = pair_types.map(&:first).max rescue Types::TyObject.new(Object, node)
-        max_value_type = pair_types.map(&:last).max rescue Types::TyObject.new(Object, node)
+        max_key_type = pair_types.map(&:first).reduce(&:max)
+        max_value_type = pair_types.map(&:last).reduce(&:max)
         type_var_key = Types::Polymorphism::TypeVariable.new('Hash:T',
                                                              :node => node,
                                                              :gen_name => false,

data/lib/typed/model/tm_range_literal.rb

@@ -15,7 +15,7 @@ module TypedRb
       def check_type(context)
         start_range_type = start_range.check_type(context)
         end_range_type = end_range.check_type(context)
-        max_type = [start_range_type, end_range_type].max
+        max_type = start_range_type.max(end_range_type)
 
         type_var = Types::Polymorphism::TypeVariable.new('Range:T',
                                                          :node => node,

data/lib/typed/model/tm_rescue.rb

@@ -13,7 +13,7 @@ module TypedRb
 
       def check_type(context)
         if catch_var
-          exception_type = exceptions.map{|e| e.check_type(context) }.max
+          exception_type = exceptions.map{|e| e.check_type(context) }.reduce(&:max)
           context.add_binding!(catch_var, exception_type)
         end
         if rescue_body

data/lib/typed/model/tm_send.rb

@@ -52,6 +52,8 @@ module TypedRb
       def check_instantiation(context)
         self_type = singleton_object_type(receiver, context).as_object_type
         function_klass_type, function_type = self_type.find_function_type(:initialize, args.size, @block)
+        TypedRb.log_dynamic_warning(node, self_type, :initialize) if function_type.dynamic?
+
         # function application
         @message = :initialize
         begin
@@ -94,6 +96,7 @@ module TypedRb
           check_lambda_application(receiver_type, context)
         else
           function_klass_type, function_type = receiver_type.find_function_type(message, args.size, @block)
+          TypedRb.log_dynamic_warning(node, receiver_type, message) if function_type.dynamic?
           # begin
           if function_type.nil?
             error_message = "Error type checking message sent '#{message}': Type information for #{receiver_type}:#{message} not found."

data/lib/typed/types/ty_object.rb

@@ -137,6 +137,14 @@ module TypedRb
         TyObject.new(smaller_common_class, (node || self.node || other_type.node))
       end
 
+      def max(other)
+        if other.is_a?(TyObject)
+          [self, other].max rescue TyObject.new((self.classes & other.classes).first, (node || other.node))
+        else
+          fail TypedRb::UncomparableTypes(self, other).new
+        end
+      end
+
       def <=>(other)
         if other.is_a?(TyObject)
           if other.with_ruby_type

data/lib/typed/version.rb

@@ -1,3 +1,3 @@
 module TypedRb
-  VERSION = '0.0.11'
+  VERSION = '0.0.12'
 end

data/lib/typed.rb

@@ -100,6 +100,25 @@ end
 Kernel.reset_dependencies
 
 module TypedRb
+
+  def options
+    @options || {}
+  end
+
+  def options=(options)
+    @options = options
+  end
+
+  def dynamic_warnings
+    @dynamic_warnings ||= {}
+  end
+
+  def register_dynamic_warning(warning)
+    file_warnings = dynamic_warnings[$TYPECHECK_FILE] || []
+    file_warnings << warning
+    dynamic_warnings[$TYPECHECK_FILE] = file_warnings
+  end
+
   def log(client_binding, level, message)
     client = client_binding.receiver
     client_id = if client.instance_of?(Class)
@@ -121,6 +140,14 @@ module TypedRb
     logger('[' + client_id.gsub('::', '/') + ']').send(level, message)
   end
 
+  def log_dynamic_warning(node, owner, name)
+    if options[:dynamic_warnings]
+      error = TypeCheckError.new("Error type checking function #{owner}##{name}: Cannot find function type information for owner.", node)
+      print '.'.yellow
+      register_dynamic_warning(error)
+    end
+  end
+
   def logger(client)
     logger = Log4r::Logger[client]
     logger = Log4r::Logger.new(client) if logger.nil?
@@ -154,6 +181,16 @@ TypedRb.module_eval do
   public :logger
   module_function(:set_level)
   public :set_level
+  module_function(:log_dynamic_warning)
+  public :log_dynamic_warning
+  module_function(:options=)
+  public :options=
+  module_function(:options)
+  public :options
+  module_function(:dynamic_warnings)
+  public :dynamic_warnings
+  module_function(:register_dynamic_warning)
+  public :register_dynamic_warning
 end
 
 Dir[File.join(File.dirname(__FILE__), '**/*.rb')].each do |file|

data/spec/lib/language_spec.rb

@@ -1,5 +1,15 @@
 require_relative '../spec_helper'
 
+def silence_stream(stream)
+  old_stream = stream.dup
+  stream.reopen(RbConfig::CONFIG['host_os'] =~ /mswin|mingw/ ? 'NUL:' : '/dev/null')
+  stream.sync = true
+  yield
+ensure
+  stream.reopen(old_stream)
+  old_stream.close
+end
+
 describe TypedRb::Language do
   let(:language) { described_class.new }
   let(:file) { File.join(File.dirname(__FILE__), 'examples', example) }
@@ -9,7 +19,9 @@ describe TypedRb::Language do
     let(:example) { 'counter.rb' }
 
     it 'should be possible to type check the code' do
-      language.check_file(file)
+      silence_stream(STDOUT) do
+        language.check_file(file, true)
+      end
       expect_binding(language, Counter, '@counter', Integer)
     end
   end
@@ -18,7 +30,9 @@ describe TypedRb::Language do
     let(:example) { 'if.rb' }
 
     it 'should be possible to type check the code' do
-      language.check_file(file)
+      silence_stream(STDOUT) do
+        language.check_file(file, true)
+      end
       expect_binding(language, TestIf, '@state', String)
     end
   end
@@ -28,7 +42,9 @@ describe TypedRb::Language do
 
     it 'should be possible to type check errors about array invariance' do
       expect {
-        language.check_file(file)
+        silence_stream(STDOUT) do
+          language.check_file(file, true)
+        end
       }.to raise_error(TypedRb::TypeCheckError,
                        /Error type checking message sent 'mindless_func': Array\[Animal1\] expected, Array\[Cat1\] found/)
     end

data/spec/lib/typing/instance_vars_spec.rb

@@ -98,6 +98,6 @@ __END
 
     expect {
       language.check(code)
-    }.to raise_error
+    }.to raise_error(TypedRb::TypeCheckError)
   end
 end

data/spec/lib/typing/tm_raise_spec.rb

@@ -24,7 +24,7 @@ __END
 __END
       expect {
         language.check(code)
-      }.not_to raise_error(TypedRb::Types::UncomparableTypes)
+      }.not_to raise_error
     end
   end
 

data/spec/lib/typing/tm_range_literal_spec.rb

@@ -16,10 +16,10 @@ describe TypedRb::Model::TmRangeLiteral do
     expect(result.type_vars.first.bound.ruby_type).to eq(String)
   end
 
-  it 'fails for incompatible types' do
+  it 'defaults to the super type for uncomparable types' do
     code = '0..10.0'
-    expect {
-      language.check(code)
-    }.to raise_error
+    result = language.check(code)
+    expect(result.ruby_type).to eq(Range)
+    expect(result.type_vars.first.bound.ruby_type).to eq(Numeric)
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: typed.rb
 version: !ruby/object:Gem::Version
-  version: 0.0.11
+  version: 0.0.12
 platform: ruby
 authors:
 - Antonio Garrote