steep 1.6.0.pre.4 → 1.7.0.dev.1

data/lib/steep/ast/ignore.rb

@@ -0,0 +1,148 @@
+module Steep
+  module AST
+    module Ignore
+      class BufferScanner
+        attr_reader :scanner, :location
+
+        def initialize(location)
+          @location = location
+
+          @scanner = StringScanner.new(location.source)
+        end
+
+        def offset
+          @location.start_pos
+        end
+
+        def charpos
+          scanner.charpos + offset
+        end
+
+        def scan(regexp)
+          if matched = scanner.scan(regexp)
+            end_pos = charpos()
+            begin_pos = end_pos - matched.size
+            RBS::Location.new(location.buffer, begin_pos, end_pos)
+          end
+        end
+
+        def skip(regexp)
+          scanner.skip(regexp)
+        end
+
+        def eos?
+          scanner.eos?
+        end
+      end
+
+      class IgnoreStart
+        attr_reader :comment, :location
+
+        def initialize(comment, location)
+          @comment = comment
+          @location = location
+        end
+
+        def line
+          location.start_line
+        end
+      end
+
+      class IgnoreEnd
+        attr_reader :comment, :location
+
+        def initialize(comment, location)
+          @comment = comment
+          @location = location
+        end
+
+        def line
+          location.start_line
+        end
+      end
+
+      class IgnoreLine
+        attr_reader :comment, :location, :raw_diagnostics
+
+        def initialize(comment, diagnostics, location)
+          @comment = comment
+          @raw_diagnostics = diagnostics
+          @location = location
+        end
+
+        def line
+          location.start_line
+        end
+
+        def ignored_diagnostics
+          if raw_diagnostics.empty?
+            return :all
+          end
+
+          if raw_diagnostics.size == 1 && raw_diagnostics[0].source == "all"
+            return :all
+          end
+
+          raw_diagnostics.map do |diagnostic|
+            name = diagnostic[:name].source
+            name.gsub(/\ARuby::/, "")
+          end
+        end
+      end
+
+      def self.parse(comment, buffer)
+        return unless comment.inline?
+
+        comment_location = RBS::Location.new(buffer, comment.loc.expression.begin_pos, comment.loc.expression.end_pos)
+        scanner = BufferScanner.new(comment_location)
+
+        scanner.scan(/#/)
+        scanner.skip(/\s*/)
+
+        begin_pos = comment.location.expression.begin_pos
+        end_pos = comment.location.expression.end_pos
+
+        case
+        when loc = scanner.scan(/steep:ignore:start\b/)
+          scanner.skip(/\s*/)
+          return unless scanner.eos?
+
+          IgnoreStart.new(comment, loc)
+        when loc = scanner.scan(/steep:ignore:end\b/)
+          scanner.skip(/\s*/)
+          return unless scanner.eos?
+
+          IgnoreEnd.new(comment, loc)
+        when keyword_loc = scanner.scan(/steep:ignore\b/)
+          # @type var diagnostics: IgnoreLine::diagnostics
+          diagnostics = []
+
+          scanner.skip(/\s*/)
+
+          while true
+            name = scanner.scan(/[A-Z]\w*/) or break
+            scanner.skip(/\s*/)
+            comma = scanner.scan(/,/)
+            scanner.skip(/\s*/)
+
+            diagnostic = RBS::Location.new(buffer, name.start_pos, comma&.end_pos || name.end_pos) #: IgnoreLine::diagnostic
+            diagnostic.add_required_child(:name, name.range)
+            diagnostic.add_optional_child(:following_comma, comma&.range)
+            diagnostics << diagnostic
+
+            break unless comma
+          end
+
+          return unless scanner.eos?
+
+          loc = RBS::Location.new(
+            buffer,
+            keyword_loc.start_pos,
+            diagnostics.last&.end_pos || keyword_loc.end_pos
+          )
+          IgnoreLine.new(comment, diagnostics, loc)
+        end
+      end
+    end
+  end
+end

data/lib/steep/cli.rb

@@ -63,6 +63,7 @@ module Steep
     def handle_logging_options(opts)
       opts.on("--log-level=LEVEL", "Specify log level: debug, info, warn, error, fatal") do |level|
         Steep.logger.level = level
+        Steep.ui_logger.level = level
       end
 
       opts.on("--log-output=PATH", "Print logs to given path") do |file|
@@ -71,6 +72,7 @@ module Steep
 
       opts.on("--verbose", "Set log level to debug") do
         Steep.logger.level = Logger::DEBUG
+        Steep.ui_logger.level = Logger::DEBUG
       end
     end
 
@@ -129,7 +131,7 @@ module Steep
         end.parse!(argv)
 
         setup_jobs_for_ci(command.jobs_option)
-        
+
         command.command_line_patterns.push *argv
       end.run
     end
@@ -349,6 +351,9 @@ TEMPLATE
           opts.on("--index=INDEX") {|index| command.index = Integer(index) }
         end.parse!(argv)
 
+        # Disable any `ui_logger` output in workers
+        Steep.ui_logger.level = :fatal
+
         command.commandline_args.push(*argv)
       end.run
     end

data/lib/steep/diagnostic/ruby.rb

@@ -997,6 +997,19 @@ module Steep
         end
       end
 
+      class InvalidIgnoreComment < Base
+        attr_reader :comment
+
+        def initialize(comment:)
+          @comment = comment
+          super(node: nil, location: comment.location.expression)
+        end
+
+        def header_line
+          "Invalid ignore comment"
+        end
+      end
+
       ALL = ObjectSpace.each_object(Class).with_object([]) do |klass, array|
         if klass < Base
           array << klass
@@ -1028,6 +1041,7 @@ module Steep
             InsufficientKeywordArguments => :error,
             InsufficientPositionalArguments => :error,
             InsufficientTypeArgument => :hint,
+            InvalidIgnoreComment => :warning,
             MethodArityMismatch => :error,
             MethodBodyTypeMismatch => :error,
             MethodDefinitionMissing => nil,
@@ -1086,6 +1100,7 @@ module Steep
             InsufficientKeywordArguments => :error,
             InsufficientPositionalArguments => :error,
             InsufficientTypeArgument => :error,
+            InvalidIgnoreComment => :warning,
             MethodArityMismatch => :error,
             MethodBodyTypeMismatch => :error,
             MethodDefinitionMissing => :hint,
@@ -1144,6 +1159,7 @@ module Steep
             InsufficientKeywordArguments => :information,
             InsufficientPositionalArguments => :information,
             InsufficientTypeArgument => nil,
+            InvalidIgnoreComment => :warning,
             MethodArityMismatch => :information,
             MethodBodyTypeMismatch => :warning,
             MethodDefinitionMissing => nil,

data/lib/steep/drivers/utils/driver_helper.rb

@@ -5,18 +5,29 @@ module Steep
         attr_accessor :steepfile
 
         def load_config(path: steepfile || Pathname("Steepfile"))
-          raise "Cannot find a configuration at #{path}: `steep init` to scaffold" unless path.file?
-
-          steep_file_path = path.absolute? ? path : Pathname.pwd + path
-          Project.new(steepfile_path: steep_file_path).tap do |project|
-            Project::DSL.parse(project, path.read, filename: path.to_s)
-
+          if path.file?
+            steep_file_path = path.absolute? ? path : Pathname.pwd + path
+            Project.new(steepfile_path: steep_file_path).tap do |project|
+              Project::DSL.parse(project, path.read, filename: path.to_s)
+            end
+          else
+            Steep.ui_logger.error { "Cannot find a configuration at #{path}: `steep init` to scaffold. Using current directory..." }
+            Project.new(steepfile_path: nil, base_dir: Pathname.pwd).tap do |project|
+              Project::DSL.new(project: project).target :'.' do
+                check '.'
+                signature '.'
+              end
+            end
+          end.tap do |project|
             project.targets.each do |target|
-              if collection_lock = target.options.collection_lock
-                begin
-                  collection_lock.check_rbs_availability!
-                rescue RBS::Collection::Config::CollectionNotAvailable
-                  raise "Run `rbs collection install` to install type definitions"
+              case result = target.options.load_collection_lock
+              when nil, RBS::Collection::Config::Lockfile
+                # ok
+              else
+                if result == target.options.collection_config_path
+                  Steep.ui_logger.error { "rbs-collection setup is broken: `#{result}` is missing" }
+                else
+                  Steep.ui_logger.error { "Run `rbs collection install` to install type definitions" }
                 end
               end
             end

data/lib/steep/node_helper.rb

@@ -240,5 +240,17 @@ module Steep
         end
       end
     end
+
+    def clone_node(node)
+      children = node.children.map do |child|
+        if child.is_a?(Parser::AST::Node)
+          clone_node(child)
+        else
+          child.dup
+        end
+      end
+
+      node.updated(nil, children)
+    end
   end
 end

data/lib/steep/project/dsl.rb

@@ -14,9 +14,7 @@ module Steep
         attr_reader :project
         attr_reader :collection_config_path
 
-        NONE = Object.new.freeze
-
-        def initialize(name, sources: [], libraries: [], signatures: [], ignored_sources: [], repo_paths: [], code_diagnostics_config: {}, project: nil, collection_config_path: NONE)
+        def initialize(name, sources: [], libraries: [], signatures: [], ignored_sources: [], repo_paths: [], code_diagnostics_config: {}, project: nil, collection_config_path: nil)
           @name = name
           @sources = sources
           @libraries = libraries
@@ -27,14 +25,7 @@ module Steep
           @repo_paths = []
           @code_diagnostics_config = code_diagnostics_config
           @project = project
-          @collection_config_path =
-            case collection_config_path
-            when NONE
-              path = project&.absolute_path(RBS::Collection::Config::PATH)
-              path&.exist? ? path : nil
-            else
-              collection_config_path
-            end
+          @collection_config_path = collection_config_path
         end
 
         def initialize_copy(other)
@@ -135,8 +126,8 @@ module Steep
         end
 
         def stdlib_path(core_root:, stdlib_root:)
-          @core_root = core_root ? Pathname(core_root) : core_root
-          @stdlib_root = stdlib_root ? Pathname(stdlib_root) : stdlib_root
+          @core_root = Pathname(core_root)
+          @stdlib_root = Pathname(stdlib_root)
         end
 
         def repo_path(*paths)
@@ -160,7 +151,7 @@ module Steep
         end
 
         def disable_collection
-          @collection_config_path = nil
+          @collection_config_path = false
         end
       end
 
@@ -206,12 +197,18 @@ module Steep
         source_pattern = Pattern.new(patterns: target.sources, ignores: target.ignored_sources, ext: ".rb")
         signature_pattern = Pattern.new(patterns: target.signatures, ext: ".rbs")
 
-
-        if config_path = target.collection_config_path
-          lockfile_path = RBS::Collection::Config.to_lockfile_path(config_path)
-          content = YAML.load_file(lockfile_path.to_s)
-          collection_lock = RBS::Collection::Config::Lockfile.from_lockfile(lockfile_path: lockfile_path, data: content)
-        end
+        config_path =
+          case target.collection_config_path
+          when Pathname
+            target.collection_config_path
+          when nil
+            default = project.absolute_path(RBS::Collection::Config::PATH)
+            if default.file?
+              default
+            end
+          when false
+            nil
+          end
 
         Project::Target.new(
           name: target.name,
@@ -224,7 +221,7 @@ module Steep
               stdlib_root: target.stdlib_root,
               repo_paths: target.repo_paths
             )
-            options.collection_lock = collection_lock
+            options.collection_config_path = config_path
           end,
           code_diagnostics_config: target.code_diagnostics_config
         ).tap do |target|

data/lib/steep/project/options.rb

@@ -3,7 +3,7 @@ module Steep
     class Options
       PathOptions = _ = Struct.new(:core_root, :stdlib_root, :repo_paths, keyword_init: true) do
         # @implements PathOptions
-        
+
         def customized_stdlib?
           stdlib_root != nil
         end
@@ -15,12 +15,49 @@ module Steep
 
       attr_reader :libraries
       attr_accessor :paths
-      attr_accessor :collection_lock
+      attr_accessor :collection_config_path
 
       def initialize
         @paths = PathOptions.new(repo_paths: [])
         @libraries = []
       end
+
+      def collection_lock_path
+        if collection_config_path
+          RBS::Collection::Config.to_lockfile_path(collection_config_path)
+        end
+      end
+
+      def load_collection_lock(force: false)
+        @collection_lock = nil if force
+        @collection_lock ||=
+          if collection_config_path && collection_lock_path
+            case
+            when !collection_config_path.file?
+              collection_config_path
+            when !collection_lock_path.file?
+              collection_lock_path
+            else
+              begin
+                content = YAML.load_file(collection_lock_path)
+                lock_file = RBS::Collection::Config::Lockfile.from_lockfile(lockfile_path: collection_lock_path, data: content)
+                lock_file.check_rbs_availability!
+                lock_file
+              rescue YAML::SyntaxError, RBS::Collection::Config::CollectionNotAvailable => exn
+                exn
+              end
+            end
+          end
+      end
+
+      def collection_lock
+        case config = load_collection_lock()
+        when RBS::Collection::Config::Lockfile
+          config
+        else
+          nil
+        end
+      end
     end
   end
 end

data/lib/steep/project.rb

@@ -2,18 +2,22 @@ module Steep
   class Project
     attr_reader :targets
     attr_reader :steepfile_path
+    attr_reader :base_dir
 
-    def initialize(steepfile_path:)
+    def initialize(steepfile_path:, base_dir: nil)
       @targets = []
       @steepfile_path = steepfile_path
-
-      unless steepfile_path.absolute?
-        raise "Project#initialize(steepfile_path:): steepfile_path should be absolute path"
+      @base_dir = if base_dir
+        base_dir
+      elsif steepfile_path
+        steepfile_path.parent
+      else
+        raise ArgumentError, "Project#initialize(base_dir:): neither base_dir nor steepfile_path given"
       end
-    end
 
-    def base_dir
-      steepfile_path.parent
+      if steepfile_path and !steepfile_path.absolute?
+        raise ArgumentError, "Project#initialize(steepfile_path:): steepfile_path should be absolute path"
+      end
     end
 
     def relative_path(path)

data/lib/steep/server/change_buffer.rb

@@ -5,13 +5,13 @@ module Steep
       attr_reader :buffered_changes
 
       def push_buffer
-        @mutex.synchronize do
+        mutex.synchronize do
           yield buffered_changes
         end
       end
 
       def pop_buffer
-        changes = @mutex.synchronize do
+        changes = mutex.synchronize do
           copy = buffered_changes.dup
           buffered_changes.clear
           copy

data/lib/steep/server/interaction_worker.rb

@@ -10,14 +10,15 @@ module Steep
 
       LSP = LanguageServer::Protocol
 
-      attr_reader :service
+      attr_reader :service, :mutex
 
       def initialize(project:, reader:, writer:, queue: Queue.new)
         super(project: project, reader: reader, writer: writer)
         @queue = queue
-        @service = Services::TypeCheckService.new(project: project)
         @mutex = Mutex.new
+        @service = Services::TypeCheckService.new(project: project)
         @buffered_changes = {}
+        @last_job_mutex = Mutex.new
       end
 
       def handle_job(job)
@@ -33,25 +34,61 @@ module Steep
           when ApplyChangeJob
             # nop
           when HoverJob
-            writer.write({ id: job.id, result: process_hover(job) })
+            writer.write(
+              {
+                id: job.id,
+                result: process_latest_job(job) { process_hover(job) }
+              }
+            )
           when CompletionJob
-            writer.write({ id: job.id, result: process_completion(job) })
+            writer.write(
+              {
+                id: job.id,
+                result: process_latest_job(job) { process_completion(job) }
+              }
+            )
           when SignatureHelpJob
-            writer.write({ id: job.id, result: process_signature_help(job) })
+            writer.write(
+              {
+                id: job.id,
+                result: process_latest_job(job) { process_signature_help(job) }
+              }
+            )
+          end
+        end
+      end
+
+      def process_latest_job(job)
+        @last_job_mutex.synchronize do
+          unless job.equal?(@last_job)
+            Steep.logger.debug { "Skipping interaction job: latest_job=#{@last_job.class}, skipped_job#{job.class}" }
+            return
+          end
+          @last_job = nil
+        end
+
+        yield
+      end
+
+      def queue_job(job)
+        @last_job_mutex.synchronize do
+          unless job.is_a?(ApplyChangeJob)
+            @last_job = job
           end
         end
+        queue << job
       end
 
       def handle_request(request)
         case request[:method]
         when "initialize"
           load_files(project: project, commandline_args: [])
-          queue << ApplyChangeJob.new
+          queue_job ApplyChangeJob.new
           writer.write({ id: request[:id], result: nil })
 
         when "textDocument/didChange"
           collect_changes(request)
-          queue << ApplyChangeJob.new
+          queue_job ApplyChangeJob.new
 
         when "textDocument/hover"
           id = request[:id]
@@ -60,7 +97,7 @@ module Steep
           line = request[:params][:position][:line]+1
           column = request[:params][:position][:character]
 
-          queue << HoverJob.new(id: id, path: path, line: line, column: column)
+          queue_job HoverJob.new(id: id, path: path, line: line, column: column)
 
         when "textDocument/completion"
           id = request[:id]
@@ -71,14 +108,14 @@ module Steep
           line, column = params[:position].yield_self {|hash| [hash[:line]+1, hash[:character]] }
           trigger = params.dig(:context, :triggerCharacter)
 
-          queue << CompletionJob.new(id: id, path: path, line: line, column: column, trigger: trigger)
+          queue_job CompletionJob.new(id: id, path: path, line: line, column: column, trigger: trigger)
         when "textDocument/signatureHelp"
           id = request[:id]
           params = request[:params]
           path = project.relative_path(PathHelper.to_pathname!(params[:textDocument][:uri]))
           line, column = params[:position].yield_self {|hash| [hash[:line]+1, hash[:character]] }
 
-          queue << SignatureHelpJob.new(id: id, path: path, line: line, column: column)
+          queue_job SignatureHelpJob.new(id: id, path: path, line: line, column: column)
         end
       end
 
@@ -394,6 +431,17 @@ module Steep
               new_text: item.relative_type_name.to_s
             )
           )
+          when Services::CompletionProvider::TextItem
+            LSP::Interface::CompletionItem.new(
+              label: item.label,
+              label_details: item.help_text && LSP::Interface::CompletionItemLabelDetails.new(description: item.help_text),
+              kind: LSP::Constant::CompletionItemKind::SNIPPET,
+              insert_text_format: LSP::Constant::InsertTextFormat::SNIPPET,
+              text_edit: LSP::Interface::TextEdit.new(
+                range: range,
+                new_text: item.text
+              )
+            )
         end
       end
 
@@ -402,7 +450,9 @@ module Steep
           if target = project.target_for_source_path(job.path)
             file = service.source_files[job.path] or return
             subtyping = service.signature_services[target.name].current_subtyping or return
-            source = Source.parse(file.content, path: file.path, factory: subtyping.factory)
+            source =
+              Source.parse(file.content, path: file.path, factory: subtyping.factory)
+                .without_unrelated_defs(line: job.line, column: job.column)
 
             provider = Services::SignatureHelpProvider.new(source: source, subtyping: subtyping)
 

data/lib/steep/server/worker_process.rb

@@ -64,6 +64,7 @@ module Steep
 
         pid = fork do
           Process.setpgid(0, 0)
+          Steep.ui_logger.level = :fatal
           stdin_out.close
           stdout_in.close
           worker.run()
@@ -92,7 +93,8 @@ module Steep
       end
 
       def self.spawn_worker(type, name:, steepfile:, steep_command:, index:, delay_shutdown:, patterns:)
-        args = ["--name=#{name}", "--steepfile=#{steepfile}"]
+        args = ["--name=#{name}"]
+        args << "--steepfile=#{steepfile}" if steepfile
         args << (%w(debug info warn error fatal unknown)[Steep.logger.level].yield_self {|log_level| "--log-level=#{log_level}" })
 
         if Steep.log_output.is_a?(String)