steep 2.0.0 → 2.1.0

data/lib/steep/interface/builder.rb

@@ -65,7 +65,7 @@ module Steep
       end
 
       def shape(type, config)
-        Steep.logger.tagged "shape(#{type})" do
+        Steep.logger.tagged(-> { "shape(#{type})" }) do
           if shape = raw_shape(type, config)
             # Optimization that skips unnecessary substitution
             if type.free_variables.include?(AST::Types::Self.instance)
@@ -82,7 +82,7 @@ module Steep
       end
 
       def fetch_cache(cache, key)
-        if cache.key?(key) # steep:ignore ArgumentTypeMismatch
+        if cache.key?(key)
           return cache.fetch(key)
         end
 
@@ -277,7 +277,7 @@ module Steep
           definition = factory.definition_builder.build_singleton(type_name)
 
           definition.methods.each do |name, method|
-            Steep.logger.tagged "method = #{type_name}.#{name}" do
+            Steep.logger.tagged(-> { "method = #{type_name}.#{name}" }) do
               overloads = method.defs.map do |type_def|
                 method_name = method_name_for(type_def, name)
                 method_type = factory.method_type(type_def.type)
@@ -309,7 +309,7 @@ module Steep
           definition or raise
 
           definition.methods.each do |name, method|
-            Steep.logger.tagged "method = #{type_name}##{name}" do
+            Steep.logger.tagged(-> { "method = #{type_name}##{name}" }) do
               overloads = method.defs.map do |type_def|
                 method_name = method_name_for(type_def, name)
                 method_type = factory.method_type(type_def.type)
@@ -592,11 +592,31 @@ module Steep
           )
         end
 
+        to_ary_entry = Shape::Entry.new(
+          method_name: :to_ary,
+          private_method: false,
+          overloads: [
+            Shape::MethodOverload.new(
+              MethodType.new(
+                type_params: [],
+                type: Function.new(
+                  params: Function::Params.empty,
+                  return_type: tuple,
+                  location: nil
+                ),
+                block: nil
+              ),
+              []
+            )
+          ]
+        )
+
         shape.methods[:[]] = aref_entry
         shape.methods[:[]=] = aref_update_entry
         shape.methods[:fetch] = fetch_entry
         shape.methods[:first] = first_entry
         shape.methods[:last] = last_entry
+        shape.methods[:to_ary] = to_ary_entry
 
         shape
       end

data/lib/steep/node_helper.rb

@@ -220,7 +220,7 @@ module Steep
 
     def private_send?(node)
       case node.type
-      when :block, :numblock
+      when :block, :numblock, :itblock
         private_send?(node.children[0])
       when :send, :csend
         receiver, = deconstruct_send_node!(node)
@@ -243,7 +243,7 @@ module Steep
         when :send, :csend, :super
           if block_node
             case block_node.type
-            when :block, :numblock
+            when :block, :numblock, :itblock
               if send_node.equal?(block_node.children[0])
                 return [send_node, block_node]
               end

data/lib/steep/server/base_worker.rb

@@ -56,6 +56,21 @@ module Steep
                     handle_job(job)
                   rescue => exn
                     Steep.log_error exn
+
+                    # Jobs that carry an `id` answer a request. Reply with an error response, or the
+                    # client would wait for a response that never arrives.
+                    if job.respond_to?(:id) && (id = job.id)
+                      writer.write(
+                        {
+                          id: id,
+                          error: {
+                            code: LSP::Constant::ErrorCodes::INTERNAL_ERROR,
+                            message: "Unexpected error: #{exn.message} (#{exn.class})"
+                          }
+                        }
+                      )
+                    end
+
                     writer.write(
                       {
                         method: "window/showMessage",

data/lib/steep/server/command_socket.rb

@@ -0,0 +1,181 @@
+# frozen_string_literal: true
+
+module Steep
+  module Server
+    # Accepts connections on a UNIX socket and forwards the received requests to the master
+    #
+    # Started by `steep langserver` so that CLI commands like `steep query` and `steep check` can
+    # talk to the language server the IDE is running, instead of a standalone daemon process.
+    #
+    class CommandSocket
+      LSP = LanguageServer::Protocol
+
+      # A connection from a CLI client
+      #
+      # `#write` never raises even if the client is disconnected, because it may be called from
+      # the master's write thread, which should keep running for other clients.
+      #
+      class Session
+        attr_reader :socket
+
+        def initialize(socket)
+          @socket = socket
+          @writer = LSP::Transport::Io::Writer.new(socket)
+          @mutex = Mutex.new
+          @closed = false
+        end
+
+        def write(message)
+          @mutex.synchronize do
+            return if @closed
+            @writer.write(message)
+          end
+        rescue SystemCallError, IOError
+          close()
+        end
+
+        def close
+          @mutex.synchronize do
+            @closed = true
+          end
+          begin
+            @socket.close
+          rescue IOError
+            # Already closed
+          end
+        end
+      end
+
+      attr_reader :master, :configuration
+
+      def initialize(master:, configuration:)
+        @master = master
+        @configuration = configuration
+        @server = nil
+        @accept_thread = nil
+      end
+
+      def socket_path
+        configuration.socket_path
+      end
+
+      # Binds the UNIX socket and starts accepting connections in a background thread
+      #
+      # Returns `false` without binding when another process (a standalone `steep server` daemon or
+      # another language server) is already serving on the socket.
+      #
+      def start
+        if File.exist?(socket_path)
+          if socket_alive?
+            Steep.logger.warn { "Command socket is already served by another process: #{socket_path}" }
+            return false
+          end
+
+          unless File.socket?(socket_path)
+            Steep.logger.error { "#{socket_path} exists but is not a socket, skipping command socket setup" }
+            return false
+          end
+
+          File.delete(socket_path)
+        end
+
+        @server = UNIXServer.new(socket_path)
+        File.chmod(0o600, socket_path)
+
+        @accept_thread = Thread.new do
+          Thread.current.abort_on_exception = false
+          accept_loop()
+        end
+
+        Steep.logger.info { "Command socket is ready: #{socket_path}" }
+
+        true
+      rescue Errno::EADDRINUSE
+        Steep.logger.warn { "Command socket is already served by another process: #{socket_path}" }
+        false
+      end
+
+      def stop
+        server = @server
+        @server = nil
+
+        if server
+          begin
+            server.close
+          rescue IOError
+            # Already closed
+          end
+
+          @accept_thread&.join(1)
+
+          begin
+            File.delete(socket_path)
+          rescue Errno::ENOENT
+            # Already deleted
+          end
+        end
+      end
+
+      private
+
+      def socket_alive?
+        socket = UNIXSocket.new(socket_path)
+        socket.close
+        true
+      rescue SystemCallError
+        false
+      end
+
+      def accept_loop
+        while server = @server
+          socket =
+            begin
+              server.accept
+            rescue IOError, SystemCallError => error
+              Steep.logger.info { "Command socket accept loop stopping: #{error.inspect}" }
+              break
+            end
+
+          # The loop must survive anything but the accept errors above: it runs with
+          # `abort_on_exception` disabled, so an uncaught error would kill the thread
+          # silently and every connection after it would sit in the backlog forever.
+          begin
+            Steep.logger.info { "Command socket accepted a connection" }
+
+            # `session` is passed as a thread argument: `while` shares its locals across
+            # iterations, so a block reading `session` directly would serve the session of a
+            # later iteration when the accept loop wins the race against the thread's start,
+            # leaving the accepted connection unread.
+            Thread.new(Session.new(socket)) do |session|
+              Thread.current.abort_on_exception = false
+              serve(session)
+            end
+          rescue StandardError => error
+            Steep.logger.error { "Command socket could not serve an accepted connection: #{error.inspect}" }
+            begin
+              socket.close
+            rescue IOError
+              # Already closed
+            end
+          end
+        end
+      ensure
+        Steep.logger.info { "Command socket accept loop finished" }
+      end
+
+      def serve(session)
+        reader = LSP::Transport::Io::Reader.new(session.socket)
+        reader.read do |message|
+          Steep.logger.info { "Command socket received message: method=#{message[:method] || "-"}, id=#{message[:id] || "-"}" }
+          master.process_command_socket_message(message, session)
+        end
+      rescue IOError, SystemCallError => error
+        Steep.logger.warn { "Command socket client error: #{error.inspect}" }
+      ensure
+        Steep.logger.info { "Command socket connection closed" }
+        master.finish_command_socket_session(session)
+        session.close
+      end
+    end
+  end
+end

data/lib/steep/server/custom_methods.rb

@@ -96,6 +96,18 @@ module Steep
           { id: id, result: result }
         end
       end
+
+      module Query__Diagnostics
+        METHOD = "$/steep/query/diagnostics"
+
+        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