feat: 🎸 add codegen for a rule

Author: streamich

src/codegen/CodegenGrammar.ts

@@ -0,0 +1,59 @@
+// import {Codegen} from '@jsonjoy.com/util/lib/codegen'
+// import {dynamicFunction} from '@jsonjoy.com/util/lib/codegen/dynamicFunction'
+// import {emitStringMatch} from '@jsonjoy.com/util/lib/codegen/util/helpers';
+// import {RegExpTerminalMatch, StringTerminalMatch} from '../matches';
+// import {scrub} from '../util';
+// import type {Grammar, Rule, MatchParser} from '../types';
+
+// export class CodegenGrammar {
+//   public static readonly compile = (grammar: Grammar): MatchParser => {
+//     const codegen = new CodegenGrammar(grammar);
+//     codegen.generate();
+//     return codegen.compile();
+//   };
+
+//   public readonly codegen: Codegen<MatchParser>;
+//   protected readonly rules = new Map<string, MatchParser>();
+
+//   constructor(public readonly grammar: Grammar) {
+//     this.codegen = new Codegen({
+//       args: ['str', 'pos'],
+//     });
+//   }
+
+//   protected compileRule(name: string, rule: Rule): MatchParser {
+//     const {codegen} = this;
+//     const {match} = rule;
+//     const codegenProduction = dynamicFunction<MatchParser>(codegen);
+//     codegenProduction(`
+//       const results = [];
+//       ${match.map((m, i) => {
+//         const dep = codegen.linkDependency(m);
+//         return `
+//           const r${i} = ${dep}(str, pos);
+//           if (!r${i}) return;
+//           pos = r${i}.end;
+//           results.push(r${i});
+//         `;
+//       }).join('\n')}
+//       return {kind: '${name}', pos, end: pos, children: results};
+//     `);
+//     return codegenProduction.compile();
+//   }
+
+//   public generate() {
+//     const {codegen, grammar} = this;
+//     const {start, rules} = grammar;
+//     // for (const [name, rule] of Object.entries(rules)) {
+//     //   const dep = codegen.linkDependency(this.compileRule(name, rule));
+//     //   this.rules.set(name, dep);
+//     // }
+//     // const start = this.rules.get(grammar.start);
+//     // if (!start) throw new Error('INVALID_START_SYMBOL');
+//     // codegen.return(`${start}(str, pos)`);
+//   }
+
+//   public compile(): MatchParser {
+//     return this.codegen.compile();
+//   }
+// }

src/codegen/CodegenRule.ts

@@ -0,0 +1,51 @@
+import {Codegen} from '@jsonjoy.com/util/lib/codegen'
+import {RuleMatch} from '../matches';
+import type {MatchParser, Rule, RuleParser} from '../types';
+import {scrub} from '../util';
+
+export class CodegenRule {
+  public static readonly compile = (kind: string, rule: Rule, alternatives: MatchParser[]): RuleParser => {
+    const codegen = new CodegenRule(kind, rule, alternatives);
+    codegen.generate();
+    return codegen.compile();
+  };
+
+  public readonly codegen: Codegen<RuleParser>;
+
+  constructor(
+    public readonly kind: string,
+    public readonly rule: Rule,
+    public readonly alternatives: MatchParser[],
+  ) {
+    this.codegen = new Codegen({
+      args: ['str', 'pos'],
+    });
+  }
+
+  public generate() {
+    const {codegen, alternatives} = this;
+    const deps: string[] = [];
+    const dRM = codegen.linkDependency(RuleMatch);
+    const kind = scrub(this.kind);
+    for (const matcher of alternatives)
+      deps.push(codegen.linkDependency(matcher));
+    const rMatch = codegen.var(`${deps.join('(str, pos) || ')}(str, pos)`);
+    codegen.if(`!${rMatch}`, () => {
+      codegen.return('');
+    });
+    const rEnd = codegen.var();
+    const rChildren = codegen.var();
+    codegen.if(`${rMatch} instanceof Array`, () => {
+      codegen.js(`${rEnd} = ${rMatch}[${rMatch}.length - 1].end;`);
+      codegen.js(`${rChildren} = ${rMatch};`);
+    }, () => {
+      codegen.js(`${rEnd} = ${rMatch}.end;`);
+      codegen.js(`${rChildren} = [${rMatch}];`);
+    });
+    codegen.return(`new ${dRM}('${kind}', pos, ${rEnd}, ${rChildren})`);
+  }
+
+  public compile(): RuleParser {
+    return this.codegen.compile();
+  }
+}

src/codegen/__tests__/CodegenRule.spec.ts

@@ -0,0 +1,26 @@
+import {Rule} from '../../types';
+import {CodegenRule} from '../CodegenRule';
+import {CodegenTerminal} from '../CodegenTerminal';
+
+describe('CodegenRule', () => {
+  test('can parse a simple rule', () => {
+    const rule: Rule = {
+      match: ['foo', 'bar'],
+    };
+    const foo = CodegenTerminal.compile('foo');
+    const bar = CodegenTerminal.compile('bar');
+    const parse = CodegenRule.compile('FooOrBar', rule, [foo, bar]);
+    expect(parse('.foo', 1)).toEqual({
+      kind: 'FooOrBar',
+      pos: 1,
+      end: 4,
+      children: [{end: 4, kind: 'Text', pos: 1, text: 'foo'}],
+    });
+    expect(parse('bar', 0)).toEqual({
+      kind: 'FooOrBar',
+      pos: 0,
+      end: 3,
+      children: [{end: 3, kind: 'Text', pos: 0, text: 'bar'}],
+    });
+  });
+});

src/matches.ts

@@ -24,3 +24,14 @@ export class StringTerminalMatch<Kind extends string = string> extends BaseMatch
 
 export class RegExpTerminalMatch<Kind extends string = string> extends BaseMatch<Kind> {
 }
+
+export class RuleMatch<Kind extends string = string> extends BaseMatch<Kind> {
+  constructor (
+    kind: Kind,
+    pos: number,
+    end: number,
+    public readonly children: BaseMatch[],
+  ) {
+    super(kind, pos, end);
+  }
+}

src/types.ts

@@ -1,4 +1,5 @@
 import {Expr} from 'json-joy/lib/json-expression';
+import {RuleMatch} from './matches';
 
 export type MaybeArray<T> = T | T[];
 
@@ -53,5 +54,5 @@ export interface MatchResult {
 export type ProductionResult = MatchResult[];
 
 export type MatchParser = (str: string, pos: number) => MatchResult | undefined;
-
 export type ProductionParser = (str: string, pos: number) => ProductionResult | undefined;
+export type RuleParser = (str: string, pos: number) => RuleMatch | undefined;