The default implementation of {@link ANTLRErrorStrategy#sync} makes sure
that the current lookahead symbol is consistent with what were expecting
at this point in the ATN. You can call this anytime but ANTLR only
generates code to check before subrules/loops and each iteration.
<p>Implements Jim Idle's magic sync mechanism in closures and optional
subrules. E.g.,</p>
<pre>
a : sync ( stuff sync )* ;
sync : {consume to what can follow sync} ;
</pre>
At the start of a sub rule upon error, {@link #sync} performs single
token deletion, if possible. If it can't do that, it bails on the current
rule and uses the default error recovery, which consumes until the
resynchronization set of the current rule.
<p>If the sub rule is optional ({@code (...)?}, {@code (...)*}, or block
with an empty alternative), then the expected set includes what follows
the subrule.</p>
<p>During loop iteration, it consumes until it sees a token that can start a
sub rule or what follows loop. Yes, that is pretty aggressive. We opt to
stay in the loop as long as possible.</p>
<p><strong>ORIGINS</strong></p>
<p>Previous versions of ANTLR did a poor job of their recovery within loops.
A single mismatch token or missing token would force the parser to bail
out of the entire rules surrounding the loop. So, for rule</p>
<pre>
classDef : 'class' ID '{' member* '}'
</pre>
input with an extra token between members would force the parser to
consume until it found the next class definition rather than the next
member definition of the current class.
<p>This functionality cost a little bit of effort because the parser has to
compare token set at the start of the loop and at each iteration. If for
some reason speed is suffering for you, you can turn off this
functionality by simply overriding this method as a blank { }.</p>
The default implementation of {@link ANTLRErrorStrategy#sync} makes sure that the current lookahead symbol is consistent with what were expecting at this point in the ATN. You can call this anytime but ANTLR only generates code to check before subrules/loops and each iteration.
<p>Implements Jim Idle's magic sync mechanism in closures and optional subrules. E.g.,</p>
<pre> a : sync ( stuff sync )* ; sync : {consume to what can follow sync} ; </pre>
At the start of a sub rule upon error, {@link #sync} performs single token deletion, if possible. If it can't do that, it bails on the current rule and uses the default error recovery, which consumes until the resynchronization set of the current rule.
<p>If the sub rule is optional ({@code (...)?}, {@code (...)*}, or block with an empty alternative), then the expected set includes what follows the subrule.</p>
<p>During loop iteration, it consumes until it sees a token that can start a sub rule or what follows loop. Yes, that is pretty aggressive. We opt to stay in the loop as long as possible.</p>
<p><strong>ORIGINS</strong></p>
<p>Previous versions of ANTLR did a poor job of their recovery within loops. A single mismatch token or missing token would force the parser to bail out of the entire rules surrounding the loop. So, for rule</p>
<pre> classDef : 'class' ID '{' member* '}' </pre>
input with an extra token between members would force the parser to consume until it found the next class definition rather than the next member definition of the current class.
<p>This functionality cost a little bit of effort because the parser has to compare token set at the start of the loop and at each iteration. If for some reason speed is suffering for you, you can turn off this functionality by simply overriding this method as a blank { }.</p>