steep 1.7.0.dev.2 → 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

data/lib/steep/subtyping/check.rb

@@ -410,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
@@ -530,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/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

data/lib/steep/type_construction.rb

@@ -878,6 +878,7 @@ module Steep
             if self_type && method_context!.method
               if super_def = method_context!.super_method
                 super_method = Interface::Shape::Entry.new(
+                  private_method: true,
                   method_types: super_def.defs.map {|type_def|
                     decl = TypeInference::MethodCall::MethodDecl.new(
                       method_name: InstanceMethodName.new(
@@ -1812,7 +1813,7 @@ module Steep
                 .for_branch(right_node)
                 .synthesize(right_node, hint: left_truthy.type, condition: true).to_ary
 
-            right_truthy, right_falsy = interpreter.eval(env: left_falsy.env, node: right_node)
+            right_truthy, right_falsy = interpreter.eval(env: right_context.type_env, node: right_node)
 
             case
             when left_falsy.unreachable
@@ -2611,6 +2612,7 @@ module Steep
           end
         end
       rescue RBS::BaseError => exn
+        Steep.logger.warn("hello")
         Steep.logger.warn { "Unexpected RBS error: #{exn.message}" }
         exn.backtrace&.each {|loc| Steep.logger.warn "  #{loc}" }
         typing.add_error(Diagnostic::Ruby::UnexpectedError.new(node: node, error: exn))
@@ -3431,16 +3433,16 @@ module Steep
         self_type: self_type,
         class_type: module_context.module_type,
         instance_type: module_context.instance_type,
-        variable_bounds: variable_context.upper_bounds
+        variable_bounds: context.variable_context.upper_bounds
       )
     end
 
     def calculate_interface(type, method_name = nil, private:)
-      shape = checker.builder.shape(
-        type,
-        public_only: !private,
-        config: builder_config
-      )
+      shape = checker.builder.shape(type, builder_config)
+
+      unless private
+        shape = shape&.public_shape
+      end
 
       if method_name
         if shape
@@ -4349,7 +4351,7 @@ module Steep
     def for_block(body_node, block_params:, block_param_hint:, block_type_hint:, block_block_hint:, block_annotations:, node_type_hint:, block_self_hint:)
       block_param_pairs = block_param_hint && block_params.zip(block_param_hint, block_block_hint, factory: checker.factory)
 
-      # @type var param_types_hash: Hash[Symbol, AST::Types::t]
+      # @type var param_types_hash: Hash[Symbol?, AST::Types::t]
       param_types_hash = {}
       if block_param_pairs
         block_param_pairs.each do |param, type|
@@ -4384,10 +4386,12 @@ module Steep
         end
       end
 
-      param_types_hash.delete_if {|name, _| SPECIAL_LVAR_NAMES.include?(name) }
+      param_types_hash.delete_if {|name, _| name && SPECIAL_LVAR_NAMES.include?(name) }
 
       param_types = param_types_hash.each.with_object({}) do |pair, hash| #$ Hash[Symbol, [AST::Types::t, AST::Types::t?]]
         name, type = pair
+        # skip unamed arguments `*`, `**` and `&`
+        next if name.nil?
         hash[name] = [type, nil]
       end