steep 0.42.0 → 0.43.0

data/lib/steep/server/type_check_worker.rb

@@ -3,10 +3,14 @@ module Steep
     class TypeCheckWorker < BaseWorker
       attr_reader :project, :assignment, :service
       attr_reader :commandline_args
+      attr_reader :current_type_check_guid
 
-      TypeCheckJob = Class.new
       WorkspaceSymbolJob = Struct.new(:query, :id, keyword_init: true)
       StatsJob = Struct.new(:id, keyword_init: true)
+      StartTypeCheckJob = Struct.new(:guid, :changes, keyword_init: true)
+      TypeCheckCodeJob = Struct.new(:guid, :path, keyword_init: true)
+      ValidateAppSignatureJob = Struct.new(:guid, :path, keyword_init: true)
+      ValidateLibrarySignatureJob = Struct.new(:guid, :path, keyword_init: true)
 
       include ChangeBuffer
 
@@ -14,22 +18,21 @@ module Steep
         super(project: project, reader: reader, writer: writer)
 
         @assignment = assignment
-        @service = Services::TypeCheckService.new(project: project, assignment: assignment)
+        @service = Services::TypeCheckService.new(project: project)
         @buffered_changes = {}
         @mutex = Mutex.new()
         @queue = Queue.new
         @commandline_args = commandline_args
+        @current_type_check_guid = nil
       end
 
       def handle_request(request)
         case request[:method]
         when "initialize"
           load_files(project: project, commandline_args: commandline_args)
-          queue << TypeCheckJob.new()
           writer.write({ id: request[:id], result: nil})
         when "textDocument/didChange"
           collect_changes(request)
-          queue << TypeCheckJob.new()
         when "workspace/symbol"
           query = request[:params][:query]
           queue << WorkspaceSymbolJob.new(id: request[:id], query: query)
@@ -38,31 +41,134 @@ module Steep
           when "steep/stats"
             queue << StatsJob.new(id: request[:id])
           end
+        when "$/typecheck/start"
+          params = request[:params]
+          enqueue_typecheck_jobs(params)
+        end
+      end
+
+      def enqueue_typecheck_jobs(params)
+        guid = params[:guid]
+
+        @current_type_check_guid = guid
+
+        pop_buffer() do |changes|
+          Steep.logger.info { "Enqueueing StartTypeCheckJob for guid=#{guid}" }
+          queue << StartTypeCheckJob.new(guid: guid, changes: changes)
+        end
+
+        priority_paths = Set.new(params[:priority_uris].map {|uri| Pathname(URI.parse(uri).path) })
+        library_paths = params[:library_uris].map {|uri| Pathname(URI.parse(uri).path) }
+        signature_paths = params[:signature_uris].map {|uri| Pathname(URI.parse(uri).path) }
+        code_paths = params[:code_uris].map {|uri| Pathname(URI.parse(uri).path) }
+
+        library_paths.each do |path|
+          if priority_paths.include?(path)
+            Steep.logger.info { "Enqueueing ValidateLibrarySignatureJob for guid=#{guid}, path=#{path}" }
+            queue << ValidateLibrarySignatureJob.new(guid: guid, path: path)
+          end
+        end
+
+        code_paths.each do |path|
+          if priority_paths.include?(path)
+            Steep.logger.info { "Enqueueing TypeCheckCodeJob for guid=#{guid}, path=#{path}" }
+            queue << TypeCheckCodeJob.new(guid: guid, path: path)
+          end
+        end
+
+        signature_paths.each do |path|
+          if priority_paths.include?(path)
+            Steep.logger.info { "Enqueueing ValidateAppSignatureJob for guid=#{guid}, path=#{path}" }
+            queue << ValidateAppSignatureJob.new(guid: guid, path: path)
+          end
+        end
+
+        library_paths.each do |path|
+          unless priority_paths.include?(path)
+            Steep.logger.info { "Enqueueing ValidateLibrarySignatureJob for guid=#{guid}, path=#{path}" }
+            queue << ValidateLibrarySignatureJob.new(guid: guid, path: path)
+          end
+        end
+
+        code_paths.each do |path|
+          unless priority_paths.include?(path)
+            Steep.logger.info { "Enqueueing TypeCheckCodeJob for guid=#{guid}, path=#{path}" }
+            queue << TypeCheckCodeJob.new(guid: guid, path: path)
+          end
+        end
+
+        signature_paths.each do |path|
+          unless priority_paths.include?(path)
+            Steep.logger.info { "Enqueueing ValidateAppSignatureJob for guid=#{guid}, path=#{path}" }
+            queue << ValidateAppSignatureJob.new(guid: guid, path: path)
+          end
         end
       end
 
       def handle_job(job)
         case job
-        when TypeCheckJob
-          pop_buffer() do |changes|
-            break if changes.empty?
+        when StartTypeCheckJob
+          Steep.logger.info { "Processing StartTypeCheckJob for guid=#{job.guid}" }
+          service.update(changes: job.changes)
+
+        when ValidateAppSignatureJob
+          if job.guid == current_type_check_guid
+            Steep.logger.info { "Processing ValidateAppSignature for guid=#{job.guid}, path=#{job.path}" }
+            service.validate_signature(path: project.relative_path(job.path)) do |path, diagnostics|
+              formatter = Diagnostic::LSPFormatter.new()
 
-            formatter = Diagnostic::LSPFormatter.new()
+              writer.write(
+                method: :"textDocument/publishDiagnostics",
+                params: LSP::Interface::PublishDiagnosticsParams.new(
+                  uri: URI.parse(job.path.to_s).tap {|uri| uri.scheme = "file"},
+                  diagnostics: diagnostics.map {|diagnostic| formatter.format(diagnostic) }.uniq
+                )
+              )
+            end
 
-            service.update(changes: changes) do |path, diagnostics|
+            typecheck_progress(path: job.path, guid: job.guid)
+          end
+
+        when ValidateLibrarySignatureJob
+          if job.guid == current_type_check_guid
+            Steep.logger.info { "Processing ValidateLibrarySignature for guid=#{job.guid}, path=#{job.path}" }
+            service.validate_signature(path: job.path) do |path, diagnostics|
+              formatter = Diagnostic::LSPFormatter.new()
+
+              writer.write(
+                method: :"textDocument/publishDiagnostics",
+                params: LSP::Interface::PublishDiagnosticsParams.new(
+                  uri: URI.parse(job.path.to_s).tap {|uri| uri.scheme = "file"},
+                  diagnostics: diagnostics.map {|diagnostic| formatter.format(diagnostic) }.uniq
+                )
+              )
+            end
+
+            typecheck_progress(path: job.path, guid: job.guid)
+          end
+
+        when TypeCheckCodeJob
+          if job.guid == current_type_check_guid
+            Steep.logger.info { "Processing TypeCheckCodeJob for guid=#{job.guid}, path=#{job.path}" }
+            service.typecheck_source(path: project.relative_path(job.path)) do |path, diagnostics|
               if target = project.target_for_source_path(path)
                 diagnostics = diagnostics.select {|diagnostic| target.options.error_to_report?(diagnostic) }
               end
 
+              formatter = Diagnostic::LSPFormatter.new()
+
               writer.write(
                 method: :"textDocument/publishDiagnostics",
                 params: LSP::Interface::PublishDiagnosticsParams.new(
-                  uri: URI.parse(project.absolute_path(path).to_s).tap {|uri| uri.scheme = "file"},
+                  uri: URI.parse(job.path.to_s).tap {|uri| uri.scheme = "file"},
                   diagnostics: diagnostics.map {|diagnostic| formatter.format(diagnostic) }.uniq
                 )
               )
             end
+
+            typecheck_progress(path: job.path, guid: job.guid)
           end
+
         when WorkspaceSymbolJob
           writer.write(
             id: job.id,
@@ -76,14 +182,21 @@ module Steep
         end
       end
 
+      def typecheck_progress(guid:, path:)
+        writer.write(
+          method: "$/typecheck/progress",
+          params: { guid: guid, path: path }
+        )
+      end
+
       def workspace_symbol_result(query)
         Steep.measure "Generating workspace symbol list for query=`#{query}`" do
           indexes = project.targets.map {|target| service.signature_services[target.name].latest_rbs_index }
 
-          provider = Index::SignatureSymbolProvider.new()
+          provider = Index::SignatureSymbolProvider.new(project: project, assignment: assignment)
           provider.indexes.push(*indexes)
 
-          symbols = provider.query_symbol(query, assignment: assignment)
+          symbols = provider.query_symbol(query)
 
           symbols.map do |symbol|
             LSP::Interface::SymbolInformation.new(
@@ -110,8 +223,9 @@ module Steep
 
         project.targets.each.with_object([]) do |target, stats|
           service.source_files.each_value do |file|
-            next unless assignment =~ file.path
             next unless target.possible_source_file?(file.path)
+            absolute_path = project.absolute_path(file.path)
+            next unless assignment =~ absolute_path
 
             stats << calculator.calc_stats(target, file: file)
           end

data/lib/steep/server/worker_process.rb

@@ -7,16 +7,18 @@ module Steep
 
       attr_reader :name
       attr_reader :wait_thread
+      attr_reader :index
 
-      def initialize(reader:, writer:, stderr:, wait_thread:, name:)
+      def initialize(reader:, writer:, stderr:, wait_thread:, name:, index: nil)
         @reader = reader
         @writer = writer
         @stderr = stderr
         @wait_thread = wait_thread
         @name = name
+        @index = index
       end
 
-      def self.spawn_worker(type, name:, steepfile:, options: [], delay_shutdown: false)
+      def self.spawn_worker(type, name:, steepfile:, options: [], delay_shutdown: false, index: nil)
         log_level = %w(debug info warn error fatal unknown)[Steep.logger.level]
         command = case type
                   when :interaction
@@ -37,7 +39,7 @@ module Steep
         writer = LanguageServer::Protocol::Transport::Io::Writer.new(stdin)
         reader = LanguageServer::Protocol::Transport::Io::Reader.new(stdout)
 
-        new(reader: reader, writer: writer, stderr: stderr, wait_thread: thread, name: name)
+        new(reader: reader, writer: writer, stderr: stderr, wait_thread: thread, name: name, index: index)
       end
 
       def self.spawn_typecheck_workers(steepfile:, args:, count: [Etc.nprocessors - 1, 1].max, delay_shutdown: false)
@@ -46,7 +48,8 @@ module Steep
                        name: "typecheck@#{i}",
                        steepfile: steepfile,
                        options: ["--max-index=#{count}", "--index=#{i}", *args],
-                       delay_shutdown: delay_shutdown)
+                       delay_shutdown: delay_shutdown,
+                       index: i)
         end
       end
 

data/lib/steep/services/completion_provider.rb

@@ -82,7 +82,7 @@ module Steep
           end
 
         rescue Parser::SyntaxError => exn
-          Steep.logger.error "recovering syntax error: #{exn.inspect}"
+          Steep.logger.info "recovering syntax error: #{exn.inspect}"
           case possible_trigger
           when "."
             source_text[index-1] = " "
@@ -143,7 +143,7 @@ module Steep
 
         when node.type == :lvar && at_end?(position, of: node.loc)
           # foo ← (lvar)
-          local_variable_items_for_context(context, position: position, prefix: node.children[0].name.to_s, items: items)
+          local_variable_items_for_context(context, position: position, prefix: node.children[0].to_s, items: items)
 
         when node.type == :send && node.children[0] && at_end?(position, of: node.loc.selector)
           # foo.ba ←

data/lib/steep/services/hover_content.rb

@@ -43,6 +43,7 @@ module Steep
       def typecheck(target, path:, content:, line:, column:)
         subtyping = service.signature_services[target.name].current_subtyping or return
         source = Source.parse(content, path: path, factory: subtyping.factory)
+        source = source.without_unrelated_defs(line: line, column: column)
         Services::TypeCheckService.type_check(source: source, subtyping: subtyping)
       rescue
         nil
@@ -62,15 +63,15 @@ module Steep
             when :lvar
               var_name = node.children[0]
               context = typing.context_at(line: line, column: column)
-              var_type = context.lvar_env[var_name.name] || AST::Types::Any.new(location: nil)
+              var_type = context.lvar_env[var_name] || AST::Types::Any.new(location: nil)
 
-              VariableContent.new(node: node, name: var_name.name, type: var_type, location: node.location.name)
+              VariableContent.new(node: node, name: var_name, type: var_type, location: node.location.name)
             when :lvasgn
               var_name, rhs = node.children
               context = typing.context_at(line: line, column: column)
-              type = context.lvar_env[var_name.name] || typing.type_of(node: rhs)
+              type = context.lvar_env[var_name] || typing.type_of(node: rhs)
 
-              VariableContent.new(node: node, name: var_name.name, type: type, location: node.location.name)
+              VariableContent.new(node: node, name: var_name, type: type, location: node.location.name)
             when :send
               receiver, method_name, *_ = node.children
 

data/lib/steep/services/path_assignment.rb

@@ -14,15 +14,13 @@ module Steep
       end
 
       def =~(path)
-        path = path.to_s
+        (cache[path] ||= self.class.index_for(path: path.to_s, max_index: max_index)) == index
+      end
+
+      alias === =~
 
-        if cache.key?(path)
-          cache[path]
-        else
-          value = Digest::MD5.hexdigest(path).hex % max_index == index
-          cache[path] = value
-          value
-        end
+      def self.index_for(path:, max_index:)
+        Digest::MD5.hexdigest(path).hex % max_index
       end
     end
   end

data/lib/steep/services/signature_service.rb

@@ -71,11 +71,17 @@ module Steep
         new(env: env)
       end
 
+      def env_rbs_paths
+        @env_rbs_paths ||= latest_env.buffers.each.with_object(Set[]) do |buffer, set|
+          set << Pathname(buffer.name)
+        end
+      end
+
       def each_rbs_path(&block)
         if block
-          latest_env.buffers.each do |buffer|
-            unless files.key?(buffer.name)
-              yield Pathname(buffer.name)
+          env_rbs_paths.each do |path|
+            unless files.key?(path)
+              yield path
             end
           end
 
@@ -133,6 +139,12 @@ module Steep
 
                 update[path] = begin
                                  FileStatus.new(path: path, content: content, decls: RBS::Parser.parse_signature(buffer))
+                               rescue ArgumentError => exn
+                                 error = Diagnostic::Signature::UnexpectedError.new(
+                                   message: exn.message,
+                                   location: RBS::Location.new(buffer: buffer, start_pos: 0, end_pos: content.size)
+                                 )
+                                 FileStatus.new(path: path, content: content, decls: error)
                                rescue RBS::ParsingError => exn
                                  FileStatus.new(path: path, content: content, decls: exn)
                                end
@@ -148,13 +160,18 @@ module Steep
           paths = Set.new(updates.each_key)
           paths.merge(pending_changed_paths)
 
-          if updates.each_value.any? {|file| file.decls.is_a?(RBS::ParsingError) }
+          if updates.each_value.any? {|file| !file.decls.is_a?(Array) }
             diagnostics = []
 
             updates.each_value do |file|
-              if file.decls.is_a?(RBS::ParsingError)
-                # factory is not used here because the error is a syntax error.
-                diagnostics << Diagnostic::Signature.from_rbs_error(file.decls, factory: nil)
+              unless file.decls.is_a?(Array)
+                diagnostic = if file.decls.is_a?(Diagnostic::Signature::Base)
+                               file.decls
+                             else
+                               # factory is not used here because the error is a syntax error.
+                               Diagnostic::Signature.from_rbs_error(file.decls, factory: nil)
+                             end
+                diagnostics << diagnostic
               end
             end
 
@@ -206,7 +223,8 @@ module Steep
 
           Steep.measure "Loading new decls" do
             updated_files.each_value do |content|
-              if content.decls.is_a?(RBS::ErrorBase)
+              case decls = content.decls
+              when RBS::ErrorBase
                 errors << content.decls
               else
                 begin
@@ -300,13 +318,29 @@ module Steep
       def type_names(paths:, env:)
         env.declarations.each.with_object(Set[]) do |decl, set|
           if decl.location
-            if paths.include?(decl.location.buffer.name)
+            if paths.include?(Pathname(decl.location.buffer.name))
               type_name_from_decl(decl, set: set)
             end
           end
         end
       end
 
+      def const_decls(paths:, env:)
+        env.constant_decls.filter do |_, entry|
+          if location = entry.decl.location
+            paths.include?(Pathname(location.buffer.name))
+          end
+        end
+      end
+
+      def global_decls(paths:, env: latest_env)
+        env.global_decls.filter do |_, entry|
+          if location = entry.decl.location
+            paths.include?(Pathname(location.buffer.name))
+          end
+        end
+      end
+
       def type_name_from_decl(decl, set:)
         case decl
         when RBS::AST::Declarations::Class, RBS::AST::Declarations::Module, RBS::AST::Declarations::Interface

data/lib/steep/services/type_check_service.rb

@@ -2,7 +2,6 @@ module Steep
   module Services
     class TypeCheckService
       attr_reader :project
-      attr_reader :assignment
       attr_reader :signature_validation_diagnostics
       attr_reader :source_files
       attr_reader :signature_services
@@ -50,27 +49,54 @@ module Steep
         end
       end
 
-      def initialize(project:, assignment:)
-        @project = project
-        @assignment = assignment
+      class TargetRequest
+        attr_reader :target
+        attr_reader :source_paths
 
-        @signature_validation_diagnostics = {}
-        @source_files = {}
-        @signature_services = project.targets.each.with_object({}) do |target, hash|
-          loader = Project::Target.construct_env_loader(options: target.options)
-          hash[target.name] = SignatureService.load_from(loader)
+        def initialize(target:)
+          @target = target
+          @source_paths = Set[]
+          @signature_updated = false
         end
 
-        @no_type_checking = false
-      end
+        def signature_updated!(value = true)
+          @signature_updated = value
+          self
+        end
+
+        def signature_updated?
+          @signature_updated
+        end
+
+        def empty?
+          !signature_updated? && source_paths.empty?
+        end
+
+        def ==(other)
+          other.is_a?(TargetRequest) &&
+            other.target == target &&
+            other.source_paths == source_paths &&
+            other.signature_updated? == signature_updated?
+        end
 
-      def no_type_checking!
-        @no_type_checking = true
-        self
+        alias eql? ==
+
+        def hash
+          self.class.hash ^ target.hash ^ source_paths.hash ^ @signature_updated.hash
+        end
       end
 
-      def no_type_checking?
-        @no_type_checking
+      def initialize(project:)
+        @project = project
+
+        @source_files = {}
+        @signature_services = project.targets.each.with_object({}) do |target, hash|
+          loader = Project::Target.construct_env_loader(options: target.options, project: project)
+          hash[target.name] = SignatureService.load_from(loader)
+        end
+        @signature_validation_diagnostics = project.targets.each.with_object({}) do |target, hash|
+          hash[target.name] = {}
+        end
       end
 
       def signature_diagnostics
@@ -80,24 +106,18 @@ module Steep
           service = signature_services[target.name]
 
           service.each_rbs_path do |path|
-            if assignment =~ path
-              signature_diagnostics[path] ||= []
-            end
+            signature_diagnostics[path] ||= []
           end
 
           case service.status
           when SignatureService::SyntaxErrorStatus, SignatureService::AncestorErrorStatus
             service.status.diagnostics.group_by {|diag| Pathname(diag.location.buffer.name) }.each do |path, diagnostics|
-              if assignment =~ path
-                signature_diagnostics[path].push(*diagnostics)
-              end
+              signature_diagnostics[path].push(*diagnostics)
             end
           when SignatureService::LoadedStatus
             validation_diagnostics = signature_validation_diagnostics[target.name] || {}
             validation_diagnostics.each do |path, diagnostics|
-              if assignment =~ path
-                signature_diagnostics[path].push(*diagnostics)
-              end
+              signature_diagnostics[path].push(*diagnostics)
             end
           end
         end
@@ -127,166 +147,192 @@ module Steep
         end
       end
 
-      def update(changes:, &block)
-        updated_targets = Steep.measure "#update_signature" do
-          update_signature(changes: changes, &block)
+      def update(changes:)
+        requests = project.targets.each_with_object({}.compare_by_identity) do |target, hash|
+          hash[target] = TargetRequest.new(target: target)
         end
-        Steep.measure2 "Type check target" do |sampler|
-          project.targets.each do |target|
-            sampler.sample target.name.to_s do
-              update_target(target: target, changes: changes, updated: updated_targets.include?(target), &block)
-            end
-          end
+
+        Steep.measure "#update_signature" do
+          update_signature(changes: changes, requests: requests)
         end
+
+        Steep.measure "#update_sources" do
+          update_sources(changes: changes, requests: requests)
+        end
+
+        requests.transform_keys(&:name).reject {|_, request| request.empty? }
       end
 
-      def update_signature(changes:, &block)
-        Steep.logger.tagged "#update_signature" do
-          updated_targets = []
+      def update_and_check(changes:, assignment:, &block)
+        requests = update(changes: changes)
 
-          Steep.measure2 "Update signatures" do |sampler|
-            project.targets.each do |target|
-              sampler.sample target.name.to_s do
-                signature_service = signature_services[target.name]
-                signature_changes = changes.filter {|path, _| target.possible_signature_file?(path) }
+        signatures = requests.each_value.with_object(Set[]) do |request, sigs|
+          if request.signature_updated?
+            service = signature_services[request.target.name]
+            sigs.merge(service.each_rbs_path)
+          end
+        end
 
-                unless signature_changes.empty?
-                  updated_targets << target
-                  signature_service.update(signature_changes)
-                end
-              end
+        signatures.each do |path|
+          if assignment =~ path
+            validate_signature(path: path, &block)
+          end
+        end
+
+        requests.each_value do |request|
+          request.source_paths.each do |path|
+            if assignment =~ path
+              typecheck_source(path: path, target: request.target, &block)
             end
           end
+        end
+      end
 
-          Steep.measure "signature validations" do
-            accumulated_diagnostics = {}
+      def validate_signature(path:, &block)
+        Steep.logger.tagged "#validate_signature(path=#{path})" do
+          Steep.measure "validation" do
+            accumulated_diagnostics = []
 
-            updated_targets.each do |target|
+            project.targets.each do |target|
               service = signature_services[target.name]
 
-              next if no_type_checking?
+              next unless target.possible_signature_file?(path) || service.env_rbs_paths.include?(path)
 
               case service.status
-              when SignatureService::SyntaxErrorStatus, SignatureService::AncestorErrorStatus
-                service.status.diagnostics.group_by {|diag| Pathname(diag.location.buffer.name) }.each do |path, diagnostics|
-                  if assignment =~ path
-                    array = accumulated_diagnostics[path] ||= []
-                    array.push(*diagnostics)
-                    yield [path, array]
-                  end
+              when SignatureService::SyntaxErrorStatus
+                diagnostics = service.status.diagnostics.select do |diag|
+                  Pathname(diag.location.buffer.name) == path &&
+                    (diag.is_a?(Diagnostic::Signature::SyntaxError) || diag.is_a?(Diagnostic::Signature::UnexpectedError))
+                end
+                accumulated_diagnostics.push(*diagnostics)
+                unless diagnostics.empty?
+                  yield [path, accumulated_diagnostics]
                 end
+
+              when SignatureService::AncestorErrorStatus
+                diagnostics = service.status.diagnostics.select {|diag| Pathname(diag.location.buffer.name) == path }
+                accumulated_diagnostics.push(*diagnostics)
+                yield [path, accumulated_diagnostics]
+
               when SignatureService::LoadedStatus
                 validator = Signature::Validator.new(checker: service.current_subtyping)
-                paths = service.each_rbs_path.select {|path| assignment =~ path }.to_set
-                type_names = service.type_names(paths: paths, env: service.latest_env).to_set
-
-                Steep.measure2 "Validating #{type_names.size} types from #{paths.size} files" do |sampler|
-                  type_names.each do |type_name|
-                    sampler.sample type_name.to_s do
-                      case
-                      when type_name.class?
-                        validator.validate_one_class(type_name)
-                      when type_name.interface?
-                        validator.validate_one_interface(type_name)
-                      when type_name.alias?
-                        validator.validate_one_alias(type_name)
+                type_names = service.type_names(paths: Set[path], env: service.latest_env).to_set
+
+                unless type_names.empty?
+                  Steep.measure2 "Validating #{type_names.size} types" do |sampler|
+                    type_names.each do |type_name|
+                      sampler.sample(type_name.to_s) do
+                        case
+                        when type_name.class?
+                          validator.validate_one_class(type_name)
+                        when type_name.interface?
+                          validator.validate_one_interface(type_name)
+                        when type_name.alias?
+                          validator.validate_one_alias(type_name)
+                        end
                       end
                     end
                   end
                 end
 
-                Steep.measure "Validating const and globals" do
-                  validator.validate_const()
-                  validator.validate_global()
+                const_decls = service.const_decls(paths: Set[path], env: service.latest_env)
+                unless const_decls.empty?
+                  Steep.measure2 "Validating #{const_decls.size} constants" do |sampler|
+                    const_decls.each do |name, entry|
+                      sampler.sample(name.to_s) do
+                        validator.validate_one_constant(name, entry)
+                      end
+                    end
+                  end
                 end
 
-                target_diagnostics = validator.each_error.group_by {|error| Pathname(error.location.buffer.name) }
-                signature_validation_diagnostics[target.name] = target_diagnostics
-
-                paths.each do |path|
-                  array = (accumulated_diagnostics[path] ||= [])
-                  if ds = target_diagnostics[path]
-                    array.push(*ds)
+                global_decls = service.global_decls(paths: Set[path])
+                unless global_decls.empty?
+                  Steep.measure2 "Validating #{global_decls.size} globals" do |sampler|
+                    global_decls.each do |name, entry|
+                      sampler.sample(name.to_s) do
+                        validator.validate_one_global(name, entry)
+                      end
+                    end
                   end
-                  yield [path, array]
                 end
+
+                diagnostics = validator.each_error.select {|error| Pathname(error.location.buffer.name) == path }
+                accumulated_diagnostics.push(*diagnostics)
+                yield [path, accumulated_diagnostics]
               end
+
+              signature_validation_diagnostics[target.name][path] = diagnostics
             end
           end
-
-          updated_targets
         end
       end
 
-      def update_target(changes:, target:, updated:, &block)
-        Steep.logger.tagged "#update_target" do
-          contents = {}
-
-          if updated
-            source_files.each do |path, file|
-              if target.possible_source_file?(path)
-                contents[path] = file.content
-              end
+      def typecheck_source(path:, target: project.target_for_source_path(path), &block)
+        Steep.logger.tagged "#typecheck_source(path=#{path})" do
+          Steep.measure "typecheck" do
+            signature_service = signature_services[target.name]
+            subtyping = signature_service.current_subtyping
+
+            if subtyping
+              text = source_files[path].content
+              file = type_check_file(target: target, subtyping: subtyping, path: path, text: text)
+              yield [file.path, file.diagnostics]
+              source_files[path] = file
             end
+          end
+        end
+      end
 
-            changes.each do |path, changes|
-              if target.possible_source_file?(path)
-                text = contents[path] || ""
-                contents[path] = changes.inject(text) {|text, change| change.apply_to(text) }
-              end
-            end
-          else
-            changes.each do |path, changes|
-              if target.possible_source_file?(path)
-                text = source_files[path]&.content || ""
-                contents[path] = changes.inject(text) {|text, change| change.apply_to(text) }
-              end
+      def update_signature(changes:, requests:)
+        Steep.logger.tagged "#update_signature" do
+          project.targets.each do |target|
+            signature_service = signature_services[target.name]
+            signature_changes = changes.filter {|path, _| target.possible_signature_file?(path) }
+
+            unless signature_changes.empty?
+              requests[target].signature_updated!
+              signature_service.update(signature_changes)
             end
           end
+        end
+      end
 
-          signature_service = signature_services[target.name]
-          subtyping = signature_service.current_subtyping
+      def update_sources(changes:, requests:)
+        requests.each_value do |request|
+          source_files
+            .select {|path, file| request.target.possible_source_file?(path) }
+            .each do |path, file|
+            (changes[path] ||= []).prepend(ContentChange.string(file.content))
+          end
+        end
 
-          Steep.measure2 "Type check sources" do |sampler|
-            contents.each do |path, text|
-              if assignment =~ path
-                if subtyping
-                  file = sampler.sample(path.to_s) do
-                    type_check_file(target: target, subtyping: subtyping, path: path, text: text)
-                  end
-                  yield [file.path, file.diagnostics]
-                else
-                  if source_files.key?(path)
-                    file = source_files[path]&.update_content(text)
-                  else
-                    file = SourceFile.no_data(path: path, content: text)
-                    yield [file.path, []]
-                  end
-                end
+        changes.each do |path, changes|
+          target = project.target_for_source_path(path)
 
-                source_files[path] = file
-              end
-            end
+          if target
+            file = source_files[path] || SourceFile.no_data(path: path, content: "")
+            content = changes.inject(file.content) {|text, change| change.apply_to(text) }
+            source_files[path] = file.update_content(content)
+            requests[target].source_paths << path
           end
         end
       end
 
       def type_check_file(target:, subtyping:, path:, text:)
         Steep.logger.tagged "#type_check_file(#{path}@#{target.name})" do
-          if no_type_checking?
-            SourceFile.no_data(path: path, content: text)
-          else
-            source = Source.parse(text, path: path, factory: subtyping.factory)
-            typing = TypeCheckService.type_check(source: source, subtyping: subtyping)
-            SourceFile.with_typing(path: path, content: text, node: source.node, typing: typing)
-          end
+          source = Source.parse(text, path: path, factory: subtyping.factory)
+          typing = TypeCheckService.type_check(source: source, subtyping: subtyping)
+          SourceFile.with_typing(path: path, content: text, node: source.node, typing: typing)
         end
       rescue AnnotationParser::SyntaxError => exn
-        SourceFile.no_data(path: path, content: text)
-        # SourceFile.with_syntax_error(path: path, content: text, error: exn)
-      rescue ::Parser::SyntaxError, EncodingError => exn
-        SourceFile.no_data(path: path, content: text)
-        # SourceFile.with_syntax_error(path: path, content: text, error: exn)
+        error = Diagnostic::Ruby::SyntaxError.new(message: exn.message, location: exn.location)
+        SourceFile.with_syntax_error(path: path, content: text, error: error)
+      rescue ::Parser::SyntaxError => exn
+        error = Diagnostic::Ruby::SyntaxError.new(message: exn.message, location: exn.diagnostic.location)
+        SourceFile.with_syntax_error(path: path, content: text, error: error)
+      rescue EncodingError => exn
+        SourceFile.no_data(path: path, content: "")
       end
 
       def self.type_check(source:, subtyping:)