Fix multiline function signature parsing

Multiline function signatures with type annotations were incorrectly
parsed as tuples instead of calls when newlines appeared between
parentheses. For example:

```julia
function (
    ::A
)()
end
```

was parsed as `(function (tuple ...) (block))` instead of the correct
`(function (call (parens ...)) (block))`, inconsistent with the
single-line version `function (::A)() end`.

The issue was in parse_function_signature where `peek(ps, 2)` was used
to detect if a call pattern follows the closing parenthesis, but this
didn't skip newlines. Changed to `peek(ps, 2, skip_newlines=true)` to
properly detect the opening parenthesis of the argument list even when
separated by whitespace.

🤖 Generated with [Claude Code](https://claude.ai/code)

better...

Author: KristofferC

src/parser.jl

@@ -1996,17 +1996,30 @@ function parse_function(ps::ParseState)
     else
         if peek(ps) == K"("
             bump(ps, TRIVIA_FLAG)
-            # When an initial parenthesis is present, we might either have the
-            # function name or the argument list in an anonymous function. We
-            # use parse_brackets directly here (rather than dispatching to it
-            # via parse_atom) so we can distinguish these two cases by peeking
-            # at the following parenthesis, if present.
-            #
-            # The flisp parser disambiguates this case quite differently,
-            # producing less consistent syntax for anonymous functions.
-            parse_brackets(ps, K")") do _, _, _, _
+            # Handle `function (...)` specially so we can tell whether the parens
+            # wrap the function name (possibly with type annotations) or an
+            # anonymous-argument list.
+            is_empty_tuple = false
+            parse_brackets(ps, K")") do had_commas, had_splat, num_semis, num_subexprs
                 bump_closing_token(ps, K")")
-                is_anon_func = peek(ps) != K"("
+                is_empty_tuple = num_subexprs == 0
+                # A single-subexpression tuple without commas/splats/semicolons
+                # is the ambiguous case we treat as a potential grouped name.
+                single_expr_without_tuple = !had_commas && !had_splat &&
+                                            num_semis == 0 && num_subexprs == 1
+                next_kind = single_expr_without_tuple ? peek(ps, skip_newlines=true) : peek(ps)
+                needs_parse_call = next_kind ∈ KSet`( .`
+                # Determine whether the parens represent an anonymous-argument list.
+                is_anon_func = if had_commas || had_splat || num_semis > 0
+                    # Commas, splats, or semicolons mean tuple-style arguments.
+                    true
+                elseif is_empty_tuple
+                    # An empty tuple should still allow a following call.
+                    false
+                else
+                    # Otherwise treat it as arguments when no call follows.
+                    !needs_parse_call
+                end
                 return (needs_parameters     = is_anon_func,
                         eq_is_kw_before_semi = is_anon_func,
                         eq_is_kw_after_semi  = is_anon_func)
@@ -2017,6 +2030,9 @@ function parse_function(ps::ParseState)
                 # function (x=1) end    ==>  (function (tuple (kw x 1)) (block))
                 # function (;x=1) end   ==>  (function (tuple (parameters (kw x 1))) (block))
                 emit(ps, def_mark, K"tuple")
+            elseif is_empty_tuple
+                # function ()(x) end  ==> (function (call (tuple) x) (block))
+                emit(ps, def_mark, K"tuple")
             else
                 # function (:)() end    ==> (function (call :) (block))
                 # function (x::T)() end ==> (function (call (:: x T)) (block))
@@ -3392,4 +3408,3 @@ function parse_atom(ps::ParseState, check_identifiers=true)
         bump(ps, error="invalid syntax atom")
     end
 end
-

test/parser.jl

@@ -435,6 +435,12 @@ tests = [
         "function (:)() end"   =>  "(function (call :) (block))"
         "function (x::T)() end"=>  "(function (call (:: x T)) (block))"
         "function (::T)() end" =>  "(function (call (:: T)) (block))"
+        "function (\n        ::T\n        )() end" =>  "(function (call (:: T)) (block))"
+        "function (\n        x::T\n        )() end" =>  "(function (call (:: x T)) (block))"
+        "function (\n        ::T\n        )(x, y) end" =>  "(function (call (:: T) x y) (block))"
+        "function (\n        f\n        )() end" =>  "(function (call f) (block))"
+        "function ()(\n        x\n        ) end" => "(function (call (tuple) x) (block))"
+        "function (\n        x::T,\n        y::U\n        )() end" => "(function (tuple (:: x T) (:: y U)) (block (tuple)))"
         "function begin() end" =>  "(function (call (error begin)) (block))"
         "function f() end"     =>  "(function (call f) (block))"
         "function type() end"  =>  "(function (call type) (block))"
@@ -805,4 +811,3 @@ end
     @test test_parse(JuliaSyntax.parse_eq, "a \u2212= b") == "(-= a b)"
     @test test_parse(JuliaSyntax.parse_eq, "a .\u2212= b") == "(.-= a b)"
 end
-