make indexing expressions participate in dot syntax fusion

[StefanKarpinski]

Consider an expression like v[p.(v)] .*= 2 where p is a predicate (i.e. returns a boolean). Currently Julia's semantics are that p.(v) is constructed and then used to index into v. However, the optimal implementation of this would to loop through v, testing each element x in v to see if p(x) is true and then multiplying it by 2 if that's the case. While it might be possible for a compiler to optimize the current semantics to this behavior in some circumstances, arguably, the dotted application of p in the indexing expression should participate in dot fusion of the whole expression, and this expression should simply mean the optimal implementation. Marking as 1.0 since if we're going to change the semantics of this expression, we should do so before then.

[KristofferC]

Ref #19169

[stevengj]

I would tend to prefer v.[p.(v)] for something like this. If we lowered a.[i] to getindex.(a, i), then v.[p.(v)] would already work on the right-hand-side of assignments since getindex.(v, p.(v)) is fusing.

[JeffBezanson]

OK, I guess this is just a parser issue then. I can allow parsing x.[...].

[JeffBezanson]

Update: already parses, so just needs a case in the broadcast lowering code.

[mbauman]

It'll take quite a bit more than that, particularly in the logical indexing case like Stefan proposed in his example. The naive broadcast will just repeatedly pass a true or false index to the array. See my comment at #19169 (comment).

[JeffBezanson]

Yeah, I just realized that and was about to post again. a[i] is just not generally equivalent to getindex.(a, i).

[StefanKarpinski]

Writing this as v.[p.(v)] .*= 2 would be fine as well as long as there is a way to write it.

[JeffBezanson]

a.[i] would mean [ getindex(a[1], i[1]), getindex(a[2], i[2]), ... ] or [ getindex(a[1], i), getindex(a[2], i), ... ] if i is a scalar. So we'd have to change something else to make that work, but I'm not sure what.