Add keywords to completion candidates (#2317)

* Bump Sorbet version so T.let on array constants is not required

* Add keywords to completion candidates

When typing `foo d`, VS Code would send a completion request for `d`.
And then when `foo do` is typed, it would do fuzzy search on the previous
completion candidates. So currently, the completion candidates for `foo do`
would be `define_singleton_method` as demonstrated in #2304.

Sorbet LSP solved this issue by adding keywords to the completion candidates.
And this PR does the same.

Author: st0012

Gemfile.lock

@@ -95,14 +95,14 @@ GEM
       simplecov_json_formatter (~> 0.1)
     simplecov-html (0.12.3)
     simplecov_json_formatter (0.1.4)
-    sorbet (0.5.11435)
-      sorbet-static (= 0.5.11435)
-    sorbet-runtime (0.5.11435)
-    sorbet-static (0.5.11435-universal-darwin)
-    sorbet-static (0.5.11435-x86_64-linux)
-    sorbet-static-and-runtime (0.5.11435)
-      sorbet (= 0.5.11435)
-      sorbet-runtime (= 0.5.11435)
+    sorbet (0.5.11481)
+      sorbet-static (= 0.5.11481)
+    sorbet-runtime (0.5.11481)
+    sorbet-static (0.5.11481-universal-darwin)
+    sorbet-static (0.5.11481-x86_64-linux)
+    sorbet-static-and-runtime (0.5.11481)
+      sorbet (= 0.5.11481)
+      sorbet-runtime (= 0.5.11481)
     spoom (1.3.0)
       erubi (>= 1.10.0)
       prism (>= 0.19.0)

lib/ruby_lsp/listeners/completion.rb

@@ -7,6 +7,50 @@ class Completion
       extend T::Sig
       include Requests::Support::Common
 
+      KEYWORDS = [
+        "alias",
+        "and",
+        "begin",
+        "BEGIN",
+        "break",
+        "case",
+        "class",
+        "def",
+        "defined?",
+        "do",
+        "else",
+        "elsif",
+        "end",
+        "END",
+        "ensure",
+        "false",
+        "for",
+        "if",
+        "in",
+        "module",
+        "next",
+        "nil",
+        "not",
+        "or",
+        "redo",
+        "rescue",
+        "retry",
+        "return",
+        "self",
+        "super",
+        "then",
+        "true",
+        "undef",
+        "unless",
+        "until",
+        "when",
+        "while",
+        "yield",
+        "__ENCODING__",
+        "__FILE__",
+        "__LINE__",
+      ].freeze
+
       sig do
         params(
           response_builder: ResponseBuilders::CollectionResponseBuilder[Interface::CompletionItem],
@@ -277,7 +321,11 @@ def complete_require_relative(node)
 
       sig { params(node: Prism::CallNode, name: String).void }
       def complete_methods(node, name)
-        add_local_completions(node, name)
+        # If the node has a receiver, then we don't need to provide local nor keyword completions
+        if !@global_state.has_type_checker && !node.receiver
+          add_local_completions(node, name)
+          add_keyword_completions(node, name)
+        end
 
         type = @type_inferrer.infer_receiver_type(@node_context)
         return unless type
@@ -326,11 +374,6 @@ def complete_methods(node, name)
 
       sig { params(node: Prism::CallNode, name: String).void }
       def add_local_completions(node, name)
-        return if @global_state.has_type_checker
-
-        # If the call node has a receiver, then it cannot possibly be a local variable
-        return if node.receiver
-
         range = range_from_location(T.must(node.message_loc))
 
         @node_context.locals_for_scope.each do |local|
@@ -349,6 +392,24 @@ def add_local_completions(node, name)
         end
       end
 
+      sig { params(node: Prism::CallNode, name: String).void }
+      def add_keyword_completions(node, name)
+        range = range_from_location(T.must(node.message_loc))
+
+        KEYWORDS.each do |keyword|
+          next unless keyword.start_with?(name)
+
+          @response_builder << Interface::CompletionItem.new(
+            label: keyword,
+            text_edit: Interface::TextEdit.new(range: range, new_text: keyword),
+            kind: Constant::CompletionItemKind::KEYWORD,
+            data: {
+              skip_resolve: true,
+            },
+          )
+        end
+      end
+
       sig { params(label: String, node: Prism::StringNode).returns(Interface::CompletionItem) }
       def build_completion(label, node)
         # We should use the content location as we only replace the content and not the delimiters of the string

test/requests/completion_test.rb

@@ -4,6 +4,27 @@
 require "test_helper"
 
 class CompletionTest < Minitest::Test
+  def test_completion_keyword
+    source = <<~RUBY
+      foo d
+    RUBY
+
+    with_server(source, stub_no_typechecker: true) do |server, uri|
+      with_file_structure(server) do
+        server.process_message(id: 1, method: "textDocument/completion", params: {
+          textDocument: { uri: uri },
+          position: { line: 0, character: 5 },
+        })
+        result = server.pop_response.response
+
+        assert_equal(3, result.count)
+        assert_equal("def", result[0].label)
+        assert_equal("defined?", result[1].label)
+        assert_equal("do", result[2].label)
+      end
+    end
+  end
+
   def test_completion_command
     prefix = "foo/"
     source = <<~RUBY
@@ -1008,7 +1029,7 @@ def bar
       })
 
       result = server.pop_response.response
-      assert_equal(["baz", "bar"], result.map(&:label))
+      assert_equal(["begin", "break", "baz", "bar"], result.map(&:label))
     end
   end
 
@@ -1077,7 +1098,7 @@ def do_something
         position: { line: 8, character: 5 },
       })
       result = server.pop_response.response
-      assert_equal(["bar", "baz"], result.map(&:label))
+      assert_equal(["begin", "break", "bar", "baz"], result.map(&:label))
     end
   end
 
@@ -1108,31 +1129,31 @@ def do_something(abc1, abc2, abc3)
       })
 
       result = server.pop_response.response
-      assert_equal(["abc1", "abc2", "abc3"], result.map(&:label))
+      assert_equal(["abc1", "abc2", "abc3", "alias", "and"], result.map(&:label))
 
       server.process_message(id: 1, method: "textDocument/completion", params: {
         textDocument: { uri: uri },
         position: { line: 7, character: 7 },
       })
 
       result = server.pop_response.response
-      assert_equal(["abc1", "abc2", "abc3", "abc4", "abc5"], result.map(&:label))
+      assert_equal(["abc1", "abc2", "abc3", "abc4", "abc5", "alias", "and"], result.map(&:label))
 
       server.process_message(id: 1, method: "textDocument/completion", params: {
         textDocument: { uri: uri },
         position: { line: 11, character: 3 },
       })
 
       result = server.pop_response.response
-      assert_equal(["abc0"], result.map(&:label))
+      assert_equal(["abc0", "alias", "and"], result.map(&:label))
 
       server.process_message(id: 1, method: "textDocument/completion", params: {
         textDocument: { uri: uri },
         position: { line: 15, character: 1 },
       })
 
       result = server.pop_response.response
-      assert_equal(["abc"], result.map(&:label))
+      assert_equal(["abc", "alias", "and"], result.map(&:label))
     end
   end
 

vscode/snippets.json

@@ -62,11 +62,6 @@
     "body": ["module $1", "  def $2", "    $0", "  end", "end", ""],
     "description": "New Ruby module."
   },
-  "Begin block": {
-    "prefix": ["begin"],
-    "body": ["begin", "  $0", "end", ""],
-    "description": "New Ruby begin block."
-  },
   "Begin rescue block": {
     "prefix": ["begin"],
     "body": ["begin", "  $0", "rescue $1", "end", ""],
@@ -77,21 +72,6 @@
     "body": ["begin", "  $0", "rescue $1", "ensure", "end", ""],
     "description": "New Ruby begin block with rescue and ensure."
   },
-  "While": {
-    "prefix": ["while"],
-    "body": ["while $1", "  $0", "end", ""],
-    "description": "New Ruby while loop."
-  },
-  "Until": {
-    "prefix": ["until"],
-    "body": ["until $1", "  $0", "end", ""],
-    "description": "New Ruby until loop."
-  },
-  "For": {
-    "prefix": ["for"],
-    "body": ["for $1 in $2", "  $0", "end", ""],
-    "description": "New Ruby for loop."
-  },
   "Each inline": {
     "prefix": ["each"],
     "body": ["each { |$1| $0 }"],
@@ -142,11 +122,6 @@
     "body": ["find do |$1|", "  $0", "end"],
     "description": "New Ruby find loop."
   },
-  "Define method": {
-    "prefix": ["def"],
-    "body": ["def $1", "  $0", "end"],
-    "description": "New method."
-  },
   "Define singleton method": {
     "prefix": ["def"],
     "body": ["def self.$1", "  $0", "end"],
@@ -167,11 +142,6 @@
     "body": ["attr_writer :$1"],
     "description": "New attribute writer."
   },
-  "If": {
-    "prefix": ["if"],
-    "body": ["if $1", "  $0", "end"],
-    "description": "New if statement."
-  },
   "If else": {
     "prefix": ["if"],
     "body": ["if $1", "  $0", "else", "end"],
@@ -181,24 +151,5 @@
     "prefix": ["if"],
     "body": ["if $1", "  $0", "elsif $2", "  $0", "end"],
     "description": "New if statement with elsif."
-  },
-  "Unless": {
-    "prefix": ["unless"],
-    "body": ["unless $1", "  $0", "end"],
-    "description": "New unless statement."
-  },
-  "Case": {
-    "prefix": ["case"],
-    "body": [
-      "case $0",
-      "when  $1",
-      "  $2",
-      "when  $3",
-      "  $4",
-      "else",
-      "  $5",
-      "end"
-    ],
-    "description": "New case statement."
   }
 }