Improve repetition re-sync recovery.

fixes #133

docs/tutorial/step4_fault_tolerance.md

@@ -103,7 +103,7 @@ Repetition re-sync recovery happens when:
 * The next token X is invalid right after the repetition ended.
 
 In such a situation the parser will attempt to skip tokens until it detects the beginning of a another iteration of
-the repetition.
+the repetition **or** the token it originally expected after the last iteration.
 
 There are a couple of edge cases in which **other** recovery methods will be preferred:
 * If single token insertion/deletion can be performed, it is always preferred as it skips fewer tokens.

src/parse/parser_public.ts

@@ -1114,16 +1114,25 @@ export class Parser {
         let nextTokenWithoutResync = this.NEXT_TOKEN()
         let currToken = this.NEXT_TOKEN()
         let passedResyncPoint = false
+
+        let generateErrorMessage = () => {
+            // we are preemptively re-syncing before an error has been detected, therefor we must reproduce
+            // the error that would have been thrown
+            let expectedTokName = tokenName(expectedTokType)
+            let msg = "Expecting token of type -->" + expectedTokName +
+                "<-- but found -->'" + nextTokenWithoutResync.image + "'<--"
+            this.SAVE_ERROR(new exceptions.MismatchedTokenException(msg, nextTokenWithoutResync))
+        }
+
         while (!passedResyncPoint) {
+            // re-synced to a point where we can safely exit the repetition/
+            if (currToken instanceof expectedTokType) {
+                generateErrorMessage()
+                return // must return here to avoid reverting the inputIdx
+            }
             // we skipped enough tokens so we can resync right back into another iteration of the repetition grammar rule
             if (lookAheadFunc.call(this)) {
-                // we are preemptively re-syncing before an error has been detected, therefor we must reproduce
-                // the error that would have been thrown
-                let expectedTokName = tokenName(expectedTokType)
-                let msg = "Expecting token of type -->" + expectedTokName +
-                    "<-- but found -->'" + nextTokenWithoutResync.image + "'<--"
-                this.SAVE_ERROR(new exceptions.MismatchedTokenException(msg, nextTokenWithoutResync))
-
+                generateErrorMessage()
                 // recursive invocation in other to support multiple re-syncs in the same top level repetition grammar rule
                 grammarRule.apply(this, grammarRuleArgs)
                 return // must return here to avoid reverting the inputIdx

test/full_flow/error_recovery/switch_case/swithcase_recovery_spec.ts

@@ -117,7 +117,7 @@ describe("Error Recovery switch-case Example", () => {
         })
     })
 
-    it("can also sometimes fail in automatic error recovery :)", () => {
+    it("can perform re-sync recovery to the right curly after the case statements repetition", () => {
         let input = [
             // switch (name) {
             new SwitchTok(1, 1), new LParenTok(1, 1), new IdentTok("name", 0, 1, 1), new RParenTok(1, 1), new LCurlyTok(1, 1),
@@ -138,7 +138,11 @@ describe("Error Recovery switch-case Example", () => {
         let parseResult = parser.switchStmt()
         expect(parser.errors.length).to.equal(1)
         expect(parser.isAtEndOfInput()).to.equal(true)
-        expect(parseResult).to.deep.equal({})
+        expect(parseResult).to.deep.equal({
+            "Terry":   2,
+            "Robert":  4,
+            "Brandon": 6
+        })
     })
 
     it("can perform single token deletion recovery", () => {