Implement it on IEx autocomplete

Author: josevalim

Diff for: lib/elixir/lib/code/fragment.ex

@@ -46,11 +46,9 @@ defmodule Code.Fragment do
       or `{:local_or_var, charlist}` and `charlist` is a static part
       Examples are `__MODULE__.Submodule` or `@hello.Submodule`
 
-    * `:block_keyword_or_binary_operator` - may be a block keyword (do, end, after,
+    * `{:block_keyword_or_binary_operator, charlist}` - may be a block keyword (do, end, after,
       catch, else, rescue) or a binary operator
 
-    * `{:block_keyword, charlist}` - the context is a block keyword
-
     * `{:dot, inside_dot, charlist}` - the context is a dot
       where `inside_dot` is either a `{:var, charlist}`, `{:alias, charlist}`,
       `{:module_attribute, charlist}`, `{:unquoted_atom, charlist}` or a `dot`
@@ -144,8 +142,7 @@ defmodule Code.Fragment do
   @spec cursor_context(List.Chars.t(), keyword()) ::
           {:alias, charlist}
           | {:alias, inside_alias, charlist}
-          | :block_keyword_or_binary_operator
-          | {:block_keyword, charlist}
+          | {:block_keyword_or_binary_operator, charlist}
           | {:dot, inside_dot, charlist}
           | {:dot_arity, inside_dot, charlist}
           | {:dot_call, inside_dot, charlist}
@@ -278,7 +275,7 @@ defmodule Code.Fragment do
 
   defp closing_or_call_to_cursor_context({reverse, spaces}) do
     if closing?(reverse) do
-      {:block_keyword_or_binary_operator, 0}
+      {{:block_keyword_or_binary_operator, ~c""}, 0}
     else
       call_to_cursor_context({reverse, spaces})
     end
@@ -337,7 +334,9 @@ defmodule Code.Fragment do
 
           {rest, rest_count} ->
             response =
-              if rest_count > count and closing?(rest), do: :block_keyword, else: :local_or_var
+              if rest_count > count and closing?(rest),
+                do: :block_keyword_or_binary_operator,
+                else: :local_or_var
 
             {{response, acc}, count}
         end

Diff for: lib/elixir/test/elixir/code_fragment_test.exs

@@ -373,21 +373,21 @@ defmodule CodeFragmentTest do
 
     test "keyword or binary operator" do
       # Literals
-      assert CF.cursor_context("Foo.Bar ") == :block_keyword_or_binary_operator
-      assert CF.cursor_context("Foo ") == :block_keyword_or_binary_operator
-      assert CF.cursor_context(":foo ") == :block_keyword_or_binary_operator
-      assert CF.cursor_context("123 ") == :block_keyword_or_binary_operator
-      assert CF.cursor_context("nil ") == :block_keyword_or_binary_operator
-      assert CF.cursor_context("true ") == :block_keyword_or_binary_operator
-      assert CF.cursor_context("false ") == :block_keyword_or_binary_operator
-      assert CF.cursor_context("\"foo\" ") == :block_keyword_or_binary_operator
-      assert CF.cursor_context("'foo' ") == :block_keyword_or_binary_operator
+      assert CF.cursor_context("Foo.Bar ") == {:block_keyword_or_binary_operator, ~c""}
+      assert CF.cursor_context("Foo ") == {:block_keyword_or_binary_operator, ~c""}
+      assert CF.cursor_context(":foo ") == {:block_keyword_or_binary_operator, ~c""}
+      assert CF.cursor_context("123 ") == {:block_keyword_or_binary_operator, ~c""}
+      assert CF.cursor_context("nil ") == {:block_keyword_or_binary_operator, ~c""}
+      assert CF.cursor_context("true ") == {:block_keyword_or_binary_operator, ~c""}
+      assert CF.cursor_context("false ") == {:block_keyword_or_binary_operator, ~c""}
+      assert CF.cursor_context("\"foo\" ") == {:block_keyword_or_binary_operator, ~c""}
+      assert CF.cursor_context("'foo' ") == {:block_keyword_or_binary_operator, ~c""}
 
       # Containers
-      assert CF.cursor_context("(foo) ") == :block_keyword_or_binary_operator
-      assert CF.cursor_context("[foo] ") == :block_keyword_or_binary_operator
-      assert CF.cursor_context("{foo} ") == :block_keyword_or_binary_operator
-      assert CF.cursor_context("<<foo>> ") == :block_keyword_or_binary_operator
+      assert CF.cursor_context("(foo) ") == {:block_keyword_or_binary_operator, ~c""}
+      assert CF.cursor_context("[foo] ") == {:block_keyword_or_binary_operator, ~c""}
+      assert CF.cursor_context("{foo} ") == {:block_keyword_or_binary_operator, ~c""}
+      assert CF.cursor_context("<<foo>> ") == {:block_keyword_or_binary_operator, ~c""}
 
       # False positives
       assert CF.cursor_context("foo ~>> ") == {:operator_call, ~c"~>>"}
@@ -396,21 +396,22 @@ defmodule CodeFragmentTest do
 
     test "keyword from keyword or binary operator" do
       # Literals
-      assert CF.cursor_context("Foo.Bar d") == {:block_keyword, ~c"d"}
-      assert CF.cursor_context("Foo d") == {:block_keyword, ~c"d"}
-      assert CF.cursor_context(":foo d") == {:block_keyword, ~c"d"}
-      assert CF.cursor_context("123 d") == {:block_keyword, ~c"d"}
-      assert CF.cursor_context("nil d") == {:block_keyword, ~c"d"}
-      assert CF.cursor_context("true d") == {:block_keyword, ~c"d"}
-      assert CF.cursor_context("false d") == {:block_keyword, ~c"d"}
-      assert CF.cursor_context("\"foo\" d") == {:block_keyword, ~c"d"}
-      assert CF.cursor_context("'foo' d") == {:block_keyword, ~c"d"}
+      assert CF.cursor_context("Foo.Bar do") == {:block_keyword_or_binary_operator, ~c"do"}
+      assert CF.cursor_context("Foo.Bar d") == {:block_keyword_or_binary_operator, ~c"d"}
+      assert CF.cursor_context("Foo d") == {:block_keyword_or_binary_operator, ~c"d"}
+      assert CF.cursor_context(":foo d") == {:block_keyword_or_binary_operator, ~c"d"}
+      assert CF.cursor_context("123 d") == {:block_keyword_or_binary_operator, ~c"d"}
+      assert CF.cursor_context("nil d") == {:block_keyword_or_binary_operator, ~c"d"}
+      assert CF.cursor_context("true d") == {:block_keyword_or_binary_operator, ~c"d"}
+      assert CF.cursor_context("false d") == {:block_keyword_or_binary_operator, ~c"d"}
+      assert CF.cursor_context("\"foo\" d") == {:block_keyword_or_binary_operator, ~c"d"}
+      assert CF.cursor_context("'foo' d") == {:block_keyword_or_binary_operator, ~c"d"}
 
       # Containers
-      assert CF.cursor_context("(foo) d") == {:block_keyword, ~c"d"}
-      assert CF.cursor_context("[foo] d") == {:block_keyword, ~c"d"}
-      assert CF.cursor_context("{foo} d") == {:block_keyword, ~c"d"}
-      assert CF.cursor_context("<<foo>> d") == {:block_keyword, ~c"d"}
+      assert CF.cursor_context("(foo) d") == {:block_keyword_or_binary_operator, ~c"d"}
+      assert CF.cursor_context("[foo] d") == {:block_keyword_or_binary_operator, ~c"d"}
+      assert CF.cursor_context("{foo} d") == {:block_keyword_or_binary_operator, ~c"d"}
+      assert CF.cursor_context("<<foo>> d") == {:block_keyword_or_binary_operator, ~c"d"}
 
       # False positives
       assert CF.cursor_context("foo ~>> d") == {:local_or_var, ~c"d"}

Diff for: lib/iex/lib/iex/autocomplete.ex

@@ -22,6 +22,23 @@ defmodule IEx.Autocomplete do
     %{kind: :variable, name: "utf32"}
   ]
 
+  block_keywords =
+    for block_keyword <- ~w(do end after catch else rescue) do
+      %{kind: :block_keyword, name: block_keyword}
+    end
+
+  binary_operators =
+    for operator <-
+          ["**", "*", "/", "+", "-", "++", "--", "+++", "---", "..", "<>"] ++
+            ["in", "not in", "|>", "<<<", ">>>", "<<~", "~>>", "<~", "~>", "<~>"] ++
+            ["<", ">", "<=", ">=", "==", "!=", "=~", "===", "!=="] ++
+            ["&&", "&&&", "and", "||", "|||", "or"] ++
+            ["=", "=>", "|", "::", "when", "<-", "\\\\"] do
+      %{kind: :export, name: operator, arity: 2}
+    end
+
+  @block_keyword_or_binary_operator block_keywords ++ Enum.sort(binary_operators)
+
   @alias_only_atoms ~w(alias import require)a
   @alias_only_charlists ~w(alias import require)c
 
@@ -63,6 +80,9 @@ defmodule IEx.Autocomplete do
       {:unquoted_atom, unquoted_atom} ->
         expand_erlang_modules(List.to_string(unquoted_atom))
 
+      {:block_keyword_or_binary_operator, hint} ->
+        filter_and_format_expansion(@block_keyword_or_binary_operator, List.to_string(hint))
+
       expansion when helper == ?b ->
         expand_typespecs(expansion, shell, &get_module_callbacks/1)
 
@@ -519,6 +539,12 @@ defmodule IEx.Autocomplete do
 
   ## Formatting
 
+  defp filter_and_format_expansion(results, hint) do
+    results
+    |> Enum.filter(&String.starts_with?(&1.name, hint))
+    |> format_expansion(hint)
+  end
+
   defp format_expansion([], _) do
     no()
   end

Diff for: lib/iex/test/iex/autocomplete_test.exs

@@ -184,6 +184,21 @@ defmodule IEx.AutocompleteTest do
     assert expand(~c"IEx.Xyz") == {:no, ~c"", []}
   end
 
+  test "block keywords" do
+    assert expand(~c"if true do") == {:yes, ~c"", [~c"do"]}
+    assert expand(~c"if true a") == {:yes, ~c"", [~c"after", ~c"and/2"]}
+    assert expand(~c"if true d") == {:yes, ~c"o", []}
+    assert expand(~c"if true e") == {:yes, ~c"", [~c"end", ~c"else"]}
+  end
+
+  test "block keywords or operators" do
+    {:yes, ~c"", hints} = expand(~c"if true ")
+    assert ~c"do" in hints
+    assert ~c"else" in hints
+    assert ~c"+/2" in hints
+    assert ~c"and/2" in hints
+  end
+
   test "function completion" do
     assert expand(~c"System.ve") == {:yes, ~c"rsion", []}
     assert expand(~c":ets.fun2") == {:yes, ~c"ms", []}