diff --git a/apps/elixir_ls_utils/test/complete_test.exs b/apps/elixir_ls_utils/test/complete_test.exs index dbadb187b..6ae9d419e 100644 --- a/apps/elixir_ls_utils/test/complete_test.exs +++ b/apps/elixir_ls_utils/test/complete_test.exs @@ -269,7 +269,7 @@ defmodule ElixirLS.Utils.CompletionEngineTest do ] = expand(~c"String.Cha") end - @tag requires_elixir_1_14: true + if Version.match?(System.version(), ">= 1.14.0") do test "elixir submodule completion with __MODULE__" do assert [ %{ @@ -281,8 +281,9 @@ defmodule ElixirLS.Utils.CompletionEngineTest do } ] = expand(~c"__MODULE__.Cha", %Env{module: String}) end +end - @tag requires_elixir_1_14: true +if Version.match?(System.version(), ">= 1.14.0") do test "elixir submodule completion with attribute bound to module" do assert [ %{ @@ -302,6 +303,7 @@ defmodule ElixirLS.Utils.CompletionEngineTest do ] }) end +end test "find elixir modules that require alias" do assert [ @@ -361,19 +363,21 @@ defmodule ElixirLS.Utils.CompletionEngineTest do assert [%{name: "fun2ms", origin: ":ets"}] = expand(~c":ets.fun2") end - @tag requires_elixir_1_14: true + if Version.match?(System.version(), ">= 1.14.0") do test "function completion on __MODULE__" do assert [%{name: "version", origin: "System"}] = expand(~c"__MODULE__.ve", %Env{module: System}) end +end - @tag requires_elixir_1_14: true +if Version.match?(System.version(), ">= 1.14.0") do test "function completion on __MODULE__ submodules" do assert [%{name: "to_string", origin: "String.Chars"}] = expand(~c"__MODULE__.Chars.to", %Env{module: String}) end +end - @tag requires_elixir_1_14: true +if Version.match?(System.version(), ">= 1.14.0") do test "function completion on attribute bound to module" do assert [%{name: "version", origin: "System"}] = expand(~c"@my_attr.ve", %Env{ @@ -385,6 +389,7 @@ defmodule ElixirLS.Utils.CompletionEngineTest do ] }) end +end test "function completion with arity" do assert [ @@ -440,7 +445,6 @@ defmodule ElixirLS.Utils.CompletionEngineTest do ] = expand(~c"Enum.count/") end - @tag requires_elixir_1_13: true test "operator completion" do assert [%{name: "+", arity: 1}, %{name: "+", arity: 2}, %{name: "++", arity: 2}] = expand(~c"+") @@ -452,7 +456,6 @@ defmodule ElixirLS.Utils.CompletionEngineTest do assert entries |> Enum.any?(&(&1.name == "div")) end - @tag requires_elixir_1_13: true test "sigil completion" do sigils = expand(~c"~") assert sigils |> Enum.any?(fn s -> s.name == "~C" end) @@ -1562,13 +1565,14 @@ defmodule ElixirLS.Utils.CompletionEngineTest do assert Enum.any?(entries, &(&1.name == "MyDate" and &1.subtype == :struct)) end - @tag requires_elixir_1_14: true + if Version.match?(System.version(), ">= 1.14.0") do test "completion for struct names with __MODULE__" do assert [%{name: "__MODULE__"}] = expand(~c"%__MODU", %Env{module: Date.Range}) assert [%{name: "Range"}] = expand(~c"%__MODULE__.Ra", %Env{module: Date}) end +end - @tag requires_elixir_1_14: true + if Version.match?(System.version(), ">= 1.14.0") do test "completion for struct attributes" do assert [%{name: "@my_attr"}] = expand(~c"%@my", %Env{ @@ -1592,6 +1596,7 @@ defmodule ElixirLS.Utils.CompletionEngineTest do scope: MyMod }) end +end # handled elsewhere # TODO consider moving struct key completion here after elixir 1.13+ is required @@ -1966,7 +1971,7 @@ defmodule ElixirLS.Utils.CompletionEngineTest do ] = expand(~c"ArgumentError.bla") end - @tag requires_otp_23: true + if System.otp_release() |> String.to_integer() >= 23 do test "complete build in :erlang functions" do assert [ %{arity: 2, name: "open_port", origin: ":erlang"}, @@ -2013,6 +2018,7 @@ defmodule ElixirLS.Utils.CompletionEngineTest do %{arity: 2, name: "append_element", origin: ":erlang"} ] = expand(~c":erlang.and") end +end test "provide doc and specs for erlang functions" do assert [ @@ -2197,7 +2203,7 @@ defmodule ElixirLS.Utils.CompletionEngineTest do ] = expand(~c"unquote", %Env{requires: []}) end - @tag requires_elixir_1_14: true + if Version.match?(System.version(), ">= 1.14.0") do test "Application.compile_env classified as macro" do assert [ %{ @@ -2238,3 +2244,4 @@ defmodule ElixirLS.Utils.CompletionEngineTest do ] = expand(~c"Application.compile_e") end end +end diff --git a/apps/language_server/test/providers/completion/suggestions_test.exs b/apps/language_server/test/providers/completion/suggestions_test.exs index 077eb1daa..bc3918d0e 100644 --- a/apps/language_server/test/providers/completion/suggestions_test.exs +++ b/apps/language_server/test/providers/completion/suggestions_test.exs @@ -1457,32 +1457,33 @@ defmodule ElixirLS.LanguageServer.Providers.Completion.SuggestionTest do end end - @tag requires_otp_25: true - test "suggest erlang behaviour callbacks on erlang implementation" do - buffer = """ - :file_server.ini - """ + if System.otp_release() |> String.to_integer() >= 25 do + test "suggest erlang behaviour callbacks on erlang implementation" do + buffer = """ + :file_server.ini + """ - list = - Suggestion.suggestions(buffer, 1, 17) - |> Enum.filter(fn s -> s.type == :function end) + list = + Suggestion.suggestions(buffer, 1, 17) + |> Enum.filter(fn s -> s.type == :function end) - assert [ - %{ - args: "args", - args_list: ["args"], - arity: 1, - def_arity: 1, - metadata: %{implementing: :gen_server}, - name: "init", - origin: ":file_server", - snippet: nil, - spec: "@callback init(args :: term()) ::" <> _, - summary: "- Args = term" <> _, - type: :function, - visibility: :public - } - ] = list + assert [ + %{ + args: "args", + args_list: ["args"], + arity: 1, + def_arity: 1, + metadata: %{implementing: :gen_server}, + name: "init", + origin: ":file_server", + snippet: nil, + spec: "@callback init(args :: term()) ::" <> _, + summary: "- Args = term" <> _, + type: :function, + visibility: :public + } + ] = list + end end test "lists params and vars" do @@ -4443,7 +4444,6 @@ defmodule ElixirLS.LanguageServer.Providers.Completion.SuggestionTest do Suggestion.suggestions(buffer, 3, 8) |> Enum.filter(&("#{&1.name}" =~ "+")) end - @tag requires_elixir_1_13: true test "sigil" do buffer = """ defmodule ElixirSenseExample.OtherModule do diff --git a/apps/language_server/test/providers/definition/locator_test.exs b/apps/language_server/test/providers/definition/locator_test.exs index 721985a33..9ee91a87d 100644 --- a/apps/language_server/test/providers/definition/locator_test.exs +++ b/apps/language_server/test/providers/definition/locator_test.exs @@ -12,25 +12,26 @@ defmodule ElixirLS.LanguageServer.Providers.Definition.LocatorTest do assert nil == Locator.definition("__MODULE__", 1, 1) end - @tag requires_elixir_1_14: true - test "find module definition inside Phoenix's scope" do - _define_existing_atom = ExampleWeb + if Version.match?(System.version(), ">= 1.14.0") do + test "find module definition inside Phoenix's scope" do + _define_existing_atom = ExampleWeb - buffer = """ - defmodule ExampleWeb.Router do - import Phoenix.Router + buffer = """ + defmodule ExampleWeb.Router do + import Phoenix.Router - scope "/", ExampleWeb do - get "/", PageController, :home + scope "/", ExampleWeb do + get "/", PageController, :home + end end - end - """ + """ - %Location{type: :module, file: file, line: line, column: column} = - Locator.definition(buffer, 5, 15) + %Location{type: :module, file: file, line: line, column: column} = + Locator.definition(buffer, 5, 15) - assert file =~ "language_server/test/support/plugins/phoenix/page_controller.ex" - assert read_line(file, {line, column}) =~ "ExampleWeb.PageController" + assert file =~ "language_server/test/support/plugins/phoenix/page_controller.ex" + assert read_line(file, {line, column}) =~ "ExampleWeb.PageController" + end end test "find definition of aliased modules in `use`" do @@ -1125,71 +1126,74 @@ defmodule ElixirLS.LanguageServer.Providers.Definition.LocatorTest do } end - @tag requires_elixir_1_14: true - test "find definition of local functions with __MODULE__ submodule" do - buffer = """ - defmodule MyModule do - defmodule Sub do - def my_fun(), do: :ok - end + if Version.match?(System.version(), ">= 1.14.0") do + test "find definition of local functions with __MODULE__ submodule" do + buffer = """ + defmodule MyModule do + defmodule Sub do + def my_fun(), do: :ok + end - def a do - my_fun1 = 1 - __MODULE__.Sub.my_fun() + def a do + my_fun1 = 1 + __MODULE__.Sub.my_fun() + end end - end - """ + """ - assert Locator.definition(buffer, 8, 22) == %Location{ - type: :function, - file: nil, - line: 3, - column: 5 - } + assert Locator.definition(buffer, 8, 22) == %Location{ + type: :function, + file: nil, + line: 3, + column: 5 + } + end end - @tag requires_elixir_1_14: true - test "find definition of local __MODULE__ submodule" do - buffer = """ - defmodule MyModule do - defmodule Sub do - def my_fun(), do: :ok - end + if Version.match?(System.version(), ">= 1.14.0") do + test "find definition of local __MODULE__ submodule" do + buffer = """ + defmodule MyModule do + defmodule Sub do + def my_fun(), do: :ok + end - def a do - my_fun1 = 1 - __MODULE__.Sub.my_fun() + def a do + my_fun1 = 1 + __MODULE__.Sub.my_fun() + end end - end - """ + """ - assert Locator.definition(buffer, 8, 17) == %Location{ - type: :module, - file: nil, - line: 2, - column: 3 - } + assert Locator.definition(buffer, 8, 17) == %Location{ + type: :module, + file: nil, + line: 2, + column: 3 + } + end end - @tag requires_elixir_1_14: true - test "find definition of local functions with @attr" do - buffer = """ - defmodule MyModule do - def my_fun(), do: :ok - @attr MyModule - def a do - my_fun1 = 1 - @attr.my_fun() + if Version.match?(System.version(), ">= 1.14.0") do + test "find definition of local functions with @attr" do + buffer = """ + defmodule MyModule do + def my_fun(), do: :ok + @attr MyModule + def a do + my_fun1 = 1 + @attr.my_fun() + end end - end - """ + """ - assert Locator.definition(buffer, 6, 13) == %Location{ - type: :function, - file: nil, - line: 2, - column: 3 - } + assert Locator.definition(buffer, 6, 13) == %Location{ + type: :function, + file: nil, + line: 2, + column: 3 + } + end end test "find definition of local functions with current module" do diff --git a/apps/language_server/test/providers/hover/docs_test.exs b/apps/language_server/test/providers/hover/docs_test.exs index aff8eeffc..d61b73cc3 100644 --- a/apps/language_server/test/providers/hover/docs_test.exs +++ b/apps/language_server/test/providers/hover/docs_test.exs @@ -111,31 +111,32 @@ defmodule ElixirLS.LanguageServer.Providers.Hover.DocsTest do } end - @tag requires_elixir_1_14: true - test "retrieve documentation from metadata modules on __MODULE__ submodule" do - buffer = """ - defmodule MyLocalModule do - defmodule Sub do - @moduledoc "Some example doc" - @moduledoc since: "1.2.3" - end + if Version.match?(System.version(), ">= 1.14.0") do + test "retrieve documentation from metadata modules on __MODULE__ submodule" do + buffer = """ + defmodule MyLocalModule do + defmodule Sub do + @moduledoc "Some example doc" + @moduledoc since: "1.2.3" + end - def self() do - __MODULE__.Sub + def self() do + __MODULE__.Sub + end end - end - """ + """ - %{ - docs: [doc] - } = Docs.docs(buffer, 8, 17) + %{ + docs: [doc] + } = Docs.docs(buffer, 8, 17) - assert doc == %{ - module: MyLocalModule.Sub, - metadata: %{since: "1.2.3"}, - docs: "Some example doc", - kind: :module - } + assert doc == %{ + module: MyLocalModule.Sub, + metadata: %{since: "1.2.3"}, + docs: "Some example doc", + kind: :module + } + end end test "retrieve documentation from metadata modules with @moduledoc false" do @@ -796,39 +797,40 @@ defmodule ElixirLS.LanguageServer.Providers.Hover.DocsTest do } end - @tag requires_elixir_1_14: true - test "retrieve local private metadata function documentation on __MODULE__ submodule call" do - buffer = """ - defmodule MyLocalModule do - defmodule Sub do - @doc "Sample doc" - @doc since: "1.2.3" - @spec flatten(list()) :: list() - def flatten(list) do - [] + if Version.match?(System.version(), ">= 1.14.0") do + test "retrieve local private metadata function documentation on __MODULE__ submodule call" do + buffer = """ + defmodule MyLocalModule do + defmodule Sub do + @doc "Sample doc" + @doc since: "1.2.3" + @spec flatten(list()) :: list() + def flatten(list) do + [] + end end - end - def func(list) do - __MODULE__.Sub.flatten(list) + def func(list) do + __MODULE__.Sub.flatten(list) + end end - end - """ + """ - %{ - docs: [doc] - } = Docs.docs(buffer, 12, 20) + %{ + docs: [doc] + } = Docs.docs(buffer, 12, 20) - assert doc == %{ - args: ["list"], - function: :flatten, - arity: 1, - kind: :function, - metadata: %{since: "1.2.3"}, - module: MyLocalModule.Sub, - specs: ["@spec flatten(list()) :: list()"], - docs: "Sample doc" - } + assert doc == %{ + args: ["list"], + function: :flatten, + arity: 1, + kind: :function, + metadata: %{since: "1.2.3"}, + module: MyLocalModule.Sub, + specs: ["@spec flatten(list()) :: list()"], + docs: "Sample doc" + } + end end test "does not retrieve remote private metadata function documentation" do @@ -940,52 +942,53 @@ defmodule ElixirLS.LanguageServer.Providers.Hover.DocsTest do end end - @tag requires_otp_23: true - test "retrieve fallback erlang builtin function documentation" do - buffer = """ - defmodule MyModule do - def func(list) do - :erlang.or(a, b) - :erlang.orelse(a, b) + if System.otp_release() |> String.to_integer() >= 23 do + test "retrieve fallback erlang builtin function documentation" do + buffer = """ + defmodule MyModule do + def func(list) do + :erlang.or(a, b) + :erlang.orelse(a, b) + end + end + """ + + %{ + docs: [doc] + } = Docs.docs(buffer, 3, 14) + + assert %{ + arity: 2, + function: :or, + module: :erlang, + specs: ["@spec boolean() or boolean() :: boolean()"], + docs: "", + kind: :function + } = doc + + if String.to_integer(System.otp_release()) < 25 do + assert doc.args == ["boolean", "boolean"] + assert doc.metadata == %{app: :erts} + else + assert doc.args == ["term", "term"] + assert doc.metadata == %{hidden: true, app: :erts} end - end - """ - %{ - docs: [doc] - } = Docs.docs(buffer, 3, 14) + %{ + docs: [doc] + } = Docs.docs(buffer, 4, 14) - assert %{ - arity: 2, - function: :or, - module: :erlang, - specs: ["@spec boolean() or boolean() :: boolean()"], - docs: "", - kind: :function - } = doc - - if String.to_integer(System.otp_release()) < 25 do - assert doc.args == ["boolean", "boolean"] - assert doc.metadata == %{app: :erts} - else - assert doc.args == ["term", "term"] - assert doc.metadata == %{hidden: true, app: :erts} + assert %{ + args: ["term", "term"], + arity: 2, + function: :orelse, + module: :erlang, + metadata: %{builtin: true, app: :erts}, + specs: [], + docs: "", + kind: :function + } = doc end - - %{ - docs: [doc] - } = Docs.docs(buffer, 4, 14) - - assert %{ - args: ["term", "term"], - arity: 2, - function: :orelse, - module: :erlang, - metadata: %{builtin: true, app: :erts}, - specs: [], - docs: "", - kind: :function - } = doc end test "retrieve macro documentation" do @@ -1014,30 +1017,31 @@ defmodule ElixirLS.LanguageServer.Providers.Hover.DocsTest do } end - @tag requires_elixir_1_14: true - test "retrieve function documentation with __MODULE__ submodule call" do - buffer = """ - defmodule Inspect do - def func(list) do - __MODULE__.Algebra.string(list) + if Version.match?(System.version(), ">= 1.14.0") do + test "retrieve function documentation with __MODULE__ submodule call" do + buffer = """ + defmodule Inspect do + def func(list) do + __MODULE__.Algebra.string(list) + end end - end - """ + """ - %{ - docs: [doc] - } = Docs.docs(buffer, 3, 26) + %{ + docs: [doc] + } = Docs.docs(buffer, 3, 26) - assert %{ - args: ["string"], - function: :string, - module: Inspect.Algebra, - metadata: %{since: "1.6.0"}, - specs: ["@spec string(String.t()) :: doc_string()"], - kind: :function - } = doc + assert %{ + args: ["string"], + function: :string, + module: Inspect.Algebra, + metadata: %{since: "1.6.0"}, + specs: ["@spec string(String.t()) :: doc_string()"], + kind: :function + } = doc - assert doc.docs =~ "Creates a document" + assert doc.docs =~ "Creates a document" + end end test "retrieve function documentation from aliased modules" do @@ -1290,26 +1294,27 @@ defmodule ElixirLS.LanguageServer.Providers.Hover.DocsTest do } end - @tag requires_otp_25: true - test "retrieve erlang behaviour implementation" do - buffer = """ - :file_server.init(a) - """ + if System.otp_release() |> String.to_integer() >= 25 do + test "retrieve erlang behaviour implementation" do + buffer = """ + :file_server.init(a) + """ - %{ - docs: [doc] - } = Docs.docs(buffer, 1, 16) + %{ + docs: [doc] + } = Docs.docs(buffer, 1, 16) - assert %{ - args: ["args"], - function: :init, - module: :file_server, - specs: ["@callback init(args :: term())" <> _], - metadata: %{implementing: :gen_server, implementing_module_app: :stdlib}, - kind: :function - } = doc + assert %{ + args: ["args"], + function: :init, + module: :file_server, + specs: ["@callback init(args :: term())" <> _], + metadata: %{implementing: :gen_server, implementing_module_app: :stdlib}, + kind: :function + } = doc - assert doc.docs =~ "Whenever a `gen_server` process is started" + assert doc.docs =~ "Whenever a `gen_server` process is started" + end end test "do not crash for erlang behaviour callbacks" do diff --git a/apps/language_server/test/providers/references/locator_test.exs b/apps/language_server/test/providers/references/locator_test.exs index de9d6cc52..30bc69449 100644 --- a/apps/language_server/test/providers/references/locator_test.exs +++ b/apps/language_server/test/providers/references/locator_test.exs @@ -1081,76 +1081,79 @@ defmodule ElixirLS.LanguageServer.Providers.References.LocatorTest do ] = references end - @tag requires_elixir_1_14: true - test "find references when module with __MODULE__ special form submodule function", %{ - trace: trace - } do - buffer = """ - defmodule ElixirSense.Providers.ReferencesTest.Modules do - def func() do - __MODULE__.Callee3.func() - # ^ + if Version.match?(System.version(), ">= 1.14.0") do + test "find references when module with __MODULE__ special form submodule function", %{ + trace: trace + } do + buffer = """ + defmodule ElixirSense.Providers.ReferencesTest.Modules do + def func() do + __MODULE__.Callee3.func() + # ^ + end end - end - """ + """ - references = Locator.references(buffer, 3, 25, trace) + references = Locator.references(buffer, 3, 25, trace) - assert references == [ - %{range: %{end: %{column: 28, line: 3}, start: %{column: 24, line: 3}}, uri: nil}, - %{ - uri: "test/support/modules_with_references.ex", - range: %{start: %{line: 65, column: 47}, end: %{line: 65, column: 51}} - }, - %{ - range: %{end: %{column: 13, line: 70}, start: %{column: 9, line: 70}}, - uri: "test/support/modules_with_references.ex" - } - ] + assert references == [ + %{range: %{end: %{column: 28, line: 3}, start: %{column: 24, line: 3}}, uri: nil}, + %{ + uri: "test/support/modules_with_references.ex", + range: %{start: %{line: 65, column: 47}, end: %{line: 65, column: 51}} + }, + %{ + range: %{end: %{column: 13, line: 70}, start: %{column: 9, line: 70}}, + uri: "test/support/modules_with_references.ex" + } + ] + end end - @tag requires_elixir_1_14: true - test "find references when module with __MODULE__ special form submodule", %{trace: trace} do - buffer = """ - defmodule MyLocalModule do - defmodule Some do - def func() do - :ok + if Version.match?(System.version(), ">= 1.14.0") do + test "find references when module with __MODULE__ special form submodule", %{trace: trace} do + buffer = """ + defmodule MyLocalModule do + defmodule Some do + def func() do + :ok + end end + __MODULE__.Some.func() end - __MODULE__.Some.func() - end - """ + """ - references = Locator.references(buffer, 7, 15, trace) + references = Locator.references(buffer, 7, 15, trace) - assert references == [ - %{range: %{start: %{column: 19, line: 7}, end: %{column: 23, line: 7}}, uri: nil} - ] + assert references == [ + %{range: %{start: %{column: 19, line: 7}, end: %{column: 23, line: 7}}, uri: nil} + ] + end end - @tag requires_elixir_1_14: true - test "find references when module with __MODULE__ special form function", %{trace: trace} do - buffer = """ - defmodule ElixirSense.Providers.ReferencesTest.Modules do - def func() do - __MODULE__.func() - # ^ + if Version.match?(System.version(), ">= 1.14.0") do + test "find references when module with __MODULE__ special form function", %{trace: trace} do + buffer = """ + defmodule ElixirSense.Providers.ReferencesTest.Modules do + def func() do + __MODULE__.func() + # ^ + end end - end - """ + """ - references = Locator.references(buffer, 3, 18, trace) + references = Locator.references(buffer, 3, 18, trace) - assert references == [ - %{ - uri: nil, - range: %{ - end: %{column: 20, line: 3}, - start: %{column: 16, line: 3} + assert references == [ + %{ + uri: nil, + range: %{ + end: %{column: 20, line: 3}, + start: %{column: 16, line: 3} + } } - } - ] + ] + end end test "find references when module with __MODULE__ special form", %{trace: trace} do diff --git a/apps/language_server/test/providers/signature_help/signature_test.exs b/apps/language_server/test/providers/signature_help/signature_test.exs index d9008313f..2934914c8 100644 --- a/apps/language_server/test/providers/signature_help/signature_test.exs +++ b/apps/language_server/test/providers/signature_help/signature_test.exs @@ -1051,25 +1051,26 @@ defmodule ElixirLS.LanguageServer.Providers.SignatureHelp.SignatureTest do end end - @tag requires_otp_25: true - test "finds signatures from metadata erlang behaviour call from outside" do - code = """ - :file_server.init() - """ + if System.otp_release() |> String.to_integer() >= 23 do + test "finds signatures from metadata erlang behaviour call from outside" do + code = """ + :file_server.init() + """ - res = Signature.signature(code, 1, 19) + res = Signature.signature(code, 1, 19) - assert %{ - active_param: 0, - signatures: [ - %{ - documentation: "- Args = " <> _, - name: "init", - params: ["args"], - spec: "@callback init(args :: term()) ::" <> _ - } - ] - } = res + assert %{ + active_param: 0, + signatures: [ + %{ + documentation: "- Args = " <> _, + name: "init", + params: ["args"], + spec: "@callback init(args :: term()) ::" <> _ + } + ] + } = res + end end test "retrieve metadata function signature - fallback to callback in metadata" do @@ -1500,40 +1501,41 @@ defmodule ElixirLS.LanguageServer.Providers.SignatureHelp.SignatureTest do assert :none = Signature.signature(buffer, 8, 18) end - @tag requires_otp_23: true - test "find built-in erlang functions" do - buffer = """ - defmodule MyModule do - :erlang.orelse() - # ^ - :erlang.or() - # ^ - end - """ - - %{ - active_param: 0, - signatures: [ - %{ - documentation: "", - name: "orelse", - params: ["term", "term"], - spec: "" - } - ] - } = Signature.signature(buffer, 2, 18) + if System.otp_release() |> String.to_integer() >= 23 do + test "find built-in erlang functions" do + buffer = """ + defmodule MyModule do + :erlang.orelse() + # ^ + :erlang.or() + # ^ + end + """ + + %{ + active_param: 0, + signatures: [ + %{ + documentation: "", + name: "orelse", + params: ["term", "term"], + spec: "" + } + ] + } = Signature.signature(buffer, 2, 18) - assert %{ - active_param: 0, - signatures: [ - %{ - documentation: "", - name: "or", - params: [_, _], - spec: "@spec boolean() or boolean() :: boolean()" - } - ] - } = Signature.signature(buffer, 4, 14) + assert %{ + active_param: 0, + signatures: [ + %{ + documentation: "", + name: "or", + params: [_, _], + spec: "@spec boolean() or boolean() :: boolean()" + } + ] + } = Signature.signature(buffer, 4, 14) + end end test "find :erlang module functions with different forms of typespecs" do diff --git a/apps/language_server/test/test_helper.exs b/apps/language_server/test/test_helper.exs index f29e4f72e..0eaf4e09a 100644 --- a/apps/language_server/test/test_helper.exs +++ b/apps/language_server/test/test_helper.exs @@ -1,3 +1,3 @@ :persistent_term.put(:language_server_test_mode, true) Application.ensure_started(:stream_data) -ExUnit.start(exclude: [pending: true]) +ExUnit.start(exclude: [pending: true, requires_source: true])