steep 1.7.0.dev.1 → 1.7.0.dev.3

data/lib/steep/interface/function.rb

@@ -163,71 +163,93 @@ module Steep
 
             case
             when x.is_a?(Required) && y.is_a?(Required)
+              xs or raise
+              ys or raise
               required(
                 union(x.type, y.type),
                 merge_for_overload(xs.tail, ys.tail)
               )
             when x.is_a?(Required) && y.is_a?(Optional)
+              xs or raise
+              ys or raise
               optional(
                 union(x.type, y.type, null: true),
                 merge_for_overload(xs.tail, ys.tail)
               )
             when x.is_a?(Required) && y.is_a?(Rest)
+              xs or raise
+              ys or raise
               optional(
                 union(x.type, y.type, null: true),
                 merge_for_overload(xs.tail, ys)
               )
             when x.is_a?(Required) && !y
+              xs or raise
               optional(
                 union(x.type, null: true),
                 merge_for_overload(xs.tail, nil)
               )
             when x.is_a?(Optional) && y.is_a?(Required)
+              xs or raise
+              ys or raise
               optional(
                 union(x.type, y.type, null: true),
                 merge_for_overload(xs.tail, ys.tail)
               )
             when x.is_a?(Optional) && y.is_a?(Optional)
+              xs or raise
+              ys or raise
               optional(
                 union(x.type, y.type),
                 merge_for_overload(xs.tail, ys.tail)
               )
             when x.is_a?(Optional) && y.is_a?(Rest)
+              xs or raise
+              ys or raise
               optional(
                 union(x.type, y.type),
                 merge_for_overload(xs.tail, ys)
               )
             when x.is_a?(Optional) && !y
+              xs or raise
               optional(
                 x.type,
                 merge_for_overload(xs.tail, nil)
               )  # == xs
             when x.is_a?(Rest) && y.is_a?(Required)
+              xs or raise
+              ys or raise
               optional(
                 union(x.type, y.type, null: true),
                 merge_for_overload(xs, ys.tail)
               )
             when x.is_a?(Rest) && y.is_a?(Optional)
+              xs or raise
+              ys or raise
               optional(
                 union(x.type, y.type),
                 merge_for_overload(xs, ys.tail)
               )
             when x.is_a?(Rest) && y.is_a?(Rest)
+              xs or raise
+              ys or raise
               rest(union(x.type, y.type))
             when x.is_a?(Rest) && !y
-              xs
+              xs or raise
             when !x && y.is_a?(Required)
+              ys or raise
               optional(
                 union(y.type, null: true),
                 merge_for_overload(nil, ys.tail)
               )
             when !x && y.is_a?(Optional)
+              ys or raise
               optional(
                 y.type,
                 merge_for_overload(nil, ys.tail)
               )  # == ys
             when !x && y.is_a?(Rest)
-              ys
+              ys or raise
             when !x && !y
               nil
             end
@@ -240,26 +262,34 @@ module Steep
 
             case
             when x.is_a?(Required) && y.is_a?(Required)
+              xs or raise
+              ys or raise
               required(
                 union(x.type, y.type),
                 merge_for_union(xs.tail, ys.tail)
               )
             when x.is_a?(Required) && !y
+              xs or raise
               optional(
                 x.type,
                 merge_for_union(xs.tail, nil)
               )
             when x.is_a?(Required) && y.is_a?(Optional)
+              xs or raise
+              ys or raise
               optional(
                 union(x.type, y.type),
                 merge_for_union(xs.tail, ys.tail)
               )
             when x.is_a?(Required) && y.is_a?(Rest)
+              xs or raise
+              ys or raise
               optional(
                 union(x.type, y.type),
                 merge_for_union(xs.tail, ys)
               )
             when !x && y.is_a?(Required)
+              ys or raise
               optional(
                 y.type,
                 merge_for_union(nil, ys.tail)
@@ -267,39 +297,53 @@ module Steep
             when !x && !y
               nil
             when !x && y.is_a?(Optional)
+              ys or raise
               PositionalParams.new(head: y, tail: merge_for_union(nil, ys.tail))
             when !x && y.is_a?(Rest)
-              ys
+              ys or raise
             when x.is_a?(Optional) && y.is_a?(Required)
+              xs or raise
+              ys or raise
               optional(
                 union(x.type, y.type),
                 merge_for_union(xs.tail, ys.tail)
               )
             when x.is_a?(Optional) && !y
+              xs or raise
               PositionalParams.new(head: x, tail: merge_for_union(xs.tail, nil)) # == xs
             when x.is_a?(Optional) && y.is_a?(Optional)
+              xs or raise
+              ys or raise
               optional(
                 union(x.type, y.type),
                 merge_for_union(xs.tail, ys.tail)
               )
             when x.is_a?(Optional) && y.is_a?(Rest)
+              xs or raise
+              ys or raise
               optional(
                 union(x.type, y.type),
                 merge_for_union(xs.tail, ys.tail)
               )
             when x.is_a?(Rest) && y.is_a?(Required)
+              xs or raise
+              ys or raise
               optional(
                 union(x.type, y.type),
                 merge_for_union(xs, ys.tail)
               )
             when x.is_a?(Rest) && !y
-              xs
+              xs or raise
             when x.is_a?(Rest) && y.is_a?(Optional)
+              xs or raise
+              ys or raise
               optional(
                 union(x.type, y.type),
                 merge_for_union(xs, ys.tail)
               )
             when x.is_a?(Rest) && y.is_a?(Rest)
+              xs or raise
+              ys or raise
               rest(
                 union(x.type, y.type)
               )
@@ -315,6 +359,8 @@ module Steep
 
             case
             when x.is_a?(Required) && y.is_a?(Required)
+              xs or raise
+              ys or raise
               required(
                 intersection(x.type, y.type),
                 merge_for_intersection(xs.tail, ys.tail)
@@ -322,11 +368,15 @@ module Steep
             when x.is_a?(Required) && !y
               raise
             when x.is_a?(Required) && y.is_a?(Optional)
+              xs or raise
+              ys or raise
               required(
                 intersection(x.type, y.type),
                 merge_for_intersection(xs.tail, ys.tail)
               )
             when x.is_a?(Required) && y.is_a?(Rest)
+              xs or raise
+              ys or raise
               required(
                 intersection(x.type, y.type),
                 merge_for_intersection(xs.tail, ys)
@@ -340,6 +390,8 @@ module Steep
             when !x && y.is_a?(Rest)
               nil
             when x.is_a?(Optional) && y.is_a?(Required)
+              xs or raise
+              ys or raise
               required(
                 intersection(x.type, y.type),
                 merge_for_intersection(xs.tail, ys.tail)
@@ -347,16 +399,22 @@ module Steep
             when x.is_a?(Optional) && !y
               nil
             when x.is_a?(Optional) && y.is_a?(Optional)
+              xs or raise
+              ys or raise
               optional(
                 intersection(x.type, y.type),
                 merge_for_intersection(xs.tail, ys.tail)
               )
             when x.is_a?(Optional) && y.is_a?(Rest)
+              xs or raise
+              ys or raise
               optional(
                 intersection(x.type, y.type),
                 merge_for_intersection(xs.tail, ys)
               )
             when x.is_a?(Rest) && y.is_a?(Required)
+              xs or raise
+              ys or raise
               required(
                 intersection(x.type, y.type),
                 merge_for_intersection(xs, ys.tail)
@@ -364,6 +422,8 @@ module Steep
             when x.is_a?(Rest) && !y
               nil
             when x.is_a?(Rest) && y.is_a?(Optional)
+              xs or raise
+              ys or raise
               optional(
                 intersection(x.type, y.type),
                 merge_for_intersection(xs, ys.tail)
@@ -705,6 +765,8 @@ module Steep
               return param.type
             end
           end
+
+          nil
         end
 
         attr_reader :positional_params
@@ -836,7 +898,7 @@ module Steep
         end
 
         def closed?
-          each_type.all?(&:closed?)
+          each_type.all? { _1.free_variables.empty? }
         end
 
         def subst(s)
@@ -945,6 +1007,7 @@ module Steep
 
       def free_variables
         @fvs ||= Set[].tap do |fvs|
+          # @type var fvs: Set[AST::Types::variable]
           fvs.merge(params.free_variables)
           fvs.merge(return_type.free_variables)
         end
@@ -999,7 +1062,7 @@ module Steep
       end
 
       def closed?
-        params.closed? && return_type.closed?
+        params.closed? && return_type.free_variables.empty?
       end
     end
   end

data/lib/steep/interface/method_type.rb

@@ -192,10 +192,10 @@ module Steep
           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)
+              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
+              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])
 

data/lib/steep/interface/shape.rb

@@ -2,14 +2,43 @@ module Steep
   module Interface
     class Shape
       class Entry
-        attr_reader :method_types
-
-        def initialize(method_types:)
+        def initialize(method_types: nil, private_method:, &block)
           @method_types = method_types
+          @generator = block
+          @private_method = private_method
+        end
+
+        def force
+          unless @method_types
+            @method_types = @generator&.call
+            @generator = nil
+          end
+        end
+
+        def method_types
+          force
+          @method_types or raise
+        end
+
+        def has_method_type?
+          force
+          @method_types ? true : false
         end
 
         def to_s
-          "{ #{method_types.join(" || ")} }"
+          if @generator
+            "<< Lazy entry >>"
+          else
+            "{ #{method_types.join(" || ")} }"
+          end
+        end
+
+        def private_method?
+          @private_method
+        end
+
+        def public_method?
+          !private_method?
         end
       end
 
@@ -25,7 +54,11 @@ module Steep
         end
 
         def key?(name)
-          methods.key?(name)
+          if entry = methods.fetch(name, nil)
+            entry.has_method_type?
+          else
+            false
+          end
         end
 
         def []=(name, entry)
@@ -37,10 +70,12 @@ module Steep
           return nil unless key?(name)
 
           resolved_methods[name] ||= begin
+            entry = methods[name]
             Entry.new(
-              method_types: methods[name].method_types.map do |method_type|
+              method_types: entry.method_types.map do |method_type|
                 method_type.subst(subst)
-              end
+              end,
+              private_method: entry.private_method?
             )
           end
         end
@@ -48,7 +83,7 @@ module Steep
         def each(&block)
           if block
             methods.each_key do |name|
-              entry = self[name] or raise
+              entry = self[name] or next
               yield [name, entry]
             end
           else
@@ -58,7 +93,9 @@ module Steep
 
         def each_name(&block)
           if block
-            methods.each_key(&block)
+            each do |name, _|
+              yield name
+            end
           else
             enum_for :each_name
           end
@@ -76,19 +113,21 @@ module Steep
           Methods.new(substs: [*substs, subst], methods: methods)
         end
 
-        def merge!(other)
+        def merge!(other, &block)
           other.each do |name, entry|
-            methods[name] = entry
+            if block && (old_entry = methods[name])
+              methods[name] = yield(name, old_entry, entry)
+            else
+              methods[name] = entry
+            end
           end
         end
 
-        def +(other)
-          methods = Methods.new(substs: [], methods: {})
-
-          methods.merge!(self)
-          methods.merge!(other)
-
-          methods
+        def public_methods
+          Methods.new(
+            substs: substs,
+            methods: methods.reject {|_, entry| entry.private_method? }
+          )
         end
       end
 
@@ -127,6 +166,18 @@ module Steep
       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

data/lib/steep/interface/substitution.rb

@@ -138,6 +138,10 @@ module Steep
         self
       end
 
+      def update(self_type: self_type(), instance_type: instance_type(), module_type: module_type())
+        Substitution.new(dictionary: dictionary.dup, instance_type: instance_type, self_type: self_type, module_type: module_type)
+      end
+
       def merge(s)
         Substitution.new(dictionary: dictionary.dup,
                          instance_type: instance_type,

data/lib/steep/node_helper.rb

@@ -207,7 +207,7 @@ module Steep
     end
 
     def deconstruct_send_node!(node)
-      deconstruct_send_node(node) or raise
+      deconstruct_send_node(node) or raise(node.inspect)
     end
 
     def test_send_node(node)
@@ -218,6 +218,23 @@ module Steep
       end
     end
 
+    def private_send?(node)
+      case node.type
+      when :block, :numblock
+        private_send?(node.children[0])
+      when :send, :csend
+        receiver, = deconstruct_send_node!(node)
+
+        if receiver && receiver.type != :self
+          return false
+        end
+
+        true
+      else
+        raise "Unexpected node is given: #{node.inspect}"
+      end
+    end
+
     def deconstruct_sendish_and_block_nodes(*nodes)
       send_node, block_node = nodes.take(2)
 

data/lib/steep/services/completion_provider.rb

@@ -611,18 +611,21 @@ module Steep
         range = range_for(position, prefix: prefix)
         context = typing.context_at(line: position.line, column: position.column)
 
-        shape = subtyping.builder.shape(
-          type,
-          public_only: !include_private,
-          config: Interface::Builder::Config.new(
-            self_type: context.self_type,
-            class_type: context.module_context&.module_type,
-            instance_type: context.module_context&.instance_type,
-            variable_bounds: context.variable_context.upper_bounds
-          )
-        )
+        config =
+          if (module_type = context.module_context&.module_type) && (instance_type = context.module_context&.instance_type)
+            Interface::Builder::Config.new(
+              self_type: context.self_type,
+              class_type: module_type,
+              instance_type: instance_type,
+              variable_bounds: context.variable_context.upper_bounds
+            )
+          else
+            Interface::Builder::Config.new(self_type: context.self_type, variable_bounds: context.variable_context.upper_bounds)
+          end
+
+        if shape = subtyping.builder.shape(type, config)
+          shape = shape.public_shape unless include_private
 
-        if shape
           shape.methods.each do |name, method_entry|
             next if disallowed_method?(name)
 
@@ -728,13 +731,12 @@ module Steep
 
         case call
         when TypeInference::MethodCall::Typed, TypeInference::MethodCall::Error
+          context = typing.context_at(line: position.line, column: position.column)
           type = call.receiver_type
-          shape = subtyping.builder.shape(
-            type,
-            public_only: !!receiver_node,
-            config: Interface::Builder::Config.new(self_type: type, class_type: nil, instance_type: nil, variable_bounds: {})
-          )
-          if shape
+
+          config = Interface::Builder::Config.new(self_type: type, variable_bounds: context.variable_context.upper_bounds)
+          if shape = subtyping.builder.shape(type, config)
+            shape = shape.public_shape if private_send?(call_node)
             if method = shape.methods[call.method_name]
               method.method_types.each.with_index do |method_type, i|
                 defn = method_type.method_decls.to_a[0]&.method_def

data/lib/steep/services/signature_help_provider.rb

@@ -19,6 +19,8 @@ module Steep
         end
       end
 
+      include NodeHelper
+
       attr_reader :source, :path, :subtyping, :typing, :buffer
 
       def env
@@ -103,16 +105,11 @@ module Steep
         case call
         when MethodCall::Typed, MethodCall::Error
           type = call.receiver_type
-          if type.is_a?(AST::Types::Self)
-            type = context.self_type
-          end
+          config = Interface::Builder::Config.new(self_type: context.self_type, variable_bounds: context.variable_context.upper_bounds)
+
+          if shape = subtyping.builder.shape(type, config)
+            shape = shape.public_shape if private_send?(node)
 
-          shape = subtyping.builder.shape(
-            type,
-            public_only: !node.children[0].nil?,
-            config: Interface::Builder::Config.new(self_type: type, class_type: nil, instance_type: nil, variable_bounds: {})
-          )
-          if shape
             if method = shape.methods[call.method_name]
               method.method_types.each.with_index do |method_type, i|
                 defn = method_type.method_decls.to_a[0]&.method_def
@@ -175,18 +172,20 @@ module Steep
           when :splat
             method_type.type.required_positionals.size + method_type.type.optional_positionals.size if method_type.type.rest_positionals
           when :kwargs
-            case argument_nodes[-3].type
-            when :pair
-              argname = argument_nodes[-3].children.first.children.first
-              if method_type.type.required_keywords.key?(argname)
-                positionals + method_type.type.required_keywords.keys.index(argname).to_i
-              elsif method_type.type.optional_keywords.key?(argname)
-                positionals + method_type.type.required_keywords.size + method_type.type.optional_keywords.keys.index(argname).to_i
-              elsif method_type.type.rest_keywords
-                positionals + method_type.type.required_keywords.size + method_type.type.optional_keywords.size
+            if argument_nodes[-3]
+              case argument_nodes[-3].type
+              when :pair
+                argname = argument_nodes[-3].children.first.children.first
+                if method_type.type.required_keywords.key?(argname)
+                  positionals + method_type.type.required_keywords.keys.index(argname).to_i
+                elsif method_type.type.optional_keywords.key?(argname)
+                  positionals + method_type.type.required_keywords.size + method_type.type.optional_keywords.keys.index(argname).to_i
+                elsif method_type.type.rest_keywords
+                  positionals + method_type.type.required_keywords.size + method_type.type.optional_keywords.size
+                end
+              when :kwsplat
+                positionals + method_type.type.required_keywords.size + method_type.type.optional_keywords.size if method_type.type.rest_keywords
               end
-            when :kwsplat
-              positionals + method_type.type.required_keywords.size + method_type.type.optional_keywords.size if method_type.type.rest_keywords
             end
           else
             pos = (node.children[2...] || raise).index { |c| c.location == argument_nodes[-2].location }.to_i

data/lib/steep/subtyping/check.rb

@@ -1,6 +1,8 @@
 module Steep
   module Subtyping
     class Check
+      ABORT_LIMIT = ENV.fetch("STEEP_SUBTYPING_ABORT_LIMIT", 50).to_i
+
       attr_reader :builder
       attr_reader :cache
 
@@ -187,6 +189,10 @@ module Steep
       end
 
       def check_type(relation)
+        if assumptions.size > ABORT_LIMIT
+          return Failure(relation, Result::Failure::LoopAbort.new)
+        end
+
         relation.type!
 
         Steep.logger.tagged "#{relation.sub_type} <: #{relation.super_type}" do
@@ -404,14 +410,8 @@ module Steep
               relation.map {|type|
                 builder.shape(
                   type,
-                  public_only: true,
-                  config: Interface::Builder::Config.new(
-                    self_type: type,
-                    instance_type: instance_type,
-                    class_type: class_type,
-                    variable_bounds: variable_upper_bounds
-                  )
-                ) or return Failure(relation, Result::Failure::UnknownPairError.new(relation: relation))
+                  Interface::Builder::Config.new(self_type: type, variable_bounds: variable_upper_bounds)
+                )&.public_shape() or return Failure(relation, Result::Failure::UnknownPairError.new(relation: relation))
               }
             )
           end
@@ -524,14 +524,8 @@ module Steep
               relation.map {|type|
                 builder.shape(
                   type,
-                  public_only: true,
-                  config: Interface::Builder::Config.new(
-                    self_type: type,
-                    instance_type: instance_type,
-                    class_type: class_type,
-                    variable_bounds: variable_upper_bounds
-                  )
-                ) or raise
+                  Interface::Builder::Config.new(self_type: type, variable_bounds: variable_upper_bounds)
+                )&.public_shape or raise
               }
             )
           end

data/lib/steep/subtyping/result.rb

@@ -269,6 +269,12 @@ module Steep
           end
         end
 
+        class LoopAbort
+          def message
+            "Detected infinite loop with limit of `#{Check::ABORT_LIMIT}`; specify $STEEP_SUBTYPING_ABORT_LIMIT env var to override the limit."
+          end
+        end
+
         attr_reader :error
 
         def initialize(relation, error)

data/lib/steep/test.rb

@@ -0,0 +1,9 @@
+Steep.logger.warn(true)
+
+# class Steep::Subtyping::Result::All
+#   def add(*relations)
+#     rel = relations[0]  # Relation[T] < Relation::_Subject
+#     yield rel           # Relation[T] < Relation[_Subject]
+#     true
+#   end
+# end