goldstein 5.1.0 → 5.3.0

package/ChangeLog

@@ -1,3 +1,21 @@
+2024.05.06, v5.3.0
+
+feature:
+- 98f3048 goldstein: add ability to parse no async code with await
+- 45c7363 @putout/plugin-goldstein: eslint-plugin-putout v22.7.0
+- 3964832 @putout/plugin-goldstein: @putout/test v9.1.0
+- aa689c7 @putout/plugin-goldstein: eslint v9.2.0
+- 1399854 @putout/plugin-goldstein: c8 v9.1.0
+- a728422 goldstein: redlint v3.14.1
+- 6f03127 goldstein: eslint v9.2.0
+- 23c8eb3 goldstein: @putout/plugin-declare v4.0.0
+
+2024.02.20, v5.2.0
+
+feature:
+- 5728421 goldstein: improve support of comments
+- 0d997c3 goldstein: printer: visitors: await-expression: maybeVisitor
+
 2024.02.19, v5.1.0
 
 feature:

package/README.md

@@ -100,10 +100,7 @@ By default, all keywords mentioned in the next section used, but you can limit t
 You can add any keywords, and even create your own:
 
 ```js
-import {
-    compile,
-    keywords,
-} from 'goldstein';
+import {compile, keywords} from 'goldstein';
 
 const source = `
     fn hello() {
@@ -185,10 +182,7 @@ parse(`
 You can make any modifications to **Goldstein AST** and then `print` back to **Goldstein**:
 
 ```js
-import {
-    parse,
-    print,
-} from 'goldstein';
+import {parse, print} from 'goldstein';
 
 const ast = parse(`const t = try f('hello')`);
 const source = print(ast);
@@ -302,7 +296,7 @@ Is the same as:
 ```js
 import tryToCatch from 'try-catch';
 
-const [error, result] = await tryToCatch(1, 2, 3);
+const [error, result] = await tryToCatch(hello, 'world');
 ```
 
 ### `should`
@@ -413,6 +407,22 @@ That absolutely fine, it will be converted to:
 function hello() {}
 ```
 
+### `asyn`-less `Function` with `await`
+
+```gs
+function hello() {
+    await world();
+}
+```
+
+In js:
+
+```js
+async function hello() {
+    await world();
+}
+```
+
 ## How to contribute?
 
 Clone the registry, create a new keyword with a prefix `keyword-`, then create directory `fixture` and put there two files with extensions `.js` and `.gs`. Half way done 🥳!

package/build/parser.cjs

@@ -1134,6 +1134,7 @@ pp$8.parseLabeledStatement = function(node, maybeName, expr, context) {
 };
 pp$8.parseExpressionStatement = function(node, expr) {
   node.expression = expr;
+  console.log(expr);
   this.semicolon();
   return this.finishNode(node, "ExpressionStatement");
 };
@@ -5380,6 +5381,75 @@ Parser.acorn = {
   nonASCIIwhitespace
 };
 
+// node_modules/estree-util-attach-comments/lib/index.js
+var own = {}.hasOwnProperty;
+var emptyComments = [];
+function attachComments(tree, comments) {
+  const list = comments ? [...comments].sort(compare) : emptyComments;
+  if (list.length > 0)
+    walk(tree, { comments: list, index: 0 });
+}
+function walk(node, state) {
+  if (state.index === state.comments.length) {
+    return;
+  }
+  const children = [];
+  const comments = [];
+  let key;
+  for (key in node) {
+    if (own.call(node, key)) {
+      const value = node[key];
+      if (value && typeof value === "object" && key !== "comments") {
+        if (Array.isArray(value)) {
+          let index2 = -1;
+          while (++index2 < value.length) {
+            if (value[index2] && typeof value[index2].type === "string") {
+              children.push(value[index2]);
+            }
+          }
+        } else if (typeof value.type === "string") {
+          children.push(value);
+        }
+      }
+    }
+  }
+  children.sort(compare);
+  comments.push(...slice(state, node, false, { leading: true, trailing: false }));
+  let index = -1;
+  while (++index < children.length) {
+    walk(children[index], state);
+  }
+  comments.push(
+    ...slice(state, node, true, {
+      leading: false,
+      trailing: children.length > 0
+    })
+  );
+  if (comments.length > 0) {
+    node.comments = comments;
+  }
+}
+function slice(state, node, compareEnd, fields) {
+  const result = [];
+  while (state.comments[state.index] && compare(state.comments[state.index], node, compareEnd) < 1) {
+    result.push(Object.assign({}, state.comments[state.index++], fields));
+  }
+  return result;
+}
+function compare(left, right, compareEnd) {
+  const field = compareEnd ? "end" : "start";
+  if (left.range && right.range) {
+    return left.range[0] - right.range[compareEnd ? 1 : 0];
+  }
+  if (left.loc && left.loc.start && right.loc && right.loc[field]) {
+    return left.loc.start.line - right.loc[field].line || left.loc.start.column - right.loc[field].column;
+  }
+  if ("start" in left && field in right) {
+    return left.start - right[field];
+  }
+  return Number.NaN;
+}
+
 // packages/parser/index.js
 var extendParser = (keywords3) => {
   const parser = Parser.extend(...keywords3);
@@ -5396,15 +5466,13 @@ var createParse = (parser) => (source) => {
     locations: true,
     comment: true,
     ranges: true,
-    onComment: (a) => {
-      comments.push(a);
-    }
+    onComment: comments
   };
-  const result = parser.parse(source, options);
-  const tokens = Array.from(parser.tokenizer(source, options));
+  const ast = parser.parse(source, options);
+  attachComments(ast, comments);
   return {
-    ...result,
-    tokens,
+    ...ast,
+    tokens: Array.from(parser.tokenizer(source, options)),
     comments
   };
 };
@@ -5881,15 +5949,18 @@ function createIfLet({ isParenL }) {
   const node = {
     loc: {},
     range: [],
-    body: [{
-      type: "VariableDeclaration",
-      kind: "let",
-      declarations: [{
-        type: "VariableDeclarator",
-        id: assignmentExpression.left,
-        init: assignmentExpression.right
-      }]
-    }, ifNode]
+    body: [
+      {
+        type: "VariableDeclaration",
+        kind: "let",
+        declarations: [{
+          type: "VariableDeclarator",
+          id: assignmentExpression.left,
+          init: assignmentExpression.right
+        }]
+      },
+      ifNode
+    ]
   };
   return this.finishNode(node, "BlockStatement");
 }
@@ -6042,6 +6113,35 @@ function createAppendNode(context, node) {
   return context.finishNode(node, "CallExpression");
 }
 
+// packages/keyword-no-async/index.js
+var { defineProperty } = Object;
+function fn4(Parser3) {
+  return class extends Parser3 {
+    parseFunction(node, statement, allowExpressionBody, isAsync, forInit) {
+      return super.parseFunction(node, statement, allowExpressionBody, true, forInit);
+    }
+    checkUnreserved({ start, end, name }) {
+      if (this.inGenerator && name === "yield")
+        this.raiseRecoverable(start, `Cannot use 'yield' as identifier inside a generator`);
+      if (this.inAsync && name === "await")
+        this.raiseRecoverable(start, `Cannot use 'await' as identifier inside an async function`);
+      if (this.currentThisScope().inClassFieldInit && name === "arguments")
+        this.raiseRecoverable(start, `Cannot use 'arguments' in class field initializer`);
+      if (this.inClassStaticBlock && (name === "arguments" || name === "await"))
+        this.raise(start, `Cannot use ${name} in class static initialization block`);
+      if (this.keywords.test(name))
+        this.raise(start, `Unexpected keyword '` + name + `'`);
+      if (this.options.ecmaVersion < 6 && this.input.slice(start, end).includes("\\"))
+        return;
+      const re = this.strict ? this.reservedWordsStrict : this.reservedWords;
+      if (re.test(name) && !this.inAsync && name === "await")
+        defineProperty(this, "inAsync", {
+          value: true
+        });
+    }
+  };
+}
+
 // packages/goldstein/parser.js
 var defaultKeywords = {
   keywordFn: fn,
@@ -6055,7 +6155,8 @@ var defaultKeywords = {
   keywordImport,
   keywordArrow: fn3,
   keywordAddArray,
-  stringInterpolation
+  stringInterpolation,
+  keywordNoAsync: fn4
 };
 var keywords2 = defaultKeywords;
 var parse3 = (source, options = {}, keywords3 = defaultKeywords) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "goldstein",
-  "version": "5.1.0",
+  "version": "5.3.0",
   "type": "module",
   "author": "coderaiser <mnemonic.enemy@gmail.com> (https://github.com/coderaiser)",
   "description": "JavaScript with no limits",
@@ -29,14 +29,16 @@
     "wisdom": "madrun wisdom"
   },
   "dependencies": {
-    "@putout/plugin-declare": "^3.0.0",
+    "@putout/plugin-declare": "^4.0.0",
     "@putout/plugin-logical-expressions": "^5.0.0",
     "@putout/plugin-try-catch": "^3.0.0",
+    "@putout/plugin-promises": "^14.1.0",
     "@putout/printer": "^8.0.1",
     "acorn": "^8.7.1",
     "esbuild": "^0.20.1",
     "esbuild-node-builtins": "^0.1.0",
     "estree-to-babel": "^9.0.0",
+    "estree-util-attach-comments": "^3.0.0",
     "putout": "^35.0.0",
     "try-catch": "^3.0.1"
   },
@@ -44,17 +46,18 @@
   "devDependencies": {
     "@babel/core": "^8.0.0-alpha.5",
     "@cloudcmd/stub": "^4.0.1",
+    "@putout/plugin-goldstein": "./rules/goldstein",
     "@putout/test": "^9.0.1",
     "c8": "^9.1.0",
     "check-dts": "^0.7.1",
     "escover": "^4.0.1",
-    "eslint": "^8.48.0",
-    "eslint-plugin-n": "^16.0.1",
+    "eslint": "^9.2.0",
     "eslint-plugin-putout": "^22.0.0",
     "madrun": "^10.0.0",
     "mock-require": "^3.0.3",
     "montag": "^1.2.1",
     "nodemon": "^3.0.1",
+    "redlint": "^3.14.1",
     "runsome": "^1.0.0",
     "supertape": "^10.1.0",
     "typescript": "^5.0.3"

package/packages/convert/index.js

@@ -5,10 +5,7 @@ import * as removeImportTry from './remove-import-try/index.js';
 import * as applyTry from './apply-try/index.js';
 import * as addArray from './add-array/index.js';
 import * as applyIfLet from './apply-if-let/index.js';
-import {
-    fixEmpty,
-    parse,
-} from '../goldstein/index.js';
+import {fixEmpty, parse} from '../goldstein/index.js';
 
 export const convert = (source) => {
     const ast = estreeToBabel(parse(source));

package/packages/goldstein/index.js

@@ -3,6 +3,7 @@ import {print} from '@putout/printer';
 import tryCatchPlugin from '@putout/plugin-try-catch';
 import declarePlugin from '@putout/plugin-declare';
 import logicalExpressionsPlugin from '@putout/plugin-logical-expressions';
+import promisesPlugin from '@putout/plugin-promises';
 import {parse} from './parser.js';
 
 export * from './parser.js';
@@ -19,6 +20,7 @@ export const compile = (source, options = {}) => {
             ['try-catch', tryCatchPlugin],
             ['declare', declarePlugin],
             ['logical-expressions', logicalExpressionsPlugin],
+            ['promises', promisesPlugin],
         ],
     });
     

package/packages/goldstein/parser.js

@@ -12,6 +12,7 @@ import keywordIf from '../keyword-if/index.js';
 import keywordImport from '../keyword-import/index.js';
 import keywordArrow from '../keyword-arrow/index.js';
 import keywordAddArray from '../keyword-add-array/index.js';
+import keywordNoAsync from '../keyword-no-async/index.js';
 
 const defaultKeywords = {
     keywordFn,
@@ -26,6 +27,7 @@ const defaultKeywords = {
     keywordArrow,
     keywordAddArray,
     stringInterpolation,
+    keywordNoAsync,
 };
 
 export const keywords = defaultKeywords;

package/packages/keyword-fn/index.js

@@ -1,7 +1,4 @@
-import {
-    addKeyword,
-    TokenType,
-} from '../operator/index.js';
+import {addKeyword, TokenType} from '../operator/index.js';
 
 export default function fn(Parser) {
     Parser.acorn.keywordTypes.fn = new TokenType('fn', {

package/packages/keyword-freeze/index.js

@@ -1,8 +1,5 @@
 import {types} from 'putout';
-import {
-    addKeyword,
-    TokenType,
-} from '../operator/index.js';
+import {addKeyword, TokenType} from '../operator/index.js';
 
 const {
     isObjectExpression,

package/packages/keyword-if/index.js

@@ -58,7 +58,8 @@ function createIfLet({isParenL}) {
                 id: assignmentExpression.left,
                 init: assignmentExpression.right,
             }],
-        }, ifNode],
+        },
+        ifNode],
     };
     
     return this.finishNode(node, 'BlockStatement');

package/packages/keyword-no-async/index.js

@@ -0,0 +1,36 @@
+const {defineProperty} = Object;
+
+export default function fn(Parser) {
+    return class extends Parser {
+        parseFunction(node, statement, allowExpressionBody, isAsync, forInit) {
+            return super.parseFunction(node, statement, allowExpressionBody, true, forInit);
+        }
+        
+        checkUnreserved({start, end, name}) {
+            if (this.inGenerator && name === 'yield')
+                this.raiseRecoverable(start, `Cannot use 'yield' as identifier inside a generator`);
+            
+            if (this.inAsync && name === 'await')
+                this.raiseRecoverable(start, `Cannot use 'await' as identifier inside an async function`);
+            
+            if (this.currentThisScope().inClassFieldInit && name === 'arguments')
+                this.raiseRecoverable(start, `Cannot use 'arguments' in class field initializer`);
+            
+            if (this.inClassStaticBlock && (name === 'arguments' || name === 'await'))
+                this.raise(start, `Cannot use ${name} in class static initialization block`);
+            
+            if (this.keywords.test(name))
+                this.raise(start, `Unexpected keyword '` + name + `'`);
+            
+            if (this.options.ecmaVersion < 6 && this.input.slice(start, end).includes('\\'))
+                return;
+            
+            const re = this.strict ? this.reservedWordsStrict : this.reservedWords;
+            
+            if (re.test(name) && !this.inAsync && name === 'await')
+                defineProperty(this, 'inAsync', {
+                    value: true,
+                });
+        }
+    };
+}

package/packages/keyword-try/index.js

@@ -1,11 +1,11 @@
 import {types} from 'putout';
+import {setGoldsteinTry} from '../types/try.js';
 import {
     BIND_LEXICAL,
     BIND_SIMPLE_CATCH,
     SCOPE_SIMPLE_CATCH,
     tokTypes as tt,
 } from '../operator/index.js';
-import {setGoldsteinTry} from '../types/try.js';
 
 const {
     isCallExpression,

package/packages/parser/index.js

@@ -1,4 +1,5 @@
 import {Parser} from 'acorn';
+import {attachComments} from 'estree-util-attach-comments';
 
 export const extendParser = (keywords) => {
     const parser = Parser.extend(...keywords);
@@ -17,17 +18,16 @@ const createParse = (parser) => (source) => {
         locations: true,
         comment: true,
         ranges: true,
-        onComment: (a) => {
-            comments.push(a);
-        },
+        onComment: comments,
     };
     
-    const result = parser.parse(source, options);
-    const tokens = Array.from(parser.tokenizer(source, options));
+    const ast = parser.parse(source, options);
+    
+    attachComments(ast, comments);
     
     return {
-        ...result,
-        tokens,
+        ...ast,
+        tokens: Array.from(parser.tokenizer(source, options)),
         comments,
     };
 };

package/packages/printer/visitors/await-expression.js

@@ -1,10 +1,13 @@
-import {visitors as v} from '@putout/printer';
+import {
+    maybeVisitor,
+    visitors as v,
+} from '@putout/printer';
 
 export const AwaitExpression = (path, printer, semantics) => {
     const {print} = printer;
     
     if (!path.node.goldstein)
-        return v.AwaitExpression(path, printer, semantics);
+        return maybeVisitor(v.AwaitExpression, path, printer, semantics);
     
     print('__goldstein');
 };