Swift accepts both of these closure expressions
// Parens around the arguments
{(a, b) -> Void in println(a)}
// No parens
{a, b -> Void in println(a)}
According to the grammar the signature for (a, b) should be parsed via this chain:
closure-expression -> closure-signature -> parameter-clause
Because only parameter-clause can accept a list of things surrounded by parentheses, as opposed to identifier-list which is simply a list of comma separated identifiers. But how can parameter-clause match (a, b)?
parameter-clause is a comma separated list of parameter. parameter can basically have two forms
id:type
type
Where the first form allows a bunch of optional things such as 'inout', 'let', 'var', '#', etc. If the input is (a, b) and the parameter rule is used to try to match 'a' then only the second alternative consisting of 'type' would work. That means that 'a' is treated as a type node.
This 'works out' in the sense that the grammar accepts (a, b) in a closure signature, but is that really intended? It means a function that processes the closure expression syntax node must treat a parameter that only has a type as if it was an identifier.