steep 1.6.0 → 1.7.1

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)
 
@@ -240,5 +257,17 @@ module Steep
         end
       end
     end
+
+    def clone_node(node)
+      children = node.children.map do |child|
+        if child.is_a?(Parser::AST::Node)
+          clone_node(child)
+        else
+          child.dup
+        end
+      end
+
+      node.updated(nil, children)
+    end
   end
 end

data/lib/steep/project/dsl.rb

@@ -14,9 +14,7 @@ module Steep
         attr_reader :project
         attr_reader :collection_config_path
 
-        NONE = Object.new.freeze
-
-        def initialize(name, sources: [], libraries: [], signatures: [], ignored_sources: [], repo_paths: [], code_diagnostics_config: {}, project: nil, collection_config_path: NONE)
+        def initialize(name, sources: [], libraries: [], signatures: [], ignored_sources: [], repo_paths: [], code_diagnostics_config: {}, project: nil, collection_config_path: nil)
           @name = name
           @sources = sources
           @libraries = libraries
@@ -27,14 +25,7 @@ module Steep
           @repo_paths = []
           @code_diagnostics_config = code_diagnostics_config
           @project = project
-          @collection_config_path =
-            case collection_config_path
-            when NONE
-              path = project&.absolute_path(RBS::Collection::Config::PATH)
-              path&.exist? ? path : nil
-            else
-              collection_config_path
-            end
+          @collection_config_path = collection_config_path
         end
 
         def initialize_copy(other)
@@ -135,8 +126,8 @@ module Steep
         end
 
         def stdlib_path(core_root:, stdlib_root:)
-          @core_root = core_root ? Pathname(core_root) : core_root
-          @stdlib_root = stdlib_root ? Pathname(stdlib_root) : stdlib_root
+          @core_root = Pathname(core_root)
+          @stdlib_root = Pathname(stdlib_root)
         end
 
         def repo_path(*paths)
@@ -160,7 +151,7 @@ module Steep
         end
 
         def disable_collection
-          @collection_config_path = nil
+          @collection_config_path = false
         end
       end
 
@@ -206,12 +197,18 @@ module Steep
         source_pattern = Pattern.new(patterns: target.sources, ignores: target.ignored_sources, ext: ".rb")
         signature_pattern = Pattern.new(patterns: target.signatures, ext: ".rbs")
 
-
-        if config_path = target.collection_config_path
-          lockfile_path = RBS::Collection::Config.to_lockfile_path(config_path)
-          content = YAML.load_file(lockfile_path.to_s)
-          collection_lock = RBS::Collection::Config::Lockfile.from_lockfile(lockfile_path: lockfile_path, data: content)
-        end
+        config_path =
+          case target.collection_config_path
+          when Pathname
+            target.collection_config_path
+          when nil
+            default = project.absolute_path(RBS::Collection::Config::PATH)
+            if default.file?
+              default
+            end
+          when false
+            nil
+          end
 
         Project::Target.new(
           name: target.name,
@@ -224,7 +221,7 @@ module Steep
               stdlib_root: target.stdlib_root,
               repo_paths: target.repo_paths
             )
-            options.collection_lock = collection_lock
+            options.collection_config_path = config_path
           end,
           code_diagnostics_config: target.code_diagnostics_config
         ).tap do |target|