typed.rb 0.0.11

data/lib/typed/runtime/type_signature_processor.rb

@@ -0,0 +1,34 @@
+module TypedRb
+  module Runtime
+    class TypeSignatureProcessor
+      PARAMETRIC_TYPE_PREFIX = /\s*(module|class|type)\s*/
+      class << self
+        def type_signature?(signature)
+          signature.index(PARAMETRIC_TYPE_PREFIX) == 0
+        end
+
+        def process(signature)
+          type_signature = signature.split(PARAMETRIC_TYPE_PREFIX).last
+
+          type_signature, super_type_signature = 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)
+          end
+
+          BasicObject::TypeRegistry.register_generic_type_information(generic_type, generic_super_type)
+        end
+
+        private
+
+        # Generic types can have an explicit generic supertype.
+        # e.g:
+        # ts 'type Pair[S][T] super Array[Object]'
+        def parse_generic_supertype(type_signature)
+          type_signature.split(/\s*super\s*/)
+        end
+      end
+    end
+  end
+end

data/lib/typed/runtime.rb

@@ -0,0 +1,33 @@
+class BasicObject
+  def ts(signature)
+    # TODO: Add information about the script and line for the invocation here
+    # caller_infos = caller.first.split(":")
+    # puts "#{caller_infos[0]} : #{caller_infos[1]} : #{str}"
+    ::TypedRb.log(binding, :debug, "Parsing signature: #{signature}")
+    if $TYPECHECK
+      if ::TypedRb::Runtime::TypeSignatureProcessor.type_signature?(signature)
+        ::TypedRb::Runtime::TypeSignatureProcessor.process(signature)
+      else
+        ::TypedRb::Runtime::MethodSignatureProcessor.process(signature, self)
+      end
+    end
+    # rescue ::StandardError => ex
+    #  puts ex.message
+    #  puts ex.backtrace.join("\n")
+    #  raise ::StandardError, "Error parsing type signature '#{signature}': #{ex.message}"
+  end
+
+  def ts_ignore; end
+
+  def cast(from, _to)
+    # noop
+    from
+  end
+end
+
+class Class
+  ts '.call / Class... -> unit'
+  def call(*_types)
+    self
+  end
+end

data/lib/typed/type_signature/parser.rb

@@ -0,0 +1,240 @@
+module TypedRb
+  module TypeSignature
+    class ParsingError < StandardError
+      def initialize(expr, reason)
+        super "Error parsing type signature '#{expr}': #{reason}"
+      end
+    end
+
+    module TokenProcessor
+      def group_tokens(tokens)
+        next_group = []
+        groups = [next_group]
+        tokens.each do |token|
+          if token == :<
+            next_group = []
+            groups << next_group
+          else
+            next_group << token
+          end
+        end
+        groups
+      end
+
+      def transform_function_tokens(tokens)
+        group_tokens(tokens).map do |token_group|
+          if token_group.is_a?(Array)
+            transform_nested_function(token_group)
+          elsif token_group.is_a?(String)
+            token_group
+          end
+        end.compact
+      end
+
+      def variable_group?(token_group)
+        token_group.drop(1).all? do |token|
+          token.is_a?(Hash) &&
+            (token[:kind] == :type_var ||
+             token[:kind] == :generic_type)
+        end
+      end
+
+      def transform_nested_function(token_group)
+        if token_group.size > 1 &&
+           token_group.last.is_a?(Hash) &&
+           token_group.last[:kind] == :rest
+          remaining_tokens = transform_nested_function(token_group[0...-1] + token_group.last[:parameters])
+          {:kind => :rest,
+           :type => 'Array',
+           :parameters => [remaining_tokens]}
+        elsif token_group.size > 1 &&
+           variable_group?(token_group) &&
+           token_group[0].is_a?(String)
+          { :type       => token_group.first,
+            :parameters => token_group.drop(1),
+            :kind       => :generic_type }
+        elsif token_group.size < 2
+          token_group.first
+        else
+          token_group
+        end
+      end
+    end
+
+    module TypeProcessor
+      def parse_start_of_type
+        new_type = parse_new_type
+        @current_function << new_type unless @current_type.empty?
+        @stack << @current_function
+        @current_type = []
+        @current_function = []
+      end
+
+      def parse_end_of_function
+        new_type = parse_new_type
+        @current_function << new_type unless @current_type.empty?
+        parent_function = @stack.pop
+        next_function_elem = transform_function_tokens(@current_function)
+        parent_function << next_function_elem
+        parse_block_arg(parent_function) if block_arg?(parent_function)
+        @current_function = parent_function
+        @current_type = []
+      end
+
+      def block_arg?(function_tokens)
+        function_tokens[-2] == '&'
+      end
+
+      def parse_block_arg(function_tokens)
+        block = { :block => function_tokens.pop,
+                  :kind  => :block_arg }
+        function_tokens.pop
+        function_tokens << block
+      end
+
+      def parse_binding
+        new_type = parse_new_type
+        @current_function << new_type unless @current_type.empty?
+        @current_type = []
+      end
+
+      def parse_end_of_binding
+        bound = parse_variable_binding
+        # method variables
+        if bound[:kind] == :type_var && method_info[bound[:type]]
+          bound = method_info[bound[:type]].dup
+          bound[:sub_kind] = :method_type_var
+        end
+        @binding = nil
+        parent_function = @stack.pop
+        parent_function << bound
+        @current_function = parent_function
+        @current_type = []
+      end
+
+      def parse_variable_binding
+        new_type = parse_new_type
+        @current_function << new_type unless @current_type.empty?
+        if @current_function.size == 1
+          { :type => @current_function.first,
+            :kind => :type_var }
+        else
+          if @binding.nil?
+            # This is the case for nested generic types
+            { :type       => @current_function.first,
+              :parameters => @current_function.drop(1),
+              :kind       => :generic_type }
+          else
+            { :type    => @current_function.first,
+              :bound   => @current_function.last,
+              :binding => @binding,
+              :kind    => :type_var }
+          end
+        end
+      end
+
+      def parse_next_elem
+        return parse_binding if @in_binding
+
+        new_type = parse_new_type
+        @current_function << new_type unless @current_type.empty?
+        @current_function << :<
+        @current_type = []
+      end
+
+      def parse_new_type
+        new_type = @current_type.join
+        new_type = :unit if new_type == 'unit'
+        if new_type.to_s.end_with?('...')
+          new_type = new_type.split('...').first
+          new_type = @current_function.pop if new_type.nil?
+          new_type =  { :type       => 'Array',
+                        :kind       => :rest,
+                        :parameters => [new_type] }
+        end
+        new_type
+      end
+    end
+
+    class Parser
+      include TokenProcessor
+      include TypeProcessor
+
+      def self.parse(expr, method_info = {})
+        (@parser || Parser.new(method_info)).parse(expr)
+      end
+
+      attr_reader :method_info
+
+      def initialize(method_info = {})
+        @method_info = method_info
+        @current_type = []
+        @current_function = []
+        @stack = []
+        @in_binding = false
+      end
+
+      def parse(expr)
+        @input_expression = expr
+        expr = sanitize_input(expr)
+        expr.each_char { |elem| parse_next_char(elem) }
+        build_final_signature
+      rescue TypedRb::TypeSignature::ParsingError => e
+        raise e
+      rescue StandardError => e
+        raise TypedRb::TypeSignature::ParsingError.new(expr, e.message)
+      end
+
+      private
+
+      def sanitize_input(expr)
+        expr.gsub(/\s+/, '').gsub('->', '/')
+      end
+
+      PARSERS = {
+        '(' => ->(parser) { parser.parse_start_of_type },
+        '[' => ->(parser) { parser.parse_start_of_type },
+        ')' => ->(parser) { parser.parse_end_of_function },
+        '<' => ->(parser) { parser.parse_binding },
+        '>' => ->(parser) { parser.parse_binding },
+        ']' => ->(parser) { parser.parse_end_of_binding },
+        '/' => ->(parser) { parser.parse_next_elem }
+      }
+
+      def parse_next_char(elem)
+        setup_binding_context(elem)
+        if PARSERS[elem]
+          PARSERS[elem][self]
+        else
+          @current_type << elem
+        end
+      end
+
+      def setup_binding_context(elem)
+        @in_binding = true  if elem == '['
+        @in_binding = false if elem == ']'
+        @binding = elem     if elem == '<' || elem == '>'
+      end
+
+      def build_final_signature
+        fail ParsingError.new(@input_expression, 'Unbalanced parentheses.') unless @stack.empty?
+        new_type = parse_new_type
+
+        @current_function << new_type unless @current_type.empty?
+        @current_type = []
+        final_function = transform_function_tokens(@current_function)
+
+        # Distinguis between function without arguments:
+        #   -> unit => [:<, 'unit']
+        # and generic type without function (e.g. in the
+        # type parameter of a class Array.('Array[Integer]'))
+        #   Array[Integer] => ['Array', {:type ... }]
+        if @current_function.at(0) != :< && final_function.size == 1
+          final_function.last
+        else
+          final_function
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+require_relative './type_variable'
+module TypedRb
+  module Types
+    module Polymorphism
+      class ExistentialTypeVariable < TypeVariable
+        attr_accessor :module_type
+        def find_var_type(var)
+          module_type.find_var_type(var)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,134 @@
+module TypedRb
+  module Types
+    module Polymorphism
+      module GenericComparisons
+        def ==(other)
+          return false if !other.is_a?(TyObject) || !other.generic?
+          return false if other.ruby_type != ruby_type
+          to_s == other.to_s
+        end
+
+        def !=(other)
+          ! (self == other)
+        end
+
+        def <(other)
+          self.compatible?(other, :lt)
+        end
+
+        def >(other)
+          self.compatible?(other, :gt)
+        end
+
+        def <=(other)
+          self == other || self.compatible?(other, :lt)
+        end
+
+        def >=(other)
+          self == other || self.compatible?(other, :gt)
+        end
+
+        def compatible?(other_type, relation = :lt)
+          if other_type.is_a?(TyDynamic) || other_type.is_a?(TyError)
+            true
+          elsif other_type.is_a?(TyGenericObject) || other_type.is_a?(TyGenericSingletonObject)
+            if check_generic_type_relation(other_type.ruby_type, relation)
+              type_vars.each_with_index do |type_var, i|
+                other_type_var = other_type.type_vars[i]
+                compatible = if incompatible_free_type_vars?(type_var, other_type_var)
+                               false
+                             elsif compatible_free_type_vars?(type_var, other_type_var)
+                               true
+                             else
+                               check_type_var_inclusion(type_var, other_type_var, relation)
+                             end
+                return false unless compatible
+              end
+              true
+            else
+              false
+            end
+          else
+            check_generic_type_relation(other_type.ruby_type, relation)
+          end
+        rescue ArgumentError
+          raise TypedRb::Types::UncomparableTypes.new(self, other_type)
+        end
+
+        def incompatible_free_type_vars?(type_var, other_type_var)
+          left_var = type_var.bound || type_var.lower_bound || type_var.upper_bound || type_var
+          right_var = other_type_var.bound || other_type_var.lower_bound || other_type_var.upper_bound || other_type_var
+
+          left_var.is_a?(Polymorphism::TypeVariable) &&
+            right_var.is_a?(Polymorphism::TypeVariable) &&
+            left_var.variable != right_var.variable &&
+            (TypingContext.bound_generic_type_var?(left_var) &&
+             TypingContext.bound_generic_type_var?(right_var))
+        end
+
+        def compatible_free_type_vars?(type_var, other_type_var)
+          left_var = type_var.bound || type_var.lower_bound || type_var.upper_bound || type_var
+          right_var = other_type_var.bound || other_type_var.lower_bound || other_type_var.upper_bound || other_type_var
+
+          left_var.is_a?(Polymorphism::TypeVariable) &&
+            right_var.is_a?(Polymorphism::TypeVariable) &&
+            left_var.variable == right_var.variable &&
+            (TypingContext.bound_generic_type_var?(left_var) &&
+             TypingContext.bound_generic_type_var?(right_var))
+        end
+
+        def check_generic_type_relation(other_ruby_type, relation)
+          if relation == :gt
+            TyObject.new(ruby_type) >= TyObject.new(other_ruby_type)
+          else
+            TyObject.new(ruby_type) <= TyObject.new(other_ruby_type)
+          end
+        end
+
+        def check_type_var_inclusion(type_var, other_type_var, relation)
+          if (!type_var.wildcard? && !type_var.fully_bound?) ||
+             (!other_type_var.wildcard? && !other_type_var.fully_bound?)
+            add_type_var_constraint(type_var, other_type_var, relation)
+          else
+            superset, subset = relation == :lt ? [other_type_var, type_var] : [type_var, other_type_var]
+
+            super_min, super_max, sub_min, sub_max = [superset.lower_bound, superset.upper_bound, subset.lower_bound, subset.upper_bound]. map do |bound|
+              if bound.nil?
+                nil
+              else
+                bound
+              end
+            end
+            super_max ||= TyObject.new(Object)
+            sub_max ||= TyObject.new(Object)
+
+            check_inferior_or_equal_binding(super_min, sub_min) &&
+              check_inferior_or_equal_binding(sub_max, super_max)
+          end
+        end
+
+        # nil < Type_i < Object
+        def check_inferior_or_equal_binding(binding_a, binding_b)
+          if binding_a.nil? && binding_b.nil?
+            true
+          elsif binding_a.nil? && !binding_b.nil?
+            true
+          elsif !binding_a.nil? && binding_b.nil?
+            false
+          else
+            binding_a <= binding_b
+          end
+        end
+
+        def add_type_var_constraint(type_var, other_type_var, relation)
+          if type_var.bound
+            type_var, other_type_var = other_type_var, type_var
+            relation = relation == :lt ? :gt : :lt
+          end
+          type_var.add_constraint(relation, other_type_var.bound)
+          true
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+module TypedRb
+  module Types
+    module Polymorphism
+      module GenericVariables
+        def type_vars(options = { recursive: true })
+          return @type_vars unless options[:recursive]
+          return @type_vars if self.class == TypedRb::Types::TyGenericObject
+          @type_vars.map do |type_var|
+            if type_var.is_a?(Polymorphism::TypeVariable) && type_var.bound_to_generic?
+              type_var.bound.type_vars
+            elsif type_var.is_a?(Polymorphism::TypeVariable)
+              type_var
+            else
+              type_var.type_vars
+            end
+          end.flatten
+          #  .each_with_object({}) do |type_var, acc|
+          #  acc[type_var.variable] = type_var
+          #end.values
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,138 @@
+module TypedRb
+  module Types
+    module Polymorphism
+      class TypeVariable
+        attr_accessor :bound, :variable, :upper_bound, :lower_bound, :name, :node
+
+        def initialize(var_name, options = {})
+          gen_name = options[:gen_name].nil? ? true : options[:gen_name]
+          @upper_bound = options[:upper_bound]
+          @lower_bound = options[:lower_bound]
+          @node = options[:node]
+          @wildcard = var_name.to_s.end_with?('?')
+          var_name.sub!(/:?\?/, '') if @wildcard
+          @name = var_name
+          @variable = gen_name ? Model::GenSym.next("TV_#{var_name}") : var_name
+          @bound = options[:bound]
+        end
+
+        def stack_jump?
+          false
+        end
+
+        def either?
+          false
+        end
+
+        def add_constraint(relation, type)
+          if type.is_a?(TypeVariable) && type.bound
+            TypingContext.add_constraint(variable, relation, type.bound)
+          else
+            TypingContext.add_constraint(variable, relation, type)
+          end
+        end
+
+        def add_message_constraint(message, args)
+          return_type = TypingContext.type_variable_for_message(variable, message)
+          return_type.node = node
+          # add constraint for this
+          add_constraint(:send, args: args, return: return_type, message: message)
+          # return return type
+          return_type
+        end
+
+        def compatible?(type, relation = :lt)
+          if @bound
+            @bound.compatible?(type, relation)
+          elsif incompatible_vars?(type)
+            false
+          else
+            add_constraint(relation, type)
+            true
+          end
+        end
+
+        def constraints(register = TypingContext)
+          register.constraints_for(variable).map { |(t, c)| [self, t, c] }
+        end
+
+        def check_type(_context)
+          self
+        end
+
+        def bind(type)
+          @bound = type
+        end
+
+        def fully_bound?
+          !upper_bound.nil? && !lower_bound.nil?
+        end
+
+        def wildcard?
+          @wildcard
+        end
+
+        def to_wildcard!
+          @wildcard = true
+        end
+
+        def apply_bindings(bindings_map)
+          bound_var = bindings_map[variable]
+          if bound_var && bound.nil?
+            self.bound = bound_var.bound
+            self.upper_bound = bound_var.upper_bound
+            self.lower_bound = bound_var.lower_bound
+            self.to_wildcard! if bound_var.wildcard?
+          elsif bound && (bound.is_a?(TyGenericSingletonObject) || bound.is_a?(TyGenericObject))
+             bound.apply_bindings(bindings_map)
+          end
+          self
+        end
+
+        def unbind
+          @bound = nil
+        end
+
+        def clone
+          var = TypeVariable.new(variable,
+                                 node: node,
+                                 gen_name: false,
+                                 upper_bound: upper_bound,
+                                 lower_bound: lower_bound,
+                                 bound: bound)
+          var.to_wildcard! if wildcard?
+          var
+        end
+
+        def to_s
+          wildcard_part = wildcard? ? '*' : ''
+          bound_part = if @bound
+                         @bound
+                       else
+                         "[#{lower_bound || '?'},#{upper_bound || '?'}]"
+                       end
+          "#{@variable}#{wildcard_part}::#{bound_part}"
+        end
+
+        def bound_to_generic?
+          bound && bound.respond_to?(:generic?) && bound.generic?
+        end
+
+        private
+
+        def incompatible_vars?(type)
+          if type.is_a?(TypeVariable)
+            left_var = bound || self
+            right_var = type.bound || type
+
+            left_var.is_a?(TypeVariable) &&
+              right_var.is_a?(TypeVariable) &&
+              left_var.variable != right_var.variable &&
+              (TypingContext.bound_generic_type_var?(left_var) &&
+               TypingContext.bound_generic_type_var?(right_var))
+          end
+        end
+      end
+    end
+  end
+end