добавление (…) {…} литералов функций при воздержании от возврата

Составляя ответ, найденный в Как иметь как вызовы функций, так и группировку в скобках без возврата назад, Я хотел бы добавить функциональные литералы, которые не являются средствами LL (*), реализованными как

...

tokens {
 ...
 FN;
 ID_LIST;
}

stmt
 : expr SEMI // SEMI=';'
 ;

callable
 : ...
 | fn
 ;

fn
 : OPAREN opt_id_list CPAREN compound_stmt
   -> ^(FN opt_id_list compound_stmt)
 ;

compound_stmt
 : OBRACE stmt* CBRACE

opt_id_list
 : (ID (COMMA ID)*)? -> ^(ID_LIST ID*)
 ;

То, что я хотел бы сделать, это разрешить литералам анонимных функций, которые имеют список аргументов (например,() или(a) или(a, b, c)) сопровождаемыйcompound_stmt. Так(a, b, c){...} хороший. Но(x)(y){} не так много. (Конечно(x) * (y){} "действителен" с точки зрения синтаксического анализатора, так же как((y){})()[1].x было бы.

Ответы на вопрос(1)

что это могло бы быть сделано без него, но это определенно привело бы к некоторым ужасно выглядящим правилам парсера, которые трудно поддерживата такж парсер, который примет(a, 2, 3){...} (функциональный литерал со списком выражений вместо списка идентификаторов), например. Это заставит вас сделать небольшую семантическую проверку после создания AST.

(IMO) лучший способ решить эту проблему, добавив буквальная функция править вcallable и добавление синтаксического предиката перед ним, который скажет парсеру убедиться, что тамдействительн является такой альтернативой, прежде чем сопоставить ее.

callable
 : (fn_literal)=> fn_literal
 | OPAREN expr CPAREN -> expr
 | ID
 ;

Демо:

grammar T;

options {
  output=AST;
}

tokens {
 // literal tokens
 EQ     = '==' ;
 GT     = '>' ;
 LT     = '<' ;
 GTE    = '>=' ;
 LTE    = '<=' ;
 LAND   = '&&' ;
 LOR    = '||' ;
 PLUS   = '+' ;
 MINUS  = '-' ;
 TIMES  = '*' ;
 DIVIDE = '/' ;
 OPAREN = '(' ;
 CPAREN = ')' ;
 OBRACK = '[' ;
 CBRACK = ']' ;
 DOT    = '.' ;
 COMMA  = ',' ;
 OBRACE = '{' ;
 CBRACE = '}' ;
 SEMI   = ';' ;

 // imaginary tokens
 CALL;
 INDEX;
 LOOKUP;
 UNARY_MINUS;
 PARAMS;
 FN;
 ID_LIST;
 STATS;
}

prog
 : expr EOF -> expr
 ;

expr
 : boolExpr
 ;

boolExpr
 : relExpr ((LAND | LOR)^ relExpr)?
 ;

relExpr
 : (a=addExpr -> $a) ( (oa=relOp b=addExpr    -> ^($oa $a $b))
                         ( ob=relOp c=addExpr -> ^(LAND ^($oa $a $b) ^($ob $b $c))
                         )?
                     )?
 ;

addExpr
 : mulExpr ((PLUS | MINUS)^ mulExpr)*
 ;

mulExpr
 : unaryExpr ((TIMES | DIVIDE)^ unaryExpr)*
 ;

unaryExpr
 : MINUS atomExpr -> ^(UNARY_MINUS atomExpr)
 | atomExpr
 ;

atomExpr
 : INT
 | call
 ;

call
 : (callable -> callable) ( OPAREN params CPAREN -> ^(CALL $call params)
                          | OBRACK expr CBRACK   -> ^(INDEX $call expr)
                          | DOT ID               -> ^(INDEX $call ID)
                          )*
 ;

callable
 : (fn_literal)=> fn_literal
 | OPAREN expr CPAREN -> expr
 | ID
 ;

fn_literal
 : OPAREN id_list CPAREN compound_stmt -> ^(FN id_list compound_stmt)
 ;

id_list
 : (ID (COMMA ID)*)? -> ^(ID_LIST ID*)
 ;

params
 : (expr (COMMA expr)*)? -> ^(PARAMS expr*)
 ;

compound_stmt
 : OBRACE stmt* CBRACE -> ^(STATS stmt*)
 ;

stmt
 : expr SEMI
 ;

relOp
 : EQ | GT | LT | GTE | LTE
 ;

ID     : 'a'..'z'+ ;
INT    : '0'..'9'+ ;
SPACE  : (' ' | '\t') {skip();};

Синтаксический анализатор, сгенерированный вышеуказанной грамматикой, отклонит ввод(x)(y){} пока он правильно анализирует следующие 3 фрагмента кода:

1

(a, b, c){ a+b*c; }

2

(x) * (y){ x.y; }

3

((y){})()[1].x

ВАШ ОТВЕТ НА ВОПРОС