steep 1.10.0 → 2.0.0

data/lib/steep/drivers/check.rb

@@ -17,9 +17,18 @@ module Steep
       attr_accessor :validate_project_signatures
       attr_accessor :validate_library_signatures
       attr_accessor :formatter
+      attr_accessor :use_daemon
+      attr_reader :expressions
 
       include Utils::DriverHelper
 
+      PLURALIZE = {
+        "diagnostic" => "diagnostics",
+        "expression" => "expressions",
+        "file" => "files",
+        "problem" => "problems",
+      }.freeze
+
       def initialize(stdout:, stderr:)
         @stdout = stdout
         @stderr = stderr
@@ -32,6 +41,8 @@ module Steep
         @validate_project_signatures = false
         @validate_library_signatures = false
         @formatter = 'code'
+        @use_daemon = true
+        @expressions = []
       end
 
       def active_group?(group)
@@ -53,178 +64,121 @@ module Steep
       def run
         project = load_config()
 
-        stdout.puts Rainbow("# Type checking files:").bold
-        stdout.puts
+        unless expressions.empty?
+          return run_expressions(project)
+        end
 
-        client_read, server_write = IO.pipe
-        server_read, client_write = IO.pipe
+        params = build_typecheck_params(project)
 
-        client_reader = LSP::Transport::Io::Reader.new(client_read)
-        client_writer = LSP::Transport::Io::Writer.new(client_write)
+        diagnostic_notifications = [] #: Array[LanguageServer::Protocol::Interface::PublishDiagnosticsParams]
+        error_messages = [] #: Array[String]
 
-        server_reader = LSP::Transport::Io::Reader.new(server_read)
-        server_writer = LSP::Transport::Io::Writer.new(server_write)
+        setup_connection(project) do |reader, writer|
+          request_guid = SecureRandom.uuid
+          writer.write(Server::CustomMethods::TypeCheck.request(request_guid, params))
+
+          wait_for_response_id(reader: reader, id: request_guid) do |message|
+            case message[:method]
+            when "textDocument/publishDiagnostics"
+              ds = message[:params][:diagnostics]
+              ds.select! { |d| keep_diagnostic?(d, severity_level: severity_level) }
+              stdout.print(ds.empty? ? "." : "F")
+              diagnostic_notifications << message[:params]
+              stdout.flush
+            when "window/showMessage"
+              if message[:params][:type] == LSP::Constant::MessageType::ERROR
+                error_messages << message[:params][:message]
+              end
+            end
+          end
+        end
 
-        typecheck_workers = Server::WorkerProcess.start_typecheck_workers(
-          steepfile: project.steepfile_path,
-          args: command_line_patterns,
-          delay_shutdown: true,
-          steep_command: jobs_option.steep_command,
-          count: jobs_option.jobs_count_value
-        )
+        stdout.puts
+        stdout.puts
 
-        master = Server::Master.new(
-          project: project,
-          reader: server_reader,
-          writer: server_writer,
-          interaction_worker: nil,
-          typecheck_workers: typecheck_workers
-        )
-        master.typecheck_automatically = false
-        master.commandline_args.push(*command_line_patterns)
+        print_typecheck_result(project: project, diagnostic_notifications: diagnostic_notifications, error_messages: error_messages)
+      rescue Errno::EPIPE => error
+        stdout.puts Rainbow("Steep shutdown with an error: #{error.inspect}").red.bold
+        1
+      end
 
-        main_thread = Thread.start do
-          Thread.current.abort_on_exception = true
-          master.start()
-        end
+      def run_expressions(project)
+        target = project.targets.first or raise "No targets configured"
 
-        Steep.logger.info { "Initializing server" }
-        initialize_id = request_id()
-        client_writer.write({ method: :initialize, id: initialize_id, params: DEFAULT_CLI_LSP_INITIALIZE_PARAMS })
-        wait_for_response_id(reader: client_reader, id: initialize_id)
+        stdout.puts Rainbow("# Type checking expression:").bold
+        stdout.puts
 
-        params = { library_paths: [], signature_paths: [], code_paths: [] } #: Server::CustomMethods::TypeCheck::params
+        loader = Project::Target.construct_env_loader(options: target.options, project: project)
+        signature_service = Services::SignatureService.load_from(loader, implicitly_returns_nil: target.implicitly_returns_nil)
+        subtyping = signature_service.current_subtyping or raise "Failed to build subtyping"
 
-        if command_line_patterns.empty?
-          files = Server::TargetGroupFiles.new(project)
-          loader = Services::FileLoader.new(base_dir: project.base_dir)
+        lsp_formatter = Diagnostic::LSPFormatter.new(target.code_diagnostics_config)
+        total = 0
 
-          project.targets.each do |target|
-            target.new_env_loader.each_dir do |_, dir|
-              RBS::FileFinder.each_file(dir, skip_hidden: true) do |path|
-                files.add_library_path(target, path)
-              end
-            end
+        expressions.each_with_index do |expr, index|
+          expr_path = Pathname(expressions.size > 1 ? "(expression:#{index})" : "(expression)")
 
-            loader.each_path_in_target(target) do |path|
-              files.add_path(path)
-            end
+          begin
+            source = Source.parse(expr, path: expr_path, factory: subtyping.factory)
+          rescue ::Parser::SyntaxError => exn
+            stdout.puts Rainbow("Syntax error in #{expr_path}: #{exn.message}").red.bold
+            total += 1
+            next
           end
 
-          project.targets.each do |target|
-            target.groups.each do |group|
-              if active_group?(group)
-                load_files(files, group.target, group, params: params)
-              end
-            end
-            if active_group?(target)
-              load_files(files, target, target, params: params)
-            end
-          end
-        else
-          command_line_patterns.each do |pattern|
-            path = Pathname(pattern)
-            path = project.absolute_path(path)
-            next unless path.file?
-            if target = project.target_for_source_path(path)
-              params[:code_paths] << [target.name.to_s, path.to_s]
-            end
-            if target = project.target_for_signature_path(path)
-              params[:signature_paths] << [target.name.to_s, path.to_s]
-            end
-          end
-        end
+          typing = Services::TypeCheckService.type_check(
+            source: source,
+            subtyping: subtyping,
+            constant_resolver: signature_service.latest_constant_resolver,
+            cursor: nil
+          )
 
-        Steep.logger.info { "Starting type check with #{params[:code_paths].size} Ruby files and #{params[:signature_paths].size} RBS signatures..." }
-        Steep.logger.debug { params.inspect }
+          diagnostics = typing.errors.filter_map { |error| lsp_formatter.format(error) }
+          diagnostics.select! { |d| keep_diagnostic?(d, severity_level: severity_level) }
 
-        request_guid = SecureRandom.uuid
-        Steep.logger.info { "Starting type checking: #{request_guid}" }
-        client_writer.write(Server::CustomMethods::TypeCheck.request(request_guid, params))
+          unless diagnostics.empty?
+            buffer = RBS::Buffer.new(name: expr_path, content: expr)
+            printer = DiagnosticPrinter.new(buffer: buffer, stdout: stdout, formatter: self.formatter)
 
-        diagnostic_notifications = [] #: Array[LanguageServer::Protocol::Interface::PublishDiagnosticsParams]
-        error_messages = [] #: Array[String]
-
-        response = wait_for_response_id(reader: client_reader, id: request_guid) do |message|
-          case
-          when message[:method] == "textDocument/publishDiagnostics"
-            ds = message[:params][:diagnostics]
-            ds.select! {|d| keep_diagnostic?(d, severity_level: severity_level) }
-            if ds.empty?
-              stdout.print "."
-            else
-              stdout.print "F"
-            end
-            diagnostic_notifications << message[:params]
-            stdout.flush
-          when message[:method] == "window/showMessage"
-            # Assuming ERROR message means unrecoverable error.
-            message = message[:params]
-            if message[:type] == LSP::Constant::MessageType::ERROR
-              error_messages << message[:message]
+            diagnostics.each do |diag|
+              printer.print(diag)
+              stdout.puts
             end
+
+            total += diagnostics.size
           end
         end
 
-        Steep.logger.info { "Finished type checking: #{response.inspect}" }
-
-        Steep.logger.info { "Shutting down..." }
-
-        shutdown_exit(reader: client_reader, writer: client_writer)
-        main_thread.join()
-
-        stdout.puts
-        stdout.puts
-
-        if error_messages.empty?
-          loader = Services::FileLoader.new(base_dir: project.base_dir)
-          all_files = project.targets.each.with_object(Set[]) do |target, set|
-            set.merge(loader.load_changes(target.source_pattern, command_line_patterns, changes: {}).each_key)
-            set.merge(loader.load_changes(target.signature_pattern, changes: {}).each_key)
-          end.to_a
-
-          case
-          when with_expectations_path
-            print_expectations(project: project,
-                               all_files: all_files,
-                               expectations_path: with_expectations_path,
-                               notifications: diagnostic_notifications)
-          when save_expectations_path
-            save_expectations(project: project,
-                              all_files: all_files,
-                              expectations_path: save_expectations_path,
-                              notifications: diagnostic_notifications)
-          else
-            print_result(project: project, notifications: diagnostic_notifications)
-          end
+        if total == 0
+          emoji = %w(🫖 🫖 🫖 🫖 🫖 🫖 🫖 🫖 🍵 🧋 🧉).sample
+          stdout.puts Rainbow("No type error detected. #{emoji}").green.bold
+          0
         else
-          stdout.puts Rainbow("Unexpected error reported. 🚨").red.bold
+          stdout.puts Rainbow("Detected #{total} #{pluralize("problem", total)} from #{expressions.size} #{pluralize("expression", expressions.size)}").red.bold
           1
         end
-      rescue Errno::EPIPE => error
-        stdout.puts Rainbow("Steep shutdown with an error: #{error.inspect}").red.bold
-        return 1
       end
 
       def load_files(files, target, group, params:)
         if type_check_code
-          files.each_group_source_path(group, true) do |path|
+          files.source_paths.each_group_path(group) do |path,|
             params[:code_paths] << [target.name.to_s, target.project.absolute_path(path).to_s]
           end
+          files.inline_paths.each_group_path(group) do |path,|
+            params[:inline_paths] << [target.name.to_s, target.project.absolute_path(path).to_s]
+          end
         end
         if validate_group_signatures
-          files.each_group_signature_path(group) do |path|
+          files.signature_paths.each_group_path(group) do |path,|
             params[:signature_paths] << [target.name.to_s, target.project.absolute_path(path).to_s]
           end
         end
         if validate_project_signatures
-          files.each_project_signature_path(target) do |path|
-            if path_target = files.signature_path_target(path)
-              params[:signature_paths] << [path_target.name.to_s, target.project.absolute_path(path).to_s]
-            end
+          files.signature_paths.each_project_path(except: target) do |path, path_target|
+            params[:signature_paths] << [path_target.name.to_s, target.project.absolute_path(path).to_s]
           end
           if group.is_a?(Project::Group)
-            files.each_target_signature_path(target, group) do |path|
+            files.signature_paths.each_target_path(target, except: group) do |path,|
               params[:signature_paths] << [target.name.to_s, target.project.absolute_path(path).to_s]
             end
           end
@@ -274,13 +228,13 @@ module Steep
           stdout.puts
 
           stdout.puts Rainbow("Expectations unsatisfied:").bold.red
-          stdout.puts "  #{expected_count} expected #{"diagnostic".pluralize(expected_count)}"
-          stdout.puts Rainbow("  + #{unexpected_count} unexpected #{"diagnostic".pluralize(unexpected_count)}").green
-          stdout.puts Rainbow("  - #{missing_count} missing #{"diagnostic".pluralize(missing_count)}").red
+          stdout.puts "  #{expected_count} expected #{pluralize("diagnostic", expected_count)}"
+          stdout.puts Rainbow("  + #{unexpected_count} unexpected #{pluralize("diagnostic", unexpected_count)}").green
+          stdout.puts Rainbow("  - #{missing_count} missing #{pluralize("diagnostic", missing_count)}").red
           1
         else
           stdout.puts Rainbow("Expectations satisfied:").bold.green
-          stdout.puts "  #{expected_count} expected #{"diagnostic".pluralize(expected_count)}"
+          stdout.puts "  #{expected_count} expected #{pluralize("diagnostic", expected_count)}"
           0
         end
       end
@@ -332,10 +286,217 @@ module Steep
             end
           end
 
-          stdout.puts Rainbow("Detected #{total} #{"problem".pluralize(total)} from #{errors.size} #{"file".pluralize(errors.size)}").red.bold
+          stdout.puts Rainbow("Detected #{total} #{pluralize("problem", total)} from #{errors.size} #{pluralize("file", errors.size)}").red.bold
           1
         end
       end
+
+      def pluralize(string, count)
+        if count == 1
+          string
+        else
+          PLURALIZE.fetch(string)
+        end
+      end
+
+      private
+
+      def setup_connection(project, &block)
+        if use_daemon && daemon_available?
+          begin
+            stdout.puts Rainbow("# Type checking files (server mode):").bold
+            stdout.puts
+            return with_daemon_connection(&block)
+          rescue Errno::ECONNREFUSED, Errno::ENOENT => e
+            stderr.puts "Steep server connection failed (#{e.message}), falling back to standard mode"
+          end
+        end
+
+        stdout.puts Rainbow("# Type checking files:").bold
+        stdout.puts
+        with_local_server(project, &block)
+      end
+
+      def daemon_available?
+        if Daemon.running?
+          Steep.logger.info { "Daemon detected, using server mode" }
+          return true
+        end
+
+        if Daemon.starting?
+          Steep.logger.info { "Daemon is starting, waiting for it to be ready" }
+          if wait_for_daemon
+            return true
+          else
+            stderr.puts Rainbow("Daemon failed to start, falling back to standard mode").yellow
+          end
+        end
+
+        false
+      end
+
+      def with_daemon_connection
+        socket = UNIXSocket.new(Daemon.socket_path)
+        reader = LSP::Transport::Io::Reader.new(socket)
+        writer = LSP::Transport::Io::Writer.new(socket)
+        yield reader, writer
+      ensure
+        socket&.close
+      end
+
+      def with_local_server(project)
+        client_read, server_write = IO.pipe
+        server_read, client_write = IO.pipe
+
+        client_reader = LSP::Transport::Io::Reader.new(client_read)
+        client_writer = LSP::Transport::Io::Writer.new(client_write)
+
+        server_reader = LSP::Transport::Io::Reader.new(server_read)
+        server_writer = LSP::Transport::Io::Writer.new(server_write)
+
+        typecheck_workers = Server::WorkerProcess.start_typecheck_workers(
+          steepfile: project.steepfile_path,
+          args: command_line_patterns,
+          delay_shutdown: true,
+          steep_command: jobs_option.steep_command,
+          count: jobs_option.jobs_count_value
+        )
+
+        master = Server::Master.new(
+          project: project,
+          reader: server_reader,
+          writer: server_writer,
+          interaction_worker: nil,
+          typecheck_workers: typecheck_workers
+        )
+        master.typecheck_automatically = false
+        master.commandline_args.push(*command_line_patterns)
+
+        main_thread = Thread.start do
+          Thread.current.abort_on_exception = true
+          master.start()
+        end
+
+        Steep.logger.info { "Initializing server" }
+        initialize_id = request_id()
+        client_writer.write({ method: :initialize, id: initialize_id, params: DEFAULT_CLI_LSP_INITIALIZE_PARAMS })
+        wait_for_response_id(reader: client_reader, id: initialize_id)
+
+        yield client_reader, client_writer
+      ensure
+        if client_reader && client_writer
+          shutdown_exit(reader: client_reader, writer: client_writer)
+        end
+        main_thread&.join()
+      end
+
+      def print_typecheck_result(project:, diagnostic_notifications:, error_messages:)
+        if error_messages.empty?
+          loader = Services::FileLoader.new(base_dir: project.base_dir)
+          all_files = project.targets.each.with_object(Set[]) do |target, set|
+            set.merge(loader.load_changes(target.source_pattern, command_line_patterns, changes: {}).each_key)
+            set.merge(loader.load_changes(target.signature_pattern, changes: {}).each_key)
+          end.to_a
+
+          case
+          when with_expectations_path
+            print_expectations(project: project,
+                               all_files: all_files,
+                               expectations_path: with_expectations_path,
+                               notifications: diagnostic_notifications)
+          when save_expectations_path
+            save_expectations(project: project,
+                              all_files: all_files,
+                              expectations_path: save_expectations_path,
+                              notifications: diagnostic_notifications)
+          else
+            print_result(project: project, notifications: diagnostic_notifications)
+          end
+        else
+          stdout.puts Rainbow("Unexpected error reported. 🚨").red.bold
+          1
+        end
+      end
+
+      def build_typecheck_params(project)
+        params = { library_paths: [], inline_paths: [], signature_paths: [], code_paths: [] } #: Server::CustomMethods::TypeCheck::params
+
+        if command_line_patterns.empty?
+          files = Server::TargetGroupFiles.new(project)
+          loader = Services::FileLoader.new(base_dir: project.base_dir)
+
+          project.targets.each do |target|
+            target.new_env_loader.each_dir do |_, dir|
+              RBS::FileFinder.each_file(dir, skip_hidden: true) do |path|
+                files.add_library_path(target, path)
+              end
+            end
+
+            loader.each_path_in_target(target) do |path|
+              files.add_path(path)
+            end
+          end
+
+          project.targets.each do |target|
+            target.groups.each do |group|
+              if active_group?(group)
+                load_files(files, target, group, params: params)
+              end
+            end
+            if active_group?(target)
+              load_files(files, target, target, params: params)
+            end
+          end
+        else
+          command_line_patterns.each do |pattern|
+            path = Pathname(pattern)
+            path = project.absolute_path(path)
+            next unless path.file?
+            if target = project.target_for_source_path(path)
+              params[:code_paths] << [target.name.to_s, path.to_s]
+            end
+            if target = project.target_for_signature_path(path)
+              params[:signature_paths] << [target.name.to_s, path.to_s]
+            end
+            if target = project.target_for_inline_source_path(path)
+              params[:inline_paths] << [target.name.to_s, path.to_s]
+            end
+          end
+        end
+
+        params
+      end
+
+      def wait_for_daemon(timeout: 300)
+        stdout.puts "Daemon is warming up, waiting for it to be ready..."
+        start_time = Time.now
+        dots_printed = 0
+
+        loop do
+          if Daemon.running?
+            stdout.puts unless dots_printed == 0
+            return true
+          end
+
+          elapsed = Time.now - start_time
+          if elapsed > timeout
+            stdout.puts unless dots_printed == 0
+            Steep.logger.warn { "Daemon warm-up timed out after #{timeout}s" }
+            return false
+          end
+
+          unless Daemon.starting?
+            stdout.puts unless dots_printed == 0
+            Steep.logger.warn { "Daemon process died during warm-up" }
+            return false
+          end
+
+          sleep 1
+          stdout.print "."
+          stdout.flush
+          dots_printed += 1
+        end
+      end
     end
   end
 end

data/lib/steep/drivers/print_project.rb

@@ -1,5 +1,3 @@
-require "active_support/core_ext/hash/keys"
-
 module Steep
   module Drivers
     class PrintProject
@@ -19,17 +17,18 @@ module Steep
 
       def as_json(project)
         {
-          steepfile: project.steepfile_path.to_s,
-          targets: project.targets.map do |target|
+          "steepfile" => project.steepfile_path.to_s,
+          "targets" => project.targets.map do |target|
             target_as_json(target)
           end
-        }.stringify_keys
+        }
       end
 
       def target_as_json(target)
         json = {
           "name" => target.name.to_s,
           "source_pattern" => pattern_as_json(target.source_pattern),
+          "inline_source_pattern" => pattern_as_json(target.inline_source_pattern),
           "signature_pattern" => pattern_as_json(target.signature_pattern),
           "groups" => target.groups.map do |group|
             group_as_json(group)
@@ -52,10 +51,10 @@ module Steep
         } #: target_json
 
         if files
-          files.each_group_signature_path(target, true) do |path|
+          files.signature_paths.each_group_path(target) do |path,|
             (json["signature_paths"] ||= []) << path.to_s
           end
-          files.each_group_source_path(target, true) do |path|
+          files.source_paths.each_group_path(target) do |path,|
             (json["source_paths"] ||= []) << path.to_s
           end
         end
@@ -71,11 +70,11 @@ module Steep
         } #: group_json
 
         if files
-          files.each_group_signature_path(group, true) do |path|
+          files.signature_paths.each_group_path(group) do |path,|
             (json["signature_paths"] ||= []) << path.to_s
-
           end
-          files.each_group_source_path(group, true) do |path|
+
+          files.source_paths.each_group_path(group) do |path,|
             (json["source_paths"] ||= []) << path.to_s
           end
         end

data/lib/steep/drivers/query.rb

@@ -0,0 +1,102 @@
+module Steep
+  module Drivers
+    class Query
+      LSP = LanguageServer::Protocol
+
+      attr_reader :stdout
+      attr_reader :stderr
+
+      def initialize(stdout:, stderr:)
+        @stdout = stdout
+        @stderr = stderr
+      end
+
+      # @rbs locations: Array[[String, Integer, Integer]] -- array of [path, line, column]
+      # @rbs return: Integer
+      def run_hover(locations:)
+        unless Daemon.running?
+          stderr.puts "Error: Steep daemon is not running. Start it with `steep server start`."
+          return 1
+        end
+
+        locations.each do |path, line, column|
+          absolute_path = to_absolute_path(path)
+          unless absolute_path
+            stdout.puts JSON.generate({ file: path, line: line, column: column, error: "File not found: #{path}" })
+            next
+          end
+
+          uri = PathHelper.to_uri(absolute_path).to_s
+
+          request = {
+            id: SecureRandom.uuid,
+            method: "textDocument/hover",
+            params: {
+              textDocument: { uri: uri },
+              position: { line: line - 1, character: column - 1 }
+            }
+          }
+
+          result = send_request(request)
+          stdout.puts JSON.generate({ file: path, line: line, column: column, result: result })
+        end
+
+        0
+      rescue Errno::ECONNREFUSED, Errno::ENOENT => e
+        stderr.puts "Error: Failed to connect to Steep daemon: #{e.message}"
+        1
+      end
+
+      # @rbs names: Array[String]
+      # @rbs return: Integer
+      def run_definition(names:)
+        unless Daemon.running?
+          stderr.puts "Error: Steep daemon is not running. Start it with `steep server start`."
+          return 1
+        end
+
+        names.each do |name|
+          request = {
+            id: SecureRandom.uuid,
+            method: Server::CustomMethods::Query__Definition::METHOD,
+            params: { name: name }
+          }
+
+          result = send_request(request)
+          stdout.puts JSON.generate({ name: name, result: result })
+        end
+
+        0
+      rescue Errno::ECONNREFUSED, Errno::ENOENT => e
+        stderr.puts "Error: Failed to connect to Steep daemon: #{e.message}"
+        1
+      end
+
+      private
+
+      def to_absolute_path(path)
+        pathname = Pathname(path)
+        pathname = Pathname.pwd + pathname unless pathname.absolute?
+        pathname.file? ? pathname : nil
+      end
+
+      def send_request(request)
+        socket = UNIXSocket.new(Daemon.socket_path)
+        reader = LSP::Transport::Io::Reader.new(socket)
+        writer = LSP::Transport::Io::Writer.new(socket)
+
+        writer.write(request)
+
+        result = nil #: untyped
+        reader.read do |message|
+          result = message[:result]
+          break
+        end
+
+        result
+      ensure
+        socket&.close
+      end
+    end
+  end
+end