steep 1.6.0 → 1.7.1

data/lib/steep/project/options.rb

@@ -3,7 +3,7 @@ module Steep
     class Options
       PathOptions = _ = Struct.new(:core_root, :stdlib_root, :repo_paths, keyword_init: true) do
         # @implements PathOptions
-        
+
         def customized_stdlib?
           stdlib_root != nil
         end
@@ -15,12 +15,49 @@ module Steep
 
       attr_reader :libraries
       attr_accessor :paths
-      attr_accessor :collection_lock
+      attr_accessor :collection_config_path
 
       def initialize
         @paths = PathOptions.new(repo_paths: [])
         @libraries = []
       end
+
+      def collection_lock_path
+        if collection_config_path
+          RBS::Collection::Config.to_lockfile_path(collection_config_path)
+        end
+      end
+
+      def load_collection_lock(force: false)
+        @collection_lock = nil if force
+        @collection_lock ||=
+          if collection_config_path && collection_lock_path
+            case
+            when !collection_config_path.file?
+              collection_config_path
+            when !collection_lock_path.file?
+              collection_lock_path
+            else
+              begin
+                content = YAML.load_file(collection_lock_path)
+                lock_file = RBS::Collection::Config::Lockfile.from_lockfile(lockfile_path: collection_lock_path, data: content)
+                lock_file.check_rbs_availability!
+                lock_file
+              rescue YAML::SyntaxError, RBS::Collection::Config::CollectionNotAvailable => exn
+                exn
+              end
+            end
+          end
+      end
+
+      def collection_lock
+        case config = load_collection_lock()
+        when RBS::Collection::Config::Lockfile
+          config
+        else
+          nil
+        end
+      end
     end
   end
 end

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

@@ -2,18 +2,22 @@ module Steep
   class Project
     attr_reader :targets
     attr_reader :steepfile_path
+    attr_reader :base_dir
 
-    def initialize(steepfile_path:)
+    def initialize(steepfile_path:, base_dir: nil)
       @targets = []
       @steepfile_path = steepfile_path
-
-      unless steepfile_path.absolute?
-        raise "Project#initialize(steepfile_path:): steepfile_path should be absolute path"
+      @base_dir = if base_dir
+        base_dir
+      elsif steepfile_path
+        steepfile_path.parent
+      else
+        raise ArgumentError, "Project#initialize(base_dir:): neither base_dir nor steepfile_path given"
       end
-    end
 
-    def base_dir
-      steepfile_path.parent
+      if steepfile_path and !steepfile_path.absolute?
+        raise ArgumentError, "Project#initialize(steepfile_path:): steepfile_path should be absolute path"
+      end
     end
 
     def relative_path(path)

data/lib/steep/rake_task.rb

@@ -0,0 +1,132 @@
+require "rake"
+require "rake/tasklib"
+require "steep/cli"
+
+module Steep
+  # Provides Rake tasks for running Steep commands.
+  #
+  # require "steep/rake_task"
+  # Steep::RakeTask.new do |t|
+  #   t.check.severity_level = :error
+  #   t.watch.verbose
+  #   t.stats << "--format=table"
+  # end
+  class RakeTask < Rake::TaskLib # steep:ignore UnknownConstant
+    attr_accessor :name
+
+    def self.available_commands
+      %i(init check stats binstub project watch)
+    end
+
+    def initialize(name = :steep, cli_runner = default_cli_runner)
+      super()
+
+      @name = name
+
+      configuration = TaskConfiguration.new
+
+      yield configuration if block_given?
+
+      define_tasks(configuration, cli_runner)
+    end
+
+    private
+
+    # :nodoc:
+    class TaskConfiguration
+      def initialize
+        @commands = {}
+      end
+
+      def method_missing(command)
+        if respond_to?(command)
+          @commands[command] ||= CommandConfiguration.new
+        else
+          super
+        end
+      end
+
+      def respond_to_missing?(name, include_private = false)
+        RakeTask.available_commands.include?(name) || super
+      end
+
+      def options(command)
+        @commands[command]&.to_a || []
+      end
+    end
+
+    # :nodoc:
+    class CommandConfiguration
+      def initialize
+        @options = []
+      end
+
+      def method_missing(name, value = nil)
+        option = "--#{name.to_s.gsub(/_/, '-').gsub(/=/, '')}"
+        option << "=#{value}" if value
+
+        self << option
+      end
+
+      def respond_to_missing?(_name)
+        true
+      end
+
+      def <<(value)
+        @options << value
+        self
+      end
+
+      def to_a
+        @options
+      end
+    end
+
+    def default_cli_runner
+      lambda do |arguments|
+        require "steep"
+
+        cli = Steep::CLI.new(
+          stdout: $stdout,
+          stdin: $stdin,
+          stderr: $stderr,
+          argv: arguments
+        )
+
+        cli.run
+      end
+    end
+
+    def define_tasks(configuration, cli_runner)
+      namespace name do
+        RakeTask.available_commands.each do |command|
+          desc "Run steep #{command}"
+          task command do |_, args|
+            configured_options = configuration.options(command)
+
+            argv = [
+              command.to_s,
+              *configured_options,
+              *args.extras
+            ]
+
+            result = cli_runner[argv]
+
+            raise "Steep failed" if result.nonzero?
+          end
+        end
+
+        desc "Run steep help"
+        task "help" do
+          arguments = ["--help"]
+
+          cli_runner[arguments]
+        end
+      end
+
+      # Default steep task to steep:check
+      desc "Run steep check" unless ::Rake.application.last_description # steep:ignore UnknownConstant
+      task name => ["#{name}:check"]
+    end
+  end
+end

data/lib/steep/server/change_buffer.rb

@@ -5,13 +5,13 @@ module Steep
       attr_reader :buffered_changes
 
       def push_buffer
-        @mutex.synchronize do
+        mutex.synchronize do
           yield buffered_changes
         end
       end
 
       def pop_buffer
-        changes = @mutex.synchronize do
+        changes = mutex.synchronize do
           copy = buffered_changes.dup
           buffered_changes.clear
           copy

data/lib/steep/server/interaction_worker.rb

@@ -10,14 +10,15 @@ module Steep
 
       LSP = LanguageServer::Protocol
 
-      attr_reader :service
+      attr_reader :service, :mutex
 
       def initialize(project:, reader:, writer:, queue: Queue.new)
         super(project: project, reader: reader, writer: writer)
         @queue = queue
-        @service = Services::TypeCheckService.new(project: project)
         @mutex = Mutex.new
+        @service = Services::TypeCheckService.new(project: project)
         @buffered_changes = {}
+        @last_job_mutex = Mutex.new
       end
 
       def handle_job(job)
@@ -33,25 +34,67 @@ module Steep
           when ApplyChangeJob
             # nop
           when HoverJob
-            writer.write({ id: job.id, result: process_hover(job) })
+            writer.write(
+              {
+                id: job.id,
+                result: process_latest_job(job) { process_hover(job) }
+              }
+            )
           when CompletionJob
-            writer.write({ id: job.id, result: process_completion(job) })
+            writer.write(
+              {
+                id: job.id,
+                result: process_latest_job(job) { process_completion(job) }
+              }
+            )
           when SignatureHelpJob
-            writer.write({ id: job.id, result: process_signature_help(job) })
+            writer.write(
+              {
+                id: job.id,
+                result: process_latest_job(job) { process_signature_help(job) }
+              }
+            )
           end
         end
       end
 
+      def process_latest_job(job)
+        @last_job_mutex.synchronize do
+          unless job.equal?(@last_job)
+            Steep.logger.debug { "Skipping interaction job: latest_job=#{@last_job.class}, skipped_job#{job.class}" }
+            return
+          end
+          @last_job = nil
+        end
+
+        yield
+      end
+
+      def queue_job(job)
+        @last_job_mutex.synchronize do
+          unless job.is_a?(ApplyChangeJob)
+            @last_job = job
+          end
+        end
+        queue << job
+      end
+
       def handle_request(request)
         case request[:method]
         when "initialize"
           load_files(project: project, commandline_args: [])
-          queue << ApplyChangeJob.new
+          queue_job ApplyChangeJob.new
           writer.write({ id: request[:id], result: nil })
 
         when "textDocument/didChange"
           collect_changes(request)
-          queue << ApplyChangeJob.new
+          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]
@@ -60,7 +103,7 @@ module Steep
           line = request[:params][:position][:line]+1
           column = request[:params][:position][:character]
 
-          queue << HoverJob.new(id: id, path: path, line: line, column: column)
+          queue_job HoverJob.new(id: id, path: path, line: line, column: column)
 
         when "textDocument/completion"
           id = request[:id]
@@ -71,14 +114,14 @@ module Steep
           line, column = params[:position].yield_self {|hash| [hash[:line]+1, hash[:character]] }
           trigger = params.dig(:context, :triggerCharacter)
 
-          queue << CompletionJob.new(id: id, path: path, line: line, column: column, trigger: trigger)
+          queue_job CompletionJob.new(id: id, path: path, line: line, column: column, trigger: trigger)
         when "textDocument/signatureHelp"
           id = request[:id]
           params = request[:params]
           path = project.relative_path(PathHelper.to_pathname!(params[:textDocument][:uri]))
           line, column = params[:position].yield_self {|hash| [hash[:line]+1, hash[:character]] }
 
-          queue << SignatureHelpJob.new(id: id, path: path, line: line, column: column)
+          queue_job SignatureHelpJob.new(id: id, path: path, line: line, column: column)
         end
       end
 
@@ -394,6 +437,17 @@ module Steep
               new_text: item.relative_type_name.to_s
             )
           )
+          when Services::CompletionProvider::TextItem
+            LSP::Interface::CompletionItem.new(
+              label: item.label,
+              label_details: item.help_text && LSP::Interface::CompletionItemLabelDetails.new(description: item.help_text),
+              kind: LSP::Constant::CompletionItemKind::SNIPPET,
+              insert_text_format: LSP::Constant::InsertTextFormat::SNIPPET,
+              text_edit: LSP::Interface::TextEdit.new(
+                range: range,
+                new_text: item.text
+              )
+            )
         end
       end
 
@@ -402,7 +456,9 @@ module Steep
           if target = project.target_for_source_path(job.path)
             file = service.source_files[job.path] or return
             subtyping = service.signature_services[target.name].current_subtyping or return
-            source = Source.parse(file.content, path: file.path, factory: subtyping.factory)
+            source =
+              Source.parse(file.content, path: file.path, factory: subtyping.factory)
+                .without_unrelated_defs(line: job.line, column: job.column)
 
             provider = Services::SignatureHelpProvider.new(source: source, subtyping: subtyping)
 

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/server/worker_process.rb

@@ -64,6 +64,7 @@ module Steep
 
         pid = fork do
           Process.setpgid(0, 0)
+          Steep.ui_logger.level = :fatal
           stdin_out.close
           stdout_in.close
           worker.run()
@@ -92,7 +93,8 @@ module Steep
       end
 
       def self.spawn_worker(type, name:, steepfile:, steep_command:, index:, delay_shutdown:, patterns:)
-        args = ["--name=#{name}", "--steepfile=#{steepfile}"]
+        args = ["--name=#{name}"]
+        args << "--steepfile=#{steepfile}" if steepfile
         args << (%w(debug info warn error fatal unknown)[Steep.logger.level].yield_self {|log_level| "--log-level=#{log_level}" })
 
         if Steep.log_output.is_a?(String)

data/lib/steep/services/completion_provider.rb

@@ -157,6 +157,9 @@ module Steep
         end
       end
 
+      class TextItem < Struct.new(:text, :help_text, :range, :label, keyword_init: true)
+      end
+
       attr_reader :source_text
       attr_reader :path
       attr_reader :subtyping
@@ -205,7 +208,7 @@ module Steep
             end
           end
 
-          if at_comment?(position)
+          if comment = at_comment?(position)
             node, *parents = source.find_nodes(line: position.line, column: position.column)
 
             case
@@ -232,9 +235,41 @@ module Steep
               if annotation
                 annotation.location or raise
                 return items_for_rbs(position: position, buffer: annotation.location.buffer)
-              else
-                return []
               end
+
+              comment_content = comment.text[1..] || ""
+              comment_content.strip!
+
+              range = Range.new(
+                start: Position.new(line: line, column: column),
+                end: Position.new(line: line, column: column)
+              )
+
+              items = [
+                TextItem.new(label: "steep:ignore:start", text: "steep:ignore:start", help_text: "Open ignore block", range: range),
+                TextItem.new(label: "steep:ignore:end", text: "steep:ignore:end", help_text: "Close ignore block", range: range),
+                TextItem.new(label: "steep:ignore", text: "steep:ignore ${1:optional diagnostics}", help_text: "Ignore line", range: range),
+                TextItem.new(label: "@type var x: T", text: "@type var ${1:variable}: ${2:var type}", help_text: "Type of local variable", range: range),
+                TextItem.new(label: "@type self: T", text: "@type self: ${1:self type}", help_text: "Type of `self`", range: range),
+                TextItem.new(label: "@type block: T", text: "@type block: ${1:block type}", help_text: "Type of `block`", range: range),
+                TextItem.new(label: "@type break: T", text: "@type break: ${1:break type}", help_text: "Type of `block`", range: range),
+              ]
+
+              items = items.filter_map do |item|
+                if item.text.start_with?(comment_content)
+                  TextItem.new(
+                    label: item.label,
+                    text: item.text,
+                    help_text: item.help_text,
+                    range: Range.new(
+                      start: Position.new(line: item.range.start.line, column: item.range.start.column - comment_content.size),
+                      end: item.range.end
+                    )
+                  )
+                end
+              end
+
+              return items
             end
           end
 
@@ -294,11 +329,7 @@ module Steep
       end
 
       def at_comment?(position)
-        if source.find_comment(line: position.line, column: position.column)
-          true
-        else
-          false
-        end
+        source.find_comment(line: position.line, column: position.column)
       end
 
       def range_for(position, prefix: "")
@@ -580,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)
 
@@ -697,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 }

data/lib/steep/services/file_loader.rb

@@ -12,29 +12,25 @@ module Steep
           pats = commandline_patterns.empty? ? pattern.patterns : commandline_patterns
 
           pats.each do |path|
-            absolute_path = base_dir + path
-
-            if absolute_path.file?
-              if pattern =~ path
-                yield absolute_path.relative_path_from(base_dir)
-              end
-            else
-              files = if absolute_path.directory?
-                        Pathname.glob("#{absolute_path}/**/*#{pattern.ext}")
-                      else
-                        Pathname.glob(absolute_path.to_s)
-                      end
-
-              files.sort.each do |source_path|
-                if source_path.file?
-                  relative_path = source_path.relative_path_from(base_dir)
-                  unless pattern.ignore?(relative_path)
-                    yield relative_path
+            Pathname.glob((base_dir + path).to_s).each do |absolute_path|
+              if absolute_path.file?
+                relative_path = absolute_path.relative_path_from(base_dir)
+                if pattern =~ relative_path
+                  yield relative_path
+                end
+              else
+                files = Pathname.glob("#{absolute_path}/**/*#{pattern.ext}")
+
+                files.sort.each do |source_path|
+                  if source_path.file?
+                    relative_path = source_path.relative_path_from(base_dir)
+                    unless pattern.ignore?(relative_path)
+                      yield relative_path
+                    end
                   end
                 end
               end
             end
-
           end
         else
           enum_for :each_path_in_patterns, pattern, commandline_patterns