format with elixir 1.15

Author: lukaszsamson

apps/elixir_ls_debugger/test/variables_test.exs

@@ -37,7 +37,7 @@ defmodule ElixirLS.Debugger.VariablesTest do
 
     assert Variables.type([]) == "list"
     assert Variables.type([1]) == "list"
-    assert Variables.type('asd') == "list"
+    assert Variables.type(~c"asd") == "list"
 
     assert Variables.type(abc: 123) == "keyword"
 
@@ -90,7 +90,7 @@ defmodule ElixirLS.Debugger.VariablesTest do
 
     assert Variables.num_children([]) == 0
     assert Variables.num_children([1]) == 1
-    assert Variables.num_children('asd') == 3
+    assert Variables.num_children(~c"asd") == 3
 
     assert Variables.num_children(abc: 123) == 1
 
@@ -108,7 +108,7 @@ defmodule ElixirLS.Debugger.VariablesTest do
       assert Variables.children([1], 0, 10) == [{"0", 1}]
       assert Variables.children([1, 2, 3, 4], 0, 2) == [{"0", 1}, {"1", 2}]
       assert Variables.children([1, 2, 3, 4], 1, 2) == [{"1", 2}, {"2", 3}]
-      assert Variables.children('asd', 0, 10) == [{"0", 97}, {"1", 115}, {"2", 100}]
+      assert Variables.children(~c"asd", 0, 10) == [{"0", 97}, {"1", 115}, {"2", 100}]
     end
 
     test "keyword" do
@@ -195,10 +195,10 @@ defmodule ElixirLS.Debugger.VariablesTest do
 
       case :os.type() do
         {:win32, _} ->
-          assert children[:name] == '2/2'
+          assert children[:name] == ~c"2/2"
 
         _ ->
-          assert children[:name] == 'forker'
+          assert children[:name] == ~c"forker"
       end
     end
   end

apps/elixir_ls_utils/test/output_device_test.exs

@@ -161,7 +161,7 @@ defmodule ElixirLS.Utils.OutputDeviceTest do
     end
   end
 
-  def get_chars_list("abc"), do: 'some'
+  def get_chars_list("abc"), do: ~c"some"
   def get_chars_binary("abc"), do: "some"
   def get_chars_invalid("abc"), do: :some
   def get_chars_raise("abc"), do: raise(ArgumentError)
@@ -241,7 +241,7 @@ defmodule ElixirLS.Utils.OutputDeviceTest do
     test "unicode list", %{
       output_device: output_device
     } do
-      request = {:put_chars, :unicode, 'sąme👨‍👩‍👦'}
+      request = {:put_chars, :unicode, ~c"sąme👨‍👩‍👦"}
       send(output_device, {:io_request, self(), 123, request})
       assert_receive({:io_reply, 123, :ok})
 
@@ -261,7 +261,7 @@ defmodule ElixirLS.Utils.OutputDeviceTest do
     test "latin1 list", %{
       output_device: output_device
     } do
-      request = {:put_chars, :latin1, 'some'}
+      request = {:put_chars, :latin1, ~c"some"}
       send(output_device, {:io_request, self(), 123, request})
       assert_receive({:io_reply, 123, :ok})
 
@@ -271,7 +271,7 @@ defmodule ElixirLS.Utils.OutputDeviceTest do
     test "latin1 list with chars > 255", %{
       output_device: output_device
     } do
-      request = {:put_chars, :latin1, 'sąme👨‍👩‍👦'}
+      request = {:put_chars, :latin1, ~c"sąme👨‍👩‍👦"}
       send(output_device, {:io_request, self(), 123, request})
       assert_receive({:io_reply, 123, {:error, :put_chars}})
 

apps/language_server/lib/language_server/cli.ex

@@ -81,14 +81,14 @@ defmodule ElixirLS.LanguageServer.CLI do
       {:ok, _} ->
         :ok
 
-      {:error, {:edoc, {'no such file or directory', 'edoc.app'}}} ->
+      {:error, {:edoc, {~c"no such file or directory", ~c"edoc.app"}}} ->
         message = incomplete_installation_message("#edoc-missing")
 
         JsonRpc.show_message(:error, message)
         Process.sleep(5000)
         raise message
 
-      {:error, {:dialyzer, {'no such file or directory', 'dialyzer.app'}}} ->
+      {:error, {:dialyzer, {~c"no such file or directory", ~c"dialyzer.app"}}} ->
         message = incomplete_installation_message("#dialyzer-missing")
 
         JsonRpc.show_message(:error, message)

apps/language_server/test/providers/code_lens/type_spec/contract_translator_test.exs

@@ -3,26 +3,26 @@ defmodule ElixirLS.LanguageServer.Providers.CodeLens.TypeSpec.ContractTranslator
   alias ElixirLS.LanguageServer.Providers.CodeLens.TypeSpec.ContractTranslator
 
   test "translate struct when struct.t type exists" do
-    contract = '() -> \#{\'__struct__\':=\'Elixir.DateTime\'}'
+    contract = ~c"() -> \#{'__struct__':='Elixir.DateTime'}"
 
     assert "foo :: DateTime.t()" ==
              ContractTranslator.translate_contract(:foo, contract, false, Atom)
   end
 
   test "don't translate struct when struct.t type does not exist" do
-    contract = '() -> \#{\'__struct__\':=\'Elixir.SomeOtherStruct\'}'
+    contract = ~c"() -> \#{'__struct__':='Elixir.SomeOtherStruct'}"
 
     assert "foo :: %SomeOtherStruct{}" ==
              ContractTranslator.translate_contract(:foo, contract, false, Atom)
   end
 
   test "struct" do
-    contract = '() -> \#{\'__struct__\':=atom(), atom()=>any()}'
+    contract = ~c"() -> \#{'__struct__':=atom(), atom()=>any()}"
     assert "foo :: struct" == ContractTranslator.translate_contract(:foo, contract, false, Atom)
   end
 
   test "drop macro env argument" do
-    contract = '(any(), integer()) -> integer()'
+    contract = ~c"(any(), integer()) -> integer()"
 
     assert "foo(any, integer) :: integer" ==
              ContractTranslator.translate_contract(:foo, contract, false, Atom)
@@ -32,119 +32,119 @@ defmodule ElixirLS.LanguageServer.Providers.CodeLens.TypeSpec.ContractTranslator
   end
 
   test "atom :ok" do
-    contract = '(any()) -> ok'
+    contract = ~c"(any()) -> ok"
     assert "foo(any) :: :ok" == ContractTranslator.translate_contract(:foo, contract, false, Atom)
   end
 
   test "atom true" do
-    contract = '(any()) -> true'
+    contract = ~c"(any()) -> true"
 
     assert "foo(any) :: true" ==
              ContractTranslator.translate_contract(:foo, contract, false, Atom)
   end
 
   test "atom _ substitution" do
-    contract = '(_) -> false'
+    contract = ~c"(_) -> false"
 
     assert "foo(any) :: false" ==
              ContractTranslator.translate_contract(:foo, contract, false, Atom)
   end
 
   test "do not drop when substitutions" do
-    contract = '(X) -> atom() when X :: any()'
+    contract = ~c"(X) -> atom() when X :: any()"
 
     assert "foo(x) :: atom when x: any" ==
              ContractTranslator.translate_contract(:foo, contract, false, Atom)
   end
 
   test "keyword" do
-    contract = '(any()) -> list({atom(), any()})'
+    contract = ~c"(any()) -> list({atom(), any()})"
 
     assert "foo(any) :: keyword" ==
              ContractTranslator.translate_contract(:foo, contract, false, Atom)
 
-    contract = '(any()) -> list({atom(), _})'
+    contract = ~c"(any()) -> list({atom(), _})"
 
     assert "foo(any) :: keyword" ==
              ContractTranslator.translate_contract(:foo, contract, false, Atom)
   end
 
   test "keyword(t)" do
-    contract = '(any()) -> list({atom(), integer()})'
+    contract = ~c"(any()) -> list({atom(), integer()})"
 
     assert "foo(any) :: keyword(integer)" ==
              ContractTranslator.translate_contract(:foo, contract, false, Atom)
   end
 
   test "[type]" do
-    contract = '(any()) -> list(atom())'
+    contract = ~c"(any()) -> list(atom())"
 
     assert "foo(any) :: [atom]" ==
              ContractTranslator.translate_contract(:foo, contract, false, Atom)
   end
 
   test "list" do
-    contract = '(any()) -> list(any())'
+    contract = ~c"(any()) -> list(any())"
 
     assert "foo(any) :: list" ==
              ContractTranslator.translate_contract(:foo, contract, false, Atom)
   end
 
   test "empty list" do
-    contract = '(any()) -> []'
+    contract = ~c"(any()) -> []"
     assert "foo(any) :: []" == ContractTranslator.translate_contract(:foo, contract, false, Atom)
   end
 
   test "[...]" do
-    contract = '(any()) -> nonempty_list(any())'
+    contract = ~c"(any()) -> nonempty_list(any())"
 
     assert "foo(any) :: [...]" ==
              ContractTranslator.translate_contract(:foo, contract, false, Atom)
 
-    contract = '(any()) -> nonempty_list(_)'
+    contract = ~c"(any()) -> nonempty_list(_)"
 
     assert "foo(any) :: [...]" ==
              ContractTranslator.translate_contract(:foo, contract, false, Atom)
   end
 
   test "[type, ...]" do
-    contract = '(any()) -> nonempty_list(atom())'
+    contract = ~c"(any()) -> nonempty_list(atom())"
 
     assert "foo(any) :: [atom, ...]" ==
              ContractTranslator.translate_contract(:foo, contract, false, Atom)
   end
 
   test "undoes conversion of :_ to any inside bitstring" do
-    contract = '(any()) -> <<_:2, _:_*3>>'
+    contract = ~c"(any()) -> <<_:2, _:_*3>>"
 
     assert "foo(any) :: <<_::2, _::_*3>>" ==
              ContractTranslator.translate_contract(:foo, contract, false, Atom)
   end
 
   test "function" do
-    contract = '(any()) -> fun((...) -> ok)'
+    contract = ~c"(any()) -> fun((...) -> ok)"
 
     assert "foo(any) :: (... -> :ok)" ==
              ContractTranslator.translate_contract(:foo, contract, false, Atom)
   end
 
   test "fun" do
-    contract = '(any()) -> fun((...) -> any())'
+    contract = ~c"(any()) -> fun((...) -> any())"
     assert "foo(any) :: fun" == ContractTranslator.translate_contract(:foo, contract, false, Atom)
   end
 
   test "empty map" do
-    contract = '(any()) -> \#{}'
+    contract = ~c"(any()) -> \#{}"
     assert "foo(any) :: %{}" == ContractTranslator.translate_contract(:foo, contract, false, Atom)
   end
 
   test "map" do
-    contract = '(any()) -> \#{any()=>any()}'
+    contract = ~c"(any()) -> \#{any()=>any()}"
     assert "foo(any) :: map" == ContractTranslator.translate_contract(:foo, contract, false, Atom)
   end
 
   test "map with fields" do
-    contract = '(any()) -> \#{integer()=>any(), 1:=atom(), abc:=4}'
+    contract = ~c"(any()) -> \#{integer()=>any(), 1:=atom(), abc:=4}"
 
     expected =
       if Version.match?(System.version(), "< 1.13.0") do
@@ -158,32 +158,32 @@ defmodule ElixirLS.LanguageServer.Providers.CodeLens.TypeSpec.ContractTranslator
   end
 
   test "defprotocol type t" do
-    contract = '(any()) -> any()'
+    contract = ~c"(any()) -> any()"
 
     assert "foo(t) :: any" ==
              ContractTranslator.translate_contract(:foo, contract, false, Enumerable)
 
-    contract = '(any(), any()) -> any()'
+    contract = ~c"(any(), any()) -> any()"
 
     assert "foo(t, any) :: any" ==
              ContractTranslator.translate_contract(:foo, contract, false, Enumerable)
 
-    contract = '(any()) -> any()'
+    contract = ~c"(any()) -> any()"
     assert "foo(any) :: any" == ContractTranslator.translate_contract(:foo, contract, false, Atom)
 
-    contract = '(any(), any()) -> any()'
+    contract = ~c"(any(), any()) -> any()"
 
     assert "foo(any, any) :: any" ==
              ContractTranslator.translate_contract(:foo, contract, false, Atom)
   end
 
   test "defimpl first arg" do
-    contract = '(any()) -> any()'
+    contract = ~c"(any()) -> any()"
 
     assert "count(list) :: any" ==
              ContractTranslator.translate_contract(:count, contract, false, Enumerable.List)
 
-    contract = '(any()) -> any()'
+    contract = ~c"(any()) -> any()"
 
     assert "count(Date.Range.t()) :: any" ==
              ContractTranslator.translate_contract(:count, contract, false, Enumerable.Date.Range)