parser-lr 0.4.1 → 0.6.0

package/grammars/fixtures/build-optional/build-optional.grammar

@@ -0,0 +1,32 @@
+name "build-optional-repro" ;
+
+tokens
+    kw_cls = /CLS/i ;
+    kw_with = /WITH/i ;
+    ident = /[a-z]+/ ;
+
+skip
+    whitespace = /[ \t\r\n]+/ ;
+
+start program_line ;
+
+grammar
+    program_line =
+        #statement [stmt]:cls_stmt
+      ;
+
+    cls_stmt =
+        kw_cls [ kw_with ident ]
+      ;
+
+ast
+    cls_stmt =
+        #main kw_cls [withKw]:kw_with [target]:ident
+      ;
+
+transform
+    cls_stmt ->
+        #main cls_stmt.#main(kw_cls, withKw, target) ;
+
+    program_line ->
+        #statement pass(stmt) ;

package/grammars/fixtures/build-optional/input.txt

@@ -0,0 +1 @@
+CLS

package/grammars/fixtures/comparison-op/comparison-op.grammar

@@ -0,0 +1,28 @@
+name "comparison-op-repro" ;
+
+tokens
+    kw_case = /CASE/i ;
+    kw_is = /IS/i ;
+    less = /</ ;
+    greater = />/ ;
+    number = /[0-9]+/ ;
+
+skip
+    whitespace = /[ \t\r\n]+/ ;
+
+start case_selector ;
+
+grammar
+    case_selector =
+        #relational kw_case kw_is comparison_op postfix_expr
+      | #value postfix_expr
+      ;
+
+    comparison_op =
+        #less less
+      | #greater greater
+      ;
+
+    postfix_expr =
+        number
+      ;

package/grammars/fixtures/comparison-op/input.txt

@@ -0,0 +1 @@
+CASE IS < 0

package/grammars/fixtures/flatten-repeat/flatten-repeat.grammar

@@ -0,0 +1,28 @@
+name "flatten-repeat-repro" ;
+
+tokens
+    ident = /[a-z]+/ ;
+    comma = /,/ ;
+
+skip
+    whitespace = /[ \t\r\n]+/ ;
+
+start list ;
+
+grammar
+    list =
+        #list [first]:item { comma [rest]:item }
+      ;
+
+    item =
+        ident
+      ;
+
+ast
+    list =
+        #list [first]:item { [rest]:item }
+      ;
+
+transform
+    list ->
+        #list flatten(list.#list, first, list$repeat_0) ;

package/grammars/fixtures/flatten-repeat/input.txt

@@ -0,0 +1 @@
+a,b,c

package/grammars/fixtures/help-topic/help-topic.grammar

@@ -0,0 +1,28 @@
+name "help-topic-repro" ;
+
+tokens
+    kw_help = /HELP/i ;
+    kw_print = /PRINT/i ;
+
+skip
+    whitespace = /[ \t\r\n]+/ ;
+
+start program_line ;
+
+grammar
+    program_line =
+        #statement [stmt]:help_stmt
+      ;
+
+    help_stmt =
+        kw_help help_topic
+      ;
+
+    help_topic =
+        #keyword kw_print
+      | #punct kw_print
+      ;
+
+transform
+    program_line ->
+        #statement pass(stmt) ;

package/grammars/fixtures/help-topic/input.txt

@@ -0,0 +1 @@
+HELP PRINT

package/grammars/fixtures/let-target/input.txt

@@ -0,0 +1 @@
+LET x% = 1

package/grammars/fixtures/let-target/let-target.grammar

@@ -0,0 +1,33 @@
+name "let-target-repro" ;
+
+tokens
+    kw_let = /LET/i ;
+    identifier = /[a-z][a-z0-9%]*/i ;
+    equal = /=/ ;
+    number = /[0-9]+/ ;
+
+skip
+    whitespace = /[ \t\r\n]+/ ;
+
+start program_line ;
+
+grammar
+    program_line =
+        #statement [stmt]:let_stmt
+      ;
+
+    let_stmt =
+        kw_let let_target equal expr
+      ;
+
+    let_target =
+        identifier
+      ;
+
+    expr =
+        number
+      ;
+
+transform
+    program_line ->
+        #statement pass(stmt) ;

package/grammars/fixtures/nested-production-repro/input.txt

@@ -0,0 +1 @@
+CASE IS < 0

package/grammars/fixtures/nested-production-repro/nested-production-repro.grammar

@@ -0,0 +1,26 @@
+name "nested-production-repro" ;
+
+tokens
+    kw_is = /IS/i ;
+    kw_case = /CASE/i ;
+    less = /</ ;
+    integer = /[0-9]+/ ;
+
+skip
+    whitespace = /[ \t\r\n]+/ ;
+
+start line ;
+
+grammar
+    line = kw_case case_selector ;
+    case_selector = #relational kw_is comparison_op integer ;
+    comparison_op = #less [tok]:less ;
+
+ast
+    comparison_op =
+        #less [tok]:less
+      ;
+
+transform
+    comparison_op ->
+        #less comparison_op.#less(tok) ;

package/grammars/fixtures/pass-preserves-production/bare-terminal/bare-terminal.grammar

@@ -0,0 +1,24 @@
+name "pass-collapse-repro" ;
+
+tokens
+    kw_cls = /CLS/i ;
+    kw_with = /WITH/i ;
+    ident = /[a-z]+/ ;
+
+skip
+    whitespace = /[ \t\r\n]+/ ;
+
+start program_line ;
+
+grammar
+    program_line =
+        #statement [stmt]:cls_stmt
+      ;
+
+    cls_stmt =
+        kw_cls [ kw_with ident ]
+      ;
+
+transform
+    program_line ->
+        #statement pass(stmt) ;

package/grammars/fixtures/pass-preserves-production/bare-terminal/input.txt

@@ -0,0 +1 @@
+CLS

package/grammars/fixtures/pass-preserves-production/labeled-variant/input-end-if.txt

@@ -0,0 +1 @@
+END IF

package/grammars/fixtures/pass-preserves-production/labeled-variant/input-end.txt

@@ -0,0 +1 @@
+END

package/grammars/fixtures/pass-preserves-production/labeled-variant/labeled-variant.grammar

@@ -0,0 +1,24 @@
+name "labeled-variant-repro" ;
+
+tokens
+    kw_end = /END/i ;
+    kw_if = /IF/i ;
+
+skip
+    whitespace = /[ \t\r\n]+/ ;
+
+start program_line ;
+
+grammar
+    program_line =
+        #statement [stmt]:end_stmt
+      ;
+
+    end_stmt =
+        #program kw_end
+      | #if kw_end kw_if
+      ;
+
+transform
+    program_line ->
+        #statement pass(stmt) ;

package/grammars/fixtures/pass-preserves-production/optional-absent/input.txt

@@ -0,0 +1 @@
+CLS

package/grammars/fixtures/pass-preserves-production/optional-absent/optional-absent.grammar

@@ -0,0 +1,24 @@
+name "optional-absent-repro" ;
+
+tokens
+    kw_cls = /CLS/i ;
+    kw_with = /WITH/i ;
+    ident = /[a-z]+/ ;
+
+skip
+    whitespace = /[ \t\r\n]+/ ;
+
+start program_line ;
+
+grammar
+    program_line =
+        #statement [stmt]:cls_stmt
+      ;
+
+    cls_stmt =
+        kw_cls [ kw_with ident ]
+      ;
+
+transform
+    program_line ->
+        #statement pass(stmt) ;

package/grammars/fixtures/pass-preserves-production/optional-present/input.txt

@@ -0,0 +1 @@
+CLS WITH foo

package/grammars/fixtures/pass-preserves-production/optional-present/optional-present.grammar

@@ -0,0 +1,24 @@
+name "optional-present-repro" ;
+
+tokens
+    kw_cls = /CLS/i ;
+    kw_with = /WITH/i ;
+    ident = /[a-z]+/ ;
+
+skip
+    whitespace = /[ \t\r\n]+/ ;
+
+start program_line ;
+
+grammar
+    program_line =
+        #statement [stmt]:cls_stmt
+      ;
+
+    cls_stmt =
+        kw_cls [ kw_with ident ]
+      ;
+
+transform
+    program_line ->
+        #statement pass(stmt) ;

package/grammars/fixtures/table-only-import/calc.table.json

@@ -0,0 +1,190 @@
+{
+    "version": 2,
+    "algorithm": "lalr",
+    "grammarName": "calc",
+    "startSymbol": "expr",
+    "tokens": [
+        "number",
+        "plus",
+        "$eof"
+    ],
+    "tokenRules": [
+        {
+            "name": "number",
+            "pattern": "[0-9]+",
+            "flags": ""
+        },
+        {
+            "name": "plus",
+            "pattern": "\\+",
+            "flags": ""
+        }
+    ],
+    "skipRules": [
+        {
+            "name": "whitespace",
+            "pattern": "[ \\t\\r\\n]+",
+            "flags": ""
+        }
+    ],
+    "states": [],
+    "parserStateCount": 5,
+    "productions": [
+        {
+            "id": 0,
+            "name": "expr",
+            "rhs": [
+                "[left]:expr",
+                "[operator]:plus",
+                "[right]:number"
+            ],
+            "variant": "binary",
+            "origin": "expr"
+        },
+        {
+            "id": 1,
+            "name": "expr",
+            "rhs": [
+                "number"
+            ],
+            "variant": "literal",
+            "origin": "expr"
+        },
+        {
+            "id": 2,
+            "name": "$accept",
+            "rhs": [
+                "expr"
+            ],
+            "variant": null,
+            "origin": "$accept"
+        }
+    ],
+    "actions": [
+        {
+            "state": 0,
+            "symbol": "number",
+            "kind": "shift",
+            "target": 2
+        },
+        {
+            "state": 1,
+            "symbol": "$eof",
+            "kind": "accept"
+        },
+        {
+            "state": 1,
+            "symbol": "plus",
+            "kind": "shift",
+            "target": 3
+        },
+        {
+            "state": 2,
+            "symbol": "$eof",
+            "kind": "reduce",
+            "productionId": 1
+        },
+        {
+            "state": 2,
+            "symbol": "plus",
+            "kind": "reduce",
+            "productionId": 1
+        },
+        {
+            "state": 3,
+            "symbol": "number",
+            "kind": "shift",
+            "target": 4
+        },
+        {
+            "state": 4,
+            "symbol": "$eof",
+            "kind": "reduce",
+            "productionId": 0
+        },
+        {
+            "state": 4,
+            "symbol": "plus",
+            "kind": "reduce",
+            "productionId": 0
+        }
+    ],
+    "gotos": [
+        {
+            "state": 0,
+            "symbol": "expr",
+            "target": 1
+        }
+    ],
+    "ast": [
+        {
+            "name": "expr",
+            "expression": {
+                "kind": "choice",
+                "alternatives": [
+                    {
+                        "label": "binary",
+                        "expression": {
+                            "kind": "sequence",
+                            "elements": [
+                                {
+                                    "kind": "boundReference",
+                                    "binding": "left",
+                                    "name": "expr"
+                                },
+                                {
+                                    "kind": "boundReference",
+                                    "binding": "operator",
+                                    "name": "plus"
+                                },
+                                {
+                                    "kind": "boundReference",
+                                    "binding": "right",
+                                    "name": "number"
+                                }
+                            ]
+                        }
+                    },
+                    {
+                        "label": "literal",
+                        "expression": {
+                            "kind": "reference",
+                            "name": "number"
+                        }
+                    }
+                ]
+            }
+        }
+    ],
+    "transform": [
+        {
+            "production": "expr",
+            "alternatives": [
+                {
+                    "label": "binary",
+                    "expression": {
+                        "kind": "build",
+                        "typeName": "expr",
+                        "variant": "binary",
+                        "arguments": [
+                            "left",
+                            "operator",
+                            "right"
+                        ]
+                    }
+                },
+                {
+                    "label": "literal",
+                    "expression": {
+                        "kind": "build",
+                        "typeName": "expr",
+                        "variant": "literal",
+                        "arguments": [
+                            "number"
+                        ]
+                    }
+                }
+            ]
+        }
+    ]
+}

package/grammars/fixtures/table-only-import/table-only-smoke.cjs

@@ -0,0 +1,38 @@
+const { readFileSync } = require('node:fs');
+const { join } = require('node:path');
+
+const fs = require('node:fs');
+const originalReadFileSync = fs.readFileSync;
+let readMetaGrammar = false;
+
+fs.readFileSync = function patchedReadFileSync(path, ...rest)
+{
+    if (String(path).endsWith('grammar.json'))
+    {
+        readMetaGrammar = true;
+    }
+
+    return originalReadFileSync.call(this, path, ...rest);
+};
+
+const { ParseContext } = require('parser-lr');
+
+const tableJson = readFileSync(
+    join(__dirname, 'calc.table.json'),
+    'utf8',
+);
+
+const context = ParseContext.fromTableJson(tableJson);
+const ast = context.parseSource('1 + 2');
+
+if (ast === null)
+{
+    throw new Error('table-only smoke (cjs): expected a non-null AST');
+}
+
+if (readMetaGrammar)
+{
+    throw new Error('table-only smoke (cjs): unexpected grammar.json read');
+}
+
+process.stdout.write(`cjs ${ast.symbol}\n`);

package/grammars/fixtures/table-only-import/table-only-smoke.mjs

@@ -0,0 +1,18 @@
+import { readFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+import { ParseContext } from 'parser-lr';
+
+const here = dirname(fileURLToPath(import.meta.url));
+const tableJson = readFileSync(join(here, 'calc.table.json'), 'utf8');
+
+const context = ParseContext.fromTableJson(tableJson);
+const ast = context.parseSource('1 + 2');
+
+if (ast === null)
+{
+    throw new Error('table-only smoke (mjs): expected a non-null AST');
+}
+
+process.stdout.write(`mjs ${ast.symbol}\n`);