Incorrect parsing of `-(a=2)`

[oscardssmith]

On Julia master:

julia> @Meta.lower -(a = 2)
:($(Expr(:thunk, CodeInfo(
    @ none within `top-level scope`
1 ─ %1 = Core.get_binding_type(Main, :a)
│   %2 = Base.convert(%1, 2)
│   %3 = Core.typeassert(%2, %1)
│        a = %3
│   %5 = -2
└──      return %5
))))

With JuliaSyntax:

:($(Expr(:thunk, CodeInfo(
    @ none within `top-level scope`
1 ─ %1 = Core.tuple(:a)
│   %2 = Core.apply_type(Core.NamedTuple, %1)
│   %3 = Core.tuple(2)
│   %4 = (%2)(%3)
│   %5 = Core.kwfunc(-)
│   %6 = (%5)(%4, -)
└──      return %6
))))

[KristofferC]

Out of curiosity, why are we looking at the lowered code and not the parsed code? The lowering is the same no matter the parser, or?

[oscardssmith]

Good point.
master

julia> dump(:(-(a=2)))
Expr
  head: Symbol call
  args: Array{Any}((2,))
    1: Symbol -
    2: Expr
      head: Symbol =
      args: Array{Any}((2,))
        1: Symbol a
        2: Int64 2

JuliaSyntax

julia> dump(:(-(a=2)))
Expr
  head: Symbol call
  args: Array{Any}((2,))
    1: Symbol -
    2: Expr
      head: Symbol kw
      args: Array{Any}((2,))
        1: Symbol a
        2: Int64 2

[pfitzseb]

Probably a missed special case somewhere here.

[oscardssmith]

Another one that is either the same error or a similar one occurs for (a=1)[] which JuliaSyntax tries to parse as a kw rather than an =

[c42f]

Yes these would be due to the recent change in #103

[c42f]

Derived from this case, here's a particularly ugly parsing subtlety (reference parser):

julia> dump(:(-(a=1,)))
Expr
  head: Symbol call
  args: Array{Any}((2,))
    1: Symbol -
    2: Expr
      head: Symbol kw
      args: Array{Any}((2,))
        1: Symbol a
        2: Int64 1

julia> dump(:(-(a=1)))
Expr
  head: Symbol call
  args: Array{Any}((2,))
    1: Symbol -
    2: Expr
      head: Symbol =
      args: Array{Any}((2,))
        1: Symbol a
        2: Int64 1

which makes me wonder whether #103 is viable.

[JeffBezanson]

I think it might still be viable --- the first case is function call syntax and the second case is unary/prefix operator syntax, so if those cases can be distinguished than the two uses of = can as well.

[c42f]

Yes! I eventually came to much the same conclusion as I was working on reverting this.

I wrote down some ideas in #99 (comment). I'll try something like that (maybe adding a flag to the head, or a new Kind).

I think it will work out but it'd be nice to find something simple as well as workable. If anyone has ideas on how to do it neatly I'm all ears :)