typed.rb 0.0.11

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 12f994fd40b7d71db8aa86c0875aa723347a8edd
+  data.tar.gz: 13a8daf59012cddba4a106476f9609c901cd6f9b
+SHA512:
+  metadata.gz: c9f9d208d55df978a5e1fa6f6014f955ffd3c10922970ce9d9801c9ed56bfd0775840f43978283b6ebd9139dfc0a3b595b81473b16823342a413c1e4fd0d37ea
+  data.tar.gz: aaa9b40826ca304563e4e5eb34e60f74efd3a5a47985bac003f2bd77c60f7ea25405bec24e4e3cffe5fa261a338370592cad42b68ebd25f52818a2192bc01abd

data/Rakefile

@@ -0,0 +1,26 @@
+require 'rspec/core/rake_task'
+require 'open3'
+
+RSpec::Core::RakeTask.new(:spec)
+
+desc 'type checks the library itself'
+task :check_lib do
+  $TYPECHECK = false
+  $LOAD_TO_TYPECHECK = true
+  require_relative './lib/init'
+  $LOAD_TO_TYPECHECK = false
+  puts ' * Dependencies'
+  Kernel.computed_dependencies.each { |f| puts " - #{f}" }
+  puts ' * Type Checking'
+  cmd = "./bin/typed.rb #{Kernel.computed_dependencies.join(' ')}"
+  Open3.popen3(cmd) do |stdin, stdout, stderr, waith|
+    { :out => stdout, :err => stderr }.each do |key, stream|
+      Thread.new do
+        until (raw_line = stream.gets).nil? do
+          puts raw_line
+        end
+      end
+    end
+    waith.join
+  end
+end

data/bin/typed.rb

@@ -0,0 +1,110 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+require 'pry'
+require_relative '../lib/typed'
+require 'benchmark'
+
+require 'set'
+
+class TargetFinder
+  # Generate a list of target files by expanding globbing patterns
+  # (if any). If args is empty, recursively find all Ruby source
+  # files under the current directory
+  # @return [Array] array of file paths
+  def find(args)
+    return target_files_in_dir if args.empty?
+
+    files = []
+
+    args.uniq.each do |arg|
+      files += if File.directory?(arg)
+                 target_files_in_dir(arg.chomp(File::SEPARATOR))
+               else
+                 process_explicit_path(arg)
+               end
+    end
+
+    files.map { |f| File.expand_path(f) }.uniq
+  end
+
+  # Finds all Ruby source files under the current or other supplied
+  # directory. A Ruby source file is defined as a file with the `.rb`
+  # extension or a file with no extension that has a ruby shebang line
+  # as its first line.
+  # It is possible to specify includes and excludes using the config file,
+  # so you can include other Ruby files like Rakefiles and gemspecs.
+  # @param base_dir Root directory under which to search for
+  #   ruby source files
+  # @return [Array] Array of filenames
+  def target_files_in_dir(base_dir = Dir.pwd)
+    # Support Windows: Backslashes from command-line -> forward slashes
+    base_dir.gsub!(File::ALT_SEPARATOR, File::SEPARATOR) if File::ALT_SEPARATOR
+    all_files = find_files(base_dir, File::FNM_DOTMATCH)
+    hidden_files = Set.new(all_files - find_files(base_dir, 0))
+
+    target_files = all_files.select do |file|
+      to_inspect?(file, hidden_files)
+    end
+
+    target_files
+  end
+
+  def to_inspect?(file, hidden_files)
+    unless hidden_files.include?(file)
+      return true if File.extname(file) == '.rb'
+      return true if ruby_executable?(file)
+    end
+    false
+  end
+
+  # Search for files recursively starting at the given base directory using
+  # the given flags that determine how the match is made. Excluded files will
+  # be removed later by the caller, but as an optimization find_files removes
+  # the top level directories that are excluded in configuration in the
+  # normal way (dir/**/*).
+  def find_files(base_dir, flags)
+    wanted_toplevel_dirs = toplevel_dirs(base_dir, flags)
+    wanted_toplevel_dirs.map! { |dir| dir << '/**/*' }
+
+    pattern = if wanted_toplevel_dirs.empty?
+                # We need this special case to avoid creating the pattern
+                # /**/* which searches the entire file system.
+                ["#{base_dir}/**/*"]
+              else
+                # Search the non-excluded top directories, but also add files
+                # on the top level, which would otherwise not be found.
+                wanted_toplevel_dirs.unshift("#{base_dir}/*")
+              end
+    Dir.glob(pattern, flags).select { |path| FileTest.file?(path) }
+  end
+
+  def toplevel_dirs(base_dir, flags)
+    Dir.glob(File.join(base_dir, '*'), flags).select do |dir|
+      File.directory?(dir) && !(dir.end_with?('/.') || dir.end_with?('/..'))
+    end
+  end
+
+  def ruby_executable?(file)
+    return false unless File.extname(file).empty?
+    first_line = File.open(file, &:readline)
+    first_line =~ /#!.*ruby/
+  rescue EOFError, ArgumentError => e
+    warn "Unprocessable file #{file}: #{e.class}, #{e.message}" if debug?
+    false
+  end
+
+  def process_explicit_path(path)
+    if path.include?('*')
+      Dir[path]
+    else
+      [path]
+    end
+  end
+end
+
+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)
+end
+
+puts "Finished in #{time} seconds"

data/lib/typed/language.rb

@@ -0,0 +1,131 @@
+require_relative './runtime/ast_parser'
+
+module TypedRb
+  class Language
+    include Model
+    include Types
+
+    attr_reader :unification_result
+
+    def check(expr)
+      restore_prelude
+      $TYPECHECK = true
+      eval(expr, TOPLEVEL_BINDING)
+      $TYPECHECK = false
+      TypedRb.log(binding, :debug, 'Normalize top level')
+      ::BasicObject::TypeRegistry.normalize_types!
+      TypingContext.clear(:top_level)
+      check_result = check_type(parse(expr))
+      ::BasicObject::TypeRegistry.check_super_type_annotations
+      @unification_result = run_unification
+      check_result
+    end
+
+    def gen_bin_prelude
+      File.open(File.join(File.dirname(__FILE__), 'prelude_registry.bin'), 'w') do |f|
+        f.write(Marshal.dump(::BasicObject::TypeRegistry.send(:registry)))
+      end
+      File.open(File.join(File.dirname(__FILE__), 'prelude_generic_registry.bin'), 'w') do |f|
+        f.write(Marshal.dump(::BasicObject::TypeRegistry.send(:generic_types_registry)))
+      end
+      File.open(File.join(File.dirname(__FILE__), 'prelude_existential_registry.bin'), 'w') do |f|
+        f.write(Marshal.dump(::BasicObject::TypeRegistry.send(:existential_types_registry)))
+      end
+    end
+
+    def load_bin_prelude
+      old_value = $TYPECHECK
+      $TYPECHECK = false
+      require_relative('./prelude')
+      $TYPECHECK = old_value
+      ::BasicObject::TypeRegistry.clear
+      File.open(File.join(File.dirname(__FILE__), 'prelude_registry.bin'), 'r') do |f|
+        ::BasicObject::TypeRegistry.registry =  Marshal.load(f.read)
+      end
+      File.open(File.join(File.dirname(__FILE__), 'prelude_generic_registry.bin'), 'r') do |f|
+        ::BasicObject::TypeRegistry.generic_types_registry = Marshal.load(f.read)
+      end
+      File.open(File.join(File.dirname(__FILE__), 'prelude_existential_registry.bin'), 'r') do |f|
+        ::BasicObject::TypeRegistry.existential_types_registry = Marshal.load(f.read)
+      end
+      ::BasicObject::TypeRegistry.clear_parsing_registries
+      true
+    rescue
+      false
+    end
+
+    def restore_prelude
+      unless load_bin_prelude
+        ::BasicObject::TypeRegistry.clear
+        $TYPECHECK = true
+        load File.join(File.dirname(__FILE__), 'prelude.rb')
+        $TYPECHECK = false
+        ::BasicObject::TypeRegistry.normalize_types!
+        gen_bin_prelude
+        TypingContext.clear(:top_level)
+        ::BasicObject::TypeRegistry.clear_parsing_registries
+      end
+    end
+
+    def check_files(files)
+      ::BasicObject::TypeRegistry.clear
+      $TYPECHECK = true
+      prelude_path = File.join(File.dirname(__FILE__), 'prelude.rb')
+      load prelude_path
+      Kernel.reset_dependencies
+      Kernel.with_dependency_tracking do
+        files.each { |file| load file if file != prelude_path }
+      end
+      ordered_files = Kernel.computed_dependencies.select do |file|
+        files.include?(file)
+      end
+      ordered_files += files.select { |file| !ordered_files.include?(file) }
+      $TYPECHECK = false
+      TypedRb.log(binding, :debug, 'Normalize top level')
+      ::BasicObject::TypeRegistry.normalize_types!
+      TypingContext.clear(:top_level)
+      check_result = nil
+      ordered_files.each do |file|
+        puts "*** FILE #{file}"
+        $TYPECHECK_FILE = file
+        expr = File.open(file, 'r').read
+        #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
+      end
+      ::BasicObject::TypeRegistry.check_super_type_annotations
+      @unification_result = run_unification
+      check_result
+    end
+
+    def check_file(path)
+      check_files([path])
+    end
+
+    def parse(expr)
+      Model::GenSym.reset
+      parser = AstParser.new
+      parser.parse(expr)
+    end
+
+    def check_type(expr)
+      expr.check_type(TypingContext.top_level)
+    end
+
+    def run_unification
+      constraints = Types::TypingContext.all_constraints
+      unif = Types::Polymorphism::Unification.new(constraints)
+      unif.run(true)
+    end
+
+    def type_variables
+      TypingContext.all_variables
+    end
+  end
+end

data/lib/typed/model/tm_abs.rb

@@ -0,0 +1,104 @@
+require_relative '../model'
+
+module TypedRb
+  module Model
+    # abstraction
+    class TmAbs < Expr
+      attr_accessor :args, :term, :arity, :abs_type
+      def initialize(args, term, abs_type, node)
+        super(node, type)
+        @args     = args
+        @term     = term
+        @abs_type = abs_type
+        @arity    = args.count { |(arg_type, _, _)|  arg_type == :arg }
+        @instantiation_count = 0
+      end
+
+      def check_type(context)
+        with_fresh_bindings(context) do |var_type_args, var_type_return, context|
+          type_term = term.check_type(context)
+          fail TypeCheckError.new("Invalid 'return' statement inside abstraction", type_term.node) if type_term.stack_jump? && type_term.return?
+          if type_term.stack_jump? && type_term.break?
+            Types::TyGenericFunction.new(var_type_args, type_term, resolve_ruby_method_parameters, node)
+          elsif type_term.stack_jump? && (type_term.next? || type_term.return?)
+            wrapped_type = type_term.wrapped_type.check_type(context)
+            if var_type_return.compatible?(wrapped_type, :gt)
+              Types::TyGenericFunction.new(var_type_args, var_type_return, resolve_ruby_method_parameters, node)
+            else
+              # TODO: improve message
+              error_msg = "Error parsing abstraction, incompatible break return type found: #{var_type_return} < #{wrapped_type}"
+              fail TypeCheckError.new(error_msg, node)
+            end
+          elsif type_term.either?
+            max_either_type = type_term.check_type(context, [:normal, :return, :next])
+            if var_type_return.compatible?(max_either_type, :gt)
+              if type_term.break?
+                either_return = Types::TyEither.new(node)
+                either_return[:break] = type_term[:break]
+                either_return[:normal] = var_type_return
+                Types::TyGenericFunction.new(var_type_args, either_return, resolve_ruby_method_parameters, node)
+              else
+                Types::TyGenericFunction.new(var_type_args, var_type_return, resolve_ruby_method_parameters, node)
+              end
+            else
+              error_msg = "Error parsing abstraction, incompatible either return type found: #{var_type_return} < #{type_term}}"
+              fail TypeCheckError.new(error_msg, node)
+            end
+          elsif var_type_return.compatible?(type_term, :gt)
+            Types::TyGenericFunction.new(var_type_args, var_type_return, resolve_ruby_method_parameters, node)
+          else
+            # TODO: improve message
+            error_msg = "Error parsing abstraction, incompatible return type found: #{var_type_return} < #{type_term}"
+            fail TypeCheckError.new(error_msg, node)
+          end
+        end
+      end
+
+      # abstractions are polymorphic universal types by default,
+      # we need new bindings in the type variables with each instantiation of the lambda.
+      def with_fresh_bindings(context)
+        orig_context = Types::TypingContext.type_variables_register
+        Types::TypingContext.push_context(:lambda)
+        fresh_args = args.map do |(type, var, opt)|
+          if type == :mlhs
+            context = var.check_type(:lambda, context)
+            var
+          else
+            type_var_arg = Types::TypingContext.type_variable_for_abstraction(:lambda, "#{var}", context)
+            type_var_arg.node = node
+            context = case type
+                      when :arg, :block
+                        context.add_binding(var, type_var_arg)
+                      when :optarg
+                        declared_arg_type = opt.check_type(orig_context)
+                        if type_var_arg.compatible?(declared_arg_type, :gt)
+                          context.add_binding(var, type_var_arg)
+                        end
+                      end
+            type_var_arg
+          end
+        end
+
+        return_type_var_arg = Types::TypingContext.type_variable_for_abstraction(:lambda, nil, context)
+        return_type_var_arg.node = node
+        lambda_type  = yield fresh_args, return_type_var_arg, context
+        lambda_type.local_typing_context = Types::TypingContext.pop_context
+        lambda_type
+      end
+
+      protected
+
+      def resolve_ruby_method_parameters
+        args.map do |(arg_type, val, _)|
+          if arg_type == :optarg
+            [:opt, val]
+          elsif arg_type == :blockarg
+            [:block, val]
+          else
+            [:req, val]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/typed/model/tm_array_literal.rb

@@ -0,0 +1,25 @@
+require_relative '../model'
+
+module TypedRb
+  module Model
+    class TmArrayLiteral < Expr
+      attr_reader :elements
+      def initialize(elements, node)
+        super(node)
+        @elements = elements
+      end
+
+      def check_type(context)
+        element_types = elements.map { |element|  element.check_type(context) }
+        max_type = element_types.max rescue Types::TyObject.new(Object, node)
+        type_var = Types::Polymorphism::TypeVariable.new('Array:T',
+                                                         :node => node,
+                                                         :gen_name => false,
+                                                         :upper_bound => max_type,
+                                                         :lower_bound => max_type)
+        type_var.bind(max_type)
+        Types::TyGenericObject.new(Array, [type_var], node)
+      end
+    end
+  end
+end

data/lib/typed/model/tm_boolean.rb

@@ -0,0 +1,15 @@
+# -*- coding: utf-8 -*-
+require_relative '../model'
+
+module TypedRb
+  module Model
+    # booleans
+    class TmBoolean < Expr
+      attr_accessor :val
+      def initialize(node)
+        super(node, Types::TyBoolean.new(node))
+        @val = node.type == 'true' ? true : false
+      end
+    end
+  end
+end

data/lib/typed/model/tm_boolean_operator.rb

@@ -0,0 +1,34 @@
+require_relative '../model'
+
+module TypedRb
+  module Model
+    # abstraction
+    class TmBooleanOperator < Expr
+      attr_accessor :operator, :lhs, :rhs
+
+      def initialize(operator, lhs, rhs, node)
+        super(node)
+        @lhs = lhs
+        @rhs = rhs
+        @operator = operator
+      end
+
+      def check_type(context)
+        lhs_type = @lhs.check_type(context)
+        rhs_type = @rhs.check_type(context)
+        if lhs_type.is_a?(Types::Polymorphism::TypeVariable) || rhs_type.is_a?(Types::Polymorphism::TypeVariable)
+          var = Types::TypingContext.local_type_variable
+          var.compatible?(lhs_type, :gt)
+          var.compatible?(rhs_type, :gt)
+          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::TyUnit.new if type.nil?
+          type.node = node
+          type
+        end
+      end
+    end
+  end
+end

data/lib/typed/model/tm_break.rb

@@ -0,0 +1,24 @@
+require_relative '../model'
+
+module TypedRb
+  module Model
+    class TmBreak < Expr
+      attr_reader :elements
+      def initialize(elements, node)
+        super(node)
+        @elements = elements
+      end
+
+      def check_type(context)
+        returned_type = if elements.size == 0
+                          Types::TyUnit.new(node)
+                        elsif elements.size == 1
+                          elements.first.check_type(context)
+                        else
+                          TmArrayLiteral.new(elements, node).check_type(context)
+                        end
+        Types::TyStackJump.break(returned_type, node)
+      end
+    end
+  end
+end

data/lib/typed/model/tm_case_when.rb

@@ -0,0 +1,38 @@
+# -*- coding: utf-8 -*-
+require_relative '../model'
+
+module TypedRb
+  module Model
+    class TmCaseWhen < Expr
+      attr_reader :case_statement, :when_statements, :default_statement
+      def initialize(node, case_statement, when_statements, default_statement)
+        super(node, nil)
+        @case_statement = case_statement
+        @when_statements = when_statements
+        @default_statement = default_statement
+      end
+
+      def check_type(context)
+        conditions = build_conditionals(case_statement, when_statements)
+        conditions = conditions.reduce([]) do |acc, (node, condition, then_statement)|
+          next_condition = TmIfElse.new(node, condition, then_statement, nil)
+          prev_condition = acc.last
+          prev_condition.else_expr = next_condition unless prev_condition.nil?
+          acc << next_condition
+        end
+        conditions.last.else_expr = default_statement if default_statement
+        conditions.first.check_type(context)
+      end
+
+      protected
+
+      def build_conditionals(case_statement, when_statements)
+        when_statements.map do |when_statement|
+          node, conditional, then_statement = when_statement
+          condition = TmSend.new(case_statement, :===, [conditional], node)
+          [node, condition, then_statement]
+        end
+      end
+    end
+  end
+end

data/lib/typed/model/tm_class.rb

@@ -0,0 +1,63 @@
+# -*- coding: utf-8 -*-
+require_relative '../model'
+
+module TypedRb
+  module Model
+    # Class expression
+    class TmClass < Expr
+      attr_reader :class_name, :super_class_name, :body
+
+      def initialize(class_name, super_class_name, body, node)
+        super(node)
+        @class_name = class_name
+        @super_class_name = super_class_name
+        @body = body
+      end
+
+      def check_type(context)
+        class_ruby_type = Types::TypingContext.find_namespace(class_name)
+        class_type = Runtime::TypeParser.parse_singleton_object_type(class_ruby_type.name)
+        context = context.add_binding(:self, class_type)
+        Types::TypingContext.namespace_push(class_name)
+        result_type = if class_type.is_a?(Types::TyGenericSingletonObject)
+                        # If the type is generic, we will collect all the restrictions
+                        # found while processing the class body in a local type_context.
+                        # This context will be complemented with the remaining restrictions
+                        # coming from type var application when the generic type becomes
+                        # concrete to yield the final type.
+                        TmClass.with_fresh_bindings(class_type, context, node) do
+                          body.check_type(context) if body
+                        end
+                      else
+                        body.check_type(context) if body
+                      end
+        Types::TypingContext.namespace_pop
+        result_type || Types::TyUnit.new(node)
+      end
+
+      def self.with_fresh_bindings(generic_class, _context, node)
+        Types::TypingContext.push_context(:class)
+        # Deal with upper/lower bounds here if required
+        generic_class.type_vars.each do |type_var|
+          type_var = Types::TypingContext.type_variable_for_generic_type(type_var)
+          type_var.node = node
+
+          if type_var.upper_bound
+            type_var.compatible?(type_var.upper_bound, :lt)
+          end
+
+          if type_var.lower_bound
+            type_var.compatible?(type_var.lower_bound, :gt)
+          end
+        end
+        body_return_type  = yield if block_given?
+        # Since every single time we find the generic type the same instance
+        # will be returned, the local_typing_context will still be associated.
+        # This is the reason we need to build a new typing context cloning this
+        # one while type materialization.
+        generic_class.local_typing_context = Types::TypingContext.pop_context
+        body_return_type
+      end
+    end
+  end
+end

data/lib/typed/model/tm_const.rb

@@ -0,0 +1,29 @@
+require_relative '../model'
+
+module TypedRb
+  module Model
+    # A constant expression
+    class TmConst < Expr
+      attr_reader :val
+
+      def initialize(val, node)
+        super(node)
+        @val = val
+      end
+
+      def check_type(_context)
+        value_ruby_type = Types::TypingContext.find_namespace(@val)
+        type = if value_ruby_type.instance_of?(Class)
+                 Runtime::TypeParser.parse_singleton_object_type(value_ruby_type.name)
+               elsif value_ruby_type.instance_of?(Module)
+                 Runtime::TypeParser.parse_existential_object_type(value_ruby_type.name)
+               else
+                 # Must be a user defined constant
+                 Types::TyObject.new(value_ruby_type.class)
+               end
+        type.node = node
+        type
+      end
+    end
+  end
+end

data/lib/typed/model/tm_defined.rb

@@ -0,0 +1,19 @@
+# -*- coding: utf-8 -*-
+require_relative '../model'
+
+module TypedRb
+  module Model
+    class TmDefined < Expr
+      attr_reader :expression
+      def initialize(expression, node)
+        super(node)
+        @expression = expression
+      end
+
+      def check_type(context)
+        expression.check_type(context)
+        Types::TyString.new(node)
+      end
+    end
+  end
+end

data/lib/typed/model/tm_error.rb

@@ -0,0 +1,16 @@
+# -*- coding: utf-8 -*-
+require_relative '../model'
+
+module TypedRb
+  module Model
+    class TmError < Expr
+      def initialize(node)
+        super(node)
+      end
+
+      def check_type(_context)
+        Types::TyError.new(node)
+      end
+    end
+  end
+end

data/lib/typed/model/tm_float.rb

@@ -0,0 +1,15 @@
+# -*- coding: utf-8 -*-
+require_relative '../model'
+
+module TypedRb
+  module Model
+    # floats
+    class TmFloat < Expr
+      attr_accessor :val
+      def initialize(node)
+        super(node, Types::TyFloat.new(node))
+        @val = node.children.first
+      end
+    end
+  end
+end