steep 1.10.0 → 2.0.0

data/lib/steep/server/inline_source_change_detector.rb

@@ -0,0 +1,94 @@
+module Steep
+  module Server
+    class InlineSourceChangeDetector
+      class Source
+        attr_reader :content
+        attr_reader :changes
+        attr_reader :last_fingerprint
+
+        def initialize(content)
+          @content = content
+          @changes = []
+          update_fingerprint!
+        end
+
+        def <<(changes)
+          @changes << changes
+        end
+
+        def updated?
+          if changes.empty?
+            return false
+          end
+
+          updated_content = changes.inject(content) do |current_content, change|
+            change.apply_to(current_content)
+          end
+          changes.clear
+
+          if updated_content == content
+            return false
+          end
+
+          @content = updated_content
+
+          update_fingerprint!
+        end
+
+        def update_fingerprint!
+          buffer = RBS::Buffer.new(name: Pathname("test.rb"), content: content)
+          prism = Prism.parse(content)
+          result = RBS::InlineParser.parse(buffer, prism)
+
+          new_fingerprint = result.type_fingerprint
+
+          (new_fingerprint != last_fingerprint).tap do
+            @last_fingerprint = new_fingerprint
+          end
+        end
+
+        def clear
+          @changes.clear
+        end
+      end
+
+      attr_reader :sources
+
+      def initialize
+        @sources = {}
+      end
+
+      def add_source(path, content)
+        sources.key?(path) and raise "Source already exists for #{path}"
+        sources[path] = Source.new(content)
+      end
+
+      def replace_source(path, content)
+        source = sources.fetch(path)
+        if source.content == content
+          source.clear
+        else
+          source << Services::ContentChange.string(content)
+        end
+      end
+
+      def accumulate_change(file_path, changes)
+        changes.each do |change|
+          sources.fetch(file_path) << change
+        end
+      end
+
+      def type_updated_paths(paths)
+        paths.select { sources[_1]&.updated? }.to_set
+      end
+
+      def has_source?(path)
+        sources.key?(path)
+      end
+
+      def reset
+        sources.each_value { _1.updated? }
+      end
+    end
+  end
+end

data/lib/steep/server/interaction_worker.rb

@@ -154,19 +154,25 @@ module Steep
             Steep.logger.info "path: #{job.path}, line: #{job.line}, column: #{job.column}, trigger: #{job.trigger}"
 
             case
-            when target = project.target_for_source_path(job.path)
+            when target = project.target_for_inline_source_path(job.path) || project.target_for_source_path(job.path)
               file = service.source_files[job.path] or return
               subtyping = service.signature_services.fetch(target.name).current_subtyping or return
 
-              provider = Services::CompletionProvider.new(source_text: file.content, path: job.path, subtyping: subtyping)
-              items = begin
-                        provider.run(line: job.line, column: job.column)
-                      rescue Parser::SyntaxError
-                        [] #: Array[Services::CompletionProvider::item]
-                      end
+              provider = Services::CompletionProvider::Ruby.new(source_text: file.content, path: job.path, subtyping: subtyping)
 
-              completion_items = items.map do |item|
-                format_completion_item(item)
+              if (prefix_size, items = provider.run_at_comment(line: job.line, column: job.column))
+                completion_items = items.map { format_completion_item(_1) }
+                completion_items.concat builtin_types(prefix_size, job.line, job.column)
+              else
+                items = begin
+                          provider.run(line: job.line, column: job.column)
+                        rescue Parser::SyntaxError
+                          [] #: Array[Services::CompletionProvider::item]
+                        end
+
+                completion_items = items.map do |item|
+                  format_completion_item(item)
+                end
               end
 
               Steep.logger.debug "items = #{completion_items.inspect}"
@@ -179,71 +185,14 @@ module Steep
               sig_service = service.signature_services[target.name] or raise
               relative_path = job.path
 
-              context = nil #: RBS::Resolver::context
+              completion = Services::CompletionProvider::RBS.new(relative_path, sig_service)
+              prefix_size, type_names = completion.run(job.line, job.column)
 
-              case sig_service.status
-              when Services::SignatureService::SyntaxErrorStatus, Services::SignatureService::AncestorErrorStatus
-                if buffer = sig_service.latest_env.buffers.find {|buf| Pathname(buf.name) == Pathname(relative_path) }
-                  dirs = sig_service.latest_env.signatures.fetch(buffer)[0]
-                else
-                  dirs = [] #: Array[RBS::AST::Directives::t]
-                end
-              else
-                signature = sig_service.files.fetch(relative_path).signature
-                signature.is_a?(Array) or raise
-                buffer, dirs, decls = signature
-
-                locator = RBS::Locator.new(buffer: buffer, dirs: dirs, decls: decls)
-
-                _hd, tail = locator.find2(line: job.line, column: job.column)
-                tail ||= [] #: Array[RBS::Locator::component]
-
-                tail.reverse_each do |t|
-                  case t
-                  when RBS::AST::Declarations::Module, RBS::AST::Declarations::Class
-                    if (last_type_name = context&.[](1)).is_a?(RBS::TypeName)
-                      context = [context, last_type_name + t.name]
-                    else
-                      context = [context, t.name.absolute!]
-                    end
-                  end
-                end
-              end
-
-              buffer = RBS::Buffer.new(name: relative_path, content: sig_service.files.fetch(relative_path).content)
-              prefix = Services::TypeNameCompletion::Prefix.parse(buffer, line: job.line, column: job.column)
-
-              completion = Services::TypeNameCompletion.new(env: sig_service.latest_env, context: context, dirs: dirs)
-              type_names = completion.find_type_names(prefix)
-              prefix_size = prefix ? prefix.size : 0
-
-              completion_items = type_names.map do |type_name|
-                absolute_name, relative_name = completion.resolve_name_in_context(type_name)
+              completion_items = type_names.map do |absolute_name, relative_name|
                 format_completion_item_for_rbs(sig_service, absolute_name, job, relative_name.to_s, prefix_size)
               end
 
-              ["untyped", "void", "bool", "class", "module", "instance", "nil"].each do |name|
-                completion_items << LSP::Interface::CompletionItem.new(
-                  label: name,
-                  detail: "(builtin type)",
-                  text_edit: LSP::Interface::TextEdit.new(
-                    range: LSP::Interface::Range.new(
-                      start: LSP::Interface::Position.new(
-                        line: job.line - 1,
-                        character: job.column - prefix_size
-                      ),
-                      end: LSP::Interface::Position.new(
-                        line: job.line - 1,
-                        character: job.column
-                      )
-                    ),
-                    new_text: name
-                  ),
-                  kind: LSP::Constant::CompletionItemKind::KEYWORD,
-                  filter_text: name,
-                  sort_text: "zz__#{name}"
-                )
-              end
+              completion_items.concat(builtin_types(prefix_size, job.line, job.column))
 
               LSP::Interface::CompletionList.new(
                 is_incomplete: !sig_service.status.is_a?(Services::SignatureService::LoadedStatus),
@@ -280,10 +229,13 @@ module Steep
 
           case class_entry
           when RBS::Environment::ClassEntry, RBS::Environment::ModuleEntry
-            comments = class_entry.decls.map {|decl| decl.decl.comment }.compact
-            decl = class_entry.primary.decl
+            comments = class_entry.each_decl.map {|decl| decl.is_a?(RBS::AST::Declarations::Base) ? decl.comment : nil }.compact
+            decl = class_entry.primary_decl
           when RBS::Environment::ClassAliasEntry, RBS::Environment::ModuleAliasEntry
-            comments = [class_entry.decl.comment].compact
+            comments = [] #: Array[RBS::AST::Comment]
+            if comment = class_entry.decl.comment
+              comments << comment
+            end
             decl = class_entry.decl
           end
 
@@ -476,7 +428,7 @@ module Steep
 
       def process_signature_help(job)
         Steep.logger.tagged("##{__method__}") do
-          if target = project.target_for_source_path(job.path)
+          if target = project.target_for_inline_source_path(job.path) || project.target_for_source_path(job.path)
             file = service.source_files[job.path] or return
             subtyping = service.signature_services.fetch(target.name).current_subtyping or return
             source =
@@ -514,6 +466,31 @@ module Steep
         # Reuse the latest result to keep SignatureHelp opened while typing
         @last_signature_help_result if @last_signature_help_line == job.line
       end
+
+      def builtin_types(prefix_size, line, column)
+        ["untyped", "void", "bool", "class", "module", "instance", "nil", "top", "bot"].map do |name|
+          LSP::Interface::CompletionItem.new(
+            label: name,
+            detail: "(builtin type)",
+            text_edit: LSP::Interface::TextEdit.new(
+              range: LSP::Interface::Range.new(
+                start: LSP::Interface::Position.new(
+                  line: line - 1,
+                  character: column - prefix_size
+                ),
+                end: LSP::Interface::Position.new(
+                  line: line - 1,
+                  character: column
+                )
+              ),
+              new_text: name
+            ),
+            kind: LSP::Constant::CompletionItemKind::KEYWORD,
+            filter_text: name,
+            sort_text: "zz__#{name}"
+          )
+        end
+      end
     end
   end
 end

data/lib/steep/server/lsp_formatter.rb

@@ -19,10 +19,10 @@ module Steep
 
       def format_hover_content(content)
         case content
-        when HoverProvider::Ruby::VariableContent
+        when HoverProvider::VariableContent
           local_variable(content.name, content.type)
 
-        when HoverProvider::Ruby::MethodCallContent
+        when HoverProvider::MethodCallContent
           io = StringIO.new
           call = content.method_call
 
@@ -76,7 +76,7 @@ module Steep
 
           io.string
 
-        when HoverProvider::Ruby::DefinitionContent
+        when HoverProvider::DefinitionContent
           io = StringIO.new
 
           method_name =
@@ -115,13 +115,13 @@ module Steep
           )
 
           io.string
-        when HoverProvider::Ruby::ConstantContent
+        when HoverProvider::ConstantContent
           io = StringIO.new
 
           decl_summary =
             case
             when decl = content.class_decl
-              declaration_summary(decl.primary.decl)
+              declaration_summary(decl.primary_decl)
             when decl = content.constant_decl
               declaration_summary(decl.decl)
             when decl = content.class_alias
@@ -144,14 +144,14 @@ module Steep
           end
 
           io.string
-        when HoverProvider::Ruby::TypeContent
+        when HoverProvider::TypeContent
           <<~MD
             ```rbs
             #{content.type}
             ```
           MD
 
-        when HoverProvider::Ruby::TypeAssertionContent
+        when HoverProvider::TypeAssertionContent
           <<~MD
             ```rbs
             #{content.asserted_type}
@@ -160,7 +160,7 @@ module Steep
             ↑ Converted from `#{content.original_type.to_s}`
           MD
 
-        when HoverProvider::RBS::TypeAliasContent, HoverProvider::RBS::InterfaceContent
+        when HoverProvider::TypeAliasContent, HoverProvider::InterfaceTypeContent
           io = StringIO.new()
 
           io.puts <<~MD
@@ -178,7 +178,7 @@ module Steep
 
           io.string
 
-        when HoverProvider::RBS::ClassContent
+        when HoverProvider::ClassTypeContent
           io = StringIO.new
 
           io << <<~MD
@@ -187,7 +187,15 @@ module Steep
           ```
           MD
 
-          if content.decl.comment
+          comment =
+            case content.decl
+            when RBS::AST::Declarations::Base
+              content.decl.comment
+            when RBS::AST::Ruby::Declarations::Base
+              nil
+            end
+
+          if comment
             io.puts "----"
 
             class_name =
@@ -235,10 +243,24 @@ module Steep
         when Services::CompletionProvider::InstanceVariableItem
           instance_variable(item.identifier, item.type)
         when Services::CompletionProvider::SimpleMethodNameItem
-          format_method_item_doc(item.method_types, [], { item.method_name => item.method_member.comment })
+          item_comment =
+            case item.method_member
+            when RBS::AST::Members::Base
+              item.method_member.comment
+            when RBS::AST::Ruby::Members::Base
+              nil
+            end
+          format_method_item_doc(item.method_types, [], { item.method_name => item_comment })
         when Services::CompletionProvider::ComplexMethodNameItem
           method_names = item.method_names.map(&:relative).uniq
-          comments = item.method_definitions.transform_values {|member| member.comment }
+          comments = item.method_definitions.transform_values do |member|
+            case member
+            when RBS::AST::Members::Base
+              member.comment
+            when RBS::AST::Ruby::Members::Base
+              nil
+            end
+          end
           format_method_item_doc(item.method_types, method_names, comments)
         when Services::CompletionProvider::GeneratedMethodNameItem
           format_method_item_doc(item.method_types, [], {}, "🤖 Generated method for receiver type")
@@ -419,6 +441,20 @@ module Steep
           "#{decl.name}: #{decl.type}"
         when RBS::AST::Declarations::Constant
           "#{decl.name.relative!}: #{decl.type}"
+        when RBS::AST::Ruby::Declarations::ClassDecl
+          "class #{decl.class_name.relative!}"
+        when RBS::AST::Ruby::Declarations::ModuleDecl
+          "module #{decl.module_name.relative!}"
+        when RBS::AST::Ruby::Declarations::ConstantDecl
+          "#{decl.constant_name.relative!}: #{decl.type}"
+        when RBS::AST::Ruby::Declarations::ClassModuleAliasDecl
+          keyword =
+            if decl.annotation.is_a?(RBS::AST::Ruby::Annotations::ClassAliasAnnotation)
+              "class"
+            else
+              "module"
+            end
+          "#{keyword} #{decl.new_name} = #{decl.old_name}"
         end
       end
 

data/lib/steep/server/master.rb

@@ -207,14 +207,14 @@ module Steep
 
       def start
         Steep.logger.tagged "master" do
-          tags = Steep.logger.formatter.current_tags.dup
+          tags = Steep.logger.current_tags.dup
 
           # @type var worker_threads: Array[Thread]
           worker_threads = []
 
           if interaction_worker
             worker_threads << Thread.new do
-              Steep.logger.formatter.push_tags(*tags, "from-worker@interaction")
+              Steep.logger.push_tags(*tags, "from-worker@interaction")
               interaction_worker.reader.read do |message|
                 job_queue << ReceiveMessageJob.new(source: interaction_worker, message: message)
               end
@@ -223,7 +223,7 @@ module Steep
 
           typecheck_workers.each do |worker|
             worker_threads << Thread.new do
-              Steep.logger.formatter.push_tags(*tags, "from-worker@#{worker.name}")
+              Steep.logger.push_tags(*tags, "from-worker@#{worker.name}")
               worker.reader.read do |message|
                 job_queue << ReceiveMessageJob.new(source: worker, message: message)
               end
@@ -238,7 +238,7 @@ module Steep
           end
 
           write_thread = Thread.new do
-            Steep.logger.formatter.push_tags(*tags)
+            Steep.logger.push_tags(*tags)
             Steep.logger.tagged "write" do
               while job = write_queue.deq
                 # @type var job: SendMessageJob
@@ -257,7 +257,7 @@ module Steep
           end
 
           loop_thread = Thread.new do
-            Steep.logger.formatter.push_tags(*tags)
+            Steep.logger.push_tags(*tags)
             Steep.logger.tagged "main" do
               while job = job_queue.deq
                 case job
@@ -408,7 +408,8 @@ module Steep
                     if content.valid_encoding?
                       content
                     else
-                      { text: Base64.encode64(content), binary: true }
+                      base64_encoded = [content].pack("m")
+                      { text: base64_encoded, binary: true }
                     end
                   end
                   broadcast_notification(CustomMethods::FileLoad.notification({ content: input }))
@@ -423,7 +424,7 @@ module Steep
                 setup_file_system_watcher()
               end
 
-              controller.changed_paths.clear()
+              # controller.changed_paths.clear()
 
               # if typecheck_automatically
               #   if request = controller.make_request(guid: progress.guid, include_unchanged: true, progress: progress)
@@ -442,11 +443,9 @@ module Steep
 
             path = PathHelper.to_pathname!(uri)
 
-            unless controller.priority_paths.include?(path)
+            unless controller.open_paths.include?(path)
               updated_watched_files << path
 
-              controller.push_changes(path)
-
               case type
               when LSP::Constant::FileChangeType::CREATED, LSP::Constant::FileChangeType::CHANGED
                 content = path.read
@@ -456,6 +455,15 @@ module Steep
 
               content or raise
 
+              case
+              when controller.code_path?(path)
+                controller.add_dirty_code_path(path)
+              when controller.signature_path?(path)
+                controller.add_dirty_signature_path(path)
+              when controller.inline_path?(path)
+                controller.add_dirty_inline_path(path, content)
+              end
+
               broadcast_notification(CustomMethods::FileReset.notification({ uri: uri, content: content }))
             end
           end
@@ -485,7 +493,21 @@ module Steep
         when "textDocument/didChange"
           if path = pathname(message[:params][:textDocument][:uri])
             broadcast_notification(message)
-            controller.push_changes(path)
+
+            Steep.logger.debug { path.to_s }
+
+            case
+            when controller.code_path?(path)
+              Steep.logger.debug { "code_path?" }
+              controller.add_dirty_code_path(path)
+            when controller.signature_path?(path)
+              Steep.logger.debug { "signature_path?" }
+              controller.add_dirty_signature_path(path)
+            when controller.inline_path?(path)
+              Steep.logger.debug { "inline_path?" }
+              changes = Services::ContentChange.from_lsp(message[:params][:contentChanges])
+              controller.add_dirty_inline_path(path, changes)
+            end
 
             if typecheck_automatically
               start_type_checking_queue.execute do
@@ -513,7 +535,12 @@ module Steep
 
           if path = pathname(uri)
             if target = project.group_for_path(path)
-              controller.update_priority(open: path)
+              if controller.inline_path?(path)
+                controller.open_inline_path(path, text)
+              else
+                controller.open_path(path)
+              end
+
               # broadcast_notification(CustomMethods::FileReset.notification({ uri: uri, content: text }))
 
               start_type_checking_queue.execute do
@@ -525,7 +552,7 @@ module Steep
 
         when "textDocument/didClose"
           if path = pathname(message[:params][:textDocument][:uri])
-            controller.update_priority(close: path)
+            controller.close_path(path)
           end
 
         when "textDocument/hover", "textDocument/completion", "textDocument/signatureHelp"
@@ -605,6 +632,38 @@ module Steep
             )
           end
 
+        when CustomMethods::Query__Definition::METHOD
+          params = message[:params] #: CustomMethods::Query__Definition::params
+          result_controller << group_request do |group|
+            typecheck_workers.each do |worker|
+              group << send_request(method: CustomMethods::Query__Definition::METHOD, params: params, worker: worker)
+            end
+
+            group.on_completion do |handlers|
+              kind = "unknown" #: CustomMethods::Query__Definition::kind
+              locations = [] #: Array[CustomMethods::Query__Definition::location]
+
+              handlers.each do |handler|
+                result = handler.result #: CustomMethods::Query__Definition::result
+                next unless result
+
+                if kind == "unknown"
+                  kind = result[:kind]
+                end
+                locations.concat(result[:locations])
+              end
+
+              locations.uniq!
+
+              enqueue_write_job SendMessageJob.to_client(
+                message: CustomMethods::Query__Definition.response(
+                  message[:id],
+                  { name: params[:name], kind: kind, locations: locations }
+                )
+              )
+            end
+          end
+
         when CustomMethods::TypeCheck::METHOD
           id = message[:id]
           params = message[:params] #: CustomMethods::TypeCheck::params
@@ -621,6 +680,9 @@ module Steep
           params[:library_paths].each do |target_name, path|
             request.library_paths << [target_name.to_sym, Pathname(path)]
           end
+          params[:inline_paths].each do |target_name, path|
+            request.inline_paths << [target_name.to_sym, Pathname(path)]
+          end
 
           start_type_check(request: request, last_request: nil)
 
@@ -632,7 +694,12 @@ module Steep
           progress = work_done_progress(SecureRandom.uuid)
           progress.begin("Type checking #{groups.empty? ? "project" : groups.join(", ")}", request_id: fresh_request_id)
 
-          request = controller.make_group_request(groups, progress: progress)
+          if groups.empty?
+            request = controller.make_all_request(progress: progress)
+          else
+            request = controller.make_group_request(groups, progress: progress)
+          end
+
           request.needs_response = false
           start_type_check(request: request, last_request: current_type_check_request, report_progress_threshold: 0)
 
@@ -744,7 +811,14 @@ module Steep
 
           unless request
             progress or raise
-            request = controller.make_request(guid: progress.guid, include_unchanged: include_unchanged, progress: progress) or return
+            request =
+              if include_unchanged
+                controller.make_all_request(guid: progress.guid, progress: progress)
+              else
+                controller.make_request(guid: progress.guid, progress: progress)
+              end
+            return unless request
+
             request.needs_response = needs_response ? true : false
           end
 
@@ -752,6 +826,14 @@ module Steep
             request.merge!(last_request)
           end
 
+          Steep.logger.debug {
+            {
+              code_paths: request.code_paths.map { _1[1].to_s },
+              signature_paths: request.signature_paths.map { _1[1].to_s },
+              inline_paths: request.inline_paths.map { _1[1].to_s }
+            }.inspect
+          }
+
           if request.total > report_progress_threshold
             request.report_progress!
           end
@@ -854,8 +936,8 @@ module Steep
                   end
 
                   Thread.new do
-                    tags = Steep.logger.formatter.current_tags.dup
-                    Steep.logger.formatter.push_tags(*tags, "from-worker@#{new_worker.name}")
+                    tags = Steep.logger.current_tags.dup
+                    Steep.logger.push_tags(*tags, "from-worker@#{new_worker.name}")
                     new_worker.reader.read do |message|
                       job_queue << ReceiveMessageJob.new(source: new_worker, message: message)
                     end
@@ -936,7 +1018,7 @@ module Steep
 
       def enqueue_write_job(job)
         Steep.logger.info { "Write_queue has #{write_queue.size} items"}
-        write_queue.push(job) # steep:ignore InsufficientKeywordArguments
+        write_queue.push(job)
       end
 
       def work_done_progress(guid)