steep 1.8.3 → 1.9.0.dev.1

data/lib/steep/services/type_check_service.rb

@@ -76,52 +76,15 @@ module Steep
         end
       end
 
-      class TargetRequest
-        attr_reader :target
-        attr_reader :source_paths
-
-        def initialize(target:)
-          @target = target
-          @source_paths = Set[]
-          @signature_updated = 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
-
-        alias eql? ==
-
-        def hash
-          self.class.hash ^ target.hash ^ source_paths.hash ^ @signature_updated.hash
-        end
-      end
-
       def initialize(project:)
         @project = project
 
         @source_files = {}
-        @signature_services = project.targets.each.with_object({}) do |target, hash|
+        @signature_services = project.targets.each.with_object({}) do |target, hash| #$ Hash[Symbol, SignatureService]
           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|
+        @signature_validation_diagnostics = project.targets.each.with_object({}) do |target, hash| #$ Hash[Symbol, Hash[Pathname, Array[Diagnostic::Signature::Base]]]
           hash[target.name] = {}
         end
       end
@@ -179,135 +142,91 @@ module Steep
       end
 
       def update(changes:)
-        requests = project.targets.each_with_object({}.compare_by_identity) do |target, hash|
-          hash[target] = TargetRequest.new(target: target)
-        end
-
         Steep.measure "#update_signature" do
-          update_signature(changes: changes, requests: requests)
+          update_signature(changes: changes)
         end
 
         Steep.measure "#update_sources" do
-          update_sources(changes: changes, requests: requests)
+          update_sources(changes: changes)
         end
-
-        requests.transform_keys(&:name).reject {|_, request| request.empty? }
       end
 
-      def update_and_check(changes:, assignment:, &block)
-        requests = update(changes: changes)
-
-        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
-
-        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
-
-      def validate_signature(path:, &block)
+      def validate_signature(path:, target:)
         Steep.logger.tagged "#validate_signature(path=#{path})" do
           Steep.measure "validation" do
-            # @type var accumulated_diagnostics: Array[Diagnostic::Signature::Base]
-            accumulated_diagnostics = []
+            service = signature_services[target.name]
 
-            project.targets.each do |target|
-              service = signature_services[target.name]
+            raise "#{path} is not library nor signature of #{target.name}" unless target.possible_signature_file?(path) || service.env_rbs_paths.include?(path)
 
-              next unless target.possible_signature_file?(path) || service.env_rbs_paths.include?(path)
+            case service.status
+            when SignatureService::SyntaxErrorStatus
+              diagnostics = service.status.diagnostics.select do |diag|
+                diag.location or raise
+                Pathname(diag.location.buffer.name) == path &&
+                  (diag.is_a?(Diagnostic::Signature::SyntaxError) || diag.is_a?(Diagnostic::Signature::UnexpectedError))
+              end
 
-              case service.status
-              when SignatureService::SyntaxErrorStatus
-                diagnostics = service.status.diagnostics.select do |diag|
-                  diag.location or raise
-                  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 do |diag|
+                diag.location or raise
+                Pathname(diag.location.buffer.name) == path
+              end
 
-              when SignatureService::AncestorErrorStatus
-                diagnostics = service.status.diagnostics.select do |diag|
-                  diag.location or raise
-                  Pathname(diag.location.buffer.name) == path
-                end
-                accumulated_diagnostics.push(*diagnostics)
-                yield [path, accumulated_diagnostics]
-
-              when SignatureService::LoadedStatus
-                validator = Signature::Validator.new(checker: service.current_subtyping || raise)
-                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
+            when SignatureService::LoadedStatus
+              validator = Signature::Validator.new(checker: service.current_subtyping || raise)
+              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
 
-                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
+              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
 
-                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
+              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
-
-                diagnostics = validator.each_error.select do |error|
-                  error.location or raise
-                  Pathname(error.location.buffer.name) == path
-                end
-                accumulated_diagnostics.push(*diagnostics)
-                yield [path, accumulated_diagnostics]
               end
 
-              signature_validation_diagnostics[target.name][path] = diagnostics
+              diagnostics = validator.each_error.select do |error|
+                error.location or raise
+                Pathname(error.location.buffer.name) == path
+              end
             end
+
+            signature_validation_diagnostics[target.name][path] = diagnostics
           end
         end
       end
 
-      def typecheck_source(path:, target: project.target_for_source_path(path), &block)
+      def typecheck_source(path:, target:)
         return unless target
 
         Steep.logger.tagged "#typecheck_source(path=#{path})" do
@@ -318,44 +237,44 @@ module Steep
             if subtyping
               text = source_files[path].content
               file = type_check_file(target: target, subtyping: subtyping, path: path, text: text) { signature_service.latest_constant_resolver }
-              yield [file.path, file.diagnostics]
               source_files[path] = file
+
+              file.diagnostics
             end
           end
         end
       end
 
-      def update_signature(changes:, requests:)
+      def update_signature(changes:)
         Steep.logger.tagged "#update_signature" do
+          signature_targets = {} #: Hash[Pathname, Project::Target]
+          changes.each do |path, changes|
+            target = project.targets.find { _1.possible_signature_file?(path) } or next
+            signature_targets[path] = target
+          end
+
           project.targets.each do |target|
-            signature_service = signature_services[target.name]
-            signature_changes = changes.filter {|path, _| target.possible_signature_file?(path) }
+            Steep.logger.tagged "#{target.name}" do
+              # Load signatures from all project targets but `#unreferenced` ones
+              target_changes = changes.select do |path, _|
+                signature_target = signature_targets.fetch(path, nil) or next
+                signature_target == target || !signature_target.unreferenced
+              end
 
-            unless signature_changes.empty?
-              requests[target].signature_updated!
-              signature_service.update(signature_changes)
+              unless target_changes.empty?
+                signature_services.fetch(target.name).update(target_changes)
+              end
             end
           end
         end
       end
 
-      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
-
+      def update_sources(changes:)
         changes.each do |path, changes|
-          target = project.target_for_source_path(path)
-
-          if target
+          if source_file?(path)
             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
@@ -434,9 +353,7 @@ module Steep
       end
 
       def source_file?(path)
-        if source_files.key?(path)
-          project.target_for_source_path(path)
-        end
+        source_files.key?(path) || (project.target_for_source_path(path) ? true : false)
       end
 
       def signature_file?(path)

data/lib/steep/signature/validator.rb

@@ -237,7 +237,7 @@ module Steep
 
       def validate_definition_type(definition)
         each_method_type(definition) do |method_type|
-          upper_bounds = method_type.type_params.each.with_object({}) do |param, hash|
+          upper_bounds = method_type.type_params.each.with_object({}) do |param, hash| #$ Hash[Symbol, AST::Types::t?]
             hash[param.name] = factory.type_opt(param.upper_bound_type)
           end
 
@@ -298,7 +298,7 @@ module Steep
 
           Steep.logger.tagged "#{name}" do
             builder.build_instance(name).tap do |definition|
-              upper_bounds = definition.type_params_decl.each.with_object({}) do |param, bounds|
+              upper_bounds = definition.type_params_decl.each.with_object({}) do |param, bounds| #$ Hash[Symbol, AST::Types::t?]
                 bounds[param.name] = factory.type_opt(param.upper_bound_type)
               end
 
@@ -518,7 +518,7 @@ module Steep
 
             validate_type_params(name, definition.type_params_decl)
 
-            upper_bounds = definition.type_params_decl.each.with_object({}) do |param, bounds|
+            upper_bounds = definition.type_params_decl.each.with_object({}) do |param, bounds| #$ Hash[Symbol, AST::Types::t?]
               bounds[param.name] = factory.type_opt(param.upper_bound_type)
             end
 
@@ -615,7 +615,7 @@ module Steep
 
             validate_type_params(name, entry.decl.type_params)
 
-            upper_bounds = entry.decl.type_params.each.with_object({}) do |param, bounds|
+            upper_bounds = entry.decl.type_params.each.with_object({}) do |param, bounds| #$ Hash[Symbol, AST::Types::t?]
               bounds[param.name] = factory.type_opt(param.upper_bound_type)
             end
 

data/lib/steep/subtyping/check.rb

@@ -42,7 +42,7 @@ module Steep
       def push_variable_bounds(params)
         case params
         when Array
-          b = params.each.with_object({}) do |param, hash|
+          b = params.each.with_object({}) do |param, hash| #$ Hash[Symbol, AST::Types::t?]
             hash[param.name] = param.upper_bound
           end
         when Hash
@@ -67,7 +67,7 @@ module Steep
       end
 
       def variable_upper_bounds
-        @bounds.each_with_object({}) do |bounds, hash|
+        @bounds.each_with_object({}) do |bounds, hash| #$ Hash[Symbol, AST::Types::t?]
           hash.merge!(bounds)
         end
       end

data/lib/steep/thread_waiter.rb

@@ -1,34 +1,42 @@
 module Steep
   class ThreadWaiter
-    attr_reader :objects, :queue, :waiter_threads
+    attr_reader :queue, :waiter_threads
 
-    def initialize(objects)
-      @objects = objects
+    def initialize(objects = nil)
       @queue = Thread::Queue.new()
       @waiter_threads = Set[].compare_by_identity
 
-      objects.each do |object|
-        thread = yield(object)
+      if objects
+        objects.each do |object|
+          thread = yield(object)
+          self << thread
+        end
+      end
+    end
 
-        waiter_thread = Thread.new(thread) do |thread|
-          Thread.current.report_on_exception = false
+    def <<(thread)
+      waiter_thread = Thread.new(thread) do |thread|
+        # @type var thread: Thread
 
-          begin
-            thread.join
-          ensure
-            queue << [object, thread]
-          end
-        end
+        Thread.current.report_on_exception = false
 
-        waiter_threads << waiter_thread
+        begin
+          thread.join
+        ensure
+          queue << thread
+        end
       end
+
+      waiter_threads << waiter_thread
+
+      self
     end
 
     def wait_one
       unless waiter_threads.empty?
-        obj, th = queue.pop()
+        th = queue.pop() or raise
         waiter_threads.delete(th)
-        obj
+        th
       end
     end
   end

data/lib/steep/type_construction.rb

@@ -2192,7 +2192,7 @@ module Steep
                     if first_param = block.type&.params&.first_param
                       var_type = first_param.type #: AST::Types::t
                     else
-                      var_type - AST::Builtin.any_type
+                      var_type = AST::Builtin.any_type
                     end
                   end
                 end

data/lib/steep/type_inference/block_params.rb

@@ -56,9 +56,8 @@ module Steep
         end
 
         def variable_types
-          each_param.with_object({}) do |param, hash|
+          each_param.with_object({}) do |param, hash| #$ Hash[Symbol, AST::Types::t?]
             var_name = param.var || next
-            # @type var hash: Hash[Symbol, AST::Types::t?]
             hash[var_name] = param.type
           end
         end

data/lib/steep/type_inference/context.rb

@@ -125,7 +125,7 @@ module Steep
         end
 
         def upper_bounds
-          @upper_bounds ||= table.each_value.with_object({}) do |type_param, bounds|
+          @upper_bounds ||= table.each_value.with_object({}) do |type_param, bounds| #$ Hash[Symbol, AST::Types::t]
             if type_param.upper_bound
               bounds[type_param.name] = type_param.upper_bound
             end

data/lib/steep/type_inference/type_env.rb

@@ -176,7 +176,7 @@ module Steep
       def pin_local_variables(names)
         names = Set.new(names) if names
 
-        local_variable_types.each.with_object({}) do |pair, hash|
+        local_variable_types.each.with_object({}) do |pair, hash| #$ Hash[Symbol, [AST::Types::t, AST::Types::t?]]
           name, entry = pair
 
           local_variable_name!(name)
@@ -193,7 +193,7 @@ module Steep
       def unpin_local_variables(names)
         names = Set.new(names) if names
 
-        local_var_types = local_variable_types.each.with_object({}) do |pair, hash|
+        local_var_types = local_variable_types.each.with_object({}) do |pair, hash| #$ Hash[Symbol, [AST::Types::t, AST::Types::t?]]
           name, entry = pair
 
           local_variable_name!(name)
@@ -223,7 +223,7 @@ module Steep
 
       def join(*envs)
         # @type var all_lvar_types: Hash[Symbol, Array[AST::Types::t]]
-        all_lvar_types = envs.each_with_object({}) do |env, hash|
+        all_lvar_types = envs.each_with_object({}) do |env, hash| #$ Hash[Symbol, Array[AST::Types::t]]
           env.local_variable_types.each_key do |name|
             hash[name] = []
           end
@@ -244,7 +244,7 @@ module Steep
           .map {|env| Set.new(env.pure_method_calls.each_key) }
           .inject {|s1, s2| s1.intersection(s2) } || Set[]
 
-        pure_call_updates = common_pure_nodes.each_with_object({}) do |node, hash|
+        pure_call_updates = common_pure_nodes.each_with_object({}) do |node, hash| #$ Hash[Parser::AST::Node, [MethodCall::Typed, AST::Types::t]]
           pairs = envs.map {|env| env.pure_method_calls[node] }
           refined_type = AST::Types::Union.build(types: pairs.map {|call, type| type || call.return_type })
 

data/lib/steep/type_inference/type_env_builder.rb

@@ -41,7 +41,7 @@ module Steep
           end
 
           def call(env)
-            local_variable_types = annotations.var_type_annotations.each.with_object({}) do |pair, hash|
+            local_variable_types = annotations.var_type_annotations.each.with_object({}) do |pair, hash| #$ Hash[Symbol, [AST::Types::t, AST::Types::t]]
               name, annotation = pair
               annotation_type = annotations.absolute_type(annotation.type) || annotation.type
 

data/lib/steep/version.rb

@@ -1,3 +1,3 @@
 module Steep
-  VERSION = "1.8.3"
+  VERSION = "1.9.0.dev.1"
 end

data/lib/steep.rb

@@ -125,12 +125,15 @@ require "steep/server/base_worker"
 require "steep/server/worker_process"
 require "steep/server/interaction_worker"
 require "steep/server/type_check_worker"
+require "steep/server/target_group_files"
+require "steep/server/type_check_controller"
 require "steep/server/master"
 
 require "steep/project"
 require "steep/project/pattern"
 require "steep/project/options"
 require "steep/project/target"
+require "steep/project/group"
 require "steep/project/dsl"
 
 require "steep/expectations"
@@ -139,7 +142,6 @@ require "steep/drivers/utils/jobs_option"
 require "steep/drivers/check"
 require "steep/drivers/checkfile"
 require "steep/drivers/stats"
-require "steep/drivers/validate"
 require "steep/drivers/annotations"
 require "steep/drivers/watch"
 require "steep/drivers/langserver"
@@ -289,7 +291,7 @@ end
 
 klasses = [
   # Steep::Interface::MethodType
-]
+] #: Array[Class]
 
 klasses.each do |klass|
   klass.instance_eval do
@@ -312,7 +314,7 @@ module GCCounter
         ensure
           Steep.logger.fatal "===== #{title} ==============================="
 
-          klasses = []
+          klasses = [] #: Array[Class]
 
           ObjectSpace.each_object(Class) do |klass|
             if (klass.name || "") =~ regexp
@@ -320,7 +322,7 @@ module GCCounter
             end
           end
 
-          before = {}
+          before = {} #: Hash[Class, Integer]
 
           klasses.each do |klass|
             count = ObjectSpace.each_object(klass).count

data/sample/Steepfile

@@ -14,3 +14,9 @@ target :lib do
   #   hash[D::Ruby::NoMethod] = :information
   # end
 end
+
+# target :lib2 do
+#   check "lib/length.rb"                       # Directory name
+#   signature "sig/length.rbs"
+#   unreferenced!
+# end

data/sample/lib/conference.rb

@@ -11,19 +11,16 @@ end
 
 Conference.new()
 
-
-Konference
-
 Konference.new()
 
 
+
 # @type var foo: Konference
 
 foo = Conference.new
 
 class Conference12
   class Integer
-
   end
 end
 
@@ -34,6 +31,5 @@ class HogeHoge
 end
 
 
-
 conference = nil #: Conference?
 

data/steep.gemspec

@@ -29,6 +29,12 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
+  if false
+    # This is to let dependabot use 3.3, instead of 3.1.x.
+    # They use `required_ruby_version=` method to detect the Ruby version they use.
+    spec.required_ruby_version = ">= 3.3.0"
+  end
+
   spec.required_ruby_version = '>= 3.1.0'
 
   spec.add_runtime_dependency "parser", ">= 3.1"
@@ -36,7 +42,7 @@ Gem::Specification.new do |spec|
   spec.add_runtime_dependency "rainbow", ">= 2.2.2", "< 4.0"
   spec.add_runtime_dependency "listen", "~> 3.0"
   spec.add_runtime_dependency "language_server-protocol", ">= 3.15", "< 4.0"
-  spec.add_runtime_dependency "rbs", "~> 3.6.0"
+  spec.add_runtime_dependency "rbs", "~> 3.7.0.dev"
   spec.add_runtime_dependency "concurrent-ruby", ">= 1.1.10"
   spec.add_runtime_dependency "terminal-table", ">= 2", "< 4"
   spec.add_runtime_dependency "securerandom", ">= 0.1"