steep 1.4.0 → 1.5.0.pre.1

data/lib/steep/server/master.rb

@@ -450,50 +450,65 @@ module Steep
             end
           end
 
-          Steep.logger.tagged "main" do
-            while job = job_queue.deq
-              case job
-              when ReceiveMessageJob
-                src = case job.source
+          loop_thread = Thread.new do
+            Steep.logger.formatter.push_tags(*tags)
+            Steep.logger.tagged "main" do
+              while job = job_queue.deq
+                case job
+                when ReceiveMessageJob
+                  src = case job.source
+                        when :client
+                          :client
+                        else
+                          job.source.name
+                        end
+                  Steep.logger.tagged("ReceiveMessageJob(#{src}/#{job.message[:method]}/#{job.message[:id]})") do
+                    if job.response? && result_controller.process_response(job.message)
+                      # nop
+                      Steep.logger.info { "Processed by ResultController" }
+                    else
+                      case job.source
                       when :client
-                        :client
-                      else
-                        job.source.name
-                      end
-                Steep.logger.tagged("ReceiveMessageJob(#{src}/#{job.message[:method]}/#{job.message[:id]})") do
-                  if job.response? && result_controller.process_response(job.message)
-                    # nop
-                    Steep.logger.info { "Processed by ResultController" }
-                  else
-                    case job.source
-                    when :client
-                      process_message_from_client(job.message)
-
-                      if job.message[:method] == "exit"
-                        job_queue.close()
+                        process_message_from_client(job.message)
+
+                        if job.message[:method] == "exit"
+                          job_queue.close()
+                        end
+                      when WorkerProcess
+                        process_message_from_worker(job.message, worker: job.source)
                       end
-                    when WorkerProcess
-                      process_message_from_worker(job.message, worker: job.source)
                     end
                   end
-                end
-              when SendMessageJob
-                case job.dest
-                when :client
-                  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
+                when SendMessageJob
+                  case job.dest
+                  when :client
+                    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
+                  end
                 end
               end
             end
+          end
+
+          waiter = ThreadWaiter.new(each_worker.to_a) {|worker| worker.wait_thread }
+          waiter.wait_one()
 
-            read_client_thread.join()
-            worker_threads.each do |thread|
-              thread.join
+          unless job_queue.closed?
+            # Exit by error
+            each_worker do |worker|
+              worker.kill(force: true)
             end
+            raise "Unexpected worker process exit"
+          end
+
+          read_client_thread.join()
+          worker_threads.each do |thread|
+            thread.join
           end
+          loop_thread.join
         end
       end
 
@@ -555,7 +570,7 @@ module Steep
                       definition_provider: true,
                       declaration_provider: false,
                       implementation_provider: true,
-                      type_definition_provider: false
+                      type_definition_provider: true
                     )
                   )
                 }
@@ -654,7 +669,7 @@ module Steep
             end
           end
 
-        when "textDocument/definition", "textDocument/implementation"
+        when "textDocument/definition", "textDocument/implementation", "textDocument/typeDefinition"
           if path = pathname(message[:params][:textDocument][:uri])
             result_controller << group_request do |group|
               typecheck_workers.each do |worker|

data/lib/steep/server/type_check_worker.rb

@@ -30,6 +30,14 @@ module Steep
           )
         end
 
+        def self.type_definition(id:, params:)
+          new(
+            kind: :type_definition,
+            id: id,
+            params: params
+          )
+        end
+
         def implementation?
           kind == :implementation
         end
@@ -37,6 +45,10 @@ module Steep
         def definition?
           kind == :definition
         end
+
+        def type_definition?
+          kind == :type_definition
+        end
       end
 
       include ChangeBuffer
@@ -75,6 +87,8 @@ module Steep
           queue << GotoJob.definition(id: request[:id], params: request[:params])
         when "textDocument/implementation"
           queue << GotoJob.implementation(id: request[:id], params: request[:params])
+        when "textDocument/typeDefinition"
+          queue << GotoJob.type_definition(id: request[:id], params: request[:params])
         end
       end
 
@@ -266,7 +280,7 @@ module Steep
       end
 
       def goto(job)
-        path = Steep::PathHelper.to_pathname(job.params[:textDocument][:uri])
+        path = Steep::PathHelper.to_pathname(job.params[:textDocument][:uri]) or return []
         line = job.params[:position][:line] + 1
         column = job.params[:position][:character]
 
@@ -277,6 +291,8 @@ module Steep
             goto_service.definition(path: path, line: line, column: column)
           when job.implementation?
             goto_service.implementation(path: path, line: line, column: column)
+          when job.type_definition?
+            goto_service.type_definition(path: path, line: line, column: column)
           else
             raise
           end
@@ -293,7 +309,7 @@ module Steep
           path = project.absolute_path(path)
 
           {
-            uri: Steep::PathHelper.to_uri(path.to_s).to_s,
+            uri: Steep::PathHelper.to_uri(path).to_s,
             range: loc.as_lsp_range
           }
         end

data/lib/steep/server/worker_process.rb

@@ -63,6 +63,9 @@ module Steep
         worker.commandline_args = patterns
 
         pid = fork do
+          Process.setpgid(0, 0)
+          stdin_out.close
+          stdout_in.close
           worker.run()
         end
 
@@ -149,8 +152,22 @@ module Steep
         reader.read(&block)
       end
 
-      def kill
-        Process.kill(:TERM, @wait_thread.pid)
+      def kill(force: false)
+        Steep.logger.tagged("WorkerProcess#kill@#{name}(#{wait_thread.pid})") do
+          begin
+            signal = force ? :KILL : :TERM
+            Steep.logger.debug("Sending signal SIG#{signal}...")
+            Process.kill(signal, wait_thread.pid)
+            Steep.logger.debug("Successfully sent the signal.")
+          rescue Errno::ESRCH => error
+            Steep.logger.debug("Failed #{error.inspect}")
+          end
+          unless force
+            Steep.logger.debug("Waiting for process exit...")
+            wait_thread.join()
+            Steep.logger.debug("Confirmed process exit.")
+          end
+        end
       end
     end
   end

data/lib/steep/services/completion_provider.rb

@@ -98,6 +98,62 @@ module Steep
         # @implements GeneratedMethodNameItem
       end
 
+      class TypeNameItem < Struct.new(:env, :absolute_type_name, :relative_type_name, :range, keyword_init: true)
+        def decl
+          case
+          when absolute_type_name.interface?
+            env.interface_decls[absolute_type_name].decl
+          when absolute_type_name.alias?
+            env.type_alias_decls[absolute_type_name].decl
+          when absolute_type_name.class?
+            case entry = env.module_class_entry(absolute_type_name)
+            when RBS::Environment::ClassEntry, RBS::Environment::ModuleEntry
+              entry.primary.decl
+            when RBS::Environment::ClassAliasEntry, RBS::Environment::ModuleAliasEntry
+              entry.decl
+            else
+              raise
+            end
+          else
+            raise
+          end
+        end
+
+        def comments
+          comments = [] #: Array[RBS::AST::Comment]
+
+          case
+          when absolute_type_name.interface?
+            if comment = env.interface_decls[absolute_type_name].decl.comment
+              comments << comment
+            end
+          when absolute_type_name.alias?
+            if comment = env.type_alias_decls[absolute_type_name].decl.comment
+              comments << comment
+            end
+          when absolute_type_name.class?
+            case entry = env.module_class_entry(absolute_type_name)
+            when RBS::Environment::ClassEntry, RBS::Environment::ModuleEntry
+              entry.decls.each do |decl|
+                if comment = decl.decl.comment
+                  comments << comment
+                end
+              end
+            when RBS::Environment::ClassAliasEntry, RBS::Environment::ModuleAliasEntry
+              if comment = entry.decl.comment
+                comments << comment
+              end
+            else
+              raise
+            end
+          else
+            raise
+          end
+
+          comments
+        end
+      end
+
       attr_reader :source_text
       attr_reader :path
       attr_reader :subtyping
@@ -146,6 +202,39 @@ module Steep
             end
           end
 
+          if at_comment?(position)
+            node, *parents = source.find_nodes(line: position.line, column: position.column)
+
+            case
+            when node&.type == :assertion
+              # continue
+              node or raise
+              assertion = node.children[1] #: AST::Node::TypeAssertion
+              return items_for_rbs(position: position, buffer: assertion.location.buffer)
+
+            when node && parents && tapp_node = ([node] + parents).find {|n| n.type == :tapp }
+              tapp = tapp_node.children[1] #: AST::Node::TypeApplication
+              type_range = tapp.type_location.range
+
+              if type_range.begin < index && index <= type_range.end
+                return items_for_rbs(position: position, buffer: tapp.location.buffer)
+              end
+            else
+              annotation = source.each_annotation.flat_map {|_, annots| annots }.find do |a|
+                if a.location
+                  a.location.start_pos < index && index <= a.location.end_pos
+                end
+              end
+
+              if annotation
+                annotation.location or raise
+                return items_for_rbs(position: position, buffer: annotation.location.buffer)
+              else
+                return []
+              end
+            end
+          end
+
           Steep.measure "completion item collection" do
             items_for_trigger(position: position)
           end
@@ -154,9 +243,16 @@ module Steep
           Steep.logger.info "recovering syntax error: #{exn.inspect}"
           case possible_trigger
           when "."
-            source_text[index-1] = " "
-            type_check!(source_text, line: line, column: column)
-            items_for_dot(position: position)
+            if source_text[index-2] == "&"
+              source_text[index-1] = " "
+              source_text[index-2] = " "
+              type_check!(source_text, line: line, column: column)
+              items_for_qcall(position: position)
+            else
+              source_text[index-1] = " "
+              type_check!(source_text, line: line, column: column)
+              items_for_dot(position: position)
+            end
           when "@"
             source_text[index-1] = " "
             type_check!(source_text, line: line, column: column)
@@ -189,6 +285,14 @@ module Steep
         end
       end
 
+      def at_comment?(position)
+        if source.find_comment(line: position.line, column: position.column)
+          true
+        else
+          false
+        end
+      end
+
       def range_for(position, prefix: "")
         if prefix.empty?
           Range.new(start: position, end: position)
@@ -232,6 +336,19 @@ module Steep
 
           method_items_for_receiver_type(receiver_type, include_private: false, prefix: prefix, position: position, items: items)
 
+        when node.type == :csend && node.children[0] && at_end?(position, of: (_ = node.loc).selector)
+          # foo&.ba ←
+          receiver_type =
+            case (type = typing.type_of(node: node.children[0]))
+            when AST::Types::Self
+              context.self_type
+            else
+              unwrap_optional(type)
+            end
+          prefix = node.children[1].to_s
+
+          method_items_for_receiver_type(receiver_type, include_private: false, prefix: prefix, position: position, items: items)
+
         when node.type == :const && node.children[0] == nil && at_end?(position, of: node.loc)
           # Foo ← (const)
           prefix = node.children[1].to_s
@@ -267,6 +384,18 @@ module Steep
           # foo::← ba
           items.push(*items_for_colon2(position: position))
 
+        when node.type == :csend && at_end?(position, of: (_ = node.loc).dot)
+          # foo&.← ba
+          receiver_type =
+            case (type = typing.type_of(node: node.children[0]))
+            when AST::Types::Self
+              context.self_type
+            else
+              unwrap_optional(type)
+            end
+
+          method_items_for_receiver_type(receiver_type, include_private: false, prefix: "", position: position, items: items)
+
         when node.type == :ivar && at_end?(position, of: node.loc)
           # @fo ←
           instance_variable_items_for_context(context, position: position, prefix: node.children[0].to_s, items: items)
@@ -311,6 +440,36 @@ module Steep
         end
       end
 
+      def items_for_qcall(position:)
+        # foo&. ←
+        shift_pos = position-2
+        node, *_parents = source.find_nodes(line: shift_pos.line, column: shift_pos.column)
+        node ||= source.node
+
+        return [] unless node
+
+        if at_end?(shift_pos, of: node.loc)
+          begin
+            context = typing.context_at(line: position.line, column: position.column)
+            receiver_type =
+              case (type = typing.type_of(node: node))
+              when AST::Types::Self
+                context.self_type
+              else
+                unwrap_optional(type)
+              end
+
+            items = [] #: Array[item]
+            method_items_for_receiver_type(receiver_type, include_private: false, prefix: "", position: position, items: items)
+            items
+          rescue Typing::UnknownNodeError
+            []
+          end
+        else
+          []
+        end
+      end
+
       def items_for_colon2(position:)
         # :: ←
         shift_pos = position-2
@@ -350,6 +509,24 @@ module Steep
         items
       end
 
+      def items_for_rbs(position:, buffer:)
+        items = [] #: Array[item]
+
+        context = typing.context_at(line: position.line, column: position.column)
+        completion = TypeNameCompletion.new(env: context.env, context: context.module_context.nesting, dirs: [])
+        prefix = TypeNameCompletion::Prefix.parse(buffer, line: position.line, column: position.column)
+
+        size = prefix&.size || 0
+        range = Range.new(start: position - size, end: position)
+
+        completion.find_type_names(prefix).each do |name|
+          absolute, relative = completion.resolve_name_in_context(name)
+          items << TypeNameItem.new(relative_type_name: relative, absolute_type_name: absolute, env: context.env, range: range)
+        end
+
+        items
+      end
+
       def method_items_for_receiver_type(type, include_private:, prefix:, position:, items:)
         range = range_for(position, prefix: prefix)
         context = typing.context_at(line: position.line, column: position.column)
@@ -485,6 +662,15 @@ module Steep
         # an LSP option
         name == :initialize
       end
+
+      def unwrap_optional(type)
+        if type.is_a?(AST::Types::Union) && type.types.include?(AST::Builtin.nil_type)
+          types = type.types.reject { |t| t == AST::Builtin.nil_type }
+          AST::Types::Union.new(types: types, location: type.location)
+        else
+          type
+        end
+      end
     end
   end
 end

data/lib/steep/services/file_loader.rb

@@ -22,7 +22,7 @@ module Steep
               files = if absolute_path.directory?
                         Pathname.glob("#{absolute_path}/**/*#{pattern.ext}")
                       else
-                        Pathname.glob(absolute_path)
+                        Pathname.glob(absolute_path.to_s)
                       end
 
               files.sort.each do |source_path|