Fix for operator-named macros: parse @+x as @+ x (#197)

Allow operator-named macros to be used without spaces.

Author: c42f

src/parser.jl

@@ -1466,7 +1466,13 @@ function parse_identifier_or_interpolate(ps::ParseState)
 end
 
 # Parses a chain of sufficies at function call precedence, leftmost binding
-# tightest.
+# tightest. This handles
+#  * Bracketed calls like a() b[] c{}
+#  * Field access like a.b.c
+#    - Various dotted syntax like f.() and f.:x
+#  * Adjoint suffix like a'
+#  * String macros like a"str" b"""str""" c`str` d```str```
+#
 # f(a).g(b) ==> (call (. (call f a) (quote g)) b)
 #
 # flisp: parse-call-chain, parse-call-with-initial-ex
@@ -1487,15 +1493,23 @@ function parse_call_chain(ps::ParseState, mark, is_macrocall=false)
         maybe_strmac_1 = false
         t = peek_token(ps)
         k = kind(t)
-        if is_macrocall && (preceding_whitespace(t) || is_closing_token(ps, k))
+        if !is_macrocall && ps.space_sensitive && preceding_whitespace(t) &&
+                k in KSet"( [ { \" \"\"\" ` ```"
+            # [f (x)]  ==>  (hcat f x)
+            # [f x]    ==>  (hcat f x)
+            break
+        elseif is_macrocall && (preceding_whitespace(t) || !(k in KSet"( [ { ' ."))
             # Macro calls with space-separated arguments
             # @foo a b    ==> (macrocall @foo a b)
             # @foo (x)    ==> (macrocall @foo x)
             # @foo (x,y)  ==> (macrocall @foo (tuple x y))
             # [@foo x]    ==> (vect (macrocall @foo x))
+            # [@foo]      ==> (vect (macrocall @foo))
             # @var"#" a   ==> (macrocall (var @#) a)
             # A.@x y      ==> (macrocall (. A (quote @x)) y)
             # A.@var"#" a ==> (macrocall (. A (quote (var @#))) a)
+            # @+x y       ==> (macrocall @+ x y)
+            # [email protected]       ==> (macrocall (. A (quote @.)) x)
             fix_macro_name_kind!(ps, macro_name_position)
             let ps = with_space_sensitive(ps)
                 # Space separated macro arguments
@@ -1523,11 +1537,6 @@ function parse_call_chain(ps::ParseState, mark, is_macrocall=false)
                 emit(ps, mark, K"macrocall")
             end
             break
-        elseif (ps.space_sensitive && preceding_whitespace(t) &&
-                k in KSet"( [ { \ Char \" \"\"\" ` ```")
-            # [f (x)]  ==>  (hcat f x)
-            # [f x]    ==>  (hcat f x)
-            break
         elseif k == K"("
             # f(a,b)  ==>  (call f a b)
             # f(a=1; b=2) ==> (call f (= a 1) (parameters (= b 2)))

test/parser.jl

@@ -306,16 +306,22 @@ tests = [
         "f(a).g(b)" => "(call (. (call f a) (quote g)) b)"
         "\$A.@x"    =>  "(macrocall (. (\$ A) (quote @x)))"
 
+        # non-errors in space sensitive contexts
+        "[f (x)]"    =>  "(hcat f x)"
+        "[f x]"      =>  "(hcat f x)"
         # space separated macro calls
         "@foo a b"     =>  "(macrocall @foo a b)"
         "@foo (x)"     =>  "(macrocall @foo x)"
         "@foo (x,y)"   =>  "(macrocall @foo (tuple x y))"
         "A.@foo a b"   =>  "(macrocall (. A (quote @foo)) a b)"
         "@A.foo a b"   =>  "(macrocall (. A (quote @foo)) a b)"
         "[@foo x]"     =>  "(vect (macrocall @foo x))"
+        "[@foo]"       =>  "(vect (macrocall @foo))"
         "@var\"#\" a"  =>  "(macrocall (var @#) a)"                => Expr(:macrocall, Symbol("@#"), LineNumberNode(1), :a)
         "A.@x y"       =>  "(macrocall (. A (quote @x)) y)"
         "A.@var\"#\" a"=>  "(macrocall (. A (quote (var @#))) a)"  => Expr(:macrocall, Expr(:., :A, QuoteNode(Symbol("@#"))), LineNumberNode(1), :a)
+        "@+x y"        =>  "(macrocall @+ x y)"
+        "[email protected]"        =>  "(macrocall (. A (quote @.)) x)"
         # Macro names
         "@! x"  => "(macrocall @! x)"
         "@.. x" => "(macrocall @.. x)"
@@ -329,9 +335,6 @@ tests = [
         "@doc x\n\ny"  =>  "(macrocall @doc x)"
         "@doc x\nend"  =>  "(macrocall @doc x)"
 
-        # non-errors in space sensitive contexts
-        "[f (x)]"    =>  "(hcat f x)"
-        "[f x]"      =>  "(hcat f x)"
         # calls with brackets
         "f(a,b)"  => "(call f a b)"
         "f(a=1; b=2)" => "(call f (= a 1) (parameters (= b 2)))" =>
@@ -941,26 +944,9 @@ parseall_test_specs = [
     end
 end
 
-# Known bugs / incompatibilities
-broken_tests = [
-    JuliaSyntax.parse_atom => [
-        """var""\"x""\""""  =>  "x"
-        # Operator-named macros without spaces
-        "@!x"   => "(macrocall @! x)"
-        "@..x"  => "(macrocall @.. x)"
-        "@.x"   => "(macrocall @__dot__ x)"
-    ]
-]
-
-@testset "Broken $production" for (production, test_specs) in broken_tests
-    @testset "$(repr(input))" for (input,output) in test_specs
-        if !(input isa AbstractString)
-            opts,input = input
-        else
-            opts = NamedTuple()
-        end
-        @test_broken parse_to_sexpr_str(production, input; opts...) == output
-    end
+@testset "Broken tests" begin
+    # Technically broken. But do we even want this behavior?
+    @test_broken parse_to_sexpr_str(JuliaSyntax.parse_eq, "var\"\"\"x\"\"\"") == "(var x)"
 end
 
 @testset "Trivia attachment" begin