Fix parsing of chained unary and unary type operators (#249)

* Parsing `* <: A` doesn't crash the parser
* `+ <: A` now parses correctly as `(call-pre + (<:-pre A))`.

Author: c42f

src/parser.jl

@@ -1300,7 +1300,6 @@ function parse_unary(ps::ParseState)
             end
         end
     else
-        @assert !is_type_operator(op_t) # `<:x` handled in parse_unary_subtype
         if is_unary_op(op_t)
             # Normal unary calls
             # +x  ==>  (call-pre + x)
@@ -1310,15 +1309,21 @@ function parse_unary(ps::ParseState)
             # -0x1 ==> (call-pre - 0x01)
             # - 2  ==> (call-pre - 2)
             # .-2  ==> (dotcall-pre - 2)
-            bump_dotsplit(ps, EMPTY_FLAGS)
+            op_pos = bump_dotsplit(ps, EMPTY_FLAGS)
         else
             # /x     ==>  (call-pre (error /) x)
             # +₁ x   ==>  (call-pre (error +₁) x)
-            # .<: x  ==>  (dotcall-pre (error .<:) x)
-            bump(ps, error="not a unary operator")
+            # .<: x  ==>  (dotcall-pre (error (. <:)) x)
+            bump_dotsplit(ps, EMPTY_FLAGS, emit_dot_node=true)
+            op_pos = emit(ps, mark, K"error", error="not a unary operator")
         end
         parse_unary(ps)
-        emit(ps, mark, is_dotted(op_t) ? K"dotcall" : K"call", PREFIX_OP_FLAG)
+        if is_type_operator(op_t)
+            reset_node!(ps, op_pos, flags=TRIVIA_FLAG)
+            emit(ps, mark, op_k, PREFIX_OP_FLAG)
+        else
+            emit(ps, mark, is_dotted(op_t) ? K"dotcall" : K"call", PREFIX_OP_FLAG)
+        end
     end
 end
 

test/parser.jl

@@ -260,7 +260,7 @@ tests = [
         # Not a unary operator
         "/x"     => "(call-pre (error /) x)"
         "+₁ x"   => "(call-pre (error +₁) x)"
-        ".<: x"  => "(dotcall-pre (error .<:) x)"
+        ".<: x"  => "(dotcall-pre (error (. <:)) x)"
         "?\"str\"" => """(call-pre (error ?) (string "str"))"""
     ],
     JuliaSyntax.parse_factor => [
@@ -283,6 +283,9 @@ tests = [
         "<: x"          =>  "(<:-pre x)"
         "<: <: x"       =>  "(<:-pre (<:-pre x))"
         "<: A where B"  =>  "(<:-pre (where A B))"
+        # FIXME: The following bizarre precedence seems broken, but is
+        # compatible with the reference parser (see #248)
+        "+ <: A where B"  =>  "(where (call-pre + (<:-pre A)) B)"
         # Really for parse_where
         "x where \n {T}"  =>  "(where x T)"
         "x where {T,S}"  =>  "(where x T S)"
@@ -291,6 +294,9 @@ tests = [
         "x where T"  =>  "(where x T)"
         "x where \n T"  =>  "(where x T)"
         "x where T<:S"  =>  "(where x (<: T S))"
+        # nested unary and unary-syntactic ops
+        "<: + <: + A" => "(<:-pre (call-pre + (<:-pre (call-pre + A))))"
+        "* <: A"      => "(call-pre (error *) (<:-pre A))"
     ],
     JuliaSyntax.parse_unary_prefix => [
         "&)"   => "&"