steep 1.8.2 → 1.9.0.dev.1

data/lib/steep/server/type_check_worker.rb

@@ -8,9 +8,9 @@ module Steep
       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)
+      TypeCheckCodeJob = _ = Struct.new(:guid, :path, :target, keyword_init: true)
+      ValidateAppSignatureJob = _ = Struct.new(:guid, :path, :target, keyword_init: true)
+      ValidateLibrarySignatureJob = _ = Struct.new(:guid, :path, :target, keyword_init: true)
       class GotoJob < Struct.new(:id, :kind, :params, keyword_init: true)
         def self.implementation(id:, params:)
           new(
@@ -111,51 +111,47 @@ module Steep
           queue << StartTypeCheckJob.new(guid: guid, changes: changes)
         end
 
-        priority_paths = Set.new(params[:priority_uris].map {|uri| Steep::PathHelper.to_pathname(uri) || raise })
-        library_paths = params[:library_uris].map {|uri| Steep::PathHelper.to_pathname(uri) || raise }
-        signature_paths = params[:signature_uris].map {|uri| Steep::PathHelper.to_pathname(uri) || raise }
-        code_paths = params[:code_uris].map {|uri| Steep::PathHelper.to_pathname(uri) || raise }
+        targets = project.targets.each.with_object({}) do |target, hash| #$ Hash[String, Project::Target]
+          hash[target.name.to_s] = target
+        end
 
-        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
+        priority_paths = Set.new(params[:priority_uris].map {|uri| Steep::PathHelper.to_pathname!(uri) })
+        libraries = params[:library_uris].map {|target_name, uri| [targets.fetch(target_name), Steep::PathHelper.to_pathname!(uri)] } #: Array[[Project::Target, Pathname]]
+        signatures = params[:signature_uris].map {|target_name, uri| [targets.fetch(target_name), Steep::PathHelper.to_pathname!(uri)] } #: Array[[Project::Target, Pathname]]
+        codes = params[:code_uris].map {|target_name, uri| [targets.fetch(target_name), Steep::PathHelper.to_pathname!(uri)] } #: Array[[Project::Target, Pathname]]
+
+        priority_libs, non_priority_libs = libraries.partition {|_, path| priority_paths.include?(path) }
+        priority_sigs, non_priority_sigs = signatures.partition {|_, path| priority_paths.include?(path) }
+        priority_codes, non_priority_codes = codes.partition {|_, path| priority_paths.include?(path) }
+
+        priority_codes.each do |target, path|
+          Steep.logger.info { "Enqueueing TypeCheckCodeJob for guid=#{guid}, path=#{path}, target=#{target.name}" }
+          queue << TypeCheckCodeJob.new(guid: guid, path: path, target: target)
         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
+        priority_sigs.each do |target, path|
+          Steep.logger.info { "Enqueueing ValidateAppSignatureJob for guid=#{guid}, path=#{path}, target=#{target.name}" }
+          queue << ValidateAppSignatureJob.new(guid: guid, path: path, target: target)
         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
+        priority_libs.each do |target, path|
+          Steep.logger.info { "Enqueueing ValidateLibrarySignatureJob for guid=#{guid}, path=#{path}, target=#{target.name}" }
+          queue << ValidateLibrarySignatureJob.new(guid: guid, path: path, target: target)
         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
+        non_priority_codes.each do |target, path|
+          Steep.logger.info { "Enqueueing TypeCheckCodeJob for guid=#{guid}, path=#{path}, target=#{target.name}" }
+          queue << TypeCheckCodeJob.new(guid: guid, path: path, target: target)
         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
+        non_priority_sigs.each do |target, path|
+          Steep.logger.info { "Enqueueing ValidateAppSignatureJob for guid=#{guid}, path=#{path}, target=#{target.name}" }
+          queue << ValidateAppSignatureJob.new(guid: guid, path: path, target: target)
         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
+        non_priority_libs.each do |target, path|
+          Steep.logger.info { "Enqueueing ValidateLibrarySignatureJob for guid=#{guid}, path=#{path}, target=#{target.name}" }
+          queue << ValidateLibrarySignatureJob.new(guid: guid, path: path, target: target)
         end
       end
 
@@ -168,60 +164,37 @@ module Steep
         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({}, **{})
-
-              writer.write(
-                method: :"textDocument/publishDiagnostics",
-                params: LSP::Interface::PublishDiagnosticsParams.new(
-                  uri: Steep::PathHelper.to_uri(job.path).to_s,
-                  diagnostics: diagnostics.map {|diagnostic|
-                    _ = formatter.format(diagnostic)
-                  }.uniq
-                )
-              )
-            end
 
-            typecheck_progress(path: job.path, guid: job.guid)
+            formatter = Diagnostic::LSPFormatter.new({}, **{})
+
+            diagnostics = service.validate_signature(path: project.relative_path(job.path), target: job.target)
+
+            typecheck_progress(
+              path: job.path,
+              guid: job.guid,
+              target: job.target,
+              diagnostics: diagnostics.filter_map { formatter.format(_1) }
+            )
           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: Steep::PathHelper.to_uri(job.path).to_s,
-                  diagnostics: diagnostics.map {|diagnostic| _ = formatter.format(diagnostic) }.uniq.compact
-                )
-              )
-            end
 
-            typecheck_progress(path: job.path, guid: job.guid)
+            formatter = Diagnostic::LSPFormatter.new({}, **{})
+            diagnostics = service.validate_signature(path: job.path, target: job.target)
+
+            typecheck_progress(path: job.path, guid: job.guid, target: job.target, diagnostics: diagnostics.filter_map { formatter.format(_1) })
           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|
-              target = project.target_for_source_path(path)
-              formatter = Diagnostic::LSPFormatter.new(target&.code_diagnostics_config || {})
-
-              writer.write(
-                method: :"textDocument/publishDiagnostics",
-                params: LSP::Interface::PublishDiagnosticsParams.new(
-                  uri: Steep::PathHelper.to_uri(job.path).to_s,
-                  diagnostics: diagnostics.map {|diagnostic|
-                    _ = formatter.format(diagnostic)
-                  }.uniq.compact
-                )
-              )
-            end
-
-            typecheck_progress(path: job.path, guid: job.guid)
+            Steep.logger.info { "Processing TypeCheckCodeJob for guid=#{job.guid}, path=#{job.path}, target=#{job.target.name}" }
+            group_target = project.group_for_source_path(job.path) || job.target
+            formatter = Diagnostic::LSPFormatter.new(group_target.code_diagnostics_config)
+            relative_path = project.relative_path(job.path)
+            diagnostics = service.typecheck_source(path: relative_path, target: job.target)
+            typecheck_progress(path: job.path, guid: job.guid, target: job.target, diagnostics: diagnostics&.filter_map { formatter.format(_1) })
           end
 
         when WorkspaceSymbolJob
@@ -242,16 +215,17 @@ module Steep
         end
       end
 
-      def typecheck_progress(guid:, path:)
-        writer.write(CustomMethods::TypeCheck__Progress.notification({ guid: guid, path: path.to_s }))
+      def typecheck_progress(guid:, path:, target:, diagnostics:)
+        writer.write(CustomMethods::TypeCheck__Progress.notification({ guid: guid, path: path.to_s, target: target.name.to_s, diagnostics: diagnostics }))
       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(project: project, assignment: assignment)
-          provider.indexes.push(*indexes)
+          project.targets.each do |target|
+            index = service.signature_services[target.name].latest_rbs_index
+            provider.indexes[target] = index
+          end
 
           symbols = provider.query_symbol(query)
 
@@ -282,7 +256,7 @@ module Steep
           service.source_files.each_value do |file|
             next unless target.possible_source_file?(file.path)
             absolute_path = project.absolute_path(file.path)
-            next unless assignment =~ absolute_path
+            next unless assignment =~ [target, absolute_path]
 
             stats << calculator.calc_stats(target, file: file)
           end

data/lib/steep/services/file_loader.rb

@@ -7,6 +7,29 @@ module Steep
         @base_dir = base_dir
       end
 
+      def each_path_in_target(target, command_line_patterns = [], &block)
+        if block
+          done = Set[] #: Set[Pathname]
+
+          handler = -> (path) do
+            unless done.include?(path)
+              done << path
+              yield path
+            end
+          end
+
+          target.groups.each do |group|
+            each_path_in_patterns(group.source_pattern, command_line_patterns, &handler)
+            each_path_in_patterns(group.signature_pattern, &handler)
+          end
+
+          each_path_in_patterns(target.source_pattern, command_line_patterns, &handler)
+          each_path_in_patterns(target.signature_pattern, &handler)
+        else
+          enum_for :each_path_in_target, target, command_line_patterns
+        end
+      end
+
       def each_path_in_patterns(pattern, commandline_patterns = [])
         if block_given?
           pats = commandline_patterns.empty? ? pattern.patterns : commandline_patterns

data/lib/steep/services/goto_service.rb

@@ -34,7 +34,7 @@ module Steep
       end
 
       def implementation(path:, line:, column:)
-        locations = [] #: Array[loc]
+        locations = [] #: Array[target_loc]
 
         queries = query_at(path: path, line: line, column: column)
         queries.uniq!
@@ -46,15 +46,15 @@ module Steep
           when MethodQuery
             method_locations(query.name, locations: locations, in_ruby: true, in_rbs: false)
           when TypeNameQuery
-            type_name_locations(query.name, locations: locations)
+            constant_definition_in_ruby(query.name, locations: locations)
           end
         end
 
-        locations.uniq
+        locations.map { _1[1] }.uniq
       end
 
       def definition(path:, line:, column:)
-        locations = [] #: Array[loc]
+        locations = [] #: Array[target_loc]
 
         queries = query_at(path: path, line: line, column: column)
         queries.uniq!
@@ -79,22 +79,24 @@ module Steep
         # Drop un-assigned paths here.
         # The path assignment makes sense only for `.rbs` files, because un-assigned `.rb` files are already skipped since they are not type checked.
         #
-        locations.uniq.select do |loc|
+        locations.filter_map do |target, loc|
           case loc
           when RBS::Location
-            assignment =~ loc.name
+            if assignment =~ [target, loc.name]
+              loc
+            end
           else
-            true
+            loc
           end
-        end
+        end.uniq
       end
 
       def type_definition(path:, line:, column:)
-        locations = [] #: Array[loc]
+        locations = [] #: Array[target_loc]
 
         relative_path = project.relative_path(path)
 
-        target = type_check.source_file?(relative_path) or return []
+        target = type_check.project.target_for_path(relative_path) or return []
         source = type_check.source_files[relative_path]
         typing, signature = type_check_path(target: target, path: relative_path, content: source.content, line: line, column: column)
 
@@ -112,14 +114,16 @@ module Steep
           type_name_locations(name, locations: locations)
         end
 
-        locations.uniq.select do |loc|
+        locations.filter_map do |target, loc|
           case loc
           when RBS::Location
-            assignment =~ loc.name
+            if assignment =~ [target, loc.name]
+              loc
+            end
           else
-            true
+            loc
           end
-        end
+        end.uniq
       end
 
       def each_type_name(type, &block)
@@ -158,8 +162,8 @@ module Steep
         relative_path = project.relative_path(path)
 
         case
-        when target = type_check.source_file?(relative_path)
-          source = type_check.source_files[relative_path]
+        when target = type_check.project.target_for_source_path(relative_path)
+          source = type_check.source_files[relative_path] or return []
           typing, _signature = type_check_path(target: target, path: relative_path, content: source.content, line: line, column: column)
           if typing
             node, *parents = typing.source.find_nodes(line: line, column: column)
@@ -295,23 +299,24 @@ module Steep
       end
 
       def constant_definition_in_rbs(name, locations:)
-        type_check.signature_services.each_value do |signature|
+        project.targets.each do |target|
+          signature = type_check.signature_services.fetch(target.name)
           env = signature.latest_env #: RBS::Environment
 
           case entry = env.constant_entry(name)
           when RBS::Environment::ConstantEntry
             if entry.decl.location
-              locations << entry.decl.location[:name]
+              locations << [target, entry.decl.location[:name]]
             end
           when RBS::Environment::ClassEntry, RBS::Environment::ModuleEntry
             entry.decls.each do |d|
               if d.decl.location
-                locations << d.decl.location[:name]
+                locations << [target, d.decl.location[:name]]
               end
             end
           when RBS::Environment::ClassAliasEntry, RBS::Environment::ModuleAliasEntry
             if entry.decl.location
-              locations << entry.decl.location[:new_name]
+              locations << [target, entry.decl.location[:new_name]]
             end
           end
         end
@@ -322,11 +327,12 @@ module Steep
       def constant_definition_in_ruby(name, locations:)
         type_check.source_files.each do |path, source|
           if typing = source.typing
+            target = project.target_for_source_path(path) or raise
             entry = typing.source_index.entry(constant: name)
             entry.definitions.each do |node|
               case node.type
               when :const
-                locations << node.location.expression
+                locations << [target, node.location.expression]
               when :casgn
                 parent = node.children[0]
                 location =
@@ -335,7 +341,7 @@ module Steep
                   else
                     node.location.name
                   end
-                locations << location
+                locations << [target, location]
               end
             end
           end
@@ -348,6 +354,7 @@ module Steep
         if in_ruby
           type_check.source_files.each do |path, source|
             if typing = source.typing
+              target = project.target_for_source_path(path) or raise
               entry = typing.source_index.entry(method: name)
 
               if entry.definitions.empty?
@@ -360,9 +367,9 @@ module Steep
               entry.definitions.each do |node|
                 case node.type
                 when :def
-                  locations << node.location.name
+                  locations << [target, node.location.name]
                 when :defs
-                  locations << node.location.name
+                  locations << [target, node.location.name]
                 end
               end
             end
@@ -370,7 +377,8 @@ module Steep
         end
 
         if in_rbs
-          type_check.signature_services.each_value do |signature|
+          project.targets.each do |target|
+            signature = type_check.signature_services.fetch(target.name)
             index = signature.latest_rbs_index
 
             entry = index.entry(method_name: name)
@@ -386,15 +394,15 @@ module Steep
               case decl
               when RBS::AST::Members::MethodDefinition
                 if decl.location
-                  locations << decl.location[:name]
+                  locations << [target, decl.location[:name]]
                 end
               when RBS::AST::Members::Alias
                 if decl.location
-                  locations << decl.location[:new_name]
+                  locations << [target, decl.location[:new_name]]
                 end
               when RBS::AST::Members::AttrAccessor, RBS::AST::Members::AttrReader, RBS::AST::Members::AttrWriter
                 if decl.location
-                  locations << decl.location[:name]
+                  locations << [target, decl.location[:name]]
                 end
               end
             end
@@ -405,7 +413,8 @@ module Steep
       end
 
       def type_name_locations(name, locations: [])
-        type_check.signature_services.each_value do |signature|
+        project.targets.each do |target|
+          signature = type_check.signature_services.fetch(target.name)
           index = signature.latest_rbs_index
 
           entry = index.entry(type_name: name)
@@ -413,11 +422,11 @@ module Steep
             case decl
             when RBS::AST::Declarations::Class, RBS::AST::Declarations::Module, RBS::AST::Declarations::Interface, RBS::AST::Declarations::TypeAlias
               if decl.location
-                locations << decl.location[:name]
+                locations << [target, decl.location[:name]]
               end
             when RBS::AST::Declarations::AliasDecl
               if decl.location
-                locations << decl.location[:new_name]
+                locations << [target, decl.location[:new_name]]
               end
             else
               raise

data/lib/steep/services/hover_provider/singleton_methods.rb

@@ -5,11 +5,11 @@ module Steep
         def content_for(service:, path:, line:, column:)
           project = service.project
 
-          case (target = project.targets_for_path(path))
-          when Project::Target
+          case
+          when target = project.target_for_source_path(path)
             Ruby.new(service: service).content_for(target: target, path: path, line: line, column: column)
-          when Array
-            RBS.new(service: service).content_for(target: target[0], path: path, line: line, column: column)
+          when target = project.target_for_signature_path(path)
+            RBS.new(service: service).content_for(target: target, path: path, line: line, column: column)
           end
         end
       end

data/lib/steep/services/path_assignment.rb

@@ -13,14 +13,33 @@ module Steep
         new(index: 0, max_index: 1)
       end
 
-      def =~(path)
-        (cache[path] ||= self.class.index_for(path: path.to_s, max_index: max_index)) == index
+      def =~(target_path)
+        key = stringify(target_path)
+        (cache[key] ||= self.class.index_for(key: key, max_index: max_index)) == index
       end
 
       alias === =~
 
-      def self.index_for(path:, max_index:)
-        Digest::MD5.hexdigest(path).hex % max_index
+      def assign!(path, index)
+        key = stringify(path)
+        cache[key] = index
+        self
+      end
+
+      def stringify(target_path)
+        target =
+          case target_path[0]
+          when Project::Target
+            target_path[0].name.to_s
+          else
+            target_path[0].to_s
+          end
+        path = target_path[1].to_s
+        "#{target}::#{path}"
+      end
+
+      def self.index_for(key:, max_index:)
+        Digest::MD5.hexdigest(key).hex % max_index
       end
     end
   end