steep-relaxed 1.9.3.3

data/lib/steep/interface/method_type.rb

@@ -0,0 +1,330 @@
+module Steep
+  module Interface
+    class MethodType
+      attr_reader :type_params
+      attr_reader :type
+      attr_reader :block
+
+      def initialize(type_params:, type:, block:)
+        @type_params = type_params
+        @type = type
+        @block = block
+      end
+
+      def ==(other)
+        other.is_a?(self.class) &&
+          other.type_params == type_params &&
+          other.type == type &&
+          other.block == block
+      end
+
+      alias eql? ==
+
+      def hash
+        type_params.hash ^ type.hash ^ block.hash
+      end
+
+      def free_variables
+        @fvs ||= Set.new.tap do |set|
+          set.merge(type.free_variables)
+          if block
+            set.merge(block.free_variables)
+          end
+          set.subtract(type_params.map(&:name))
+        end
+      end
+
+      def subst(s)
+        return self if s.empty?
+        return self if each_type.none? {|t| s.apply?(t) }
+
+        if type_params.any? {|param| s.key?(param.name) }
+          s_ = s.except(type_params.map(&:name))
+        else
+          s_ = s
+        end
+
+        ty = type.subst(s_)
+        bl = block&.subst(s_)
+
+        if ty == type && bl == block
+          self
+        else
+          self.class.new(type_params: type_params, type: ty, block: bl)
+        end
+      end
+
+      def each_type(&block)
+        if block
+          type.each_type(&block)
+          if block()
+            yield(block().self_type) if block().self_type
+            block().type.params&.each_type(&block)
+            yield(block().type.return_type)
+          end
+        else
+          enum_for :each_type
+        end
+      end
+
+      def instantiate(s)
+        self.class.new(type_params: [],
+                       type: type.subst(s),
+                       block: block&.subst(s))
+      end
+
+      def with(type_params: self.type_params, type: self.type, block: self.block)
+        self.class.new(type_params: type_params,
+                       type: type,
+                       block: block)
+      end
+
+      def to_s
+        type_params = !self.type_params.empty? ? "[#{self.type_params.join(", ")}] " : ""
+        params = type.params.to_s
+        return_type = type.return_type
+        block = self.block ? " #{self.block}" : ""
+
+        "#{type_params}#{params}#{block} -> #{return_type}"
+      end
+
+      def map_type(&block)
+        self.class.new(type_params: type_params,
+                       type: type.map_type(&block),
+                       block: self.block&.yield_self {|blk| blk.map_type(&block) })
+      end
+
+      # Returns a new method type which can be used for the method implementation type of both `self` and `other`.
+      #
+      def unify_overload(other)
+        type_params_1, s1 = TypeParam.rename(self.type_params)
+        type_params_2, s2 = TypeParam.rename(other.type_params)
+        type_params = type_params_1 + type_params_2
+
+        block =
+          case
+          when (b = self.block) && (ob = other.block)
+            b.subst(s1) + ob.subst(s2)
+          when b = self.block
+            b.to_optional.subst(s1)
+          when ob = other.block
+            ob.to_optional.subst(s2)
+          end
+
+        self.class.new(
+          type_params: type_params,
+          type: Function.new(
+            params: type.params && other.type.params ? type.params.subst(s1) + other.type.params.subst(s2) : nil,
+            return_type: AST::Types::Union.build(
+              types: [type.return_type.subst(s1), other.type.return_type.subst(s2)]
+            ),
+            location: nil
+          ),
+          block: block
+        )
+      end
+
+      def +(other)
+        unify_overload(other)
+      end
+
+      def equals_modulo_type_params?(other)
+        case
+        when self.type_params.empty? && other.type_params.empty?
+          self == other
+        when self.type_params.size == other.type_params.size
+          new_names = self.type_params.map(&:name)
+
+          self_params, self_subst = TypeParam.rename(self.type_params, self.type_params.map(&:name), new_names)
+          other_params, other_subst = TypeParam.rename(other.type_params, other.type_params.map(&:name), new_names)
+
+          self_params == other_params && self.instantiate(self_subst) == other.instantiate(other_subst)
+        else
+          false
+        end
+      end
+
+      def self.union(type1, type2, check)
+        try_type_params(
+          type1,
+          type2,
+          check,
+          -> (t1, t2) { t1 | t2 },
+          -> (original, generated) { Subtyping::Relation.new(sub_type: original, super_type: generated) }
+        )
+      end
+
+      def self.intersection(type1, type2, check)
+        try_type_params(
+          type1,
+          type2,
+          check,
+          -> (t1, t2) { t1 & t2 },
+          -> (original, generated) { Subtyping::Relation.new(sub_type: generated, super_type: original) }
+        )
+      end
+
+      def self.try_type_params(type1, type2, check, generate, relation)
+        return type1 if type1.equals_modulo_type_params?(type2)
+
+        case
+        when type1.type_params.empty? && type2.type_params.empty?
+          generate[type1, type2]
+        when type1.type_params.empty?
+          if mt = generate[type1, type2.with(type_params: [])]
+            mt.with(type_params: type2.type_params)
+          end
+        when type2.type_params.empty?
+          if mt = generate[type1.with(type_params: []), type2]
+            mt.with(type_params: type1.type_params)
+          end
+        when type1.type_params.size == type2.type_params.size
+          params1, s1 = TypeParam.rename(type1.type_params)
+          params2, s2 = TypeParam.rename(type2.type_params)
+
+          type1_ = type1.instantiate(s1)
+          type2_ = type2.instantiate(s2)
+          if mt = generate[type1_, type2_]
+            check.push_variable_bounds(params1 + params2) do
+              variables = type1.type_params.map(&:name) + type2.type_params.map(&:name)
+              constraints = Subtyping::Constraints.new(unknowns: variables)
+
+              check.with_context(self_type: AST::Builtin.any_type, instance_type: AST::Builtin.any_type, class_type: AST::Builtin.any_type, constraints: constraints) do
+                result1 = check.check_method_type(:__method_on_type1, relation[type1.with(type_params: []), mt])
+                result2 = check.check_method_type(:__method_on_type2, relation[type2.with(type_params: []), mt])
+
+                if result1.success? && result2.success?
+                  unless type1.type_params.map(&:name).zip(type2.type_params.map(&:name)).all? {|pair|
+                    constraints.upper_bound(pair[0]) == constraints.upper_bound(pair[1] || raise) &&
+                       constraints.lower_bound(pair[0]) == constraints.lower_bound(pair[1] || raise)
+                  }
+                    return
+                  end
+
+                  params2_, s2_ = TypeParam.rename(type2.type_params, type2.type_params.map(&:name), type1.type_params.map(&:name))
+                  if mt_ = generate[type1.with(type_params: []), type2.instantiate(s2_)]
+                    mt_.with(
+                      type_params: type1.type_params.map.with_index {|param1, index|
+                        param2 = params2_[index] or raise
+                        ub1 = param1.upper_bound
+                        ub2 = param2.upper_bound
+
+                        case
+                        when ub1 && ub2
+                          param1.update(upper_bound: AST::Types::Union.build(types: [ub1, ub2]))
+                        when ub2
+                          param1.update(upper_bound: ub2)
+                        else
+                          param1
+                        end
+                      }
+                    )
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+
+      def |(other)
+        return self if other == self
+
+        params = self.type.params & other.type.params or return
+        block =
+          case
+          when (b = block()) && (ob = other.block)
+            self_type =
+              case
+              when (self_self = b.self_type) && (other_self = ob.self_type)
+                AST::Types::Union.build(types: [self_self, other_self])
+              when b.self_type || ob.self_type
+                AST::Types::Bot.instance
+              else
+                nil
+              end
+
+            if b.type.params && ob.type.params
+              # Return when the two block parameters are imcompatible.
+              return unless b.type.params & ob.type.params
+              block_params = b.type.params | ob.type.params or return
+            else
+              block_params = b.type.params || ob.type.params
+            end
+
+            block_return_type = AST::Types::Intersection.build(types: [b.type.return_type, ob.type.return_type])
+            block_type = Function.new(params: block_params, return_type: block_return_type, location: nil)
+
+            Block.new(
+              type: block_type,
+              optional: b.optional && ob.optional,
+              self_type: self_type
+            )
+          when (b = block()) && b.optional?
+            b
+          when other.block && other.block.optional?
+            other.block
+          when !self.block && !other.block
+            nil
+          else
+            return
+          end
+        return_type = AST::Types::Union.build(types: [self.type.return_type, other.type.return_type])
+
+        MethodType.new(
+          type_params: [],
+          type: Function.new(params: params, return_type: return_type, location: nil),
+          block: block
+        )
+      end
+
+      def &(other)
+        return self if self == other
+
+        if self.type.params && other.type.params
+          params = self.type.params | other.type.params or return
+        else
+          params = self.type.params || other.type.params
+        end
+
+        block =
+          case
+          when (b = self.block) && (ob = other.block)
+            self_type =
+              case
+              when (self_self = b.self_type) && (other_self = ob.self_type)
+                AST::Types::Intersection.build(types: [self_self, other_self])
+              when b.self_type || ob.self_type
+                AST::Types::Top.instance
+              else
+                nil
+              end
+
+            block_params = b.type.params & ob.type.params or return
+            block_return_type = AST::Types::Union.build(types: [b.type.return_type, ob.type.return_type])
+            block_type = Function.new(params: block_params, return_type: block_return_type, location: nil)
+            Block.new(
+              type: block_type,
+              optional: b.optional || ob.optional,
+              self_type: self_type
+            )
+          else
+            self.block || other.block
+          end
+
+        return_type = AST::Types::Intersection.build(types: [self.type.return_type, other.type.return_type])
+
+        MethodType.new(
+          type_params: [],
+          type: Function.new(params: params, return_type: return_type, location: nil),
+          block: block
+        )
+      end
+
+      def accept_one_arg?
+        return false if block && block.required?
+        type.accept_one_arg?
+      end
+    end
+  end
+end

data/lib/steep/interface/shape.rb

@@ -0,0 +1,239 @@
+module Steep
+  module Interface
+    class Shape
+      class MethodOverload
+        attr_reader :method_type
+
+        attr_reader :method_defs
+
+        def initialize(method_type, defs)
+          @method_type = method_type
+          @method_defs = defs.sort_by do |defn|
+            buf = +""
+
+            if loc = defn.type.location
+              buf << loc.buffer.name.to_s
+              buf << ":"
+              buf << loc.start_pos.to_s
+            end
+
+            buf
+          end
+          @method_defs.uniq!
+        end
+
+        def subst(s)
+          overload = MethodOverload.new(method_type.subst(s), [])
+          overload.method_defs.replace(method_defs)
+          overload
+        end
+
+        def method_decls(name)
+          method_defs.map do |defn|
+            type_name = defn.implemented_in || defn.defined_in
+
+            if name == :new && defn.member.is_a?(RBS::AST::Members::MethodDefinition) && defn.member.name == :initialize
+              method_name = SingletonMethodName.new(type_name: type_name, method_name: name)
+            else
+              method_name =
+                if defn.member.kind == :singleton
+                  SingletonMethodName.new(type_name: defn.defined_in, method_name: name)
+                else
+                  # Call the `self?` method an instance method, because the definition is done with instance method definition, not with singleton method
+                  InstanceMethodName.new(type_name: defn.defined_in, method_name: name)
+                end
+            end
+
+            TypeInference::MethodCall::MethodDecl.new(method_def: defn, method_name: method_name)
+          end
+        end
+      end
+
+      class Entry
+        attr_reader :method_name
+
+        def initialize(overloads: nil, private_method:, method_name:, &block)
+          @overloads = overloads
+          @generator = block
+          @private_method = private_method
+          @method_name = method_name
+        end
+
+        def force
+          unless @overloads
+            @overloads = @generator&.call
+            @generator = nil
+          end
+        end
+
+        def overloads
+          force
+          @overloads or raise
+        end
+
+        def method_types
+          overloads.map(&:method_type)
+        end
+
+        def has_method_type?
+          force
+          @overloads ? true : false
+        end
+
+        def to_s
+          if @generator
+            "<< Lazy entry >>"
+          else
+            "{ #{method_types.join(" || ")} }"
+          end
+        end
+
+        def private_method?
+          @private_method
+        end
+
+        def public_method?
+          !private_method?
+        end
+      end
+
+      class Methods
+        attr_reader :substs, :methods, :resolved_methods
+
+        include Enumerable
+
+        def initialize(substs:, methods:)
+          @substs = substs
+          @methods = methods
+          @resolved_methods = {}
+        end
+
+        def key?(name)
+          if entry = methods.fetch(name, nil)
+            entry.has_method_type?
+          else
+            false
+          end
+        end
+
+        def []=(name, entry)
+          resolved_methods[name] = nil
+          methods[name] = entry
+        end
+
+        def [](name)
+          return nil unless key?(name)
+
+          resolved_methods[name] ||= begin
+            entry = methods.fetch(name)
+            Entry.new(
+              method_name: name,
+              overloads: entry.overloads.map do |overload|
+                overload.subst(subst)
+              end,
+              private_method: entry.private_method?
+            )
+          end
+        end
+
+        def each(&block)
+          if block
+            methods.each_key do |name|
+              entry = self[name] or next
+              yield [name, entry]
+            end
+          else
+            enum_for :each
+          end
+        end
+
+        def each_name(&block)
+          if block
+            each do |name, _|
+              yield name
+            end
+          else
+            enum_for :each_name
+          end
+        end
+
+        def subst
+          @subst ||= begin
+            substs.each_with_object(Substitution.empty) do |s, ss|
+              ss.merge!(s, overwrite: true)
+            end
+          end
+        end
+
+        def push_substitution(subst)
+          Methods.new(substs: [*substs, subst], methods: methods)
+        end
+
+        def merge!(other, &block)
+          other.each do |name, entry|
+            if block && (old_entry = methods[name])
+              methods[name] = yield(name, old_entry, entry)
+            else
+              methods[name] = entry
+            end
+          end
+        end
+
+        def public_methods
+          Methods.new(
+            substs: substs,
+            methods: methods.reject {|_, entry| entry.private_method? }
+          )
+        end
+      end
+
+      attr_reader :type
+      attr_reader :methods
+
+      def initialize(type:, private:, methods: nil)
+        @type = type
+        @private = private
+        @methods = methods || Methods.new(substs: [], methods: {})
+      end
+
+      def to_s
+        "#<#{self.class.name}: type=#{type}, private?=#{@private}, methods={#{methods.each_name.sort.join(", ")}}"
+      end
+
+      def update(type: self.type, methods: self.methods)
+        _ = self.class.new(type: type, private: private?, methods: methods)
+      end
+
+      def subst(s, type: nil)
+        ty =
+          if type
+            type
+          else
+            self.type.subst(s)
+          end
+
+        Shape.new(type: ty, private: private?, methods: methods.push_substitution(s))
+      end
+
+      def private?
+        @private
+      end
+
+      def public?
+        !private?
+      end
+
+      def public_shape
+        if public?
+          self
+        else
+          @public_shape ||= Shape.new(
+            type: type,
+            private: false,
+            methods: methods.public_methods
+          )
+        end
+      end
+    end
+  end
+end