ruby-lsp 0.17.16 → 0.18.0

data/lib/ruby_indexer/test/classes_and_modules_test.rb

@@ -213,10 +213,10 @@ module RubyIndexer
       RUBY
 
       foo_entry = @index["Foo"].first
-      assert_equal("This is a Foo comment\nThis is another Foo comment", foo_entry.comments.join("\n"))
+      assert_equal("This is a Foo comment\nThis is another Foo comment", foo_entry.comments)
 
       bar_entry = @index["Bar"].first
-      assert_equal("This Bar comment has 1 line padding", bar_entry.comments.join("\n"))
+      assert_equal("This Bar comment has 1 line padding", bar_entry.comments)
     end
 
     def test_skips_comments_containing_invalid_encodings
@@ -239,10 +239,10 @@ module RubyIndexer
       RUBY
 
       foo_entry = @index["Foo"].first
-      assert_equal("This is a Foo comment\nThis is another Foo comment", foo_entry.comments.join("\n"))
+      assert_equal("This is a Foo comment\nThis is another Foo comment", foo_entry.comments)
 
       bar_entry = @index["Foo::Bar"].first
-      assert_equal("This is a Bar comment", bar_entry.comments.join("\n"))
+      assert_equal("This is a Bar comment", bar_entry.comments)
     end
 
     def test_comments_can_be_attached_to_a_reopened_class
@@ -255,10 +255,10 @@ module RubyIndexer
       RUBY
 
       first_foo_entry = @index["Foo"][0]
-      assert_equal("This is a Foo comment", first_foo_entry.comments.join("\n"))
+      assert_equal("This is a Foo comment", first_foo_entry.comments)
 
       second_foo_entry = @index["Foo"][1]
-      assert_equal("This is another Foo comment", second_foo_entry.comments.join("\n"))
+      assert_equal("This is another Foo comment", second_foo_entry.comments)
     end
 
     def test_comments_removes_the_leading_pound_and_space
@@ -271,10 +271,10 @@ module RubyIndexer
       RUBY
 
       first_foo_entry = @index["Foo"][0]
-      assert_equal("This is a Foo comment", first_foo_entry.comments.join("\n"))
+      assert_equal("This is a Foo comment", first_foo_entry.comments)
 
       second_foo_entry = @index["Bar"][0]
-      assert_equal("This is a Bar comment", second_foo_entry.comments.join("\n"))
+      assert_equal("This is a Bar comment", second_foo_entry.comments)
     end
 
     def test_private_class_and_module_indexing
@@ -483,7 +483,7 @@ module RubyIndexer
 
       foo = T.must(@index["Foo::<Class:Foo>"].first)
       assert_equal(4, foo.location.start_line)
-      assert_equal("Some extra comments", foo.comments.join("\n"))
+      assert_equal("Some extra comments", foo.comments)
     end
 
     def test_dynamic_singleton_class_blocks
@@ -501,7 +501,7 @@ module RubyIndexer
       # That pattern cannot be properly analyzed statically and assuming that it's always a regular singleton simplifies
       # the implementation considerably.
       assert_equal(3, singleton.location.start_line)
-      assert_equal("Some extra comments", singleton.comments.join("\n"))
+      assert_equal("Some extra comments", singleton.comments)
     end
 
     def test_namespaces_inside_singleton_blocks

data/lib/ruby_indexer/test/constant_test.rb

@@ -86,16 +86,16 @@ module RubyIndexer
         A::BAZ = 1
       RUBY
 
-      foo_comment = @index["FOO"].first.comments.join("\n")
+      foo_comment = @index["FOO"].first.comments
       assert_equal("FOO comment", foo_comment)
 
-      a_foo_comment = @index["A::FOO"].first.comments.join("\n")
+      a_foo_comment = @index["A::FOO"].first.comments
       assert_equal("A::FOO comment", a_foo_comment)
 
-      bar_comment = @index["BAR"].first.comments.join("\n")
+      bar_comment = @index["BAR"].first.comments
       assert_equal("::BAR comment", bar_comment)
 
-      a_baz_comment = @index["A::BAZ"].first.comments.join("\n")
+      a_baz_comment = @index["A::BAZ"].first.comments
       assert_equal("A::BAZ comment", a_baz_comment)
     end
 

data/lib/ruby_indexer/test/enhancements_test.rb

@@ -38,7 +38,7 @@ module RubyIndexer
               file_path,
               location,
               location,
-              [],
+              nil,
               [Entry::Signature.new([Entry::RequiredParameter.new(name: :a)])],
               Entry::Visibility::PUBLIC,
               owner,
@@ -120,7 +120,7 @@ module RubyIndexer
             file_path,
             location,
             location,
-            [],
+            nil,
             [],
             Entry::Visibility::PUBLIC,
             owner,

data/lib/ruby_indexer/test/index_test.rb

@@ -1822,5 +1822,46 @@ module RubyIndexer
         @index.linearized_ancestors_of("Foo::Child::<Class:Child>"),
       )
     end
+
+    def test_resolving_circular_method_aliases_on_class_reopen
+      index(<<~RUBY)
+        class Foo
+          alias bar ==
+          def ==(other) = true
+        end
+
+        class Foo
+          alias == bar
+        end
+      RUBY
+
+      method = @index.resolve_method("==", "Foo").first
+      assert_kind_of(Entry::Method, method)
+      assert_equal("==", method.name)
+
+      candidates = @index.method_completion_candidates("=", "Foo")
+      assert_equal(["==", "==="], candidates.map(&:name))
+    end
+
+    def test_entries_for
+      index(<<~RUBY)
+        class Foo; end
+
+        module Bar
+          def my_def; end
+          def self.my_singleton_def; end
+        end
+      RUBY
+
+      entries = @index.entries_for("/fake/path/foo.rb", Entry)
+      assert_equal(["Foo", "Bar", "my_def", "Bar::<Class:Bar>", "my_singleton_def"], entries.map(&:name))
+
+      entries = @index.entries_for("/fake/path/foo.rb", RubyIndexer::Entry::Namespace)
+      assert_equal(["Foo", "Bar", "Bar::<Class:Bar>"], entries.map(&:name))
+    end
+
+    def test_entries_for_returns_nil_if_no_matches
+      assert_nil(@index.entries_for("non_existing_file.rb", Entry::Namespace))
+    end
   end
 end

data/lib/ruby_indexer/test/method_test.rb

@@ -330,6 +330,33 @@ module RubyIndexer
       assert_empty(parameters)
     end
 
+    def test_methods_with_argument_forwarding
+      index(<<~RUBY)
+        class Foo
+          def bar(...)
+          end
+
+          def baz(a, ...)
+          end
+        end
+      RUBY
+
+      entry = T.must(@index["bar"].first)
+      assert_instance_of(Entry::Method, entry, "Expected `bar` to be indexed")
+
+      parameters = entry.signatures.first.parameters
+      assert_equal(1, parameters.length)
+      assert_instance_of(Entry::ForwardingParameter, parameters.first)
+
+      entry = T.must(@index["baz"].first)
+      assert_instance_of(Entry::Method, entry, "Expected `baz` to be indexed")
+
+      parameters = entry.signatures.first.parameters
+      assert_equal(2, parameters.length)
+      assert_instance_of(Entry::RequiredParameter, parameters[0])
+      assert_instance_of(Entry::ForwardingParameter, parameters[1])
+    end
+
     def test_keeps_track_of_method_owner
       index(<<~RUBY)
         class Foo
@@ -355,9 +382,9 @@ module RubyIndexer
       RUBY
 
       assert_entry("bar", Entry::Accessor, "/fake/path/foo.rb:2-15:2-18")
-      assert_equal("Hello there", @index["bar"].first.comments.join("\n"))
+      assert_equal("Hello there", @index["bar"].first.comments)
       assert_entry("other", Entry::Accessor, "/fake/path/foo.rb:2-21:2-26")
-      assert_equal("Hello there", @index["other"].first.comments.join("\n"))
+      assert_equal("Hello there", @index["other"].first.comments)
       assert_entry("baz=", Entry::Accessor, "/fake/path/foo.rb:3-15:3-18")
       assert_entry("qux", Entry::Accessor, "/fake/path/foo.rb:4-17:4-20")
       assert_entry("qux=", Entry::Accessor, "/fake/path/foo.rb:4-17:4-20")
@@ -461,5 +488,233 @@ module RubyIndexer
       assert_equal(6, name_location.start_column)
       assert_equal(9, name_location.end_column)
     end
+
+    def test_signature_matches_for_a_method_with_positional_params
+      index(<<~RUBY)
+        class Foo
+          def bar(a, b = 123)
+          end
+        end
+      RUBY
+
+      entry = T.must(@index["bar"].first)
+
+      # Matching calls
+      assert_signature_matches(entry, "bar()")
+      assert_signature_matches(entry, "bar(1)")
+      assert_signature_matches(entry, "bar(1, 2)")
+      assert_signature_matches(entry, "bar(...)")
+      assert_signature_matches(entry, "bar(1, ...)")
+      assert_signature_matches(entry, "bar(*a)")
+      assert_signature_matches(entry, "bar(1, *a)")
+      assert_signature_matches(entry, "bar(1, *a, 2)")
+      assert_signature_matches(entry, "bar(*a, 2)")
+      assert_signature_matches(entry, "bar(1, **a)")
+      assert_signature_matches(entry, "bar(1) {}")
+      # This call is impossible to analyze statically because it depends on whether there are elements inside `a` or
+      # not. If there's nothing, the call will fail. But if there's anything inside, the hash will become the first
+      # positional argument
+      assert_signature_matches(entry, "bar(**a)")
+
+      # Non matching calls
+
+      refute_signature_matches(entry, "bar(1, 2, 3)")
+      refute_signature_matches(entry, "bar(1, b: 2)")
+      refute_signature_matches(entry, "bar(1, 2, c: 3)")
+    end
+
+    def test_signature_matches_for_a_method_with_argument_forwarding
+      index(<<~RUBY)
+        class Foo
+          def bar(...)
+          end
+        end
+      RUBY
+
+      entry = T.must(@index["bar"].first)
+
+      # All calls match a forwarding parameter
+      assert_signature_matches(entry, "bar(1)")
+      assert_signature_matches(entry, "bar(1, 2)")
+      assert_signature_matches(entry, "bar(...)")
+      assert_signature_matches(entry, "bar(1, ...)")
+      assert_signature_matches(entry, "bar(*a)")
+      assert_signature_matches(entry, "bar(1, *a)")
+      assert_signature_matches(entry, "bar(1, *a, 2)")
+      assert_signature_matches(entry, "bar(*a, 2)")
+      assert_signature_matches(entry, "bar(1, **a)")
+      assert_signature_matches(entry, "bar(1) {}")
+      assert_signature_matches(entry, "bar()")
+      assert_signature_matches(entry, "bar(1, 2, 3)")
+      assert_signature_matches(entry, "bar(1, 2, a: 1, b: 5) {}")
+    end
+
+    def test_signature_matches_for_post_forwarding_parameter
+      index(<<~RUBY)
+        class Foo
+          def bar(a, ...)
+          end
+        end
+      RUBY
+
+      entry = T.must(@index["bar"].first)
+
+      # All calls with at least one positional argument match
+      assert_signature_matches(entry, "bar(1)")
+      assert_signature_matches(entry, "bar(1, 2)")
+      assert_signature_matches(entry, "bar(...)")
+      assert_signature_matches(entry, "bar(1, ...)")
+      assert_signature_matches(entry, "bar(*a)")
+      assert_signature_matches(entry, "bar(1, *a)")
+      assert_signature_matches(entry, "bar(1, *a, 2)")
+      assert_signature_matches(entry, "bar(*a, 2)")
+      assert_signature_matches(entry, "bar(1, **a)")
+      assert_signature_matches(entry, "bar(1) {}")
+      assert_signature_matches(entry, "bar(1, 2, 3)")
+      assert_signature_matches(entry, "bar(1, 2, a: 1, b: 5) {}")
+      assert_signature_matches(entry, "bar()")
+    end
+
+    def test_signature_matches_for_destructured_parameters
+      index(<<~RUBY)
+        class Foo
+          def bar(a, (b, c))
+          end
+        end
+      RUBY
+
+      entry = T.must(@index["bar"].first)
+
+      # All calls with at least one positional argument match
+      assert_signature_matches(entry, "bar()")
+      assert_signature_matches(entry, "bar(1)")
+      assert_signature_matches(entry, "bar(1, 2)")
+      assert_signature_matches(entry, "bar(...)")
+      assert_signature_matches(entry, "bar(1, ...)")
+      assert_signature_matches(entry, "bar(*a)")
+      assert_signature_matches(entry, "bar(1, *a)")
+      assert_signature_matches(entry, "bar(*a, 2)")
+      # This matches because `bar(1, *[], 2)` would result in `bar(1, 2)`, which is a valid call
+      assert_signature_matches(entry, "bar(1, *a, 2)")
+      assert_signature_matches(entry, "bar(1, **a)")
+      assert_signature_matches(entry, "bar(1) {}")
+
+      refute_signature_matches(entry, "bar(1, 2, 3)")
+      refute_signature_matches(entry, "bar(1, 2, a: 1, b: 5) {}")
+    end
+
+    def test_signature_matches_for_post_parameters
+      index(<<~RUBY)
+        class Foo
+          def bar(*splat, a)
+          end
+        end
+      RUBY
+
+      entry = T.must(@index["bar"].first)
+
+      # All calls with at least one positional argument match
+      assert_signature_matches(entry, "bar(1)")
+      assert_signature_matches(entry, "bar(1, 2)")
+      assert_signature_matches(entry, "bar(...)")
+      assert_signature_matches(entry, "bar(1, ...)")
+      assert_signature_matches(entry, "bar(*a)")
+      assert_signature_matches(entry, "bar(1, *a)")
+      assert_signature_matches(entry, "bar(*a, 2)")
+      assert_signature_matches(entry, "bar(1, *a, 2)")
+      assert_signature_matches(entry, "bar(1, **a)")
+      assert_signature_matches(entry, "bar(1, 2, 3)")
+      assert_signature_matches(entry, "bar(1) {}")
+      assert_signature_matches(entry, "bar()")
+
+      refute_signature_matches(entry, "bar(1, 2, a: 1, b: 5) {}")
+    end
+
+    def test_signature_matches_for_keyword_parameters
+      index(<<~RUBY)
+        class Foo
+          def bar(a:, b: 123)
+          end
+        end
+      RUBY
+
+      entry = T.must(@index["bar"].first)
+
+      assert_signature_matches(entry, "bar(...)")
+      assert_signature_matches(entry, "bar()")
+      assert_signature_matches(entry, "bar(a: 1)")
+      assert_signature_matches(entry, "bar(a: 1, b: 32)")
+
+      refute_signature_matches(entry, "bar(a: 1, c: 2)")
+      refute_signature_matches(entry, "bar(1, ...)")
+      refute_signature_matches(entry, "bar(1) {}")
+      refute_signature_matches(entry, "bar(1, *a)")
+      refute_signature_matches(entry, "bar(*a, 2)")
+      refute_signature_matches(entry, "bar(1, *a, 2)")
+      refute_signature_matches(entry, "bar(1, **a)")
+      refute_signature_matches(entry, "bar(*a)")
+      refute_signature_matches(entry, "bar(1)")
+      refute_signature_matches(entry, "bar(1, 2)")
+      refute_signature_matches(entry, "bar(1, 2, a: 1, b: 5) {}")
+    end
+
+    def test_signature_matches_for_keyword_splats
+      index(<<~RUBY)
+        class Foo
+          def bar(a, b:, **kwargs)
+          end
+        end
+      RUBY
+
+      entry = T.must(@index["bar"].first)
+
+      assert_signature_matches(entry, "bar(...)")
+      assert_signature_matches(entry, "bar()")
+      assert_signature_matches(entry, "bar(1)")
+      assert_signature_matches(entry, "bar(1, b: 2)")
+      assert_signature_matches(entry, "bar(1, b: 2, c: 3, d: 4)")
+
+      refute_signature_matches(entry, "bar(1, 2, b: 2)")
+    end
+
+    def test_partial_signature_matches
+      # It's important to match signatures partially, because we want to figure out which signature we should show while
+      # the user is in the middle of typing
+      index(<<~RUBY)
+        class Foo
+          def bar(a:, b:)
+          end
+
+          def baz(a, b)
+          end
+        end
+      RUBY
+
+      entry = T.must(@index["bar"].first)
+      assert_signature_matches(entry, "bar(a: 1)")
+
+      entry = T.must(@index["baz"].first)
+      assert_signature_matches(entry, "baz(1)")
+    end
+
+    private
+
+    sig { params(entry: Entry::Method, call_string: String).void }
+    def assert_signature_matches(entry, call_string)
+      sig = T.must(entry.signatures.first)
+      arguments = parse_prism_args(call_string)
+      assert(sig.matches?(arguments), "Expected #{call_string} to match #{entry.name}#{entry.decorated_parameters}")
+    end
+
+    sig { params(entry: Entry::Method, call_string: String).void }
+    def refute_signature_matches(entry, call_string)
+      sig = T.must(entry.signatures.first)
+      arguments = parse_prism_args(call_string)
+      refute(sig.matches?(arguments), "Expected #{call_string} to not match #{entry.name}#{entry.decorated_parameters}")
+    end
+
+    def parse_prism_args(s)
+      Array(Prism.parse(s).value.statements.body.first.arguments&.arguments)
+    end
   end
 end

data/lib/ruby_indexer/test/rbs_indexer_test.rb

@@ -345,7 +345,7 @@ module RubyIndexer
       assert_equal("all?", entry.old_name)
       assert_equal("Array", entry.owner.name)
       assert(entry.file_path.end_with?("core/array.rbs"))
-      assert_includes(entry.comments[0], "Returns `true` if any element of `self` meets a given criterion.")
+      assert_includes(entry.comments, "Returns `true` if any element of `self` meets a given criterion.")
     end
 
     private

data/lib/ruby_lsp/addon.rb

@@ -30,6 +30,8 @@ module RubyLsp
     # Addon instances that have declared a handler to accept file watcher events
     @file_watcher_addons = T.let([], T::Array[Addon])
 
+    AddonNotFoundError = Class.new(StandardError)
+
     class << self
       extend T::Sig
 
@@ -78,11 +80,10 @@ module RubyLsp
         errors
       end
 
-      # Intended for use by tests for addons
       sig { params(addon_name: String).returns(Addon) }
       def get(addon_name)
         addon = addons.find { |addon| addon.name == addon_name }
-        raise "Could not find addon '#{addon_name}'" unless addon
+        raise AddonNotFoundError, "Could not find addon '#{addon_name}'" unless addon
 
         addon
       end

data/lib/ruby_lsp/base_server.rb

@@ -31,6 +31,7 @@ module RubyLsp
         Thread,
       )
 
+      @global_state = T.let(GlobalState.new, GlobalState)
       Thread.main.priority = 1
     end
 
@@ -52,7 +53,26 @@ module RubyLsp
               message[:params][:textDocument][:uri] = parsed_uri
 
               # We don't want to try to parse documents on text synchronization notifications
-              @store.get(parsed_uri).parse unless method.start_with?("textDocument/did")
+              unless method.start_with?("textDocument/did")
+                document = @store.get(parsed_uri)
+
+                # If the client supports request delegation and we're working with an ERB document and there was
+                # something to parse, then we have to maintain the client updated about the virtual state of the host
+                # language source
+                if document.parse! && @global_state.supports_request_delegation && document.is_a?(ERBDocument)
+                  send_message(
+                    Notification.new(
+                      method: "delegate/textDocument/virtualState",
+                      params: {
+                        textDocument: {
+                          uri: uri,
+                          text: document.host_language_source,
+                        },
+                      },
+                    ),
+                  )
+                end
+              end
             rescue Store::NonExistingDocumentError
               # If we receive a request for a file that no longer exists, we don't want to fail
             end

data/lib/ruby_lsp/document.rb

@@ -51,7 +51,8 @@ module RubyLsp
       @version = T.let(version, Integer)
       @uri = T.let(uri, URI::Generic)
       @needs_parsing = T.let(true, T::Boolean)
-      @parse_result = T.let(parse, ParseResultType)
+      @parse_result = T.let(T.unsafe(nil), ParseResultType)
+      parse!
     end
 
     sig { params(other: Document[T.untyped]).returns(T::Boolean) }
@@ -106,8 +107,9 @@ module RubyLsp
       @cache.clear
     end
 
-    sig { abstract.returns(ParseResultType) }
-    def parse; end
+    # Returns `true` if the document was parsed and `false` if nothing needed parsing
+    sig { abstract.returns(T::Boolean) }
+    def parse!; end
 
     sig { abstract.returns(T::Boolean) }
     def syntax_error?; end

data/lib/ruby_lsp/erb_document.rb

@@ -6,17 +6,30 @@ module RubyLsp
     extend T::Sig
     extend T::Generic
 
+    sig { returns(String) }
+    attr_reader :host_language_source
+
     ParseResultType = type_member { { fixed: Prism::ParseResult } }
 
-    sig { override.returns(ParseResultType) }
-    def parse
-      return @parse_result unless @needs_parsing
+    sig { params(source: String, version: Integer, uri: URI::Generic, encoding: Encoding).void }
+    def initialize(source:, version:, uri:, encoding: Encoding::UTF_8)
+      # This has to be initialized before calling super because we call `parse` in the parent constructor, which
+      # overrides this with the proper virtual host language source
+      @host_language_source = T.let("", String)
+      super
+    end
+
+    sig { override.returns(T::Boolean) }
+    def parse!
+      return false unless @needs_parsing
 
       @needs_parsing = false
       scanner = ERBScanner.new(@source)
       scanner.scan
+      @host_language_source = scanner.host_language
       # assigning empty scopes to turn Prism into eval mode
       @parse_result = Prism.parse(scanner.ruby, scopes: [[]])
+      true
     end
 
     sig { override.returns(T::Boolean) }
@@ -39,16 +52,22 @@ module RubyLsp
       RubyDocument.locate(@parse_result.value, create_scanner.find_char_position(position), node_types: node_types)
     end
 
+    sig { params(char_position: Integer).returns(T.nilable(T::Boolean)) }
+    def inside_host_language?(char_position)
+      char = @host_language_source[char_position]
+      char && char != " "
+    end
+
     class ERBScanner
       extend T::Sig
 
       sig { returns(String) }
-      attr_reader :ruby, :html
+      attr_reader :ruby, :host_language
 
       sig { params(source: String).void }
       def initialize(source)
         @source = source
-        @html = T.let(+"", String)
+        @host_language = T.let(+"", String)
         @ruby = T.let(+"", String)
         @current_pos = T.let(0, Integer)
         @inside_ruby = T.let(false, T::Boolean)
@@ -104,16 +123,16 @@ module RubyLsp
           end
         when "\r"
           @ruby << char
-          @html << char
+          @host_language << char
 
           if next_char == "\n"
             @ruby << next_char
-            @html << next_char
+            @host_language << next_char
             @current_pos += 1
           end
         when "\n"
           @ruby << char
-          @html << char
+          @host_language << char
         else
           push_char(T.must(char))
         end
@@ -123,10 +142,10 @@ module RubyLsp
       def push_char(char)
         if @inside_ruby
           @ruby << char
-          @html << " " * char.length
+          @host_language << " " * char.length
         else
           @ruby << " " * char.length
-          @html << char
+          @host_language << char
         end
       end
 

data/lib/ruby_lsp/global_state.rb

@@ -21,7 +21,7 @@ module RubyLsp
     attr_reader :encoding
 
     sig { returns(T::Boolean) }
-    attr_reader :supports_watching_files, :experimental_features
+    attr_reader :supports_watching_files, :experimental_features, :supports_request_delegation
 
     sig { returns(TypeInferrer) }
     attr_reader :type_inferrer
@@ -40,6 +40,13 @@ module RubyLsp
       @supports_watching_files = T.let(false, T::Boolean)
       @experimental_features = T.let(false, T::Boolean)
       @type_inferrer = T.let(TypeInferrer.new(@index, @experimental_features), TypeInferrer)
+      @addon_settings = T.let({}, T::Hash[String, T.untyped])
+      @supports_request_delegation = T.let(false, T::Boolean)
+    end
+
+    sig { params(addon_name: String).returns(T.nilable(T::Hash[Symbol, T.untyped])) }
+    def settings_for_addon(addon_name)
+      @addon_settings[addon_name]
     end
 
     sig { params(identifier: String, instance: Requests::Support::Formatter).void }
@@ -119,6 +126,13 @@ module RubyLsp
       @experimental_features = options.dig(:initializationOptions, :experimentalFeaturesEnabled) || false
       @type_inferrer.experimental_features = @experimental_features
 
+      addon_settings = options.dig(:initializationOptions, :addonSettings)
+      if addon_settings
+        addon_settings.transform_keys!(&:to_s)
+        @addon_settings.merge!(addon_settings)
+      end
+
+      @supports_request_delegation = options.dig(:capabilities, :experimental, :requestDelegation) || false
       notifications
     end