Antlr deep rule set performance issue - antlr4

Question

I've tried making a grammar that understands expression priorities for a C#-like language:
var a = expression0.expression1(expression2 + expression3() * expression4)
When correctly prioritized becomes:
var a = (expression0.expression1)(expression2 + ((expression3()) * expression4))
To achieve that, I've sorted the expressions into rules by priority. Here's the relevant excerpt from my grammar:
expression: assignmentExpression;
assignmentExpression
: equalityExpression ASSIGNMENT assignmentExpression
| equalityExpression
;
equalityExpression
: logicalExpression equals equalityExpression
| logicalExpression notEquals equalityExpression
| logicalExpression
;
logicalExpression
: relationalExpression and logicalExpression
| relationalExpression or logicalExpression
| relationalExpression
;
relationalExpression
: addExpression greaterThan relationalExpression
| addExpression lessThan relationalExpression
| addExpression greaterOrEquals relationalExpression
| addExpression lessOrEquals relationalExpression
| addExpression
;
addExpression
: multiplyExpression add addExpression
| multiplyExpression subtract addExpression
| multiplyExpression
;
multiplyExpression
: conversionExpression multiply multiplyExpression
| conversionExpression divide multiplyExpression
| conversionExpression
;
conversionExpression
: unaryExpression AS conversionExpression
| unaryExpression
;
unaryExpression
: subtract unaryExpression
| add unaryExpression
| ifExpression
;
ifExpression
: IF PAREN expression ENDPAREN expression (ELSE expression)?
| instantiationExpression
;
instantiationExpression
: NEW invocationExpression
| invocationExpression
;
invocationExpression
: reachExpression PAREN arguments? ENDPAREN
| reachExpression
;
reachExpression
: primeExpression DOT primeExpression
| primeExpression
;
Using it on the following code:
{ int a = 7 }
Produces the following output:
expression
assignmentExpression
equalityExpression
logicalExpression
relationalExpression
addExpression
multiplyExpression
conversionExpression
unaryExpression
ifExpression
instantiationExpression
invocationExpression
reachExpression
primeExpression
blockExpression
"{"
statement
variableDeclaration
variableType
type
identifier
"int"
identifier
"a"
variableInitialization
"="
expression
assignmentExpression
equalityExpression
logicalExpression
relationalExpression
addExpression
multiplyExpression
conversionExpression
unaryExpression
ifExpression
instantiationExpression
invocationExpression
reachExpression
primeExpression
literal
integer
"7"
"}"
It probably has problems, but I can't really test it, since this kind of grammar incurs a crazy performance penalty. My previous grammar that parsed expressions left to right took a couple of milliseconds to parse, and this one takes 2 whole minutes.
I've tracked it down to ParserATNSimulator.AdaptivePredict, and deeper inside, the issue is a crazy deep stack of
ParserATNSimulator.Closure
ParserATNSimulator.ClosureCheckingStopState
ParserATNSimulator.Closure_
Instead of going down the rabbit hole once to get to the correct expression (number literal: 7), it seems to go all the way down once for every rule level. So instead of this being O(n), it takes O(n^n) just to get to that damn "7".
Is this an issue with Antlr, my grammar or just the way it is?
EDIT:
OK, I've managed to eliminate the performance issue by rewriting my grammar in this style:
assignmentExpression: equalityExpression (ASSIGNMENT assignmentExpression)?;
But I still don't understand why this happens and how did this change solve the issue.