steep 1.8.3 → 1.9.0.dev.1

data/lib/steep/project.rb

@@ -3,6 +3,7 @@ module Steep
     attr_reader :targets
     attr_reader :steepfile_path
     attr_reader :base_dir
+    attr_accessor :global_options
 
     def initialize(steepfile_path:, base_dir: nil)
       @targets = []
@@ -30,21 +31,48 @@ module Steep
       (base_dir + path).cleanpath
     end
 
+    def group_for_source_path(path)
+      path = relative_path(path)
+      targets.each do |target|
+        ret = target.possible_source_file?(path)
+        return ret if ret
+      end
+      nil
+    end
+
+    def group_for_path(path)
+      group_for_source_path(path) || group_for_signature_path(path)
+    end
+
+    def group_for_signature_path(path)
+      relative = relative_path(path)
+      targets.each do
+        ret = _1.possible_signature_file?(relative)
+        return ret if ret
+      end
+      nil
+    end
+
     def target_for_source_path(path)
-      targets.find do |target|
-        target.possible_source_file?(path)
+      case group = group_for_source_path(path)
+      when Target
+        group
+      when Group
+        group.target
       end
     end
 
-    def targets_for_path(path)
-      if target = target_for_source_path(path)
-        target
-      else
-        ts = targets.select {|target| target.possible_signature_file?(path) }
-        unless ts.empty?
-          ts
-        end
+    def target_for_signature_path(path)
+      case group = group_for_signature_path(path)
+      when Target
+        group
+      when Group
+        group.target
       end
     end
+
+    def target_for_path(path)
+      target_for_source_path(path) || target_for_signature_path(path)
+    end
   end
 end

data/lib/steep/server/delay_queue.rb

@@ -10,9 +10,6 @@ module Steep
 
         @thread = Thread.new do
           while (scheduled_at, proc = queue.pop)
-            # @type var scheduled_at: Time
-            # @type var proc: ^() -> void
-
             diff = scheduled_at - Time.now
             case
             when diff > 0.1

data/lib/steep/server/interaction_worker.rb

@@ -3,7 +3,6 @@ module Steep
     class InteractionWorker < BaseWorker
       include ChangeBuffer
 
-      ApplyChangeJob = _ = Class.new()
       HoverJob = _ = Struct.new(:id, :path, :line, :column, keyword_init: true)
       CompletionJob = _ = Struct.new(:id, :path, :line, :column, :trigger, keyword_init: true)
       SignatureHelpJob = _ = Struct.new(:id, :path, :line, :column, keyword_init: true)
@@ -31,8 +30,6 @@ module Steep
           end
 
           case job
-          when ApplyChangeJob
-            # nop
           when HoverJob
             writer.write(
               {
@@ -72,9 +69,7 @@ module Steep
 
       def queue_job(job)
         @last_job_mutex.synchronize do
-          unless job.is_a?(ApplyChangeJob)
-            @last_job = job
-          end
+          @last_job = job
         end
         queue << job
       end
@@ -86,20 +81,17 @@ module Steep
 
         when "textDocument/didChange"
           collect_changes(request)
-          queue_job ApplyChangeJob.new
 
         when CustomMethods::FileLoad::METHOD
           params = request[:params] #: CustomMethods::FileLoad::params
           input = params[:content]
           load_files(input)
-          queue_job ApplyChangeJob.new
 
         when CustomMethods::FileReset::METHOD
           params = request[:params] #: CustomMethods::FileReset::params
           uri = params[:uri]
           text = params[:content]
           reset_change(uri: uri, text: text)
-          queue_job ApplyChangeJob.new
 
         when "textDocument/hover"
           id = request[:id]
@@ -183,8 +175,7 @@ module Steep
                 is_incomplete: false,
                 items: completion_items
               )
-            when (targets = project.targets_for_path(job.path)).is_a?(Array)
-              target = targets[0] or raise
+            when target = project.target_for_signature_path(job.path)
               sig_service = service.signature_services[target.name] or raise
               relative_path = job.path
 

data/lib/steep/server/master.rb

@@ -3,252 +3,6 @@ module Steep
     class Master
       LSP = LanguageServer::Protocol
 
-      class TypeCheckRequest
-        attr_reader :guid
-        attr_reader :library_paths
-        attr_reader :signature_paths
-        attr_reader :code_paths
-        attr_reader :priority_paths
-        attr_reader :checked_paths
-        attr_reader :work_done_progress
-        attr_reader :started_at
-        attr_accessor :needs_response
-
-        def initialize(guid:, progress:)
-          @guid = guid
-          @library_paths = Set[]
-          @signature_paths = Set[]
-          @code_paths = Set[]
-          @priority_paths = Set[]
-          @checked_paths = Set[]
-          @work_done_progress = progress
-          @started_at = Time.now
-          @needs_response = false
-        end
-
-        def uri(path)
-          Steep::PathHelper.to_uri(path)
-        end
-
-        def as_json(assignment:)
-          {
-            guid: guid,
-            library_uris: library_paths.grep(assignment).map {|path| uri(path).to_s },
-            signature_uris: signature_paths.grep(assignment).map {|path| uri(path).to_s },
-            code_uris: code_paths.grep(assignment).map {|path| uri(path).to_s },
-            priority_uris: priority_paths.map {|path| uri(path).to_s }
-          }
-        end
-
-        def total
-          library_paths.size + signature_paths.size + code_paths.size
-        end
-
-        def percentage
-          checked_paths.size * 100 / total
-        end
-
-        def all_paths
-          library_paths + signature_paths + code_paths
-        end
-
-        def checking_path?(path)
-          [library_paths, signature_paths, code_paths].any? do |paths|
-            paths.include?(path)
-          end
-        end
-
-        def checked(path)
-          raise unless checking_path?(path)
-          checked_paths << path
-        end
-
-        def finished?
-          total <= checked_paths.size
-        end
-
-        def unchecked_paths
-          all_paths - checked_paths
-        end
-
-        def unchecked_code_paths
-          code_paths - checked_paths
-        end
-
-        def unchecked_library_paths
-          library_paths - checked_paths
-        end
-
-        def unchecked_signature_paths
-          signature_paths - checked_paths
-        end
-      end
-
-      class TypeCheckController
-        attr_reader :project
-        attr_reader :priority_paths
-        attr_reader :changed_paths
-        attr_reader :target_paths
-
-        class TargetPaths
-          attr_reader :project
-          attr_reader :target
-          attr_reader :code_paths
-          attr_reader :signature_paths
-          attr_reader :library_paths
-
-          def initialize(project:, target:)
-            @project = project
-            @target = target
-            @code_paths = Set[]
-            @signature_paths = Set[]
-            @library_paths = Set[]
-          end
-
-          def all_paths
-            code_paths + signature_paths + library_paths
-          end
-
-          def library_path?(path)
-            library_paths.include?(path)
-          end
-
-          def signature_path?(path)
-            signature_paths.include?(path)
-          end
-
-          def code_path?(path)
-            code_paths.include?(path)
-          end
-
-          def add(path, library: false)
-            return true if signature_path?(path) || code_path?(path) || library_path?(path)
-
-            if library
-              library_paths << path
-              true
-            else
-              relative_path = project.relative_path(path)
-
-              case
-              when target.source_pattern =~ relative_path
-                code_paths << path
-                true
-              when target.signature_pattern =~ relative_path
-                signature_paths << path
-                true
-              else
-                false
-              end
-            end
-          end
-
-          alias << add
-        end
-
-        def initialize(project:)
-          @project = project
-          @priority_paths = Set[]
-          @changed_paths = Set[]
-          @target_paths = project.targets.each.map {|target| TargetPaths.new(project: project, target: target) }
-        end
-
-        def load(command_line_args:)
-          loader = Services::FileLoader.new(base_dir: project.base_dir)
-
-          files = {} #: Hash[String, String]
-
-          target_paths.each do |paths|
-            target = paths.target
-
-            signature_service = Services::SignatureService.load_from(target.new_env_loader(project: project))
-            paths.library_paths.merge(signature_service.env_rbs_paths)
-
-            loader.each_path_in_patterns(target.source_pattern, command_line_args) do |path|
-              paths.code_paths << project.absolute_path(path)
-              files[path.to_s] = project.absolute_path(path).read
-              if files.size > 1000
-                yield files.dup
-                files.clear
-              end
-            end
-            loader.each_path_in_patterns(target.signature_pattern) do |path|
-              paths.signature_paths << project.absolute_path(path)
-              files[path.to_s] = project.absolute_path(path).read
-              if files.size > 1000
-                yield files.dup
-                files.clear
-              end
-            end
-
-            changed_paths.merge(paths.all_paths)
-          end
-
-          yield files.dup unless files.empty?
-        end
-
-        def push_changes(path)
-          return if target_paths.any? {|paths| paths.library_path?(path) }
-
-          target_paths.each {|paths| paths << path }
-
-          if target_paths.any? {|paths| paths.code_path?(path) || paths.signature_path?(path) }
-            changed_paths << path
-          end
-        end
-
-        def update_priority(open: nil, close: nil)
-          path = open || close
-          path or raise
-
-          target_paths.each {|paths| paths << path }
-
-          case
-          when open
-            priority_paths << path
-          when close
-            priority_paths.delete path
-          end
-        end
-
-        def make_request(guid: SecureRandom.uuid, last_request: nil, include_unchanged: false, progress:)
-          return if changed_paths.empty? && !include_unchanged
-
-          TypeCheckRequest.new(guid: guid, progress: progress).tap do |request|
-            if last_request
-              request.library_paths.merge(last_request.unchecked_library_paths)
-              request.signature_paths.merge(last_request.unchecked_signature_paths)
-              request.code_paths.merge(last_request.unchecked_code_paths)
-            end
-
-            if include_unchanged
-              target_paths.each do |paths|
-                request.signature_paths.merge(paths.signature_paths)
-                request.library_paths.merge(paths.library_paths)
-                request.code_paths.merge(paths.code_paths)
-              end
-            else
-              updated_paths = target_paths.select {|paths| changed_paths.intersect?(paths.all_paths) }
-
-              updated_paths.each do |paths|
-                case
-                when paths.signature_paths.intersect?(changed_paths)
-                  request.signature_paths.merge(paths.signature_paths)
-                  request.library_paths.merge(paths.library_paths)
-                  request.code_paths.merge(paths.code_paths)
-                when paths.code_paths.intersect?(changed_paths)
-                  request.code_paths.merge(paths.code_paths & changed_paths)
-                end
-              end
-            end
-
-            request.priority_paths.merge(priority_paths)
-
-            changed_paths.clear()
-          end
-        end
-      end
-
       class ResultHandler
         attr_reader :request
         attr_reader :completion_handler
@@ -424,6 +178,7 @@ module Steep
       attr_reader :job_queue, :write_queue
 
       attr_reader :current_type_check_request
+      attr_reader :current_diagnostics
       attr_reader :controller
       attr_reader :result_controller
 
@@ -442,6 +197,7 @@ module Steep
         @commandline_args = []
         @job_queue = queue
         @write_queue = SizedQueue.new(100)
+        @current_diagnostics = {}
 
         @controller = TypeCheckController.new(project: project)
         @result_controller = ResultController.new()
@@ -533,7 +289,10 @@ module Steep
             end
           end
 
-          waiter = ThreadWaiter.new(each_worker.to_a) {|worker| worker.wait_thread }
+          waiter = ThreadWaiter.new
+          each_worker do |worker|
+            waiter << worker.wait_thread
+          end
           waiter.wait_one()
 
           unless job_queue.closed?
@@ -647,6 +406,10 @@ module Steep
                 end
               end
 
+              if typecheck_automatically
+                progress.end()
+              end
+
               if file_system_watcher_supported?
                 patterns = [] #: Array[String]
                 project.targets.each do |target|
@@ -693,11 +456,13 @@ module Steep
                 )
               end
 
-              if typecheck_automatically
-                if request = controller.make_request(guid: progress.guid, include_unchanged: true, progress: progress)
-                  start_type_check(request: request, last_request: nil)
-                end
-              end
+              controller.changed_paths.clear()
+
+              # if typecheck_automatically
+              #   if request = controller.make_request(guid: progress.guid, include_unchanged: true, progress: progress)
+              #     start_type_check(request: request, last_request: nil)
+              #   end
+              # end
             end
           end
 
@@ -742,7 +507,6 @@ module Steep
 
                   start_type_check(
                     last_request: last_request,
-                    include_unchanged: true,
                     progress: work_done_progress(guid),
                     needs_response: false
                   )
@@ -781,8 +545,15 @@ module Steep
           text = message[:params][:textDocument][:text]
 
           if path = pathname(uri)
-            controller.update_priority(open: path)
-            broadcast_notification(CustomMethods::FileReset.notification({ uri: uri, content: text }))
+            if target = project.group_for_path(path)
+              controller.update_priority(open: path)
+              # broadcast_notification(CustomMethods::FileReset.notification({ uri: uri, content: text }))
+
+              start_type_checking_queue.execute do
+                guid = SecureRandom.uuid
+                start_type_check(last_request: current_type_check_request, progress: work_done_progress(guid), needs_response: true)
+              end
+            end
           end
 
         when "textDocument/didClose"
@@ -821,6 +592,7 @@ module Steep
 
             group.on_completion do |handlers|
               result = handlers.flat_map(&:result)
+              result.uniq!
               enqueue_write_job SendMessageJob.to_client(message: { id: message[:id], result: result })
             end
           end
@@ -848,6 +620,7 @@ module Steep
 
               group.on_completion do |handlers|
                 links = handlers.flat_map(&:result)
+                links.uniq!
                 enqueue_write_job SendMessageJob.to_client(
                   message: {
                     id: message[:id],
@@ -866,15 +639,23 @@ module Steep
           end
 
         when CustomMethods::TypeCheck::METHOD
+          id = message[:id]
           params = message[:params] #: CustomMethods::TypeCheck::params
-          guid = params[:guid]
 
-          start_type_check(
-            last_request: current_type_check_request,
-            include_unchanged: true,
-            progress: work_done_progress(guid || SecureRandom.uuid),
-            needs_response: true
-          )
+          request = TypeCheckController::Request.new(guid: id, progress: work_done_progress(id))
+          request.needs_response = true
+
+          params[:code_paths].each do |target_name, path|
+            request.code_paths << [target_name.to_sym, Pathname(path)]
+          end
+          params[:signature_paths].each do |target_name, path|
+            request.signature_paths << [target_name.to_sym, Pathname(path)]
+          end
+          params[:library_paths].each do |target_name, path|
+            request.library_paths << [target_name.to_sym, Pathname(path)]
+          end
+
+          start_type_check(request: request, last_request: nil)
 
         when "$/ping"
           enqueue_write_job SendMessageJob.to_client(
@@ -916,9 +697,12 @@ module Steep
             case message[:method]
             when CustomMethods::TypeCheck__Progress::METHOD
               params = message[:params] #: CustomMethods::TypeCheck__Progress::params
+              target = project.targets.find {|target| target.name.to_s == params[:target] } or raise
               on_type_check_update(
                 guid: params[:guid],
-                path: Pathname(params[:path])
+                path: Pathname(params[:path]),
+                target: target,
+                diagnostics: params[:diagnostics]
               )
             else
               # Forward other notifications
@@ -966,23 +750,35 @@ module Steep
             request.needs_response = needs_response ? true : false
           end
 
+          if last_request
+            request.merge!(last_request)
+          end
+
           if request.total > report_progress_threshold
-            Steep.logger.info "Starting new progress..."
+            request.report_progress!
+          end
 
-            @current_type_check_request = request
+          if request.each_unchecked_target_path.to_a.empty?
+            finish_type_check(request)
+            @current_type_check_request = nil
+            return
+          end
 
-            if progress
-              # If `request:` keyword arg is not given
-              request.work_done_progress.begin("Type checking", request_id: fresh_request_id)
-            end
+          Steep.logger.info "Starting new progress..."
 
-            if request.finished?
-              finish_type_check(request)
-              @current_type_check_request = nil
-              return
+          @current_type_check_request = request
+          if last_request
+            checking_paths = request.each_path.to_set
+            current_diagnostics.keep_if do |path, _|
+              checking_paths.include?(path)
             end
           else
-            @current_type_check_request = nil
+            current_diagnostics.clear
+          end
+
+          if progress
+            # If `request:` keyword arg is not given
+            request.work_done_progress.begin("Type checking", request_id: fresh_request_id)
           end
 
           Steep.logger.info "Sending $/typecheck/start notifications"
@@ -1000,14 +796,17 @@ module Steep
         end
       end
 
-      def on_type_check_update(guid:, path:)
+      def on_type_check_update(guid:, path:, target:, diagnostics:)
         if current = current_type_check_request()
           if current.guid == guid
-            current.checked(path)
-            Steep.logger.info { "Request updated: checked=#{path}, unchecked=#{current.unchecked_paths.size}" }
+            current.checked(path, target)
+
+            Steep.logger.info { "Request updated: checked=#{path}, unchecked=#{current.each_unchecked_code_target_path.size}, diagnostics=#{diagnostics&.size}" }
 
             percentage = current.percentage
-            current.work_done_progress.report(percentage, "#{percentage}%")
+            current.work_done_progress.report(percentage, "#{current.checked_paths.size}/#{current.total}") if current.report_progress
+
+            push_diagnostics(path, diagnostics)
 
             if current.finished?
               finish_type_check(current)
@@ -1072,6 +871,22 @@ module Steep
           end
         end
       end
+
+      def push_diagnostics(path, diagnostics)
+        if diagnostics
+          ds = (current_diagnostics[path] ||= [])
+
+          ds.concat(diagnostics)
+          ds.uniq!
+
+          write_queue.push SendMessageJob.to_client(
+            message: {
+              method: :"textDocument/publishDiagnostics",
+              params: { uri: Steep::PathHelper.to_uri(path).to_s, diagnostics: ds }
+            }
+          )
+        end
+      end
     end
   end
 end