Controlling Parameter Slurping

I'm trying to write a grammar that supports functions calls without using parentheses:

f x, y

As in Haskell, I'd like function calls to minimally slurp up their parameters. That is, I want

g 5 + 3

to mean

(g 5) + 3

instead of

g (5 + 3)

Unfortunately, I'm getting the second parse with this grammar:

grammar Parameters;

expr
  : '(' expr ')'
  | expr MULTIPLICATIVE_OPERATOR expr
  | expr ADDITIVE_OPERATOR expr
  | ID (expr (',' expr)*?)??
  | INT
  ;

MULTIPLICATIVE_OPERATOR: [*/%];
ADDITIVE_OPERATOR: '+';

ID: [a..z]+;
INT: '-'? [0-9]+;
WHITESPACE: [ \t\n\r]+ -> skip;

The parse tree I'm getting is this:

I had thought that the subrule listed first would get attempted first. In this case, expr ADDITIVE_OPERATOR expr appears before the ID subrule, so why is the ID subrule taking higher precedence?

In this case ANTLR does not the correct rule transformation (to eliminate left recursion and to handle precedences):

expr
    : expr_1[0]
    ;

expr_1[int p]
    : ('(' expr_1[0] ')' | INT | ID (expr_1[0] (',' expr_1[0])*?)??)
      ( {4 >= $p}? MULTIPLICATIVE_OPERATOR expr_1[5]
      | {3 >= $p}? ADDITIVE_OPERATOR expr_1[4]
      )*
    ;

leading to (expr (expr_1 a (expr_1 5 + (expr_1 3))))

correct would be:

expr
    : expr_1[0]
    ;

expr_1[int p]
  : ('(' expr_1[0] ')' | INT | ID (expr_1[5] (',' expr_1[5])*?)??)
  ( {4 >= $p}? MULTIPLICATIVE_OPERATOR expr_1[5]
  | {3 >= $p}? ADDITIVE_OPERATOR expr_1[4]
  )*
  ;

leading to (expr (expr_1 a (expr_1 5) + (expr_1 3)))

I am not certain if this is a bug in ANTLR4 or a trade-off of the transformation algorithm. Perhaps one should write an issue to the ANTLR4 jira.

To solve your problem you can simply put the correctly transformed grammar into your code and it should work. The explanation of rule transformation is found in "The Definitive ANTLR4 Reference" on pages 249ff (and perhaps somewhere on the web).