bugfix: Fix improper state generation in setShiftAction

Previously, setShiftAction could modify
an already populated state instead of
regenerating its successor. This is
problematic because

0. the modified state was then not marked
   for regeneration, so it could be left
   in an inconsisten state
1. the modified state could also be a successor
   of another state and the modification could
   hypothetically be incorrect for that state

package.json

@@ -1,6 +1,6 @@
 {
   "name": "lr-parser-typescript",
-  "version": "1.1.1",
+  "version": "1.1.2",
   "scripts": {
     "build": "rm -rf ./local/out \n tsc",
     "prepublishOnly": "yarn run build && yarn run test",

src/_tests/grammar-5.ts

@@ -28,5 +28,5 @@ matchValueProcedureCall.match = ProcedureCall;
 matchValueExprRung.match = ExprRung;
 
 export const parser = new Parser(ExprRung, {
-  logLevel: LogLevel.verbose,
+  logLevel: LogLevel.none,
 });

src/_tests/grammar-6.test.ts

@@ -0,0 +1,32 @@
+import { LetDeclaration, parser } from "./grammar-6.js";
+import { ParseError } from "../parser/parser.js";
+
+describe('Parser', () => {
+  it('does not parse ""', () => {
+    const result = parser.parse('');
+
+    expect(result).toBeInstanceOf(ParseError);
+  });
+
+  it('does not parse "l"', () => {
+    const result = parser.parse('l');
+
+    expect(result).toBeInstanceOf(ParseError);
+  });
+
+  it('parses "l{}"', () => {
+    const result = parser.parse('l{}');
+
+    expect(result).toBeInstanceOf(LetDeclaration);
+    expect(result as LetDeclaration).toHaveProperty('body', []);
+  });
+
+  it('parses "l{l{}}"', () => {
+    const result = parser.parse('l{l{}}');
+
+    expect(result).toBeInstanceOf(LetDeclaration);
+    expect(result as LetDeclaration).toHaveProperty('body', [
+      expect.any(LetDeclaration),
+    ]);
+  });
+});

src/_tests/grammar-6.ts

@@ -0,0 +1,23 @@
+import { Caten, Maybe, MatchArr, SyntaxTreeNode } from "#pattern";
+import { LogLevel } from "../parser/table/generate-table.js";
+import { Parser } from "../parser/parser.js";
+
+
+export class LetDeclaration extends SyntaxTreeNode {
+  body!: LetDeclaration[];
+
+  static pattern: Caten = new Caten(
+    'l',
+    '{',
+    new Maybe(
+      new MatchArr('body', LetDeclaration),
+    ),
+    '}',
+  );
+}
+
+export const parser = new Parser(LetDeclaration, {
+  logLevel: LogLevel.verbose,
+});
+
+parser.parse('l{l{}}');

src/parser/table/parser-state.ts

@@ -120,19 +120,18 @@ export class ParserState {
     under: GrammarSymbol | null,
     ruleAt: RuleAt,
   ): GrammarConflict | null {
-    if (!this.actions.has(under)) {
-      this.actions.set(
-        under,
-        new ParserState([], [ ...this.exampleLane, under ]),
-      );
-    }
-
-    const maybeParserState = this.actions.get(under)!;
+    let maybeParserState = this.actions.get(under);
 
     if (maybeParserState instanceof GrammarRule) {
       return new GrammarConflict(this, under, maybeParserState);
     }
 
+    if (!maybeParserState || maybeParserState.isPopulated()) {
+      maybeParserState = new ParserState([], [ ...this.exampleLane, under ]);
+
+      this.actions.set(under, maybeParserState);
+    }
+
     maybeParserState.insert(ruleAt);
 
     return null;