On 2015-07-18 11:43, "Marc =?UTF-8?B?U2Now7x0eiI=?= <schue...@gmx.net>" wrote:

The AST for this statement would look something like:

(DeclStatement type=(Keyword "auto") name=(Identifier "a")
value=(AssignExpression exp=(VariableOrParenlessCall var=(Identifier
"foo"))))

This would probably be considerably harder for trailing delegates...

I think there are nine different ways a user could want write the code to call a method with a trailing delegate. Only two of them are ambiguous.

foo {
}

foo (a){ // ambiguous
}

foo (int a){
}

foo(a) { // ambiguous
}

foo(a) (b){
}

foo(a) (int b){
}

foo() (){
}

foo (){
}

foo() {
}

When it is ambiguous the compiler can always parse it as trailing delegate and store that in a variable in the call expression. The semantic analyze will then disambiguate the call. That would be similar to how my current implementation works like:

1. If the current expression is a call expression or an identifier
2. If the current token is an opening curly brace, parse an expression
3.1 If the current expression is a call expression, push the expression from step 2 to its argument list 3.2 If the current expression is an identifier, replace that with a call expression, go to 3.1

This could be extended to store the delegate expression in a new variable in the call expression instead.

--
/Jacob Carlborg

Reply via email to