steep 1.1.1 → 1.2.0.pre.1

data/lib/steep/interface/function.rb

@@ -37,7 +37,7 @@ module Steep
               if ty == type
                 self
               else
-                self.class.new(ty)
+                _ = self.class.new(ty)
               end
             end
 
@@ -47,7 +47,7 @@ module Steep
 
             def map_type(&block)
               if block_given?
-                self.class.new(yield type)
+                _ = self.class.new(yield type)
               else
                 enum_for(:map_type)
               end
@@ -94,7 +94,7 @@ module Steep
           end
 
           def map_type(&block)
-            if block_given?
+            if block
               map {|param| param.map_type(&block) }
             else
               enum_for :map_type
@@ -123,7 +123,7 @@ module Steep
           end
 
           def each(&block)
-            if block_given?
+            if block
               yield head
               tail&.each(&block)
             else
@@ -411,11 +411,11 @@ module Steep
           end
 
           def each(&block)
-            if block_given?
+            if block
               requireds.each(&block)
               optionals.each(&block)
               if rest
-                yield nil, rest
+                yield [nil, rest]
               end
             else
               enum_for :each
@@ -433,7 +433,7 @@ module Steep
           end
 
           def map_type(&block)
-            if block_given?
+            if block
               rs = requireds.transform_values(&block)
               os = optionals.transform_values(&block)
               r = rest&.yield_self(&block)
@@ -819,7 +819,7 @@ module Steep
         end
 
         def each_type(&block)
-          if block_given?
+          if block
             positional_params&.each_type(&block)
             keyword_params.each_type(&block)
           else
@@ -842,16 +842,19 @@ module Steep
         def subst(s)
           return self if s.empty?
           return self if empty?
-          return self if free_variables.disjoint?(s.domain)
+          return self if each_type.none? {|t| s.apply?(t) }
 
-          pp = positional_params&.subst(s)
-          kp = keyword_params.subst(s)
+          pp = positional_params
+          kp = keyword_params
 
-          if positional_params == pp && keyword_params == kp
-            self
-          else
-            self.class.new(positional_params: pp, keyword_params: kp)
+          if positional_params && positional_params.each_type.any? {|t| s.apply?(t) }
+            pp = positional_params.subst(s)
           end
+          if keyword_params && keyword_params.each_type.any? {|t| s.apply?(t) }
+            kp = keyword_params.subst(s)
+          end
+
+          self.class.new(positional_params: pp, keyword_params: kp)
         end
 
         def size
@@ -950,19 +953,22 @@ module Steep
       def subst(s)
         return self if s.empty?
 
-        Function.new(
-          params: params.subst(s),
-          return_type: return_type.subst(s),
-          location: location
-        )
-      end
+        ps = params.subst(s)
+        ret = return_type.subst(s)
 
-      def each_child(&block)
-        each_type(&block)
+        if ps == params && ret == return_type
+          self
+        else
+          Function.new(
+            params: ps,
+            return_type: ret,
+            location: location
+          )
+        end
       end
 
       def each_type(&block)
-        if block_given?
+        if block
           params.each_type(&block)
           yield return_type
         else
@@ -970,6 +976,8 @@ module Steep
         end
       end
 
+      alias each_child each_type
+
       def map_type(&block)
         Function.new(
           params: params.map_type(&block),

data/lib/steep/interface/method_type.rb

@@ -32,30 +32,37 @@ module Steep
           if block
             set.merge(block.free_variables)
           end
-          set.subtract(type_params)
+          set.subtract(type_params.map(&:name))
         end
       end
 
       def subst(s)
         return self if s.empty?
-        return self if free_variables.disjoint?(s.domain)
+        return self if each_type.none? {|t| s.apply?(t) }
 
-        s_ = s.except(type_params)
+        if type_params.any? {|param| s.key?(param.name) }
+          s_ = s.except(type_params.map(&:name))
+        else
+          s_ = s
+        end
 
-        self.class.new(
-          type_params: type_params,
-          type: type.subst(s_),
-          block: block&.subst(s_),
-          method_decls: method_decls
-        )
+        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, method_decls: method_decls)
+        end
       end
 
       def each_type(&block)
-        if block_given?
+        if block
           type.each_type(&block)
-          self.block&.tap do
-            self.block.type.params.each_type(&block)
-            yield(self.block.type.return_type)
+          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
@@ -99,14 +106,15 @@ module Steep
         type_params_2, s2 = TypeParam.rename(other.type_params)
         type_params = type_params_1 + type_params_2
 
-        block = case
-                when self.block && other.block
-                  self.block.subst(s1) + other.block.subst(s2)
-                when self.block
-                  self.block.to_optional.subst(s1)
-                when other.block
-                  other.block.to_optional.subst(s2)
-                end
+        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,
@@ -126,82 +134,187 @@ module Steep
         unify_overload(other)
       end
 
-      # Returns a method type which is a super-type of both self and other.
-      #   self <: (self | other) && other <: (self | other)
-      #
-      # Returns nil if self and other are incompatible.
-      #
-      def |(other)
-        if other.type_params.empty?
-          type_params = self.type_params
+      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
-          other_params, s2 = TypeParam.rename(other.type_params)
-          other = other.instantiate(s2)
-          type_params = self.type_params + other_params
+          false
         end
+      end
 
-        params = self.type.params & other.type.params or return
-        block = case
-                when self.block && other.block
-                  block_params = self.block.type.params | other.block.type.params
-                  block_return_type = AST::Types::Intersection.build(types: [self.block.type.return_type, other.block.type.return_type])
-                  block_type = Function.new(params: block_params, return_type: block_return_type, location: nil)
-                  Block.new(
-                    type: block_type,
-                    optional: self.block.optional && other.block.optional
-                  )
-                when self.block && self.block.optional?
-                  self.block
-                when other.block && other.block.optional?
-                  other.block
-                when !self.block && !other.block
-                  nil
-                else
-                  return
+      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.new()
+              else
+                nil
+              end
+
+            # 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
+
+            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_params,
+          type_params: [],
           type: Function.new(params: params, return_type: return_type, location: nil),
           block: block,
           method_decls: method_decls + other.method_decls
         )
       end
 
-      # Returns a method type which is a sub-type of both self and other.
-      #   (self & other) <: self && (self & other) <: other
-      #
-      # Returns nil if self and other are incompatible.
-      #
       def &(other)
-        if other.type_params.empty?
-          type_params = self.type_params
-        else
-          other_params, s2 = TypeParam.rename(other.type_params)
-          other = other.instantiate(s2)
-          type_params = self.type_params + other_params
-        end
+        return self if self == other
 
-        params = self.type.params | other.type.params
-        block = case
-                when self.block && other.block
-                  block_params = self.block.type.params & other.block.type.params or return
-                  block_return_type = AST::Types::Union.build(types: [self.block.type.return_type, other.block.type.return_type])
-                  block_type = Function.new(params: block_params, return_type: block_return_type, location: nil)
-                  Block.new(
-                    type: block_type,
-                    optional: self.block.optional || other.block.optional
-                  )
-
-                else
-                  self.block || other.block
-                end
+        params = self.type.params | other.type.params or return
+        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.new()
+              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_params,
+          type_params: [],
           type: Function.new(params: params, return_type: return_type, location: nil),
           block: block,
           method_decls: method_decls + other.method_decls

data/lib/steep/interface/shape.rb

@@ -0,0 +1,132 @@
+module Steep
+  module Interface
+    class Shape
+      class Entry
+        attr_reader :method_types
+
+        def initialize(method_types:)
+          @method_types = method_types
+        end
+
+        def to_s
+          "{ #{method_types.join(" || ")} }"
+        end
+      end
+
+      class Methods
+        attr_reader :substs, :methods, :resolved_methods
+
+        include Enumerable
+
+        def initialize(substs:, methods:)
+          @substs = substs
+          @methods = methods
+          @resolved_methods = methods.transform_values { nil }
+        end
+
+        def key?(name)
+          methods.key?(name)
+        end
+
+        def []=(name, entry)
+          resolved_methods[name] = nil
+          methods[name] = entry
+        end
+
+        def [](name)
+          return nil unless key?(name)
+
+          resolved_methods[name] ||= begin
+            Entry.new(
+              method_types: methods[name].method_types.map do |method_type|
+                method_type.subst(subst)
+              end
+            )
+          end
+        end
+
+        def each(&block)
+          if block
+            methods.each_key do |name|
+              entry = self[name] or raise
+              yield [name, entry]
+            end
+          else
+            enum_for :each
+          end
+        end
+
+        def each_name(&block)
+          if block
+            methods.each_key(&block)
+          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)
+          other.each do |name, entry|
+            methods[name] = entry
+          end
+        end
+
+        def +(other)
+          methods = Methods.new(substs: [], methods: {})
+
+          methods.merge!(self)
+          methods.merge!(other)
+
+          methods
+        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
+    end
+  end
+end

data/lib/steep/interface/substitution.rb

@@ -27,9 +27,9 @@ module Steep
 
       def self.empty
         new(dictionary: {},
-            instance_type: INSTANCE_TYPE,
-            module_type: CLASS_TYPE,
-            self_type: SELF_TYPE)
+            instance_type: AST::Types::Instance.instance,
+            module_type: AST::Types::Class.instance,
+            self_type: AST::Types::Self.instance)
       end
 
       def empty?
@@ -39,17 +39,13 @@ module Steep
           self_type.is_a?(AST::Types::Self)
       end
 
-      INSTANCE_TYPE = AST::Types::Instance.new
-      CLASS_TYPE = AST::Types::Class.new
-      SELF_TYPE = AST::Types::Self.new
-
       def domain
         set = Set.new
 
         set.merge(dictionary.keys)
-        set << INSTANCE_TYPE unless instance_type.is_a?(AST::Types::Instance)
-        set << CLASS_TYPE unless instance_type.is_a?(AST::Types::Class)
-        set << SELF_TYPE unless instance_type.is_a?(AST::Types::Self)
+        set << AST::Types::Instance.instance unless instance_type.is_a?(AST::Types::Instance)
+        set << AST::Types::Class.instance unless instance_type.is_a?(AST::Types::Class)
+        set << AST::Types::Instance.instance unless instance_type.is_a?(AST::Types::Self)
 
         set
       end
@@ -76,7 +72,22 @@ module Steep
         dictionary.key?(var)
       end
 
-      def self.build(vars, types = nil, instance_type: AST::Types::Instance.new, module_type: AST::Types::Class.new, self_type: AST::Types::Self.new)
+      def apply?(type)
+        case type
+        when AST::Types::Var
+          key?(type.name)
+        when AST::Types::Self
+          !self_type.is_a?(AST::Types::Self)
+        when AST::Types::Instance
+          !instance_type.is_a?(AST::Types::Instance)
+        when AST::Types::Class
+          !module_type.is_a?(AST::Types::Class)
+        else
+          type.each_child.any? {|t| apply?(t) }
+        end
+      end
+
+      def self.build(vars, types = nil, instance_type: AST::Types::Instance.instance, module_type: AST::Types::Class.instance, self_type: AST::Types::Self.instance)
         types ||= vars.map {|var| AST::Types::Var.fresh(var) }
 
         raise InvalidSubstitutionError.new(vars_size: vars.size, types_size: types.size) unless vars.size == types.size
@@ -90,7 +101,7 @@ module Steep
 
       def except(vars)
         self.class.new(
-          dictionary: dictionary,
+          dictionary: dictionary.dup,
           instance_type: instance_type,
           module_type: module_type,
           self_type: self_type

data/lib/steep/interface/type_param.rb

@@ -29,9 +29,8 @@ module Steep
         name.hash ^ upper_bound.hash ^ variance.hash ^ unchecked.hash
       end
 
-      def self.rename(params, conflicting_names = params.map(&:name))
+      def self.rename(params, conflicting_names = params.map(&:name), new_names = conflicting_names.map {|n| AST::Types::Var.fresh_name(n) })
         unless conflicting_names.empty?
-          new_names = conflicting_names.map {|n| AST::Types::Var.fresh_name(n) }
           hash = conflicting_names.zip(new_names).to_h
           new_types = new_names.map {|n| AST::Types::Var.new(name: n) }
 

data/lib/steep/path_helper.rb

@@ -5,7 +5,7 @@ module Steep
     def to_pathname(uri, dosish: Gem.win_platform?)
       uri = URI.parse(uri)
       if uri.scheme == "file"
-        path = uri.path
+        path = uri.path or raise
         path.sub!(%r{^/([a-zA-Z])(:|%3A)//?}i, '\1:/') if dosish
         Pathname(path)
       end