typed.rb 0.0.11

data/lib/typed/types/ty_either.rb

@@ -0,0 +1,168 @@
+module TypedRb
+  module Types
+    class TyEither < TyObject
+      attr_accessor :options
+      def initialize(node=nil)
+        super(NilClass, node)
+        @options = { :normal => TypedRb::Types::TyUnit.new }
+      end
+
+      def self.wrap(type)
+        if type.either?
+          type
+        elsif type.stack_jump?
+          either = TyEither.new(type.node)
+          either[type.jump_kind] = type
+          either
+        else
+          either = TyEither.new(type.node)
+          either[:normal] = type
+          either
+        end
+      end
+
+      def unwrap
+        normal = self[:normal].is_a?(TypedRb::Types::TyUnit) ? nil : self[:normal]
+        wrapped_types = [normal, self[:return], self[:break], self[:next]].compact
+        if wrapped_types.count > 1
+          self
+        elsif wrapped_types.count == 1
+          wrapped_types.first
+        else
+          TypedRb::Types::TyUnit.new
+        end
+      end
+
+      def either?
+        true
+      end
+
+      def return?
+        !options[:return].nil? && options[:return].return?
+      end
+
+      def break?
+        !options[:break].nil? && options[:break].break?
+      end
+
+      def next?
+        !options[:next].nil? && options[:next].next?
+      end
+
+      def has_jump?
+        !(options[:return] || options[:next] || options[:break]).nil?
+      end
+
+      def kinds
+        [:return, :next, :break]
+      end
+
+      def all_kinds
+        [:normal] + kinds
+      end
+
+      def [](kind)
+        valid_kind?(kind)
+        options[kind]
+      end
+
+      def []=(kind, value)
+        valid_kind?(kind)
+        options[kind] = value
+      end
+
+      def check_type(context, types=[:return])
+        relevant_types = types.map { |type| self[type] }.reject(&:nil?)
+        relevant_types = relevant_types.map { |type| type.stack_jump? ? type.wrapped_type : type }
+        relevant_types = relevant_types.map { |type| type.check_type(context) }
+        relevant_types.max rescue relevant_types.reduce { |type_a, type_b| type_a.union(type_b) }
+      end
+
+      # This compatible function is to use the normal wrapped type in regular comparisons
+      def compatible?(other_type, relation = :lt)
+        (options[:normal] || TyUnit.new(node)).compatible?(other_type, relation)
+      end
+
+      # This compatible function is to build the comparison in conditional terms
+      def compatible_either?(other_type)
+        if other_type.either? # either vs either
+          kinds.each do |kind|
+            check_jump_kind(kind, other_type[kind])
+          end
+          check_normal_kind(other_type[:normal])
+        elsif other_type.stack_jump? # either vs jump
+          check_jump_kind(other_type.jump_kind, other_type)
+        else # either vs normal flow
+          check_normal_kind(other_type)
+        end
+        self
+      end
+
+      def to_s
+        vals = options.to_a.reject {|(k,v)| v.nil? }.map{ |k,v| "#{k}:#{v}" }.join(" | ")
+        "Either[#{vals}]"
+      end
+
+      def apply_bindings(bindings_map)
+        all_kinds.each do |kind|
+          if self[kind]
+            if self[kind].is_a?(Polymorphism::TypeVariable)
+              self[kind].apply_bindings(bindings_map)
+              self[kind] = self[kind].bound if self[kind].bound
+            elsif self[kind].is_a?(TyGenericSingletonObject) || self[kind].is_a?(TyGenericObject)
+              self[kind].apply_bindings(bindings_map)
+            end
+          end
+        end
+        self
+      end
+
+      private
+
+      def check_jump_kind(kind, other_type)
+        if self[kind].nil? && other_type
+          self[kind] = other_type
+        elsif self[kind] && other_type
+          max_type = max(self[kind].wrapped_type, other_type.wrapped_type)
+          self[kind] = TyStackJump.new(kind, max_type)
+        end
+      end
+
+      def check_normal_kind(other_type)
+        self[:normal] = max(self[:normal], other_type)
+      end
+
+      def max(type_a, type_b)
+        return (type_a || type_b) if type_a.nil? || type_b.nil?
+        return type_b if type_a.is_a?(Types::TyDynamic) || type_a.is_a?(Types::TyDynamicFunction)
+        return type_a if type_b.is_a?(Types::TyDynamic) || type_b.is_a?(Types::TyDynamicFunction)
+        return type_b if type_a.is_a?(Types::TyError)
+        return type_a if type_b.is_a?(Types::TyError)
+
+        type_vars = [type_a, type_b].select { |type| type.is_a?(Polymorphism::TypeVariable) }
+        if type_vars.count == 2
+          type_vars[0].compatible?(type_vars[1], :lt)
+          type_vars[1].compatible?(type_vars[0], :lt)
+          type_vars[0]
+        elsif type_vars.count == 1
+          type_var = type_vars.first
+          non_type_var = ([type_a, type_b] - type_vars).first
+          type_var.compatible?(non_type_var, :gt)
+          type_var
+        else
+          begin
+            [type_a, type_b].max
+          rescue Exception => ex
+            type_a.union(type_b)
+          end
+        end
+      end
+
+      def valid_kind?(kind)
+        unless kind == :normal || kinds.include?(kind)
+          fail Exception, "Invalid kind of either type #{kind}"
+        end
+      end
+    end
+  end
+end

data/lib/typed/types/ty_error.rb

@@ -0,0 +1,18 @@
+module TypedRb
+  module Types
+    class TyError < Type
+      def initialize(node = nil)
+        super(node)
+      end
+
+      def to_s
+        'error'
+      end
+
+      def compatible?(_relation, _other_type = :lt)
+        true
+      end
+
+    end
+  end
+end

data/lib/typed/types/ty_existential_type.rb

@@ -0,0 +1,22 @@
+require_relative 'ty_object'
+
+module TypedRb
+  module Types
+    class TyExistentialType < TyObject
+      attr_accessor :local_typing_context, :self_variable
+
+      def initialize(ruby_type, node = nil)
+        super(ruby_type, node)
+      end
+
+      def check_inclusion(self_type)
+        cloned_context, _ = local_typing_context.clone(:module_self)
+        Types::TypingContext.with_context(cloned_context) do
+          context_self_type = Types::TypingContext.type_variable_for(ruby_type, :module_self, [ruby_type])
+          context_self_type.compatible?(self_type, :lt)
+          Types::Polymorphism::Unification.new(Types::TypingContext.all_constraints).run(false)
+        end
+      end
+    end
+  end
+end

data/lib/typed/types/ty_function.rb

@@ -0,0 +1,144 @@
+module TypedRb
+  module Types
+    class TyFunction < Type
+      include Comparable
+
+      attr_accessor :from, :to, :parameters_info, :block_type, :arity, :min_arity
+      attr_writer :name
+
+      def initialize(from, to, parameters_info = nil, node = nil)
+        super(node)
+        @from            = from.is_a?(Array) ? from : [from]
+        @to              = to
+        @parameters_info = parameters_info
+        if @parameters_info.nil?
+          @parameters_info = @from.map { |type| [:req, type] }
+        end
+        @arity           = parse_function_arity
+        @min_arity       = parse_min_function_arity
+        @block_type      = nil
+      end
+
+      def with_block_type(type)
+        @block_type = type
+        self
+      end
+
+      def arg_compatible?(num_args)
+        num_args >= min_arity && (arity == Float::INFINITY || arity == num_args)
+      end
+
+      def generic?
+        false
+      end
+
+      def dynamic?
+        false
+      end
+
+      def to_s
+        args = @from.map(&:to_s).join(', ')
+        args = "#{args}, &#{block_type}" if block_type
+        "(#{args} -> #{@to})"
+      end
+
+      def name
+        @name || 'lambda'
+      end
+
+      def check_args_application(actual_arguments, context)
+        parameters_info.each_with_index do |(require_info, arg_name), index|
+          actual_argument = actual_arguments[index]
+          from_type = from[index]
+          if actual_argument.nil? && require_info != :opt
+            error_msg = "Type error checking function '#{name}': Missing mandatory argument #{arg_name} in #{receiver_type}##{message}"
+            fail TypeCheckError.new(error_msg, node)
+          else
+            unless actual_argument.nil? # opt if this is nil
+              actual_argument_type = actual_argument.check_type(context)
+              unless actual_argument_type.compatible?(from_type, :lt)
+                error_message = "Type error checking function '#{name}': #{error_message} #{from_type} expected, #{argument_type} found"
+                fail TypeCheckError.new(error_message, node)
+              end
+            end
+          end
+        end
+        self
+      end
+
+      # (S1 -> S2) < (T1 -> T2) => T1 < S1 && S2 < T2
+      # Contravariant in the input, covariant in the output
+      def compatible?(other_type, relation = :lt)
+        if other_type.is_a?(TyGenericFunction)
+          other_type.compatible?(self, relation == :lt ? :gt : :lt)
+        elsif other_type.is_a?(TyFunction)
+          other_from = deconstruct_from_arguments(other_type)
+          from.each_with_index do |arg, i|
+            other_arg = other_from[i]
+            return false unless arg.compatible?(other_arg, :gt)
+          end
+          return false unless to.compatible?(other_type.to, :lt)
+        else
+          fail TypeCheckError.new("Type error checking function '#{name}': Comparing function type with no function type")
+        end
+        true
+      end
+
+      def deconstruct_from_arguments(other_type)
+        if from.size == other_type.from.size
+          other_type.from
+        elsif from.size > 1 && other_type.from.size == 1 && other_type.from.first.ruby_type.ancestors.include?(Pair)
+          other_type.from.first.type_vars(recursive: false)
+        elsif from.size > 1 && other_type.from.size == 1 && other_type.from.first.ruby_type.ancestors.include?(Array)
+          other_type.from.first.type_vars(recursive: false) * from.size
+        else
+          other_type.from
+        end
+      end
+
+      def apply_bindings(bindings_map)
+        from.each_with_index do |from_type, i|
+          if from_type.is_a?(Polymorphism::TypeVariable)
+            from_type.apply_bindings(bindings_map)
+            from[i] = from_type.bound if from_type.bound
+          elsif from_type.is_a?(TyGenericSingletonObject) || from_type.is_a?(TyGenericObject)
+            from_type.apply_bindings(bindings_map)
+          end
+        end
+
+        if to.is_a?(Polymorphism::TypeVariable)
+          @to = to.apply_bindings(bindings_map)
+          @to = to.bound if to.bound
+        elsif to.respond_to?(:apply_bindings)
+          @to = to.apply_bindings(bindings_map)
+        end
+
+        block_type.apply_bindings(bindings_map) if block_type && block_type.generic?
+        self
+      end
+
+      def <=>(other)
+        if other.is_a?(TyFunction)
+          # TODO: implement!
+          raise 'Non implemented yet'
+        else
+          TyObject.new(Method, node) <=> other
+        end
+      end
+
+
+      protected
+
+      def parse_function_arity
+        return Float::INFINITY if parameters_info.detect { |arg| arg.is_a?(Hash) && arg[:kind] == :rest }
+        parameters_info.reject { |arg| arg.is_a?(Hash) && arg[:kind] == :block_arg }.count
+      end
+
+      def parse_min_function_arity
+        parameters_info.select do |arg|
+          !(arg.is_a?(Hash) && (arg[:kind] == :rest || arg[:kind] == :block_arg ))
+        end.count
+      end
+    end
+  end
+end

data/lib/typed/types/ty_generic_function.rb

@@ -0,0 +1,115 @@
+module TypedRb
+  module Types
+    class TyGenericFunction < TyFunction
+      attr_accessor :local_typing_context
+
+      def initialize(from, to, parameters_info = nil, node = nil)
+        super(from, to, parameters_info, node)
+        @application_count = 0
+      end
+
+      def generic?
+        true
+      end
+
+      # Creates a new instance of a generic function with fresh type variables.
+      # Yields the function so new constraints can be added.
+      # Finally, it runs unification on the function typing context and returns
+      # the materialized function with the bound variables.
+      def materialize
+        TypedRb.log binding, :debug, "Materialising function '#{self}'"
+        applied_typing_context, substitutions = create_context
+        materialized_function = clone_with_substitutions(self, substitutions)
+        TypingContext.with_context(applied_typing_context) do
+          # Adding constraints for the generic vriables in the materialised function
+          yield  materialized_function
+        end
+        # got all the constraints here
+        # do something with the context -> unification? merge context?
+        unification = Polymorphism::Unification.new(applied_typing_context.all_constraints).run
+        applied_typing_context.unlink # these constraints have already been satisfied
+        materialized_function.apply_bindings(unification.bindings_map)
+      end
+
+      def free_type_variables(klass)
+        return type_variables if klass == :main
+        class_type = Runtime::TypeParser.parse_singleton_object_type(klass.name)
+        if class_type.generic?
+          type_variables.reject do |type_var|
+            class_type.type_vars.detect { |class_type_var| class_type_var.variable == type_var.variable }
+          end
+        else
+          type_variables
+        end
+      end
+
+      def check_args_application(actual_arguments, context)
+        if @local_typing_context.kind != :lambda
+          super(actual_arguments, context)
+        else
+          materialize do |materialized_function|
+            materialized_function.check_args_application(actual_arguments, context)
+          end
+        end
+      end
+
+      def compatible?(other_type, relation = :lt)
+        materialize do |materialized_function|
+          materialized_function.compatible?(other_type, relation)
+        end
+      end
+
+      protected
+
+      def create_context
+        @application_count += 1
+        @local_typing_context.clone(:method)
+      end
+
+      def clone_with_substitutions(function, substitutions)
+        # var types coming from a generic method, not a generic type will be nil
+        materialized_from = function.from.map do |from_var|
+          if from_var.is_a?(Polymorphism::TypeVariable)
+            substitutions[from_var.variable] || from_var.clone
+          elsif from_var.is_a?(TyGenericSingletonObject) || from_var.is_a?(TyGenericObject)
+            from_var.send(:clone_with_substitutions, substitutions)
+          else
+            from_var
+          end
+        end
+        to_var = function.to
+        materialized_to = if to_var.is_a?(Polymorphism::TypeVariable)
+                            substitutions[to_var.variable] || to_var.clone
+                          elsif to_var.is_a?(TyGenericSingletonObject) || to_var.is_a?(TyGenericObject)
+                            to_var.send(:clone_with_substitutions, substitutions)
+                          else
+                            to_var
+                          end
+        materialized_function = TyFunction.new(materialized_from, materialized_to, parameters_info, node)
+        materialized_function.name = function.name
+        materialized_function.block_type = clone_with_substitutions(function.block_type, substitutions) if function.block_type
+        materialized_function
+      end
+
+      def type_variables
+        vars = (from + [to]).map do |arg|
+          if arg.is_a?(Polymorphism::TypeVariable) && arg.bound_to_generic?
+            arg.bound.type_vars
+          elsif arg.is_a?(Polymorphism::TypeVariable)
+            arg
+          elsif arg.generic?
+            arg.type_vars
+          end
+        end
+        vars = vars.flatten.compact
+
+        vars += block_type.type_variables if block_type && block_type.generic?
+
+        # vars.each_with_object({}) do |type_var, acc|
+        #   acc[type_var.variable] = type_var
+        # end.values
+        vars
+      end
+    end
+  end
+end

data/lib/typed/types/ty_generic_object.rb

@@ -0,0 +1,180 @@
+require_relative 'ty_object'
+require_relative 'polymorphism/generic_comparisons'
+require_relative 'polymorphism/generic_variables'
+module TypedRb
+  module Types
+    class TyGenericObject < TyObject
+      include Polymorphism::GenericComparisons
+      include Polymorphism::GenericVariables
+
+      def initialize(ruby_type, type_vars, node = nil)
+        super(ruby_type, node)
+        @type_vars = type_vars
+      end
+
+      # This object has concrete type parameters
+      # The generic Function we retrieve from the registry might be generic
+      # If it is generic we apply the bound parameters and we obtain a concrete function type
+      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
+          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}"
+          target_class = BasicObject::TypeRegistry.find_generic_type(function_klass_type)
+          materialize_super_type_found_function(message, num_args, block, target_class, type_vars)
+        else
+          TypedRb.log binding, :debug, "Found message '#{message}', generic function: #{function_type}"
+          materialized_function = materialize_found_function(function_type)
+          TypedRb.log binding, :debug, "Found message '#{message}', materialized generic function: #{materialized_function}"
+          [function_klass_type, materialized_function]
+        end
+      end
+
+      def generic?
+        true
+      end
+
+      def materialize_found_function(function_type)
+        return function_type unless function_type.generic?
+        from_args = function_type.from.map { |arg| materialize_found_function_arg(arg) }
+        to_arg = materialize_found_function_arg(function_type.to)
+        if function_type.block_type
+          materialized_block_type = materialize_found_function(function_type.block_type)
+        end
+
+        generic_function = (from_args + [to_arg, materialized_block_type]).any? do |arg|
+          arg.is_a?(Polymorphism::TypeVariable) ||
+          (arg.respond_to?(:generic?) && arg.generic?)
+        end
+
+        if generic_function
+          materialized_function = TyGenericFunction.new(from_args, to_arg, function_type.parameters_info, node)
+          materialized_function.local_typing_context = function_type.local_typing_context
+        else
+          materialized_function = TyFunction.new(from_args, to_arg, function_type.parameters_info, node)
+        end
+
+        materialized_function.with_block_type(materialized_block_type)
+      end
+
+      def materialize_super_type_found_function(message, num_args, block,
+                                                super_type,
+                                                super_type_vars)
+        super_type_materialization_args = parse_super_type_materialization_args(super_type_vars)
+        # we build the concrete type for the arguments based in the subclass bindings and the
+        # super type parsed value
+        materialized_super_type_in_context = super_type.materialize(super_type_materialization_args).type_vars(recursive: false)
+        # Now we check if the parsed type is valid  provided the constraints of the super class
+        super_type_generic_object = BasicObject::TypeRegistry.find_generic_type(super_type.ruby_type)
+        materialized_super_type = super_type_generic_object.materialize(materialized_super_type_in_context)
+
+        # materialized_super_type.type_vars = super_type.type_vars # ...
+        materialized_super_type.as_object_type.find_function_type(message, num_args, block)
+      end
+
+      def parse_super_type_materialization_args(super_type_vars)
+        super_type_vars.map do |super_type_var|
+          parse_super_type_materialization_arg(super_type_var)
+        end
+      end
+
+      def parse_super_type_materialization_arg(super_type_var)
+        return super_type_var if super_type_var.bound
+        found_matching_var = type_vars.detect do |var|
+          var_name = var.name.split(':').last
+          super_type_var.name.index(var_name)
+        end
+        if found_matching_var
+          base_matching_var = found_matching_var.dup
+          base_matching_var.name = super_type_var.name
+          base_matching_var.variable = super_type_var.variable
+          base_matching_var
+        else
+          fail TypedRb::TypeCheckError,
+               "Error materializing super type annotation for variable #{generic_singleton_object.ruby_type} '#{super_type_var.split(':').last}' not found in base class #{ruby_type}"
+        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)
+      end
+
+      def materialize_found_function_arg(arg)
+        if arg.is_a?(Polymorphism::TypeVariable)
+          matching_var = generic_type_var_to_applied_type_var(arg)
+
+          # if matching_var && matching_var.wildcard? && matching_var.lower_bound
+          #  matching_var.lower_bound
+          # elsif matching_var
+          # WILDCARD
+          if matching_var
+            # Type variables and generic methods => function will still be generic
+            (matching_var.is_a?(Polymorphism::TypeVariable) && matching_var.bound) || matching_var
+          else
+            # generic_function = true
+            # TyUnboundType.new(matching_var.variable, :lower_bound)
+            # fail TypeCheckError, "Cannot find matching type var for #{arg.variable} instantiating #{self}", arg.node
+            # method generic var?
+            arg
+          end
+        elsif arg.is_a?(TyGenericSingletonObject)
+          arg.materialize_with_type_vars(type_vars, :lower_bound).as_object_type
+        else
+          arg
+        end
+      end
+
+      def to_s
+        base_string = super
+        var_types_strings = @type_vars.map do |var_type|
+          if var_type.respond_to?(:bound) && var_type.bound
+            # "[#{var_type.variable} <= #{var_type.bound}]"
+            "[#{var_type.bound}]"
+          else
+            "[#{var_type}]"
+          end
+        end
+        "#{base_string}#{var_types_strings.join}"
+      end
+
+      def clone_with_substitutions(substitutions)
+        materialized_type_vars = type_vars(recursive: false).map do |type_var|
+          if type_var.is_a?(Polymorphism::TypeVariable)
+            substitutions[type_var.variable] || type_var.clone
+          elsif type_var.is_a?(TyGenericSingletonObject) || type_var.is_a?(TyGenericObject)
+            type_var.clone_with_substitutions(substitutions)
+          else
+            type_var
+          end
+        end
+        self.class.new(ruby_type, materialized_type_vars, node)
+      end
+
+      def apply_bindings(bindings_map)
+        type_vars.each_with_index do |var, i|
+          if var.is_a?(Polymorphism::TypeVariable)
+            var.apply_bindings(bindings_map)
+            type_vars[i] = var.bound if var.bound && var.bound.is_a?(Polymorphism::TypeVariable)
+          elsif var.is_a?(TyGenericSingletonObject) || var.is_a?(TyGenericObject)
+            var.apply_bindings(bindings_map)
+          end
+        end
+        self
+      end
+
+      def generic_singleton_object
+        @generic_singleton_object ||= BasicObject::TypeRegistry.find_generic_type(ruby_type)
+      end
+
+      def generic_type_var_to_applied_type_var(type_var)
+        i = TypeRegistry.find_generic_type(ruby_type).type_vars.find_index { |generic_type_var| generic_type_var.variable == type_var.variable }
+        i && type_vars[i]
+      end
+    end
+  end
+end