typed.rb 0.0.11

data/lib/typed/types/ty_generic_singleton_object.rb

@@ -0,0 +1,238 @@
+require_relative 'ty_singleton_object'
+require_relative 'polymorphism/generic_comparisons'
+require_relative 'polymorphism/generic_variables'
+
+module TypedRb
+  module Types
+    class TyGenericSingletonObject < TySingletonObject
+      include Polymorphism::GenericComparisons
+      include Polymorphism::GenericVariables
+
+      attr_accessor :local_typing_context, :super_type
+
+      def initialize(ruby_type, type_vars, super_type = nil, node = nil)
+        super(ruby_type, node)
+        @super_type = super_type
+        @type_vars = type_vars
+        @application_count = 0
+      end
+
+      def materialize_with_type_vars(type_vars, bound_type)
+        TypedRb.log binding, :debug, "Materialising generic singleton object with type vars '#{self}' <= #{type_vars.map(&:to_s).join(',')} :: #{bound_type}"
+        bound_type_vars = self.type_vars.map do |type_var|
+          maybe_class_bound = type_vars.detect do |bound_type_var|
+            type_var.variable == bound_type_var.variable
+          end
+          if maybe_class_bound.nil?
+            # it has to be method generic variable
+            type_var
+          else
+            maybe_class_bound
+          end
+        end
+        materialize(bound_type_vars.map { |bound_type_var| bound_type_var.send(bound_type) })
+      end
+
+      def self_materialize
+        TypedRb.log binding, :debug, "Materialising self for generic singleton object '#{self}'"
+        BasicObject::TypeRegistry.find_generic_type(ruby_type).materialize(type_vars)
+      end
+
+      # materialize will be invoked by the logic handling invocations like:
+      # ts 'MyClass[X][Y]'
+      # class MyClass
+      #  ...
+      # end
+      # MyClass.(TypeArg1, TypeArg2)  -> make X<TypeArg1, Y<TypeArg2, X>TypeArg1, X>TypeArg2
+      # MyClass.(TypeArg1, TypeArg2)  -> Materialize here > make X<TypeArg1, Y<TypeArg2 > Unification
+      def materialize(actual_arguments)
+        TypedRb.log binding, :debug, "Materialising generic singleton object '#{self}' with args [#{actual_arguments.map(&:to_s).join(',')}]"
+        # This can happen when we're dealing with a generic singleton object that has only been
+        # annotated but we don't have the annotated implementation. e.g. Array[T]
+        # We need to provide a default local_type_context based on the upper bounds provided in the
+        # type annotation.
+        compute_minimal_typing_context if @local_typing_context.nil?
+
+        applied_typing_context, substitutions = @local_typing_context.clone(:class)
+        fresh_vars_generic_type = clone_with_substitutions(substitutions)
+        TypingContext.with_context(applied_typing_context) do
+          # Appy constraints for application of Type args
+          apply_type_arguments(fresh_vars_generic_type, actual_arguments)
+        end
+        # got all the constraints here
+        # do something with the context -> unification? merge context?
+        # applied_typing_context.all_constraints.each{|(l,t,r)| puts "#{l} #{t} #{r}" }
+        unification = Polymorphism::Unification.new(applied_typing_context.all_constraints).run
+        applied_typing_context.unlink # these constraints have already been satisfied
+        # - Create a new ty_generic_object for the  unified types
+        # - Apply the unified types to all the methods in the class/instance
+        #   - this can be dynamically done with the right implementation of find_function_type
+        # - Make the class available for the type checking system, so it can be found when
+        #   - this can be done, just returning the new ty_singleton_object with the unified types
+        #   - messages will be redirected to that instance and find_function_type/ find_var_type / as_object
+        #     will handle the mesage
+        # - looking for messages at the instance level
+        #   - this can be accomplished with the overloading version of as_object_type, that will return
+        #     an instance of a new class ty_generic_object with overloaded versions of find_function_type /find_var_type
+        ########################
+        fresh_vars_generic_type.apply_bindings(unification.bindings_map)
+      end
+
+      # TODO: We do need this for cases like Array.(Int).class_method
+
+      # def find_function_type(message)
+      #   function_type = BasicObject::TypeRegistry.find(:class, ruby_type, message)
+      #   replace_bound_type_vars(function_type, type_vars)
+      # end
+
+      #          def find_function_type(message)
+      #            BasicObject::TypeRegistry.find(:class, ruby_type, message)
+      #          end
+      #
+      #          def find_var_type(var)
+      #            var_type = BasicObject::TypeRegistry.find(:class_variable, ruby_type, var)
+      #            if var_type
+      #              var_type
+      #            else
+      #              Types::TypingContext.type_variable_for(:class_variable, var, hierarchy)
+      #            end
+      #          end
+
+      def as_object_type
+        # this should only be used to check the body type of this
+        # class. The variables are going to be unbound.
+        # This is also used in instantiation of the generic object.
+        TyGenericObject.new(ruby_type, @type_vars)
+      end
+
+      def compute_minimal_typing_context
+        Model::TmClass.with_fresh_bindings(self, nil, node)
+      end
+
+      def generic?
+        true
+      end
+
+      def apply_bindings(bindings_map)
+        type_vars(recursive: false).each_with_index do |var, _i|
+          if var.is_a?(Polymorphism::TypeVariable) && var.bound_to_generic?
+            var.bind(var.bound.apply_bindings(bindings_map))
+          elsif var.is_a?(Polymorphism::TypeVariable)
+            var.apply_bindings(bindings_map)
+          elsif var.is_a?(TyGenericSingletonObject) || var.is_a?(TyGenericObject)
+            var.apply_bindings(bindings_map)
+          end
+        end
+        self
+      end
+
+      def clone
+        cloned_type_vars = type_vars.map(&:clone)
+        TyGenericSingletonObject.new(ruby_type, cloned_type_vars, super_type, node)
+      end
+
+      def to_s
+        base_string = super
+        var_types_strings = @type_vars.map do |var_type|
+          if !var_type.is_a?(Polymorphism::TypeVariable)
+            "[#{var_type}]"
+          elsif var_type.bound && var_type.bound.is_a?(Polymorphism::TypeVariable)
+            "[#{var_type.variable} <= #{var_type.bound.bound || var_type.bound.variable}]"
+          else
+            "[#{var_type.bound || var_type.variable}]"
+          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) && type_var.bound_to_generic?
+            new_type_var = Polymorphism::TypeVariable.new(type_var.variable, node: type_var.node, gen_name: false)
+            new_type_var.to_wildcard! if type_var.wildcard?
+            bound = type_var.bound.clone_with_substitutions(substitutions)
+            new_type_var.bind(bound)
+            new_type_var.upper_bound = bound if type_var.upper_bound
+            new_type_var.lower_bound = bound if type_var.lower_bound
+            new_type_var
+          elsif 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, super_type, node)
+      end
+
+      protected
+
+      def apply_type_arguments(fresh_vars_generic_type, actual_arguments)
+        fresh_vars_generic_type.type_vars.each_with_index do |type_var, i|
+          if type_var.bound.is_a?(TyGenericSingletonObject)
+            type_var.bind(apply_type_arguments_recursively(type_var.bound, actual_arguments))
+          else
+            apply_type_argument(actual_arguments[i], type_var)
+          end
+        end
+      end
+
+      def apply_type_argument(argument, type_var)
+        if argument.is_a?(Polymorphism::TypeVariable)
+          if argument.wildcard?
+            # Wild card type
+            # If the type is T =:= E < Type1 or E > Type1 only that constraint should be added
+            { :lt => :upper_bound, :gt => :lower_bound }.each do |relation, bound|
+              if argument.send(bound)
+                value = if argument.send(bound).is_a?(TyGenericSingletonObject)
+                          argument.send(bound).clone # .self_materialize
+                        else
+                          argument.send(bound)
+                        end
+                type_var.compatible?(value, relation)
+              end
+            end
+            type_var.to_wildcard! # WILD CARD
+          elsif argument.bound # var type with a particular value
+            argument = argument.bound
+            if argument.is_a?(TyGenericSingletonObject)
+              argument = argument.clone # .self_materialize
+            end
+            # This is only for matches T =:= Type1 -> T < Type1, T > Type1
+            fail Types::UncomparableTypes.new(type_var, argument) unless type_var.compatible?(argument, :lt)
+            fail Types::UncomparableTypes.new(type_var, argument) unless type_var.compatible?(argument, :gt)
+          else
+            # Type variable
+            type_var.bound = argument
+            type_var.lower_bound = argument
+            type_var.upper_bound = argument
+          end
+        else
+          if argument.is_a?(TyGenericSingletonObject)
+            argument = argument.clone # .self_materialize
+          end
+          # This is only for matches T =:= Type1 -> T < Type1, T > Type1
+          fail Types::UncomparableTypes.new(type_var, argument) unless type_var.compatible?(argument, :lt)
+          fail Types::UncomparableTypes.new(type_var, argument) unless type_var.compatible?(argument, :gt)
+        end
+      end
+
+      def apply_type_arguments_recursively(generic_type_bound, actual_arguments)
+        arg_names = actual_arguments_hash(actual_arguments)
+        recursive_actual_arguments = generic_type_bound.type_vars.map do |type_var|
+          arg_names[type_var.variable] || fail("Unbound type variable #{type_var.variable} for recursive generic type #{generic_type_bound}")
+        end
+        generic_type_bound.materialize(recursive_actual_arguments)
+      end
+
+      def actual_arguments_hash(actual_arguments)
+        acc = {}
+        type_vars.each_with_index do |type_var, i|
+          acc[type_var.variable] = actual_arguments[i]
+        end
+        acc
+      end
+    end
+  end
+end

data/lib/typed/types/ty_object.rb

@@ -0,0 +1,256 @@
+module TypedRb
+  module Types
+    class UncomparableTypes < TypeCheckError
+      attr_reader :from, :to
+      def initialize(from, to, node = nil)
+        nodes = [from.node, to.node].compact
+        if node
+          super("Cannot compare types #{from} <=> #{to}", node)
+        elsif nodes.size == 2
+          super("Cannot compare types #{from} <=> #{to}", nodes)
+        elsif nodes.size == 1
+          super("Cannot compare types #{from} <=> #{to}", nodes.first)
+        else
+          super("Cannot compare types #{from} <=> #{to}", nil)
+        end
+      end
+    end
+
+    class TyObject < Type
+      include Comparable
+
+      attr_reader :hierarchy, :classes, :modules, :ruby_type, :with_ruby_type
+
+      def initialize(ruby_type, node = nil, classes = [], modules = [])
+        super(node)
+        if ruby_type
+          @ruby_type = ruby_type
+          @hierarchy = ruby_type.ancestors
+          @classes = @hierarchy.select { |klass| klass.instance_of?(Class) }
+          @modules = @hierarchy.select { |klass| klass.instance_of?(Module) }
+          @with_ruby_type = true
+        else
+          @ruby_type = classes.first
+          @classes = classes
+          @modules = modules
+          @hierarchy = (modules + classes).uniq
+          @with_ruby_type = false
+        end
+      end
+
+      def dynamic?
+        false
+      end
+
+      def generic?
+        false
+      end
+
+      def singleton?
+        false
+      end
+
+      def either?
+        false
+      end
+
+      def check_type(_context)
+        self
+      end
+
+      def compatible?(other_type, relation = :lt)
+        if other_type.is_a?(TyObject)
+          begin
+            if relation == :gt
+              self >= other_type
+            elsif relation == :lt
+              self <= other_type
+            end
+          rescue ArgumentError
+            raise UncomparableTypes.new(self, other_type)
+          end
+        else
+          other_type.compatible?(self, relation == :lt ? :gt : :lt)
+        end
+      end
+
+      def as_object_type
+        self
+      end
+
+      # Non generic type, the function is alwasy going to be concrete
+      def find_function_type(message, num_args, block)
+        klass, function = find_function_type_in_hierarchy(:instance, message, num_args, block)
+        if klass != ruby_type && function.generic?
+          generic_type = ::BasicObject::TypeRegistry.find_generic_type(klass)
+          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)
+          else
+            fail "Undeclared generic type variables for #{ruby_type} super class/mix-in #{klass.class} #{klass}##{message}, please add a 'super' type annotation"
+          end
+        else
+          return klass, function
+        end
+      end
+
+      def find_var_type(var, _type = ruby_type)
+        # This is only in case the type has been explicitely declared
+        var_type = BasicObject::TypeRegistry.find(:instance_variable, ruby_type, var)
+        if var_type
+          var_type
+        else
+          # If no types has been declared, we'll find a var type in the registry
+          var_type = Types::TypingContext.type_variable_for(:instance_variable, var, hierarchy)
+          var_type.node = node
+          var_type
+        end
+      end
+
+      def find_function_type_in_hierarchy(kind, message, num_args, block)
+        initial_value = select_matching_function_in_class(@hierarchy.first, kind, message, num_args, block)
+        @hierarchy.drop(1).inject([@hierarchy.first, initial_value]) do |(klass, acc), type|
+          if acc.nil? || acc.is_a?(TyDynamicFunction)
+            maybe_function = select_matching_function_in_class(type, kind, message, num_args, block)
+            [type, (maybe_function || TyDynamicFunction.new(klass, message))]
+          else
+            [klass, acc]
+          end
+        end
+      end
+
+      def resolve_ruby_method(message)
+        @ruby_type.instance_method(message)
+      end
+
+      def to_s
+        if @with_ruby_type
+          @ruby_type.name
+        else
+          "#{@classes.first} with [#{@modules.map(&:to_s).join(',')}]"
+        end
+      end
+
+      def union(other_type, node = nil)
+        smaller_common_class = (classes & other_type.classes).first
+        TyObject.new(smaller_common_class, (node || self.node || other_type.node))
+      end
+
+      def <=>(other)
+        if other.is_a?(TyObject)
+          if other.with_ruby_type
+            if with_ruby_type
+              compare_ruby_ruby(other)
+            else
+              compare_with_union(other)
+            end
+          else
+            if with_ruby_type
+              compare_with_union(other)
+            else
+              compare_with_union(other)
+            end
+          end
+        #else
+        #  fail UncomparableTypes.new(self, other)
+        end
+      end
+
+      def join(other)
+        common_classes = classes & other.classes
+        common_modules = modules & other.modules
+        if common_modules.size == 1
+          TyObject.new(common_modules.first, (node || other.node))
+        else
+          TyObject.new(nil, (node || other.node), common_classes, common_modules)
+        end
+      end
+
+      protected
+
+      def compare_ruby_ruby(other)
+        if ruby_type == NilClass && other.ruby_type == NilClass
+          0
+        elsif ruby_type == NilClass
+          -1
+        elsif other.ruby_type == NilClass
+          1
+        else
+          if other.ruby_type == ruby_type
+            0
+          elsif other.hierarchy.include?(ruby_type)
+            1
+          elsif hierarchy.include?(other.ruby_type)
+            -1
+          #else
+          #  fail UncomparableTypes.new(self, other)
+          end
+        end
+      end
+
+      def compare_with_union(other)
+        all_those_modules_included = other.modules.all? { |m| hierarchy.include?(m) }
+        all_these_modules_included = modules.all? { |m| other.hierarchy.include?(m) }
+
+        if other.ruby_type == ruby_type && all_these_modules_included && all_these_modules_included
+          0
+        elsif other.hierarchy.include?(ruby_type) && all_these_modules_included && !all_those_modules_included
+          1
+        elsif hierarchy.include?(ruby_type) && all_those_modules_included && !all_these_modules_included
+          -1
+        #else
+        #  fail UncomparableTypes.new(self, other)
+        end
+      end
+
+      def select_matching_function_in_class(klass, kind, message, num_args, block)
+        functions = BasicObject::TypeRegistry.find(kind, klass, message)
+        initial_values = functions.select { |fn| fn.arg_compatible?(num_args) }
+        if initial_values.count == 2 && block
+          initial_values.detect(&:block_type)
+        elsif initial_values.count == 2 && !block
+          initial_values.detect { |f| f.block_type.nil? }
+        else
+          initial_values.first
+        end
+      end
+    end
+
+    class TyInteger < TyObject
+      def initialize(node = nil)
+        super(Integer, node)
+      end
+    end
+
+    class TyFloat < TyObject
+      def initialize(node = nil)
+        super(Float, node)
+      end
+    end
+
+    class TyString < TyObject
+      def initialize(node = nil)
+        super(String, node)
+      end
+    end
+
+    class TyUnit < TyObject
+      def initialize(node = nil)
+        super(NilClass, node)
+      end
+    end
+
+    class TySymbol < TyObject
+      def initialize(node = nil)
+        super(Symbol, node)
+      end
+    end
+
+    class TyRegexp < TyObject
+      def initialize(node = nil)
+        super(Regexp, node)
+      end
+    end
+  end
+end

data/lib/typed/types/ty_singleton_object.rb

@@ -0,0 +1,78 @@
+module TypedRb
+  module Types
+    class TySingletonObject < TyObject
+      def initialize(ruby_type, node = nil)
+        # super(ruby_type.class)
+        # @ruby_type = ruby_type
+        super(ruby_type, node)
+      end
+
+      # No generic type, function will always be concrete
+      def find_function_type(message, num_args, block)
+        maybe_function = select_matching_function_in_class(ruby_type, :class, message, num_args, block)
+        if maybe_function && !maybe_function.dynamic?
+          [ruby_type, maybe_function]
+        else
+          # This object is a class, we need to look in the hierarhcy of the meta-class
+          find_function_type_in_metaclass_hierarchy(message, num_args, block)
+        end
+      end
+
+      def find_function_type_in_metaclass_hierarchy(message, num_args, block)
+        hierarchy = Class.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)
+            maybe_function = select_matching_function_in_class(type, :instance, message, num_args, block)
+            [type, (maybe_function || TyDynamicFunction.new(klass, message))]
+          else
+            [klass, acc]
+          end
+        end
+      end
+
+      def find_var_type(var)
+        var_type = BasicObject::TypeRegistry.find(:class_variable, ruby_type, var)
+        if var_type
+          var_type
+        else
+          var_type = Types::TypingContext.type_variable_for(:class_variable, var, hierarchy)
+          var_type.node = node
+          var_type
+        end
+      end
+
+      def compatible?(other_type, relation = :lt)
+        if other_type.is_a?(TySingletonObject)
+          if ruby_type == Class || other_type.ruby_type == Class
+            if relation == :gt
+              Class.ancestors.include(ruby_type)
+            elsif relation == :lt
+              Class.ancestors.include?(other_type.ruby_type)
+            end
+          else
+            super(other_type, relation)
+          end
+        else
+          super(other_type, relation)
+        end
+      end
+
+      def resolve_ruby_method(message)
+        @ruby_type.singleton_method(message)
+      end
+
+      def as_object_type
+        TyObject.new(ruby_type, node)
+      end
+
+      def singleton?
+        true
+      end
+
+      def to_s
+        @ruby_type.name
+      end
+    end
+  end
+end

data/lib/typed/types/ty_stack_jump.rb

@@ -0,0 +1,44 @@
+module TypedRb
+  module Types
+    class TyStackJump < TyUnit
+      attr_reader :jump_kind, :wrapped_type
+      def initialize(jump_kind, wrapped_type, node=nil)
+        super(node)
+        @jump_kind = jump_kind
+        @wrapped_type = wrapped_type
+      end
+
+      def stack_jump?
+        true
+      end
+
+      def self.return(return_type, node = nil)
+        TyStackJump.new(:return, return_type, node)
+      end
+
+      def self.break(return_type, node = nil)
+        TyStackJump.new(:break, return_type, node)
+      end
+
+      def self.next(return_type, node = nil)
+        TyStackJump.new(:next, return_type, node)
+      end
+
+      def return?
+        jump_kind == :return
+      end
+
+      def break?
+        jump_kind == :break
+      end
+
+      def next?
+        jump_kind == :next
+      end
+
+      def to_s
+        "Jump[#{jump_kind}:#{wrapped_type}]"
+      end
+    end
+  end
+end

data/lib/typed/types/ty_top_level_object.rb

@@ -0,0 +1,38 @@
+module TypedRb
+  module Types
+    class TyTopLevelObject < TyObject
+      def initialize
+        super(TOPLEVEL_BINDING.receiver.class)
+      end
+
+      def compatible?(_other_type)
+        fail StandardError, 'invoking compatible? in the top level object'
+      end
+
+      def as_object_type
+        self
+      end
+
+      def find_function_type(message, num_args, block)
+        found_type = select_matching_function_in_class(:main, :instance, message, num_args, block)
+        if found_type && !found_type.is_a?(TyDynamicFunction)
+          [:main, found_type]
+        else
+          TyObject.new(ruby_type, node).find_function_type(message, num_args, block)
+        end
+      end
+
+      def find_var_type(var)
+        super(var, :main)
+      end
+
+      def resolve_ruby_method(message)
+        @ruby_type.method(message)
+      end
+
+      def to_s
+        'Object[\'main\']'
+      end
+    end
+  end
+end