steep 1.7.0.dev.2 → 1.7.0.dev.4

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,7 +1007,8 @@ module Steep
 
       def free_variables
         @fvs ||= Set[].tap do |fvs|
-          fvs.merge(params.free_variables)
+          # @type var fvs: Set[AST::Types::variable]
+          fvs.merge(params.free_variables) if params
           fvs.merge(return_type.free_variables)
         end
       end
@@ -953,7 +1016,7 @@ module Steep
       def subst(s)
         return self if s.empty?
 
-        ps = params.subst(s)
+        ps = params.subst(s) if params
         ret = return_type.subst(s)
 
         if ps == params && ret == return_type
@@ -969,7 +1032,7 @@ module Steep
 
       def each_type(&block)
         if block
-          params.each_type(&block)
+          params&.each_type(&block)
           yield return_type
         else
           enum_for :each_type
@@ -980,7 +1043,7 @@ module Steep
 
       def map_type(&block)
         Function.new(
-          params: params.map_type(&block),
+          params: params&.map_type(&block),
           return_type: yield(return_type),
           location: location
         )
@@ -995,11 +1058,19 @@ module Steep
       end
 
       def to_s
-        "#{params} -> #{return_type}"
+        if params
+          "#{params} -> #{return_type}"
+        else
+          "(?) -> #{return_type}"
+        end
       end
 
       def closed?
-        params.closed? && return_type.closed?
+        if params
+          params.closed? && return_type.free_variables.empty?
+        else
+          return_type.free_variables.empty?
+        end
       end
     end
   end

data/lib/steep/interface/method_type.rb

@@ -61,7 +61,7 @@ module Steep
           type.each_type(&block)
           if block()
             yield(block().self_type) if block().self_type
-            block().type.params.each_type(&block)
+            block().type.params&.each_type(&block)
             yield(block().type.return_type)
           end
         else
@@ -119,7 +119,7 @@ module Steep
         self.class.new(
           type_params: type_params,
           type: Function.new(
-            params: type.params.subst(s1) + other.type.params.subst(s2),
+            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)]
             ),
@@ -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])
 
@@ -250,10 +250,13 @@ module Steep
                 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
+            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)
@@ -285,7 +288,12 @@ module Steep
       def &(other)
         return self if self == other
 
-        params = self.type.params | other.type.params or return
+        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)

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/project/pattern.rb

@@ -46,10 +46,9 @@ module Steep
 
       def test_string(path, patterns, prefixes)
         string = path.to_s
-        extension = path.extname
 
         patterns.any? {|pat| File.fnmatch(pat, string, File::FNM_PATHNAME) } ||
-          prefixes.any? {|prefix| string.start_with?(prefix) && extension == ext }
+          prefixes.any? {|prefix| File.fnmatch("#{prefix}**/*#{ext}", string, File::FNM_PATHNAME) }
       end
     end
   end

data/lib/steep/server/interaction_worker.rb

@@ -90,6 +90,12 @@ module Steep
           collect_changes(request)
           queue_job ApplyChangeJob.new
 
+        when "$/file/reset"
+          uri = request[:params][:uri]
+          text = request[:params][:content]
+          reset_change(uri: uri, text: text)
+          queue_job ApplyChangeJob.new
+
         when "textDocument/hover"
           id = request[:id]
 

data/lib/steep/server/lsp_formatter.rb

@@ -263,6 +263,8 @@ module Steep
           <<~MD
             **Keyword argument**: `#{item.identifier}`
           MD
+        else
+          raise
         end
       end
 

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,17 +731,16 @@ 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
-                if defn
+                if defn && defn.type.type
                   range = range_for(position, prefix: prefix)
                   kwargs = argument_nodes.find { |arg| arg.type == :kwargs }&.children || []
                   used_kwargs = kwargs.filter_map { |arg| arg.type == :pair && arg.children.first.children.first }