Expr consistency and stability

[aplavin]

Many packages rely on the structure of parsed Exprs, mostly to implement transformations in macros.
Sometimes, Expr parsing results aren't too consistent. And I wonder if they are considered stable/public in Julia 1.x or not. Can parsing results of expressions change? Would be nice to clarify that, especially given the recent history of backwards incompatible changes in Julia, some of which aren't acknowledged as breaking even when they lead to failures in popular packages.

[aplavin]

To be more concrete, this is an example of an inconsistency I noticed recently.
Same structure for regular calls:

julia> :(f(x, y)) |> dump
Expr
  head: Symbol call
  args: Array{Any}((3,))
    1: Symbol f
    2: Symbol x
    3: Symbol y

julia> :(+(x, y)) |> dump
Expr
  head: Symbol call
  args: Array{Any}((3,))
    1: Symbol +
    2: Symbol x
    3: Symbol y

But very different with broadcasting:

julia> :(f.(x, y)) |> dump
Expr
  head: Symbol .
  args: Array{Any}((2,))
    1: Symbol f
    2: Expr
      head: Symbol tuple
      args: Array{Any}((2,))
        1: Symbol x
        2: Symbol y

julia> :(.+(x, y)) |> dump
Expr
  head: Symbol call
  args: Array{Any}((3,))
    1: Symbol .+
    2: Symbol x
    3: Symbol y

The last one isn't just inconsistent, but also generally weird: it claims to be a call to a function named .+, but it doesn't exit:

julia> Main.:.+
ERROR: UndefVarError: `.+` not defined in `Main`

Can this or other example parse in a different way in a new Julia version?

[vtjnash]

IIRC, the .+ is a legacy parsing behavior specifically for maintaining backwards compatibility, even though it is a bit awkward to handle. Refs #37583 and #40858

[aplavin]

So, can we rely on existing parsing rules, are they considered stable?

[ararslan]

To Jameson's point, significant effort has been put into ensuring and maintaining stability. The last breaking change I can recall to expression parsing was when we started preserving do in the AST in 0.7. I'm not the authority here but that seems pretty stable to me; I'd personally consider the existing rules stable and, like all maintainers of packages that define macros, I rely on that stability.