`vec[1 +1]` gives unhelpful error

[LilithHafner]

I ran across this unhelpful error message

julia> vec = [1, 2, 3]
3-element Vector{Int64}:
 1
 2
 3

julia> vec[1+1]
2

julia> vec[1+ 1]
2

julia> vec[1 + 1]
2

julia> vec[1 +1]
ERROR: MethodError: no method matching typed_hcat(::Vector{Int64}, ::Int64, ::Int64)

Closest candidates are:
  typed_hcat(::Type{T}, ::Number...) where T
   @ Base abstractarray.jl:1614
  typed_hcat(::Type{T}, ::Union{Number, LinearAlgebra.Adjoint{T, <:AbstractVector} where T}...) where T
   @ LinearAlgebra ~/.julia/juliaup/julia-1.9.0-rc3+0.aarch64.apple.darwin14/share/julia/stdlib/v1.9/LinearAlgebra/src/adjtrans.jl:352
  typed_hcat(::Type{T}, ::Union{Number, LinearAlgebra.Transpose{T, <:AbstractVector} where T}...) where T
   @ LinearAlgebra ~/.julia/juliaup/julia-1.9.0-rc3+0.aarch64.apple.darwin14/share/julia/stdlib/v1.9/LinearAlgebra/src/adjtrans.jl:353
  ...

Stacktrace:
 [1] top-level scope
   @ REPL[54]:1

This is because typed comprehensions Float64[1 2] and array access vec[3] share the same syntax. Giving a hint when the "type" used in a typed comprehension is not a type and is an indexable object might help.

[draftman9]

julia> vec = [1, 2, 3]
3-element Vector{Int64}:
 1
 2
 3

julia> @. vec = vec + 1
3-element Vector{Int64}:
 2
 3
 4

julia> @. vec = vec +1
ERROR: LoadError: MethodError: no method matching var"@__dot__"(::LineNumberNode, ::Module, ::Expr, ::Int64)
Closest candidates are:
  var"@__dot__"(::LineNumberNode, ::Module, ::Any) at broadcast.jl:1276
in expression starting at REPL[11]:1

The problem I met today looks same as yours...
julia-1.8.5

[JeffBezanson]

Yes, we could fix this --- A[B C] is the "typed hcat" form, where A is expected to be a type. If instead it's an AbstractArray, we could give a better error message, since A being a non-type has no other definition here.

The macro syntax issue is different. Macros can take space-separated arguments, so that line passes the arguments vec = vec and +1 to the dot macro, but the macro only accepts one argument. Macros with multiple methods are somewhat rare, so it would probably make sense to intercept this case (macro has one method, mismatch in number of arguments), to print a clearer error that the number of arguments is wrong instead of a generic method error.

[romaindegivry]

Hi I'm interested in learning a bit about the inner workings of Julia. Can I work on this issue?

For the first part of the problem I'm not sure how I could intercept this cleanly before the Method Error occurs. Instead I tried registering an error hint. It looks something like:

ERROR: MethodError: no method matching typed_hcat(::Matrix{Int64}, ::Int64, ::Int64)
 If attempting to index into an array, missing or ambiguous operator placement may cause this.

 For example, this happens when writing vec[i 1] (missing operator) or vec[i +1] (ambiguous) rather than vec[i+1] .

Closest candidates are:
[...]

There's not a lot of hints in Base so am I looking in the right direction?

For the second issue, as said above I imagine adding a new macro signature to detect this and display a similar hint is enough?

[LilithHafner]

Yes! You are welcome to work on this issue (and you don't even need permission, anyone can make a pull request).

One way to intercept this before the method error would be to define a new method of typed_hcat that would be called when someone writes vec[1 +1],

I recommend starting with the first issue and only moving on to the second after seeing the first through to completion. It's common for what appears to be a simple fix to become a large project, so whenever possible, and especially for a first PR, I recommend trying to keep a narrow focus.

[romaindegivry]

Thanks for the advice. I switched to intercepting the call before we get to a method error and opened a PR.

I'll try to have a look at the second part once it's merged.