@bablr/language-en-es6 0.2.0 → 0.3.0

package/lib/grammar.js

@@ -1,149 +1,331 @@
-/* @macrome
- * @generatedby @bablr/macrome-generator-bablr
- * @generatedfrom ./grammar.macro.js#6db663572ef553014ae1495b3d21522c3bc88f0c
- * This file is autogenerated. Please do not edit it directly.
- * When editing run `npx macrome watch` then change the file this is generated from.
- */
-import _applyDecs from "@babel/runtime/helpers/applyDecs2305";
-var _importMixin;
-let _initProto, _VariableDeclarationStatementDecs, _ForStatementDecs;
 import { re, spam as m } from '@bablr/boot';
-import { AllowEmpty, CoveredBy, Node } from '@bablr/helpers/decorators';
-import { eat, eatMatch, shiftMatch, match, o } from '@bablr/helpers/grammar';
+import {
+  eat,
+  eatMatch,
+  shiftMatch,
+  match,
+  o,
+  r,
+  shift,
+  getInstrMatcher,
+  eatHeld,
+} from '@bablr/helpers/grammar';
 import { triviaEnhancer } from '@bablr/helpers/trivia';
-import * as Comment from '@bablr/language-en-c-comments';
-import * as es5 from '@bablr/language-en-es5';
-import { mixin as classMixin } from './mixins/class.js';
-import { mixin as importMixin } from './mixins/import.js';
-import { mixin as functionMixin } from './mixins/function.js';
+import * as BTree from '@bablr/agast-helpers/btree';
+import Space from '@bablr/language-en-blank-space';
+import Comment from '@bablr/language-en-c-comments';
+import {
+  default as es5,
+  reservedWords,
+  unaryPrefixOperatorAlternatives,
+} from '@bablr/language-en-es5';
+import classMixin from './mixins/class.js';
+import importMixin from './mixins/import.js';
+import functionMixin from './mixins/function.js';
+import stringMixin from './mixins/string.js';
 import { buildPattern } from '@bablr/helpers/builders';
-import { unaryPrefixOperatorAlternatives } from '@bablr/language-en-es5';
-export const dependencies = {
-  Comment
-};
-export { powerLevels, reservedWords, assignmentOperators, assignmentOperatorAlternatives, unaryPrefixOperators, unaryPrefixOperatorAlternatives, unaryPostfixOperators, unaryPostfixOperatorAlternatives, getBinaryOperatorAlternatives } from '@bablr/language-en-es5';
+import Regex from './regex.js';
+import { getRoot, printSource } from '@bablr/agast-helpers/tree';
+import { reifyMatcherReferenceName } from '@bablr/agast-vm-helpers';
+import { Coroutine } from '@bablr/coroutine';
+
+export const dependencies = { Comment, Space, Regex };
+
+let runCo = (generator) => new Coroutine(generator).advance();
+
+export {
+  powerLevels,
+  reservedWords,
+  assignmentOperators,
+  assignmentOperatorAlternatives,
+  unaryPrefixOperators,
+  unaryPrefixOperatorAlternatives,
+  unaryPostfixOperators,
+  unaryPostfixOperatorAlternatives,
+  getBinaryOperatorAlternatives,
+} from '@bablr/language-en-es5';
+
+let reservedWords_ = new Set(reservedWords);
+
 export const canonicalURL = 'https://bablr.org/languages/universe/es6';
-export const defaultMatcher = m`.+: <_Expression />`;
-export const atrivialGrammar = class ES6Grammar extends (_importMixin = importMixin(classMixin(functionMixin(es5.atrivialGrammar)))) {
-  static {
-    [_initProto] = _applyDecs(this, [[AllowEmpty, 2, "Statement"], [_VariableDeclarationStatementDecs, 2, "VariableDeclarationStatement"], [_ForStatementDecs, 2, "ForStatement"], [Node, 2, "VariableDeclarator"], [Node, 2, "Property"]], [], 0, void 0, _importMixin).e;
-  }
-  constructor(...args) {
-    super(...args);
-    _initProto(this);
+
+export const defaultMatcher = m`_+: <_Expression />`;
+
+let unaryMatcher;
+
+const atrivial = class ES6Grammar extends importMixin(
+  classMixin(functionMixin(stringMixin(es5.grammar.atrivial))),
+) {
+  constructor() {
+    super();
+    this.emptyables = new Set([...(this.emptyables || []), 'Statement']);
   }
-  *[(_VariableDeclarationStatementDecs = [CoveredBy('Statement'), Node], _ForStatementDecs = [CoveredBy('Statement'), Node], "Expression")](args) {
+
+  *Expression(args) {
     let {
-      props: {
-        power = 34,
-        noIn = false
-      },
-      s
+      props: { power = 34, noIn = false },
+      getState,
     } = args;
+    let s = getState();
+    let yieldPower = 0; // TODO fixme
+
+    let sigil;
     let res;
     if (!s.holding) {
-      if (res = yield eatMatch(m`<ArrowFunctionExpression '(' />`)) {} else if (res = yield eatMatch(m`<ParenthesisExpression '(' />`)) {} else if (res = yield eatMatch(m`<__JSONExpression />`)) {} else if (res = yield eatMatch(m`<FunctionExpression 'function' />`)) {} else if (power >= 4 && (res = yield eatMatch(m`<UnaryExpression ${buildPattern(unaryPrefixOperatorAlternatives)} />`))) {} else if (power >= 4 && (res = yield eatMatch(m`<NewExpression 'new' />`, o({
-        power
-      })))) {} else if (res = yield eatMatch(m`<Identifier />`)) {}
-    } else {
-      if (res = yield eatMatch(m`<ArrowFunctionExpression /\g=\>/ />`)) {} else {
-        res = yield eatMatch(m`<__LogicExpression />`, o({
-          power,
-          noIn
-        }));
+      sigil = yield match(
+        re`/[\u0060({['"/\d]|(?:yield|function|class|super|new|this|true|false|null|Infinity|NaN)\b/`,
+      );
+      switch (printSource(sigil)) {
+        case '`':
+          res = yield eat(m`<TemplateString />`);
+          break;
+        case '/':
+          res = yield eat(m`:Regex: <Pattern />`);
+          break;
+        case '(':
+          if ((res = yield eatMatch(m`<ArrowFunctionExpression />`))) {
+          } else {
+            res = yield eat(m`<ParenthesisExpression />`);
+          }
+          break;
+        case 'yield':
+          if (power > yieldPower) {
+            res = yield eatMatch(m`<YieldExpression />`);
+          }
+          break;
+        case 'function':
+          res = yield eat(m`<FunctionExpression />`);
+          break;
+        case 'class':
+          res = yield eat(m`<ClassExpression />`);
+          break;
+        case 'super':
+          res = yield eat(m`<SuperExpression />`);
+          break;
+        case 'true':
+        case 'false':
+        case 'null':
+        case 'Infinity':
+        case 'NaN':
+        case '[':
+        case '{':
+        case '"':
+        case "'":
+        case '0':
+        case '1':
+        case '2':
+        case '3':
+        case '4':
+        case '5':
+        case '6':
+        case '7':
+        case '8':
+        case '9':
+          res = yield eat(m`<_JSONExpression  />`);
+          break;
+
+        case 'new':
+          if (power >= 4) {
+            res = yield eatMatch(m`<NewExpression />`, o({ power }));
+          }
+          break;
+
+        case 'this':
+          res = yield eatMatch(m`<ThisExpression />`, o({ power }));
+          break;
+
+        default: {
+          if (
+            power >= 4 &&
+            (res = yield eatMatch(
+              (unaryMatcher ??= m`<UnaryExpression ${buildPattern(
+                unaryPrefixOperatorAlternatives,
+              )} />`),
+            ))
+          ) {
+          } else {
+            res = yield eat(m`<Identifier />`);
+          }
+        }
       }
+    } else if ((res = yield eatMatch(m`<TemplateString '\u0060' />`))) {
+    } else {
+      res = yield eat(m`<_LogicExpression />`, o({ power, noIn }));
     }
     if (res) {
-      return shiftMatch(m`<_Expression />`, o({
-        power
-      }));
+      return r(shiftMatch(m`<_Expression />`, o({ power })));
     }
   }
+
   *Statement(args) {
-    if (yield eatMatch(m`<ImportDeclaration 'import' />`)) {} else if (yield eatMatch(m`<ExportDeclaration 'export' />`)) {} else if (yield eatMatch(m`<ClassDeclaration 'class' />`)) {} else if (yield eatMatch(m`<YieldStatement 'yield' />`)) {} else if (yield eatMatch(m`<VariableDeclarationStatement /var|const|let/ />`)) {} else {
-      yield* super.Statement(args);
+    let res = yield match(re`/import|export|class|var|const|let/`);
+    switch (printSource(res)) {
+      case 'import':
+        yield eat(m`<ImportDeclaration />`);
+        break;
+      case 'export':
+        yield eat(m`<ExportDeclaration />`);
+        break;
+      case 'class':
+        yield eat(m`<ClassDeclaration />`);
+        break;
+      case 'var':
+      case 'const':
+      case 'let':
+        yield eat(m`<VariableDeclaration />`);
+        break;
+      default:
+        yield* super.Statement(args);
     }
   }
+
   *JSONExpression(args) {
-    if (yield eatMatch(m`<ClassExpression 'class' />`)) {} else if (yield eatMatch(m`<ThisExpression 'this' />`)) {} else if (yield eatMatch(m`<SuperExpression 'super' />`)) {} else if (yield eatMatch(m`<ArrowFunctionExpression '(' />`)) {} else {
+    if (yield eatMatch(m`<ClassExpression 'class' />`)) {
+    } else if (yield eatMatch(m`<ThisExpression 'this' />`)) {
+    } else if (yield eatMatch(m`<SuperExpression 'super' />`)) {
+    } else if (yield eatMatch(m`<ArrowFunctionExpression '(' />`)) {
+    } else {
       yield* super.JSONExpression(args);
     }
   }
-  *VariableDeclarationStatement() {
-    yield eat(m`sigilToken: <*Keyword /var|const|let/ />`);
+
+  *VariableDeclaration() {
+    yield eat(m`sigilToken*: <*Keyword /var|const|let/ />`);
+
     let sep = true;
     while (sep) {
-      yield eatMatch(m`declarations[]: <VariableDeclarator />`);
-      sep = yield eatMatch(m`#separatorTokens[]: <*Punctuator ',' />`);
+      yield eatMatch(m`declarations[]*: <VariableDeclarator />`);
+      sep = yield eatMatch(m`#separatorTokens: <* ',' />`);
     }
-    yield eatMatch(m`endToken: <*Punctuator ';' />`, null, o({
-      bind: true
-    }));
+
+    yield eatMatch(m`endToken*: <* ';' />`);
   }
-  *ForStatement() {
-    yield eat(m`sigilToken: <*Keyword 'for' />`);
-    yield eat(m`openHeaderToken: <*Punctuator '(' { balanced: ')' } />`);
-    if (!(yield eatMatch(m`init+$: <VariableDeclarationStatement />`, o({
-      noSemi: true
-    })))) {
-      yield eatMatch(m`init+$: <_Expression />`, o({
-        noIn: true
-      }));
+
+  *For() {
+    yield eat(m`sigilToken*: <*Keyword 'for' />`);
+    yield eat(m`openHeaderToken*: <* '(' />`);
+    if (!(yield eatMatch(m`init+$: <VariableDeclaration />`, o({ noSemi: true })))) {
+      yield eatMatch(m`init+$: <_Expression />`, o({ noIn: true }));
     }
-    let source = yield eatMatch(m`inToken: <*Keyword /in|of/ />`, o({}), o({
-      bind: true
-    }));
+    let source = yield eatMatch(m`inToken*: <*Keyword /in|of/ />`);
     if (source) {
       yield eatMatch(m`source+$: <_Expression />`);
     } else {
-      yield eat(m`testSeparatorToken: <*Punctuator ';' />`);
+      yield eat(m`testSeparatorToken*: <* ';' />`);
       yield eatMatch(m`test+$: <_Expression />`);
-      yield eat(m`updateSeparatorToken: <*Punctuator ';' />`);
+      yield eat(m`updateSeparatorToken*: <* ';' />`);
       yield eatMatch(m`update+$: <_Expression />`);
     }
-    yield eat(m`closeHeaderToken: <*Punctuator ')' { balancer: true } />`);
-    yield eat(m`body: <_Statement />`);
+    yield eat(m`closeHeaderToken*: <* ')' />`);
+    yield eat(m`body*: <_Statement />`);
   }
+
   *VariableDeclarator() {
     if (yield match('{')) {
-      yield eat(m`target: <ObjectPattern />`);
+      yield eat(m`receiver*: <ObjectPattern />`);
     } else {
-      yield eat(m`target: <Identifier />`);
+      yield eat(m`receiver*: <Identifier />`);
     }
-    if (yield match(re`/=/s`)) {
-      yield eat(m`assignmentOperator: <*Punctuator '=' />`);
-      yield eat(m`value+$: <_Expression />`, o({
-        power: 32
-      }));
+
+    if (yield match('=')) {
+      yield eat(m`assignmentToken*: <* '=' />`);
+      yield eat(m`value+$: <_Expression />`, o({ power: 32 }));
     } else {
-      yield eat(m`assignmentOperator: null`);
       yield eat(m`value+$: null`);
     }
   }
-  *Property() {
-    if (yield match(re`/['"]/`)) {
-      yield eat(m`key$: <String />`);
-      yield eat(m`mapOperator: <*Punctuator ':' />`);
-      yield eat(m`value+$: <_Expression />`, o({
-        power: 32
-      }));
-    } else if (yield eatMatch(m`key$: <Identifier />`)) {
-      let cn = yield eatMatch(m`mapOperator: <*Punctuator ':' />`, null, o({
-        bind: true
-      }));
-      if (cn) {
-        yield eat(m`value+$: <_Expression />`, o({
-          power: 32
-        }));
+
+  *ObjectKey() {
+    if (yield eatMatch(m`<String /['"]/ />`)) {
+    } else if (yield eatMatch(m`<UnsignedInteger /\d/ />`)) {
+    } else if (yield eatMatch(m`<ComputedObjectKey '[' />`)) {
+    } else {
+      yield eat(m`<Identifier />`, o({ scoped: false }));
+    }
+  }
+
+  *ComputedObjectKey() {
+    yield eat(m`openToken*: <* '[' />`);
+    yield eat(m`name+$: <_Expression />`);
+    yield eat(m`closeToken*: <* ']' />`);
+  }
+
+  *Method(args) {
+    let asyncToken = yield match('async');
+    let isSyncMethod = yield match(m`isSyncMethod*: <All />`, [(m`<* 'async' />`, m`<* '(' />`)]);
+
+    if (!asyncToken || !isSyncMethod) {
+      yield* super.Method(args);
+    } else {
+      let co = runCo(super.Method(args));
+      while (!co.done) {
+        let instr = co.value;
+        let refName = reifyMatcherReferenceName(getInstrMatcher(instr));
+        if (refName === 'asyncToken') {
+          co.advance(null);
+        } else {
+          co.advance(yield instr);
+        }
+      }
+    }
+  }
+
+  *ObjectElement({ s }) {
+    if (s().held) {
+      if (yield eatMatch(m`<Property ':' />`)) {
+      } else {
+        yield eatMatch(m`<Method '(' />`);
+      }
+    } else {
+      let asyncToken = yield match('async');
+      let isAsyncMethod =
+        asyncToken && !(yield match(m`<All />`, [(m`<* 'async' />`, m`<* /[(:]/ />`)]));
+
+      if (isAsyncMethod) {
+        yield eat(m`<Method />`);
       } else {
-        yield eatMatch(m`value+$: <FunctionExpression />`, o({
-          shorthand: true
-        }));
+        yield eat(m`<_ObjectKey />`);
+
+        return r(shift(m`<_ObjectElement />`));
       }
     }
   }
+
+  *Property() {
+    let key = yield eatHeld(m`key: <_ObjectKey />`);
+    let firstToken = printSource(BTree.getAt(-2, getRoot(key.node).value.bounds[0]).value.node);
+    let isIndex = /\d/.test(firstToken[0]);
+    let isComputed = firstToken === '[';
+
+    let cn =
+      isIndex || isComputed || reservedWords_.has(printSource(key.node))
+        ? yield eat(m`mapOperator*: <* ':' />`)
+        : yield eatMatch(m`mapOperator*: <* ':' />`);
+    if (cn) {
+      yield eat(m`value+$: <_Expression />`, o({ power: 32 }));
+    }
+  }
+
+  *Element() {
+    if (yield eatMatch(m`<SpreadElement '...' />`)) {
+    } else {
+      let { value } = yield eat(m`<_Expression />`, o({ power: 32 }), o({ shift: false }));
+      return value;
+    }
+  }
+
+  *SpreadElement() {
+    yield eat(m`sigilToken*: <* '...' />`);
+    yield eat(m`value+$: <_Expression />`, o({ power: 32 }));
+  }
 };
-export const grammar = triviaEnhancer({
-  triviaIsAllowed: s => s.span === 'Bare',
-  triviaMatcher: m`#: :Comment: <__Trivia /[ \n\r\t]|\/\/|\/\*/ />`
-}, atrivialGrammar);
+
+export const grammar = triviaEnhancer(
+  {
+    triviaIsAllowed: (s) => s.span === 'Bare',
+    triviaMatcher: m`#: <__Trivia /[ \n\r\t]|\/\/|\/\*/ />`,
+  },
+  atrivial,
+);
+
+export default { canonicalURL, dependencies, grammar, defaultMatcher };

package/lib/mixins/class.js

@@ -1,79 +1,79 @@
-/* @macrome
- * @generatedby @bablr/macrome-generator-bablr
- * @generatedfrom ./class.macro.js#4ea6b11c85b1d7c1bedeff0c3d61fee7cfa5fb79
- * This file is autogenerated. Please do not edit it directly.
- * When editing run `npx macrome watch` then change the file this is generated from.
- */
-import _applyDecs from "@babel/runtime/helpers/applyDecs2305";
 import { spam as m } from '@bablr/boot';
-import { CoveredBy, Node } from '@bablr/helpers/decorators';
 import { o, eat, eatMatch, fail } from '@bablr/helpers/grammar';
-export const mixin = Base => {
-  let _initProto, _ClassExpressionDecs, _ClassMethodDecs, _SuperExpressionDecs;
-  return class ES6ClassGrammar extends Base {
-    static {
-      [_initProto] = _applyDecs(this, [[Node, 2, "ClassDeclaration"], [_ClassExpressionDecs, 2, "ClassExpression"], [Node, 2, "ClassBody"], [_ClassMethodDecs, 2, "ClassMethod"], [_SuperExpressionDecs, 2, "SuperExpression"]], [], 0, void 0, Base).e;
-    }
-    constructor(...args) {
-      super(...args);
-      _initProto(this);
-    }
-    *[(_ClassExpressionDecs = [CoveredBy('Expression'), Node], _ClassMethodDecs = [CoveredBy('ClassMember'), Node], _SuperExpressionDecs = [CoveredBy('Expression'), Node], "ClassDeclaration")]() {
-      yield eat(m`sigilToken: <*Keyword 'class' />`);
+import { List } from '@bablr/helpers/productions';
+
+const mixin = (Base) =>
+  class ES6ClassGrammar extends Base {
+    *ClassDeclaration() {
+      yield eat(m`sigilToken*: <*Keyword 'class' />`);
+
       yield eat(m`name$: <Identifier />`);
-      if (yield eatMatch(m`extendsToken: <*Keyword 'extends' />`, o({}), o({
-        bind: true
-      }))) {
-        yield eat(m`superClass$: <_Expression>`);
+
+      if (yield eatMatch(m`extendsToken*: <*Keyword 'extends' />`)) {
+        yield eat(m`superClass+$: <_Expression />`);
       } else {
-        yield eat(m`superClass$: null`);
+        yield eat(m`superClass+$: null`);
       }
-      yield eat(m`body: <ClassBody />`);
+
+      yield eat(m`body$: <ClassBody />`);
     }
+
     *ClassExpression() {
-      yield eat(m`sigilToken: <*Keyword 'class' />`);
+      yield eat(m`sigilToken*: <*Keyword 'class' />`);
+
       yield eatMatch(m`name$: <Identifier />`);
-      if (yield eatMatch(m`extendsToken: <*Keyword 'extends' />`)) {
-        yield eat(m`superClass$: <_Expression>`);
+
+      if (yield eatMatch(m`extendsToken*: <*Keyword 'extends' />`)) {
+        yield eat(m`superClass+$: <_Expression />`);
       } else {
-        yield eat(m`superClass$: null`);
+        yield eat(m`superClass+$: null`);
       }
-      yield eat(m`body: <ClassBody />`);
+
+      yield eat(m`body$: <ClassBody />`);
     }
+
     *ClassBody() {
-      yield eat(m`openToken: <*Punctuator '{' { balanced: '}' } />`);
-      while (yield eatMatch(m`members[]: <_ClassMember />`)) {}
-      yield eat(m`closeToken: <*Punctuator '}' { balancer: true } />`);
+      yield eat(m`openToken*: <* '{' />`);
+      while (yield eatMatch(m`members[]$: <_ClassMember />`)) {}
+      yield eat(m`closeToken*: <* '}' />`);
     }
+
     *ClassMember() {
       yield eat(m`<ClassMethod />`);
     }
+
     *ClassMethod() {
-      yield eatMatch(m`staticToken: <*Keyword 'static' />`);
+      yield eatMatch(m`staticToken*: <*Keyword 'static' />`);
       let acc, a, gen;
-      acc = yield eatMatch(m`kindToken: <*Keyword /get|set/ />`);
+      acc = yield eatMatch(m`kindToken*: <*Keyword /get|set/ />`);
+
       if (!acc) {
-        a = yield eatMatch(m`asyncToken: <*Keyword 'async' />`);
-        gen = yield eatMatch(m`starToken: <*Punctuator '*' />`);
-      } else {
-        yield eatMatch(m`asyncToken: null`);
-        yield eatMatch(m`starToken: null`);
+        a = yield eatMatch(m`asyncToken*: <*Keyword 'async' />`);
+        gen = yield eatMatch(m`starToken*: <* '*' />`);
       }
+
       if (a && gen) yield fail();
-      yield eatMatch(m`id: <Identifier />`, o({}), o({
-        bind: true
-      }));
-      yield eat(m`openParamsToken: <*Punctuator '(' { balanced: ')' } />`);
-      yield eat(m`params[]: <__List />`, o({
-        element: m`<Identifier />`,
+
+      if (yield eatMatch(m`openNameToken*: <* '[' />`)) {
+        yield eat(m`name+$: <_Expression />`);
+        yield eat(m`closeNameToken*: <* ']' />`);
+      } else {
+        yield eatMatch(m`name+$: <Identifier />`, o({}), o({ bind: true }));
+      }
+
+      yield eat(m`openParamsToken*: <* '(' />`);
+      yield* List({
+        element: m`params[]+$: <_CapturePattern />`,
         allowTrailingSeparator: false,
-        separator: m`#separatorTokens[]: <*Punctuator ',' />`
-      }));
-      yield eat(m`closeParamsToken: <*Punctuator ')' { balancer: true } />`);
-      yield eat(m`body: <BlockStatement />`);
+        separator: m`#separatorTokens: <* ',' />`,
+      });
+      yield eat(m`closeParamsToken*: <* ')' />`);
+      yield eat(m`body$: <Block />`);
     }
+
     *SuperExpression() {
-      yield eat(m`sigilToken: <*Keyword 'super' />`);
+      yield eat(m`sigilToken*: <*Keyword 'super' />`);
     }
   };
-};
+
+export default mixin;