Fix for function signatures with grouping parens (#140)

Cater for cases where some parts of the signature are inside and some
outside of the parentheses. For example the reference parser allows an
extra set of parens such as

    function (f()) where T
        body
    end

and unfortunately this syntax is used in several packages.

Author: c42f

src/parser.jl

@@ -2016,6 +2016,7 @@ end
 # Parse function and macro definitions
 function parse_function_signature(ps::ParseState, is_function::Bool)
     is_anon_func = false
+    parsed_call = false
 
     mark = position(ps)
     if !is_function
@@ -2053,17 +2054,7 @@ function parse_function_signature(ps::ParseState, is_function::Bool)
                         parsed_call      = _parsed_call)
             end
             is_anon_func = opts.is_anon_func
-            if opts.parsed_call
-                # Compat: Ugly case where extra parentheses existed and we've
-                # already parsed the whole signature.
-                # function (f() where T) end ==> (function (where (call f) T) (block))
-                # function (f()::S) end ==> (function (:: (call f) S) (block))
-                #
-                # TODO: Warn for use of parens? The precedence of `::` and
-                # `where` don't work inside parens so this is a bit of a syntax
-                # oddity/aberration.
-                return true
-            end
+            parsed_call = opts.parsed_call
             if is_anon_func
                 # function (x) body end ==>  (function (tuple x) (block body))
                 # function (x::f()) end ==>  (function (tuple (:: x (call f))) (block))
@@ -2099,10 +2090,10 @@ function parse_function_signature(ps::ParseState, is_function::Bool)
             end
         end
     end
-    if peek(ps, skip_newlines=true) == K"end" && !is_anon_func
+    if peek(ps, skip_newlines=true) == K"end" && !is_anon_func && !parsed_call
         return false
     end
-    if !is_anon_func
+    if !is_anon_func && !parsed_call
         # Parse function argument list
         # function f(x,y)  end    ==>  (function (call f x y) (block))
         # function f{T}()  end    ==>  (function (call (curly f T)) (block))
@@ -2129,6 +2120,19 @@ function parse_function_signature(ps::ParseState, is_function::Bool)
         parse_where_chain(ps, mark)
     end
     # function f()::S where T end ==> (function (where (:: (call f) S) T) (block))
+    #
+    # Ugly cases for compat where extra parentheses existed and we've
+    # already parsed at least the call part of the signature
+    #
+    # function (f() where T) end         ==> (function (where (call f) T) (block))
+    # function (f()) where T end         ==> (function (where (call f) T) (block))
+    # function (f() where T) where U end ==> (function (where (where (call f) T) U) (block))
+    # function (f()::S) end              ==> (function (:: (call f) S) (block))
+    # function ((f()::S) where T) end    ==> (function (where (:: (call f) S) T) (block))
+    #
+    # TODO: Warn for use of parens? The precedence of `::` and
+    # `where` don't work inside parens so this is a bit of a syntax
+    # oddity/aberration.
     return true
 end
 

test/parser.jl

@@ -459,8 +459,6 @@ tests = [
         "macro (type)(ex) end" =>  "(macro (call type ex) (block))"
         "macro \$f()    end"   =>  "(macro (call (\$ f)) (block))"
         "macro (\$f)()  end"   =>  "(macro (call (\$ f)) (block))"
-        "function (f() where T) end" => "(function (where (call f) T) (block))" => Expr(:function, Expr(:where, Expr(:call, :f), :T), Expr(:block))
-        "function (f()::S) end"=>  "(function (:: (call f) S) (block))"         => Expr(:function, Expr(:(::), Expr(:call, :f), :S), Expr(:block))
         "function (x) body end"=>  "(function (tuple x) (block body))"
         "function (x,y) end"   =>  "(function (tuple x y) (block))"
         "function (x=1) end"   =>  "(function (tuple (= x 1)) (block))"
@@ -488,8 +486,17 @@ tests = [
         "function f body end"    =>  "(function (error f) (block body))"
         "function f()::T    end" =>  "(function (:: (call f) T) (block))"
         "function f()::g(T) end" =>  "(function (:: (call f) (call g T)) (block))"
-        "function f() where {T} end"  =>  "(function (where (call f) T) (block))"
-        "function f() where T   end"  =>  "(function (where (call f) T) (block))"
+        "function f() where {T} end"  => "(function (where (call f) T) (block))"
+        "function f() where T   end"  => "(function (where (call f) T) (block))"
+        "function f()::S where T end" => "(function (where (:: (call f) S) T) (block))"
+        # Ugly cases for compat where extra parentheses existed and we've
+        # already parsed at least the call part of the signature
+        "function (f() where T) end" => "(function (where (call f) T) (block))" => Expr(:function, Expr(:where, Expr(:call, :f), :T), Expr(:block))
+        "function (f()) where T end" => "(function (where (call f) T) (block))"
+        "function (f() where T) where U end" => "(function (where (where (call f) T) U) (block))"
+        "function (f()::S) end"=>  "(function (:: (call f) S) (block))"         => Expr(:function, Expr(:(::), Expr(:call, :f), :S), Expr(:block))
+        "function ((f()::S) where T) end" => "(function (where (:: (call f) S) T) (block))"
+        # body
         "function f() \n a \n b end"  =>  "(function (call f) (block a b))"
         "function f() end"       =>  "(function (call f) (block))"
         # Errors