ruby-lsp 0.18.3 → 0.18.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 399abe97e6c7a69238a01464936c1c8e9365462e142a1175fdccc37b8ee32882
-  data.tar.gz: 97fe2193dd4569a78e1e2a55911adfd833ba7c791955953385152d0fd930b685
+  metadata.gz: fd64a8dbd26620a032266729f488c5ace69ead93e1cd8ae2677333d128bd72d4
+  data.tar.gz: a7489c2405509d8764750c5946036d19106db75b6609524117f763b6279f45d1
 SHA512:
-  metadata.gz: dd5960a18a96e3f5c40aa768f47977097e74c68b470adba70903436ffeef6e4e0038e4ea6bcd8d19f9dc1d4b23e0c36b11d9f5b4fd61e75346dda28b98582620
-  data.tar.gz: d021ddfd3850a4a5378232ecc6788f5c335d56d6093211ce4fb968738ce38c8d53bddca6f0a820af13e7a240d7c157bf07263960593128d7e2c48e5a798b5cfc
+  metadata.gz: dba4de24eca9cd3db51c94a2aef71c0b77e041172a5827d24b2a4b4079c41d955e0e990972258a6fd223766eedc20490f9af809da80ff46eb289a31d2fe2dbb7
+  data.tar.gz: 49922ea026fe43cd23bfece5b5e1f6c10838dfe6e80a24c1dc5bd184d359361459af94083f773c86ce45f392ab4750f242a512136d367b8ccd95125ff13d42a9

data/VERSION

@@ -1 +1 @@
-0.18.3
+0.18.4

data/lib/ruby_indexer/lib/ruby_indexer/rbs_indexer.rb

@@ -139,13 +139,23 @@ module RubyIndexer
 
     sig { params(overload: RBS::AST::Members::MethodDefinition::Overload).returns(T::Array[Entry::Parameter]) }
     def process_overload(overload)
-      function = T.cast(overload.method_type.type, RBS::Types::Function)
-      parameters = parse_arguments(function)
+      function = overload.method_type.type
 
-      block = overload.method_type.block
-      parameters << Entry::BlockParameter.anonymous if block&.required
+      if function.is_a?(RBS::Types::Function)
+        parameters = parse_arguments(function)
 
-      parameters
+        block = overload.method_type.block
+        parameters << Entry::BlockParameter.anonymous if block&.required
+        return parameters
+      end
+
+      # Untyped functions are a new RBS feature (since v3.6.0) to declare methods that accept any parameters. For our
+      # purposes, accepting any argument is equivalent to `...`
+      if defined?(RBS::Types::UntypedFunction) && function.is_a?(RBS::Types::UntypedFunction)
+        [Entry::ForwardingParameter.new]
+      else
+        []
+      end
     end
 
     sig { params(function: RBS::Types::Function).returns(T::Array[Entry::Parameter]) }

data/lib/ruby_indexer/test/rbs_indexer_test.rb

@@ -348,6 +348,14 @@ module RubyIndexer
       assert_includes(entry.comments, "Returns `true` if any element of `self` meets a given criterion.")
     end
 
+    def test_indexing_untyped_functions
+      entries = @index.resolve_method("call", "Method")
+
+      parameters = entries.first.signatures.first.parameters
+      assert_equal(1, parameters.length)
+      assert_instance_of(Entry::ForwardingParameter, parameters.first)
+    end
+
     private
 
     def parse_rbs_methods(rbs, method_name)

data/lib/ruby_lsp/addon.rb

@@ -2,7 +2,7 @@
 # frozen_string_literal: true
 
 module RubyLsp
-  # To register an addon, inherit from this class and implement both `name` and `activate`
+  # To register an add-on, inherit from this class and implement both `name` and `activate`
   #
   # # Example
   #
@@ -14,7 +14,7 @@ module RubyLsp
   #     end
   #
   #     def name
-  #       "My addon name"
+  #       "My add-on name"
   #     end
   #   end
   # end
@@ -27,7 +27,7 @@ module RubyLsp
 
     @addons = T.let([], T::Array[Addon])
     @addon_classes = T.let([], T::Array[T.class_of(Addon)])
-    # Addon instances that have declared a handler to accept file watcher events
+    # Add-on instances that have declared a handler to accept file watcher events
     @file_watcher_addons = T.let([], T::Array[Addon])
 
     AddonNotFoundError = Class.new(StandardError)
@@ -51,12 +51,12 @@ module RubyLsp
         super
       end
 
-      # Discovers and loads all addons. Returns a list of errors when trying to require addons
+      # Discovers and loads all add-ons. Returns a list of errors when trying to require add-ons
       sig do
         params(global_state: GlobalState, outgoing_queue: Thread::Queue).returns(T::Array[StandardError])
       end
       def load_addons(global_state, outgoing_queue)
-        # Require all addons entry points, which should be placed under
+        # Require all add-ons entry points, which should be placed under
         # `some_gem/lib/ruby_lsp/your_gem_name/addon.rb`
         errors = Gem.find_files("ruby_lsp/**/addon.rb").filter_map do |addon|
           require File.expand_path(addon)
@@ -69,7 +69,7 @@ module RubyLsp
         self.addons = addon_classes.map(&:new)
         self.file_watcher_addons = addons.select { |addon| addon.respond_to?(:workspace_did_change_watched_files) }
 
-        # Activate each one of the discovered addons. If any problems occur in the addons, we don't want to
+        # Activate each one of the discovered add-ons. If any problems occur in the add-ons, we don't want to
         # fail to boot the server
         addons.each do |addon|
           addon.activate(global_state, outgoing_queue)
@@ -83,7 +83,7 @@ module RubyLsp
       sig { params(addon_name: String).returns(Addon) }
       def get(addon_name)
         addon = addons.find { |addon| addon.name == addon_name }
-        raise AddonNotFoundError, "Could not find addon '#{addon_name}'" unless addon
+        raise AddonNotFoundError, "Could not find add-on '#{addon_name}'" unless addon
 
         addon
       end
@@ -118,17 +118,17 @@ module RubyLsp
       @errors.map(&:full_message).join("\n\n")
     end
 
-    # Each addon should implement `MyAddon#activate` and use to perform any sort of initialization, such as
+    # Each add-on should implement `MyAddon#activate` and use to perform any sort of initialization, such as
     # reading information into memory or even spawning a separate process
     sig { abstract.params(global_state: GlobalState, outgoing_queue: Thread::Queue).void }
     def activate(global_state, outgoing_queue); end
 
-    # Each addon should implement `MyAddon#deactivate` and use to perform any clean up, like shutting down a
+    # Each add-on should implement `MyAddon#deactivate` and use to perform any clean up, like shutting down a
     # child process
     sig { abstract.void }
     def deactivate; end
 
-    # Addons should override the `name` method to return the addon name
+    # Add-ons should override the `name` method to return the add-on name
     sig { abstract.returns(String) }
     def name; end
 

data/lib/ruby_lsp/base_server.rb

@@ -130,6 +130,12 @@ module RubyLsp
     sig { abstract.void }
     def shutdown; end
 
+    sig { params(id: Integer, message: String, type: Integer).void }
+    def fail_request_and_notify(id, message, type: Constant::MessageType::INFO)
+      send_message(Error.new(id: id, code: Constant::ErrorCodes::REQUEST_FAILED, message: message))
+      send_message(Notification.window_show_message(message, type: type))
+    end
+
     sig { returns(Thread) }
     def new_worker
       Thread.new do

data/lib/ruby_lsp/internal.rb

@@ -26,7 +26,7 @@ require "ruby_lsp/base_server"
 require "ruby_indexer/ruby_indexer"
 require "core_ext/uri"
 require "ruby_lsp/utils"
-require "ruby_lsp/parameter_scope"
+require "ruby_lsp/scope"
 require "ruby_lsp/global_state"
 require "ruby_lsp/server"
 require "ruby_lsp/type_inferrer"

data/lib/ruby_lsp/listeners/hover.rb

@@ -21,6 +21,7 @@ module RubyLsp
           Prism::InstanceVariableWriteNode,
           Prism::SymbolNode,
           Prism::StringNode,
+          Prism::InterpolatedStringNode,
           Prism::SuperNode,
           Prism::ForwardingSuperNode,
         ],
@@ -68,9 +69,21 @@ module RubyLsp
           :on_instance_variable_target_node_enter,
           :on_super_node_enter,
           :on_forwarding_super_node_enter,
+          :on_string_node_enter,
+          :on_interpolated_string_node_enter,
         )
       end
 
+      sig { params(node: Prism::StringNode).void }
+      def on_string_node_enter(node)
+        generate_heredoc_hover(node)
+      end
+
+      sig { params(node: Prism::InterpolatedStringNode).void }
+      def on_interpolated_string_node_enter(node)
+        generate_heredoc_hover(node)
+      end
+
       sig { params(node: Prism::ConstantReadNode).void }
       def on_constant_read_node_enter(node)
         return if @sorbet_level != RubyDocument::SorbetLevel::Ignore
@@ -155,6 +168,31 @@ module RubyLsp
 
       private
 
+      sig { params(node: T.any(Prism::InterpolatedStringNode, Prism::StringNode)).void }
+      def generate_heredoc_hover(node)
+        return unless node.heredoc?
+
+        opening_content = node.opening_loc&.slice
+        return unless opening_content
+
+        match = /(<<(?<type>(-|~)?))(?<quote>['"`]?)(?<delimiter>\w+)\k<quote>/.match(opening_content)
+        return unless match
+
+        heredoc_delimiter = match.named_captures["delimiter"]
+
+        if heredoc_delimiter
+          message = if match["type"] == "~"
+            "This is a squiggly heredoc definition using the `#{heredoc_delimiter}` delimiter. " \
+              "Indentation will be ignored in the resulting string."
+          else
+            "This is a heredoc definition using the `#{heredoc_delimiter}` delimiter. " \
+              "Indentation will be considered part of the string."
+          end
+
+          @response_builder.push(message, category: :documentation)
+        end
+      end
+
       sig { void }
       def handle_super_node_hover
         # Sorbet can handle super hover on typed true or higher

data/lib/ruby_lsp/listeners/semantic_highlighting.rb

@@ -27,7 +27,7 @@ module RubyLsp
       def initialize(dispatcher, response_builder)
         @response_builder = response_builder
         @special_methods = T.let(nil, T.nilable(T::Array[String]))
-        @current_scope = T.let(ParameterScope.new, ParameterScope)
+        @current_scope = T.let(Scope.new, Scope)
         @inside_regex_capture = T.let(false, T::Boolean)
         @inside_implicit_node = T.let(false, T::Boolean)
 
@@ -102,7 +102,7 @@ module RubyLsp
 
       sig { params(node: Prism::DefNode).void }
       def on_def_node_enter(node)
-        @current_scope = ParameterScope.new(@current_scope)
+        @current_scope = Scope.new(@current_scope)
       end
 
       sig { params(node: Prism::DefNode).void }
@@ -112,7 +112,7 @@ module RubyLsp
 
       sig { params(node: Prism::BlockNode).void }
       def on_block_node_enter(node)
-        @current_scope = ParameterScope.new(@current_scope)
+        @current_scope = Scope.new(@current_scope)
       end
 
       sig { params(node: Prism::BlockNode).void }
@@ -128,39 +128,39 @@ module RubyLsp
       sig { params(node: Prism::BlockParameterNode).void }
       def on_block_parameter_node_enter(node)
         name = node.name
-        @current_scope << name.to_sym if name
+        @current_scope.add(name.to_sym, :parameter) if name
       end
 
       sig { params(node: Prism::RequiredKeywordParameterNode).void }
       def on_required_keyword_parameter_node_enter(node)
-        @current_scope << node.name
+        @current_scope.add(node.name, :parameter)
       end
 
       sig { params(node: Prism::OptionalKeywordParameterNode).void }
       def on_optional_keyword_parameter_node_enter(node)
-        @current_scope << node.name
+        @current_scope.add(node.name, :parameter)
       end
 
       sig { params(node: Prism::KeywordRestParameterNode).void }
       def on_keyword_rest_parameter_node_enter(node)
         name = node.name
-        @current_scope << name.to_sym if name
+        @current_scope.add(name.to_sym, :parameter) if name
       end
 
       sig { params(node: Prism::OptionalParameterNode).void }
       def on_optional_parameter_node_enter(node)
-        @current_scope << node.name
+        @current_scope.add(node.name, :parameter)
       end
 
       sig { params(node: Prism::RequiredParameterNode).void }
       def on_required_parameter_node_enter(node)
-        @current_scope << node.name
+        @current_scope.add(node.name, :parameter)
       end
 
       sig { params(node: Prism::RestParameterNode).void }
       def on_rest_parameter_node_enter(node)
         name = node.name
-        @current_scope << name.to_sym if name
+        @current_scope.add(name.to_sym, :parameter) if name
       end
 
       sig { params(node: Prism::SelfNode).void }
@@ -170,8 +170,8 @@ module RubyLsp
 
       sig { params(node: Prism::LocalVariableWriteNode).void }
       def on_local_variable_write_node_enter(node)
-        type = @current_scope.type_for(node.name)
-        @response_builder.add_token(node.name_loc, type) if type == :parameter
+        local = @current_scope.lookup(node.name)
+        @response_builder.add_token(node.name_loc, :parameter) if local&.type == :parameter
       end
 
       sig { params(node: Prism::LocalVariableReadNode).void }
@@ -184,25 +184,26 @@ module RubyLsp
           return
         end
 
-        @response_builder.add_token(node.location, @current_scope.type_for(node.name))
+        local = @current_scope.lookup(node.name)
+        @response_builder.add_token(node.location, local&.type || :variable)
       end
 
       sig { params(node: Prism::LocalVariableAndWriteNode).void }
       def on_local_variable_and_write_node_enter(node)
-        type = @current_scope.type_for(node.name)
-        @response_builder.add_token(node.name_loc, type) if type == :parameter
+        local = @current_scope.lookup(node.name)
+        @response_builder.add_token(node.name_loc, :parameter) if local&.type == :parameter
       end
 
       sig { params(node: Prism::LocalVariableOperatorWriteNode).void }
       def on_local_variable_operator_write_node_enter(node)
-        type = @current_scope.type_for(node.name)
-        @response_builder.add_token(node.name_loc, type) if type == :parameter
+        local = @current_scope.lookup(node.name)
+        @response_builder.add_token(node.name_loc, :parameter) if local&.type == :parameter
       end
 
       sig { params(node: Prism::LocalVariableOrWriteNode).void }
       def on_local_variable_or_write_node_enter(node)
-        type = @current_scope.type_for(node.name)
-        @response_builder.add_token(node.name_loc, type) if type == :parameter
+        local = @current_scope.lookup(node.name)
+        @response_builder.add_token(node.name_loc, :parameter) if local&.type == :parameter
       end
 
       sig { params(node: Prism::LocalVariableTargetNode).void }
@@ -213,7 +214,8 @@ module RubyLsp
         # prevent pushing local variable target tokens. See https://github.com/ruby/prism/issues/1912
         return if @inside_regex_capture
 
-        @response_builder.add_token(node.location, @current_scope.type_for(node.name))
+        local = @current_scope.lookup(node.name)
+        @response_builder.add_token(node.location, local&.type || :variable)
       end
 
       sig { params(node: Prism::ClassNode).void }
@@ -311,7 +313,8 @@ module RubyLsp
           capture_name_offset = T.must(content.index("(?<#{name}>")) + 3
           local_var_loc = loc.copy(start_offset: loc.start_offset + capture_name_offset, length: name.length)
 
-          @response_builder.add_token(local_var_loc, @current_scope.type_for(name))
+          local = @current_scope.lookup(name)
+          @response_builder.add_token(local_var_loc, local&.type || :variable)
         end
       end
     end

data/lib/ruby_lsp/requests/on_type_formatting.rb

@@ -63,7 +63,7 @@ module RubyLsp
           if (comment_match = @previous_line.match(/^#(\s*)/))
             handle_comment_line(T.must(comment_match[1]))
           elsif @document.syntax_error?
-            match = /(?<=<<(-|~))(?<quote>['"`]?)(?<delimiter>\w+)\k<quote>/.match(@previous_line)
+            match = /(<<((-|~)?))(?<quote>['"`]?)(?<delimiter>\w+)\k<quote>/.match(@previous_line)
             heredoc_delimiter = match && match.named_captures["delimiter"]
 
             if heredoc_delimiter

data/lib/ruby_lsp/requests/support/common.rb

@@ -5,8 +5,8 @@ module RubyLsp
   module Requests
     module Support
       module Common
-        # WARNING: Methods in this class may be used by Ruby LSP addons such as
-        # https://github.com/Shopify/ruby-lsp-rails, or addons by created by developers outside of Shopify, so be
+        # WARNING: Methods in this class may be used by Ruby LSP add-ons such as
+        # https://github.com/Shopify/ruby-lsp-rails, or add-ons by created by developers outside of Shopify, so be
         # cautious of changing anything.
         extend T::Sig
         extend T::Helpers

data/lib/ruby_lsp/scope.rb

@@ -0,0 +1,47 @@
+# typed: strict
+# frozen_string_literal: true
+
+module RubyLsp
+  class Scope
+    extend T::Sig
+
+    sig { returns(T.nilable(Scope)) }
+    attr_reader :parent
+
+    sig { params(parent: T.nilable(Scope)).void }
+    def initialize(parent = nil)
+      @parent = parent
+
+      # A hash of name => type
+      @locals = T.let({}, T::Hash[Symbol, Local])
+    end
+
+    # Add a new local to this scope. The types should only be `:parameter` or `:variable`
+    sig { params(name: T.any(String, Symbol), type: Symbol).void }
+    def add(name, type)
+      @locals[name.to_sym] = Local.new(type)
+    end
+
+    sig { params(name: T.any(String, Symbol)).returns(T.nilable(Local)) }
+    def lookup(name)
+      sym = name.to_sym
+      entry = @locals[sym]
+      return entry if entry
+      return unless @parent
+
+      @parent.lookup(sym)
+    end
+
+    class Local
+      extend T::Sig
+
+      sig { returns(Symbol) }
+      attr_reader :type
+
+      sig { params(type: Symbol).void }
+      def initialize(type)
+        @type = type
+      end
+    end
+  end
+end

data/lib/ruby_lsp/server.rb

@@ -142,7 +142,7 @@ module RubyLsp
             method: "window/showMessage",
             params: Interface::ShowMessageParams.new(
               type: Constant::MessageType::WARNING,
-              message: "Error loading addons:\n\n#{errored_addons.map(&:formatted_errors).join("\n\n")}",
+              message: "Error loading add-ons:\n\n#{errored_addons.map(&:formatted_errors).join("\n\n")}",
             ),
           ),
         )
@@ -285,8 +285,9 @@ module RubyLsp
         rescue RuboCop::Error => e
           # The user may have provided unknown config switches in .rubocop or
           # is trying to load a non-existant config file.
-          send_message(Notification.window_show_error(
+          send_message(Notification.window_show_message(
             "RuboCop configuration error: #{e.message}. Formatting will not be available.",
+            type: Constant::MessageType::ERROR,
           ))
         end
       end
@@ -531,10 +532,16 @@ module RubyLsp
       response = Requests::Formatting.new(@global_state, document).perform
       send_message(Result.new(id: message[:id], response: response))
     rescue Requests::Request::InvalidFormatter => error
-      send_message(Notification.window_show_error("Configuration error: #{error.message}"))
+      send_message(Notification.window_show_message(
+        "Configuration error: #{error.message}",
+        type: Constant::MessageType::ERROR,
+      ))
       send_empty_response(message[:id])
     rescue StandardError, LoadError => error
-      send_message(Notification.window_show_error("Formatting error: #{error.message}"))
+      send_message(Notification.window_show_message(
+        "Formatting error: #{error.message}",
+        type: Constant::MessageType::ERROR,
+      ))
       send_empty_response(message[:id])
     end
 
@@ -673,30 +680,19 @@ module RubyLsp
       document = @store.get(uri)
 
       unless document.is_a?(RubyDocument)
-        send_message(Notification.window_show_error("Code actions are currently only available for Ruby documents"))
-        raise Requests::CodeActionResolve::CodeActionError
+        fail_request_and_notify(message[:id], "Code actions are currently only available for Ruby documents")
+        return
       end
 
       result = Requests::CodeActionResolve.new(document, params).perform
 
       case result
       when Requests::CodeActionResolve::Error::EmptySelection
-        send_message(Notification.window_show_error("Invalid selection for Extract Variable refactor"))
-        raise Requests::CodeActionResolve::CodeActionError
+        fail_request_and_notify(message[:id], "Invalid selection for extract variable refactor")
       when Requests::CodeActionResolve::Error::InvalidTargetRange
-        send_message(
-          Notification.window_show_error(
-            "Couldn't find an appropriate location to place extracted refactor",
-          ),
-        )
-        raise Requests::CodeActionResolve::CodeActionError
+        fail_request_and_notify(message[:id], "Couldn't find an appropriate location to place extracted refactor")
       when Requests::CodeActionResolve::Error::UnknownCodeAction
-        send_message(
-          Notification.window_show_error(
-            "Unknown code action",
-          ),
-        )
-        raise Requests::CodeActionResolve::CodeActionError
+        fail_request_and_notify(message[:id], "Unknown code action")
       else
         send_message(Result.new(id: message[:id], response: result))
       end
@@ -729,10 +725,16 @@ module RubyLsp
         ),
       )
     rescue Requests::Request::InvalidFormatter => error
-      send_message(Notification.window_show_error("Configuration error: #{error.message}"))
+      send_message(Notification.window_show_message(
+        "Configuration error: #{error.message}",
+        type: Constant::MessageType::ERROR,
+      ))
       send_empty_response(message[:id])
     rescue StandardError, LoadError => error
-      send_message(Notification.window_show_error("Error running diagnostics: #{error.message}"))
+      send_message(Notification.window_show_message(
+        "Error running diagnostics: #{error.message}",
+        type: Constant::MessageType::ERROR,
+      ))
       send_empty_response(message[:id])
     end
 
@@ -969,7 +971,9 @@ module RubyLsp
             false
           end
         rescue StandardError => error
-          send_message(Notification.window_show_error("Error while indexing: #{error.message}"))
+          message = "Error while indexing (see [troubleshooting steps]" \
+            "(https://shopify.github.io/ruby-lsp/troubleshooting#indexing)): #{error.message}"
+          send_message(Notification.window_show_message(message, type: Constant::MessageType::ERROR))
         end
 
         # Indexing produces a high number of short lived object allocations. That might lead to some fragmentation and
@@ -1054,8 +1058,9 @@ module RubyLsp
         @global_state.formatter = "none"
 
         send_message(
-          Notification.window_show_error(
+          Notification.window_show_message(
             "Ruby LSP formatter is set to `rubocop` but RuboCop was not found in the Gemfile or gemspec.",
+            type: Constant::MessageType::ERROR,
           ),
         )
       end

data/lib/ruby_lsp/utils.rb

@@ -64,14 +64,11 @@ module RubyLsp
     class << self
       extend T::Sig
 
-      sig { params(message: String).returns(Notification) }
-      def window_show_error(message)
+      sig { params(message: String, type: Integer).returns(Notification) }
+      def window_show_message(message, type: Constant::MessageType::INFO)
         new(
           method: "window/showMessage",
-          params: Interface::ShowMessageParams.new(
-            type: Constant::MessageType::ERROR,
-            message: message,
-          ),
+          params: Interface::ShowMessageParams.new(type: type, message: message),
         )
       end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby-lsp
 version: !ruby/object:Gem::Version
-  version: 0.18.3
+  version: 0.18.4
 platform: ruby
 authors:
 - Shopify
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-09-24 00:00:00.000000000 Z
+date: 2024-09-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: language_server-protocol
@@ -129,7 +129,6 @@ files:
 - lib/ruby_lsp/listeners/signature_help.rb
 - lib/ruby_lsp/load_sorbet.rb
 - lib/ruby_lsp/node_context.rb
-- lib/ruby_lsp/parameter_scope.rb
 - lib/ruby_lsp/rbs_document.rb
 - lib/ruby_lsp/requests/code_action_resolve.rb
 - lib/ruby_lsp/requests/code_actions.rb
@@ -171,6 +170,7 @@ files:
 - lib/ruby_lsp/response_builders/semantic_highlighting.rb
 - lib/ruby_lsp/response_builders/signature_help.rb
 - lib/ruby_lsp/ruby_document.rb
+- lib/ruby_lsp/scope.rb
 - lib/ruby_lsp/server.rb
 - lib/ruby_lsp/setup_bundler.rb
 - lib/ruby_lsp/store.rb

data/lib/ruby_lsp/parameter_scope.rb

@@ -1,33 +0,0 @@
-# typed: strict
-# frozen_string_literal: true
-
-module RubyLsp
-  class ParameterScope
-    extend T::Sig
-
-    sig { returns(T.nilable(ParameterScope)) }
-    attr_reader :parent
-
-    sig { params(parent: T.nilable(ParameterScope)).void }
-    def initialize(parent = nil)
-      @parent = parent
-      @parameters = T.let(Set.new, T::Set[Symbol])
-    end
-
-    sig { params(name: T.any(String, Symbol)).void }
-    def <<(name)
-      @parameters << name.to_sym
-    end
-
-    sig { params(name: T.any(Symbol, String)).returns(Symbol) }
-    def type_for(name)
-      parameter?(name) ? :parameter : :variable
-    end
-
-    sig { params(name: T.any(Symbol, String)).returns(T::Boolean) }
-    def parameter?(name)
-      sym = name.to_sym
-      @parameters.include?(sym) || (!@parent.nil? && @parent.parameter?(sym))
-    end
-  end
-end