How to force parser to treat identifier as function call when arguments are incomplete?

[sho94os]

Hi, I'm implementing a grammar and running into an issue where the parser treats a function name as an Identifier instead of a FunctionCall when the argument list is incomplete, like this:

hier is my grammar,

grammar HelloWorld

// ----------------------------
// ----- AST Interfaces -------
// ----------------------------

interface Expression{

}

interface BinaryExpression extends Expression {
    left: Expression
    operator: string
    right: Expression
}

interface UnaryExpression extends Expression {
    operator: string
    value: Expression
}

interface RangeExpression extends Expression {
    start: Expression
    end?: Expression
}


interface NumberLiteral extends Expression {
    value: string
}

interface Identifier extends Expression {
    name: string
}

interface StringLiteral extends Expression {
    value: string
}

interface ListLiteral extends Expression {
    elements: Expression[]
}

interface MissingExpr extends Expression{
   
}

interface FunctionCall extends Expression {
    functionName: Identifier
    arguments: Expression[]
}



// ----------------------------
// ----- Parser Rules --------
// ----------------------------

entry Program:
    expression+=Expr*
;

Expr returns Expression:
    LogicNot ({BinaryExpression.left=current} operator=('and' | 'or') right=LogicNot)*
;

LogicNot returns Expression:
    {UnaryExpression} operator='not' value=EqualOrNot
    | EqualOrNot
;

EqualOrNot returns Expression:
    Compare ({BinaryExpression.left=current} operator=('=' | '!=') right=Compare)*
;

Compare returns Expression:
    BitOrXor ({BinaryExpression.left=current} operator=('<' | '>' | '<=' | '>=') right=BitOrXor)*
;

BitOrXor returns Expression:
    BitAnd ({BinaryExpression.left=current} operator=('|' | '^') right=BitAnd)*
;

BitAnd returns Expression:
    BitShift ({BinaryExpression.left=current} operator='&' right=BitShift)*
;

BitShift returns Expression:
    Arithmetic ({BinaryExpression.left=current} operator=('<<' | '>>') right=Arithmetic)*
;

Arithmetic returns Expression:
    Term ({BinaryExpression.left=current} operator=('+' | '-') right=Term)*
;

Term returns Expression:
    Range ({BinaryExpression.left=current} operator=('*' | '/' | '%' | '**' | '^^') right=Range)*
;

Range returns Expression:
    Factor ({RangeExpression.start=current} ':' end=Factor)?
;

Factor returns Expression:
      {UnaryExpression} operator=('+' | '-') value=Factor
    | {UnaryExpression} operator='~' value=Expr
    | FunctionCall
    | IdRef
    | NumLiteral
    | StrLiteral
    | ListLiteral
    | '(' Expr ')'


;

// ----------------------------
// ----- Leaf Rules ----------
// ----------------------------

FunctionCall returns FunctionCall:
    {FunctionCall} functionName=IdRef '(' ')'
  | {FunctionCall} functionName=IdRef '(' arguments+=Expr (',' arguments+=Expr)* ')'
   
;


IdRef returns Identifier:
    {Identifier} name=ID
;

NumLiteral returns NumberLiteral:
    {NumberLiteral} value=INT
;

StrLiteral returns StringLiteral:
    {StringLiteral} value=STRING
  | {StringLiteral} value=DQ_STRING
  | {StringLiteral} value=BT_STRING
;

ListLiteral returns ListLiteral:
      {ListLiteral} '[' ']'
    | {ListLiteral} '[' elements+=Expr (',' elements+=Expr)* ']'
;





// ----------------------------
// ----- Terminals -----------
// ----------------------------

terminal ID: /[_a-zA-Z_@$][_@$a-zA-Z0-9]*/;
terminal INT: /[0-9]+/;
terminal STRING: /"[^"]*"/;
terminal DQ_STRING: /'[^']*'/;
terminal BT_STRING: /`[^`]*`/;



hidden terminal WS: /\s+/;
hidden terminal ML_COMMENT: /\/\*(.|\n)*?\*\//;
hidden terminal SL_COMMENT: /\/\/[^\n]*/;

**when the Input

52 + myfunc(1, ) // incomplete**

the result

**but when the input correct is 52 + myfunc(1, 2 )

the output look**

[msujew]

Hey @sho94os,

unfortunately, influencing the error recovery by itself is not possible. There are however a few grammar changes you can perform in order to prevent issues like these. For example, I would always recommend to parse identifiers and function calls in one rule. See langium-lox for example.

I've adjusted your grammar slightly in a few places. It now works as expected. See this playground link.

[sho94os]

I use the playground to write my grammar and look at the tree before I go into the code phase.

i have noticed with changes you have provided:
that the function name is no longer shown in the tree.

Is it possible to access it later in the code? or what should I do to show the function name in the tree?

[msujew]

That's a bug that was fixed in #1547 (v3.3.0 of Langium). The playground is still using an older version of Langium currently (v3.0 IIRC).

[sho94os]

thanks again for your help

[sho94os]

hi @msujew

I have finished writing my grammar here.

but I have a question about the priority of the rules.

Is it possible to give a rule a high priority?

hier shared grammar langium.org/playground

in this case when the expr after operator += missing the function defnition will be not showing in the tree.

it is possible to tell the grammar i want to give functions and classes and packages the high priority?

[msujew]

No, as said earlier, it's generally not possible to influence the error recovery behavior. Chevrotain just does not expose any API for that.