produce only one Expr type from A <: B expressions

[stevengj]

As discussed in #9474, the parsing of A <: B is currently somewhat inconsistent, and this makes metaprogamming a bit harder than necessary:

julia> dump(:(A <: B))
Expr 
  head: Symbol comparison
  args: Array(Any,(3,))
    1: Symbol A
    2: Symbol <:
    3: Symbol B
  typ: Any

julia> dump(:(type A <: B; end))
Expr 
  head: Symbol type
  args: Array(Any,(3,))
    1: Bool true
    2: Expr 
      head: Symbol <:
      args: Array(Any,(2,))
        1: Symbol A
        2: Symbol B
      typ: Any
    3: Expr 
      head: Symbol block
      args: Array(Any,(0,))
      typ: Any
  typ: Any

Perhaps A <: B should be parsed as Expr(:(<:), :A, :B) in all cases. cc: @yuyichao

[JeffBezanson]

Yes, I definitely agree. Since <: is in fact a comparison operator, and one can write A <: B <: C, we should probably always parse it as a comparison. I really don't recall how it got the way it is now.

[jakebolewski]

Was it done this way to make it easier to apply pattern-lambda to the subtype expression?

[JeffBezanson]

Started working on fixing this, which in the process revealed what I think was the cause. The <: in type declarations is special syntax, and not a call to <:, so it should not have hygiene applied to it. I think the original goal was to make it easier to distinguish calls from syntax decoration.

So we could go with SGJ's suggestion of always parsing it as Expr(:(<:), ...). That would push the problem to handling comparisons A <: B <: C, which are quite uncommon.