steep 1.9.4 → 1.10.0.pre.1

data/lib/steep/drivers/diagnostic_printer/code_formatter.rb

@@ -0,0 +1,95 @@
+module Steep
+  module Drivers
+    class DiagnosticPrinter
+      class CodeFormatter < BaseFormatter
+        def print(diagnostic, prefix: "", source: true)
+          header, *rest = diagnostic[:message].split(/\n/)
+
+          stdout.puts "#{prefix}#{location(diagnostic)}: [#{severity_message(diagnostic[:severity])}] #{Rainbow(header).underline}"
+
+          unless rest.empty?
+            rest.each do |message|
+              stdout.puts "#{prefix}│ #{message}"
+            end
+          end
+
+          if diagnostic[:code]
+            stdout.puts "#{prefix}│" unless rest.empty?
+            stdout.puts "#{prefix}│ Diagnostic ID: #{diagnostic[:code]}"
+          end
+
+          stdout.puts "#{prefix}│"
+
+          if source
+            print_source_line(diagnostic, prefix: prefix)
+          else
+            stdout.puts "#{prefix}└ (no source code available)"
+            stdout.puts "#{prefix}"
+          end
+        end
+
+        private
+
+        def color_severity(string, severity:)
+          s = Rainbow(string)
+
+          case severity
+          when LSP::Constant::DiagnosticSeverity::ERROR
+            s.red
+          when LSP::Constant::DiagnosticSeverity::WARNING
+            s.yellow
+          when LSP::Constant::DiagnosticSeverity::INFORMATION
+            s.blue
+          else
+            s
+          end
+        end
+
+        def severity_message(severity)
+          string = case severity
+                  when LSP::Constant::DiagnosticSeverity::ERROR
+                    "error"
+                  when LSP::Constant::DiagnosticSeverity::WARNING
+                    "warning"
+                  when LSP::Constant::DiagnosticSeverity::INFORMATION
+                    "information"
+                  when LSP::Constant::DiagnosticSeverity::HINT
+                    "hint"
+                  else
+                    raise
+                  end
+
+          color_severity(string, severity: severity)
+        end
+
+        def location(diagnostic)
+          start = diagnostic[:range][:start]
+          Rainbow("#{path}:#{start[:line]+1}:#{start[:character]}").magenta
+        end
+
+        def print_source_line(diagnostic, prefix: "")
+          start_pos = diagnostic[:range][:start]
+          end_pos = diagnostic[:range][:end]
+
+          line = buffer.lines.fetch(start_pos[:line])
+
+          leading = line[0...start_pos[:character]] || ""
+          if start_pos[:line] == end_pos[:line]
+            subject = line[start_pos[:character]...end_pos[:character]] || ""
+            trailing = (line[end_pos[:character]...] || "").chomp
+          else
+            subject = (line[start_pos[:character]...] || "").chomp
+            trailing = ""
+          end
+
+          unless subject.valid_encoding?
+            subject.scrub!
+          end
+
+          stdout.puts "#{prefix}└ #{leading}#{color_severity(subject, severity: diagnostic[:severity])}#{trailing}"
+          stdout.puts "#{prefix}  #{" " * leading.size}#{"~" * subject.size}"
+        end
+      end
+    end
+  end
+end

data/lib/steep/drivers/diagnostic_printer/github_actions_formatter.rb

@@ -0,0 +1,44 @@
+module Steep
+  module Drivers
+    class DiagnosticPrinter
+      # https://docs.github.com/en/actions/writing-workflows/choosing-what-your-workflow-does/workflow-commands-for-github-actions
+      class GitHubActionsFormatter < BaseFormatter
+        ESCAPE_MAP = { '%' => '%25', "\n" => '%0A', "\r" => '%0D' }.freeze
+
+        def print(diagnostic, prefix: "", source: true)
+          stdout.printf(
+            "::%<severity>s file=%<file>s,line=%<line>d,endLine=%<endLine>d,col=%<column>d,endColumn=%<endColumn>d::%<message>s",
+            severity: github_severity(diagnostic[:severity]),
+            file: path,
+            line: diagnostic[:range][:start][:line] + 1,
+            endLine: diagnostic[:range][:end][:line] + 1,
+            column: diagnostic[:range][:start][:character],
+            endColumn: diagnostic[:range][:end][:character],
+            message: github_escape("[#{diagnostic[:code]}] #{diagnostic[:message]}")
+          )
+        end
+
+        private
+
+        def github_severity(severity)
+          case severity
+          when LSP::Constant::DiagnosticSeverity::ERROR
+            "error"
+          when LSP::Constant::DiagnosticSeverity::WARNING
+            "warning"
+          when LSP::Constant::DiagnosticSeverity::INFORMATION
+            "notice"
+          when LSP::Constant::DiagnosticSeverity::HINT
+            "notice"
+          else
+            raise
+          end
+        end
+
+        def github_escape(string)
+          string.gsub(Regexp.union(ESCAPE_MAP.keys), ESCAPE_MAP)
+        end
+      end
+    end
+  end
+end

data/lib/steep/drivers/diagnostic_printer.rb

@@ -1,104 +1,27 @@
 module Steep
   module Drivers
     class DiagnosticPrinter
+
       LSP = LanguageServer::Protocol
 
       attr_reader :stdout
       attr_reader :buffer
 
-      def initialize(stdout:, buffer:)
+      def initialize(stdout:, buffer:, formatter: 'code')
         @stdout = stdout
         @buffer = buffer
-      end
-
-      def path
-        Pathname(buffer.name)
-      end
-
-      def color_severity(string, severity:)
-        s = Rainbow(string)
-
-        case severity
-        when LSP::Constant::DiagnosticSeverity::ERROR
-          s.red
-        when LSP::Constant::DiagnosticSeverity::WARNING
-          s.yellow
-        when LSP::Constant::DiagnosticSeverity::INFORMATION
-          s.blue
+        @formatter = case formatter
+        when 'code'
+          CodeFormatter.new(stdout: stdout, buffer: buffer)
+        when 'github'
+          GitHubActionsFormatter.new(stdout: stdout, buffer: buffer)
         else
-          s
+          raise "Unknown formatter: #{formatter}"
         end
       end
 
-      def severity_message(severity)
-        string = case severity
-                 when LSP::Constant::DiagnosticSeverity::ERROR
-                   "error"
-                 when LSP::Constant::DiagnosticSeverity::WARNING
-                   "warning"
-                 when LSP::Constant::DiagnosticSeverity::INFORMATION
-                   "information"
-                 when LSP::Constant::DiagnosticSeverity::HINT
-                   "hint"
-                 else
-                  raise
-                 end
-
-        color_severity(string, severity: severity)
-      end
-
-      def location(diagnostic)
-        start = diagnostic[:range][:start]
-        Rainbow("#{path}:#{start[:line]+1}:#{start[:character]}").magenta
-      end
-
       def print(diagnostic, prefix: "", source: true)
-        header, *rest = diagnostic[:message].split(/\n/)
-
-        stdout.puts "#{prefix}#{location(diagnostic)}: [#{severity_message(diagnostic[:severity])}] #{Rainbow(header).underline}"
-
-        unless rest.empty?
-          rest.each do |message|
-            stdout.puts "#{prefix}│ #{message}"
-          end
-        end
-
-        if diagnostic[:code]
-          stdout.puts "#{prefix}│" unless rest.empty?
-          stdout.puts "#{prefix}│ Diagnostic ID: #{diagnostic[:code]}"
-        end
-
-        stdout.puts "#{prefix}│"
-
-        if source
-          print_source_line(diagnostic, prefix: prefix)
-        else
-          stdout.puts "#{prefix}└ (no source code available)"
-          stdout.puts "#{prefix}"
-        end
-      end
-
-      def print_source_line(diagnostic, prefix: "")
-        start_pos = diagnostic[:range][:start]
-        end_pos = diagnostic[:range][:end]
-
-        line = buffer.lines.fetch(start_pos[:line])
-
-        leading = line[0...start_pos[:character]] || ""
-        if start_pos[:line] == end_pos[:line]
-          subject = line[start_pos[:character]...end_pos[:character]] || ""
-          trailing = (line[end_pos[:character]...] || "").chomp
-        else
-          subject = (line[start_pos[:character]...] || "").chomp
-          trailing = ""
-        end
-
-        unless subject.valid_encoding?
-          subject.scrub!
-        end
-
-        stdout.puts "#{prefix}└ #{leading}#{color_severity(subject, severity: diagnostic[:severity])}#{trailing}"
-        stdout.puts "#{prefix}  #{" " * leading.size}#{"~" * subject.size}"
+        @formatter.print(diagnostic, prefix: prefix, source: source)
       end
     end
   end

data/lib/steep/drivers/langserver.rb

@@ -8,6 +8,7 @@ module Steep
       attr_reader :type_check_queue
       attr_reader :type_check_thread
       attr_reader :jobs_option
+      attr_accessor :refork
 
       include Utils::DriverHelper
 
@@ -18,6 +19,7 @@ module Steep
         @write_mutex = Mutex.new
         @type_check_queue = Queue.new
         @jobs_option = Utils::JobsOption.new(jobs_count_modifier: -1)
+        @refork = false
       end
 
       def writer
@@ -43,7 +45,8 @@ module Steep
           reader: reader,
           writer: writer,
           interaction_worker: interaction_worker,
-          typecheck_workers: typecheck_workers
+          typecheck_workers: typecheck_workers,
+          refork: refork,
         )
         master.typecheck_automatically = true
 

data/lib/steep/drivers/worker.rb

@@ -9,6 +9,7 @@ module Steep
       attr_accessor :max_index
       attr_accessor :index
       attr_accessor :commandline_args
+      attr_accessor :io_socket
 
       include Utils::DriverHelper
 
@@ -32,6 +33,7 @@ module Steep
                      Server::TypeCheckWorker.new(project: project,
                                                  reader: reader,
                                                  writer: writer,
+                                                 io_socket:,
                                                  assignment: assignment,
                                                  commandline_args: commandline_args)
                    when :interaction

data/lib/steep/interface/builder.rb

@@ -283,7 +283,7 @@ module Steep
                 method_type = factory.method_type(type_def.type)
                 method_type = replace_primitive_method(method_name, type_def, method_type)
                 method_type = replace_kernel_class(method_name, type_def, method_type) { AST::Builtin::Class.instance_type }
-                method_type = add_implicitly_returns_nil(type_def.annotations, method_type)
+                method_type = add_implicitly_returns_nil(type_def.each_annotation, method_type)
                 Shape::MethodOverload.new(method_type, [type_def])
               end
 
@@ -317,7 +317,7 @@ module Steep
                 if type_name.class?
                   method_type = replace_kernel_class(method_name, type_def, method_type) { AST::Types::Name::Singleton.new(name: type_name) }
                 end
-                method_type = add_implicitly_returns_nil(type_def.annotations, method_type)
+                method_type = add_implicitly_returns_nil(type_def.each_annotation, method_type)
                 Shape::MethodOverload.new(method_type, [type_def])
               end
 

data/lib/steep/server/custom_methods.rb

@@ -72,6 +72,18 @@ module Steep
           { id: id, result: result }
         end
       end
+
+      module Refork
+        METHOD = "$/steep/refork"
+
+        def self.request(id, params)
+          { method: METHOD, id: id, params: params }
+        end
+
+        def self.response(id, result)
+          { id: id, result: result }
+        end
+      end
     end
   end
 end

data/lib/steep/server/interaction_worker.rb

@@ -268,6 +268,11 @@ module Steep
 
         type_name = sig_service.latest_env.normalize_type_name(type_name)
 
+        tags = [] #: Array[LSP::Constant::CompletionItemTag::t]
+        if AnnotationsHelper.deprecated_type_name?(type_name, sig_service.latest_env)
+          tags << LSP::Constant::CompletionItemTag::DEPRECATED
+        end
+
         case type_name.kind
         when :class
           env = sig_service.latest_env
@@ -290,7 +295,8 @@ module Steep
               range: range,
               new_text: complete_text
             ),
-            kind: LSP::Constant::CompletionItemKind::CLASS
+            kind: LSP::Constant::CompletionItemKind::CLASS,
+            tags: tags
           )
         when :alias
           alias_decl = sig_service.latest_env.type_alias_decls[type_name]&.decl or raise
@@ -303,7 +309,8 @@ module Steep
               new_text: complete_text
             ),
             documentation: LSPFormatter.markup_content { LSPFormatter.format_rbs_completion_docs(type_name, alias_decl, [alias_decl.comment].compact) },
-            kind: LSP::Constant::CompletionItemKind::FIELD
+            kind: LSP::Constant::CompletionItemKind::FIELD,
+            tags: tags
           )
         when :interface
           interface_decl = sig_service.latest_env.interface_decls[type_name]&.decl or raise
@@ -316,7 +323,8 @@ module Steep
               new_text: complete_text
             ),
             documentation: LSPFormatter.markup_content { LSPFormatter.format_rbs_completion_docs(type_name, interface_decl, [interface_decl.comment].compact) },
-            kind: LSP::Constant::CompletionItemKind::INTERFACE
+            kind: LSP::Constant::CompletionItemKind::INTERFACE,
+            tags: tags
           )
         else
           raise
@@ -355,6 +363,11 @@ module Steep
 
           detail = LSPFormatter.declaration_summary(item.decl)
 
+          tags = [] #: Array[LSP::Constant::CompletionItemTag::t]
+          if item.deprecated?
+            tags << LSP::Constant::CompletionItemTag::DEPRECATED
+          end
+
           LSP::Interface::CompletionItem.new(
             label: item.identifier.to_s,
             kind: kind,
@@ -363,15 +376,22 @@ module Steep
             text_edit: LSP::Interface::TextEdit.new(
               range: range,
               new_text: item.identifier.to_s
-            )
+            ),
+            tags: tags
           )
         when Services::CompletionProvider::SimpleMethodNameItem
+          tags = [] #: Array[LSP::Constant::CompletionItemTag::t]
+          if item.deprecated
+            tags << LSP::Constant::CompletionItemTag::DEPRECATED
+          end
+
           LSP::Interface::CompletionItem.new(
             label: item.identifier.to_s,
             kind: LSP::Constant::CompletionItemKind::FUNCTION,
             label_details: LSP::Interface::CompletionItemLabelDetails.new(description: item.method_name.relative.to_s),
             insert_text: item.identifier.to_s,
-            documentation: LSPFormatter.markup_content { LSPFormatter.format_completion_docs(item) }
+            documentation: LSPFormatter.markup_content { LSPFormatter.format_completion_docs(item) },
+            tags: tags
           )
         when Services::CompletionProvider::ComplexMethodNameItem
           method_names = item.method_names.map(&:relative).uniq
@@ -423,6 +443,12 @@ module Steep
             when item.absolute_type_name.alias?
               LSP::Constant::CompletionItemKind::FIELD
             end
+
+          tags = [] #: Array[LSP::Constant::CompletionItemTag::t]
+          if AnnotationsHelper.deprecated_type_name?(item.absolute_type_name, item.env)
+            tags << LSP::Constant::CompletionItemTag::DEPRECATED
+          end
+
           LSP::Interface::CompletionItem.new(
             label: item.relative_type_name.to_s,
             kind: kind,
@@ -431,7 +457,8 @@ module Steep
             text_edit: LSP::Interface::TextEdit.new(
               range: range,
               new_text: item.relative_type_name.to_s
-            )
+            ),
+            tags: tags
           )
           when Services::CompletionProvider::TextItem
             LSP::Interface::CompletionItem.new(

data/lib/steep/server/master.rb

@@ -178,6 +178,7 @@ module Steep
       attr_reader :job_queue, :write_queue
 
       attr_reader :current_type_check_request
+      attr_reader :refork_mutex
       attr_reader :controller
       attr_reader :result_controller
 
@@ -185,7 +186,7 @@ module Steep
       attr_accessor :typecheck_automatically
       attr_reader :start_type_checking_queue
 
-      def initialize(project:, reader:, writer:, interaction_worker:, typecheck_workers:, queue: Queue.new)
+      def initialize(project:, reader:, writer:, interaction_worker:, typecheck_workers:, queue: Queue.new, refork: false)
         @project = project
         @reader = reader
         @writer = writer
@@ -196,6 +197,8 @@ module Steep
         @commandline_args = []
         @job_queue = queue
         @write_queue = SizedQueue.new(100)
+        @refork_mutex = Mutex.new
+        @need_to_refork = refork
 
         @controller = TypeCheckController.new(project: project)
         @result_controller = ResultController.new()
@@ -244,8 +247,10 @@ module Steep
                   Steep.logger.info { "Processing SendMessageJob: dest=client, method=#{job.message[:method] || "-"}, id=#{job.message[:id] || "-"}" }
                   writer.write job.message
                 when WorkerProcess
-                  Steep.logger.info { "Processing SendMessageJob: dest=#{job.dest.name}, method=#{job.message[:method] || "-"}, id=#{job.message[:id] || "-"}" }
-                  job.dest << job.message
+                  refork_mutex.synchronize do
+                    Steep.logger.info { "Processing SendMessageJob: dest=#{job.dest.name}, method=#{job.message[:method] || "-"}, id=#{job.message[:id] || "-"}" }
+                    job.dest << job.message
+                  end
                 end
               end
             end
@@ -287,11 +292,13 @@ module Steep
             end
           end
 
-          waiter = ThreadWaiter.new
-          each_worker do |worker|
-            waiter << worker.wait_thread
+          waiter = ThreadWaiter.new(each_worker.to_a) {|worker| worker.wait_thread }
+          # @type var th: Thread & WorkerProcess::_ProcessWaitThread
+          while th = _ = waiter.wait_one()
+            if each_worker.any? { |worker| worker.pid == th.pid }
+              break # The worker unexpectedly exited
+            end
           end
-          waiter.wait_one()
 
           unless job_queue.closed?
             # Exit by error
@@ -794,6 +801,76 @@ module Steep
             if current.finished?
               finish_type_check(current)
               @current_type_check_request = nil
+              refork_workers
+            end
+          end
+        end
+      end
+
+      def refork_workers
+        return unless @need_to_refork
+        @need_to_refork = false
+
+        Thread.new do
+          Thread.current.abort_on_exception = true
+
+          primary, *others = typecheck_workers
+          primary or raise
+          others.each do |worker|
+            worker.index or raise
+
+            refork_mutex.synchronize do
+              refork_finished = Thread::Queue.new
+              stdin_in, stdin_out = IO.pipe
+              stdout_in, stdout_out = IO.pipe
+
+              result_controller << send_refork_request(params: { index: worker.index, max_index: typecheck_workers.size }, worker: primary) do |handler|
+                handler.on_completion do |response|
+                  writer = LanguageServer::Protocol::Transport::Io::Writer.new(stdin_out)
+                  reader = LanguageServer::Protocol::Transport::Io::Reader.new(stdout_in)
+
+                  pid = response[:result][:pid]
+                  # It does not need to wait worker process
+                  # because the primary worker monitors it instead.
+                  #
+                  # @type var wait_thread: Thread & WorkerProcess::_ProcessWaitThread
+                  wait_thread = _ = Thread.new { sleep }
+                  wait_thread.define_singleton_method(:pid) { pid }
+
+                  new_worker = WorkerProcess.new(reader:, writer:, stderr: nil, wait_thread:, name: "#{worker.name}-2", index: worker.index)
+                  old_worker = typecheck_workers[worker.index] or raise
+
+                  typecheck_workers[(new_worker.index or raise)] = new_worker
+
+                  original_old_worker = old_worker.dup
+                  old_worker.redirect_to new_worker
+
+                  refork_finished << true
+
+                  result_controller << send_request(method: 'shutdown', worker: original_old_worker) do |handler|
+                    handler.on_completion do
+                      send_request(method: 'exit', worker: original_old_worker)
+                    end
+                  end
+
+                  Thread.new do
+                    tags = Steep.logger.formatter.current_tags.dup
+                    Steep.logger.formatter.push_tags(*tags, "from-worker@#{new_worker.name}")
+                    new_worker.reader.read do |message|
+                      job_queue << ReceiveMessageJob.new(source: new_worker, message: message)
+                    end
+                  end
+                end
+              end
+
+              # The primary worker starts forking when it receives the IOs.
+              primary.io_socket or raise
+              primary.io_socket.send_io(stdin_in)
+              primary.io_socket.send_io(stdout_out)
+              stdin_in.close
+              stdout_out.close
+
+              refork_finished.pop
             end
           end
         end
@@ -826,6 +903,25 @@ module Steep
         end
       end
 
+      def send_refork_request(id: fresh_request_id(), params:, worker:, &block)
+        method = CustomMethods::Refork::METHOD
+        Steep.logger.info "Sending request #{method}(#{id}) to #{worker.name}"
+
+        # @type var message: lsp_request
+        message = { method: method, id: id, params: params }
+        ResultHandler.new(request: message).tap do |handler|
+          yield handler if block
+
+          job = SendMessageJob.to_worker(worker, message: message)
+          case job.dest
+          when WorkerProcess
+            job.dest << job.message
+          else
+            raise "Unexpected destination: #{job.dest}"
+          end
+        end
+      end
+
       def group_request()
         GroupHandler.new().tap do |group|
           yield group

data/lib/steep/server/type_check_worker.rb

@@ -51,15 +51,28 @@ module Steep
 
       include ChangeBuffer
 
-      def initialize(project:, reader:, writer:, assignment:, commandline_args:)
+      attr_reader :io_socket
+
+      def initialize(project:, reader:, writer:, assignment:, commandline_args:, io_socket: nil, buffered_changes: nil, service: nil)
         super(project: project, reader: reader, writer: writer)
 
         @assignment = assignment
-        @buffered_changes = {}
+        @buffered_changes = buffered_changes || {}
         @mutex = Mutex.new()
         @queue = Queue.new
         @commandline_args = commandline_args
         @current_type_check_guid = nil
+        @io_socket = io_socket
+        @service = service if service
+        @child_pids = []
+
+        if io_socket
+          Signal.trap "SIGCHLD" do
+            while pid = Process.wait(-1, Process::WNOHANG)
+              raise "Unexpected worker process exit: #{pid}" if @child_pids.include?(pid)
+            end
+          end
+        end
       end
 
       def service
@@ -98,6 +111,39 @@ module Steep
           queue << GotoJob.implementation(id: request[:id], params: request[:params])
         when "textDocument/typeDefinition"
           queue << GotoJob.type_definition(id: request[:id], params: request[:params])
+        when CustomMethods::Refork::METHOD
+          io_socket or raise
+
+          # Receive IOs before fork to avoid receiving them from multiple processes
+          stdin = io_socket.recv_io
+          stdout = io_socket.recv_io
+
+          if pid = fork
+            stdin.close
+            stdout.close
+            @child_pids << pid
+            writer.write(CustomMethods::Refork.response(request[:id], { pid: }))
+          else
+            io_socket.close
+
+            reader.close
+            writer.close
+
+            reader = LanguageServer::Protocol::Transport::Io::Reader.new(stdin)
+            writer = LanguageServer::Protocol::Transport::Io::Writer.new(stdout)
+            Steep.logger.info("Reforked worker: #{Process.pid}, params: #{request[:params]}")
+            index = request[:params][:index]
+            assignment = Services::PathAssignment.new(max_index: request[:params][:max_index], index: index)
+
+            worker = self.class.new(project: project, reader: reader, writer: writer, assignment: assignment, commandline_args: commandline_args, io_socket: nil, buffered_changes: buffered_changes, service: service)
+
+            tags = Steep.logger.formatter.current_tags.dup
+            tags[tags.find_index("typecheck:typecheck@0")] = "typecheck:typecheck@#{index}-reforked"
+            Steep.logger.formatter.push_tags(tags)
+            worker.run()
+
+            raise "unreachable"
+          end
         end
       end