Elixir doesn't warn with trying to concat string literals with invalid operator and string interpolation

[davydog187]

Elixir and Erlang/OTP versions

Erlang/OTP 26 [erts-14.2.1] [source] [64-bit] [smp:8:8] [ds:8:8:10] [async-threads:1] [jit]

Elixir 1.16.0 (compiled with Erlang/OTP 26)

Operating system

MacOS

Current behavior

# concat.ex
defmodule Concat do
  def warns do
    "foo" + "bar"
  end

  def doesnt(reason) when is_binary(reason) do
    "#{reason}" + "bar"
  end
end

When compiling with elixirc concat.ex, I get the following warning

    warning: the call to +/2 will fail with ArithmeticError
    │
  3 │     "foo" + "bar"
    │     ~~~~~~~~~~~~~
    │
    └─ concat.ex:3

notice that it doesn't warn for doesnt/1. It seems that adding string interpolation breaks the check.

Expected behavior

I would expect the same ArithmeticError warning for doesnt/1.

[davydog187]

Also confirmed this behavior exists in elixir 1.16.2

[v0idpwn]

I may be wrong here, but my interpretation is: this warning comes from Erlang and only works for literals. Since the interpolated string isn't a literal in Erlang, the warning isn't raised there and then isn't translated by the Elixir compiler.

[davydog187]

I'm not sure how the compiler represents string interpolation internally (function call maybe?), but since it knows that the resulting type is a string, it should be smart enough to handle this case.

If it's an OTP bug so be it, but I reckon the Elixir compiler can handle this

[sabiwara]

this warning comes from Erlang and only works for literals. Since the interpolated string isn't a literal in Erlang, the warning isn't raised there and then isn't translated by the Elixir compiler.

@v0idpwn is correct.

If it's an OTP bug so be it, but I reckon the Elixir compiler can handle this

I don't think this would qualify as a bug, as it is more in the realm of what a type-system like dialyzer is providing.
But it should hopefully be addressed in Elixir by the upcoming gradual type system.

[josevalim]

Yes, and those warnings are not guaranteed. Nor Erlang nor Elixir compilers are attempting to find typing violations, those are rather found when trying to optimize code, and reported as a convenience. As mentioned above, those are rather addressed by type systems, Dialyzer, etc. :)

[davydog187]

We'll wait for the type system then 😀

FWIW, I was not aware than these warnings should be treated as a convenience, and even so the consistency is unexpected.

If there's an opportunity to clarify this somewhere I think it would be helpful as this issue was inspired by code written by a newcomer to Elixir and only caught by an obscure dialyzer error