goldstein 4.7.0 → 4.9.0

package/ChangeLog

@@ -1,3 +1,13 @@
+2023.10.19, v4.9.0
+
+feature:
+- 2346464 goldstein: convert: add-array
+
+2023.10.19, v4.8.0
+
+feature:
+- 924f182 goldstein: add-array: add
+
 2023.10.04, v4.7.0
 
 feature:

package/README.md

@@ -165,7 +165,7 @@ parse(`
 
 You can parse to **ESTree**:
 
-```
+```js
 const options = {
     type: 'estree',
 };
@@ -184,8 +184,11 @@ parse(`
 
 You can make any modifications to **Goldstein AST** and then `print` back to **Goldstein**:
 
-```
-import {parse, print} from 'goldstein';
+```js
+import {
+    parse,
+    print,
+} from 'goldstein';
 
 const ast = parse(`const t = try f('hello')`);
 const source = print(ast);
@@ -195,13 +198,13 @@ const source = print(ast);
 
 You can even convert **JavaScript** to **Goldstein** with:
 
-```
+```js
 import {convert} from 'goldstein';
 
-const ast = convert(`const t = tryCatch(f, 'hello');`;
+const ast = convert(`const t = tryCatch(f, 'hello')`);
 
 // returns
-`const t = try f('hello')`)
+`const t = try f('hello')`;
 ```
 
 ## Keywords
@@ -227,6 +230,23 @@ function hello() {
 }
 ```
 
+### `append array`
+
+Append new elements to an array just like in Swift:
+
+```js
+let a = [1];
+
+a += [2, 3];
+```
+
+Is the same as:
+
+```js
+const a = [1];
+a.push(...[2, 3]);
+```
+
 ### `guard`
 
 Applies not to `IfCondition`:

package/build/parser.cjs

@@ -5410,6 +5410,13 @@ function addKeyword(keyword, keywords3) {
   const str = keywords3.toString().replace(")$", `|${keyword})$`).slice(1, -1);
   return RegExp(str);
 }
+var DestructuringErrors3 = class {
+  shorthandAssign = -1;
+  trailingComma = -1;
+  parenthesizedAssign = -1;
+  parenthesizedBind = -1;
+  doubleProto = -1;
+};
 
 // packages/keyword-fn/index.js
 function fn(Parser3) {
@@ -5902,6 +5909,97 @@ function fn3(Parser3) {
   };
 }
 
+// packages/keyword-add-array/index.js
+var import_putout7 = require("putout");
+var { assign: assign3 } = Object;
+var {
+  identifier,
+  isArrayExpression: isArrayExpression2,
+  memberExpression,
+  spreadElement
+} = import_putout7.types;
+function keywordAddArray(Parser3) {
+  return class extends Parser3 {
+    parseMaybeAssign(forInit, refDestructuringErrors, afterLeftParse) {
+      if (this.isContextual("yield")) {
+        if (this.inGenerator) {
+          return this.parseYield(forInit);
+        }
+        this.exprAllowed = false;
+      }
+      let ownDestructuringErrors = false;
+      let oldParenAssign = -1;
+      let oldTrailingComma = -1;
+      let oldDoubleProto = -1;
+      if (refDestructuringErrors) {
+        oldParenAssign = refDestructuringErrors.parenthesizedAssign;
+        oldTrailingComma = refDestructuringErrors.trailingComma;
+        oldDoubleProto = refDestructuringErrors.doubleProto;
+        refDestructuringErrors.parenthesizedAssign = refDestructuringErrors.trailingComma = -1;
+      } else {
+        refDestructuringErrors = new DestructuringErrors3();
+        ownDestructuringErrors = true;
+      }
+      const startPos = this.start;
+      const { startLoc } = this;
+      if (this.type === types$1.parenL || this.type === types$1.name) {
+        this.potentialArrowAt = this.start;
+        this.potentialArrowInForAwait = forInit === "await";
+      }
+      let left = this.parseMaybeConditional(forInit, refDestructuringErrors);
+      if (afterLeftParse) {
+        left = afterLeftParse.call(this, left, startPos, startLoc);
+      }
+      if (this.type.isAssign) {
+        const node = this.startNodeAt(startPos, startLoc);
+        node.operator = this.value;
+        if (this.type === types$1.eq) {
+          left = this.toAssignable(left, false, refDestructuringErrors);
+        }
+        if (!ownDestructuringErrors) {
+          refDestructuringErrors.parenthesizedAssign = refDestructuringErrors.trailingComma = refDestructuringErrors.doubleProto = -1;
+        }
+        if (refDestructuringErrors.shorthandAssign >= left.start) {
+          refDestructuringErrors.shorthandAssign = -1;
+        }
+        if (this.type === types$1.eq) {
+          this.checkLValPattern(left);
+        } else {
+          this.checkLValSimple(left);
+        }
+        node.left = left;
+        this.next();
+        node.right = this.parseMaybeAssign(forInit);
+        if (oldDoubleProto > -1) {
+          refDestructuringErrors.doubleProto = oldDoubleProto;
+        }
+        if (node.operator === "+=" && isArrayExpression2(node.right))
+          return createAppendNode(this, node);
+        return this.finishNode(node, "AssignmentExpression");
+      }
+      if (ownDestructuringErrors) {
+        this.checkExpressionErrors(refDestructuringErrors, true);
+      }
+      if (oldParenAssign > -1) {
+        refDestructuringErrors.parenthesizedAssign = oldParenAssign;
+      }
+      if (oldTrailingComma > -1) {
+        refDestructuringErrors.trailingComma = oldTrailingComma;
+      }
+      return left;
+    }
+  };
+}
+function createAppendNode(context, node) {
+  const { left, right } = node;
+  assign3(node, {
+    a: "x",
+    callee: memberExpression(left, identifier("push")),
+    arguments: [spreadElement(right)]
+  });
+  return context.finishNode(node, "CallExpression");
+}
+
 // packages/goldstein/parser.js
 var defaultKeywords = {
   keywordFn: fn,
@@ -5914,6 +6012,7 @@ var defaultKeywords = {
   keywordIf: fn2,
   keywordImport,
   keywordArrow: fn3,
+  keywordAddArray,
   stringInterpolation
 };
 var keywords2 = defaultKeywords;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "goldstein",
-  "version": "4.7.0",
+  "version": "4.9.0",
   "type": "module",
   "author": "coderaiser <mnemonic.enemy@gmail.com> (https://github.com/coderaiser)",
   "description": "JavaScript with no limits",

package/packages/convert/add-array/index.js

@@ -0,0 +1,4 @@
+export const report = () => `Use 'add-array'`;
+export const replace = () => ({
+    '__a.push(...__array)': '__a += __array',
+});

package/packages/convert/index.js

@@ -3,6 +3,7 @@ import {transform} from 'putout';
 import {print} from '../printer/index.js';
 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 {
     fixEmpty,
     parse,
@@ -13,6 +14,7 @@ export const convert = (source) => {
     
     transform(ast, source, {
         plugins: [
+            ['add-array', addArray],
             ['apply-try', applyTry],
             ['remove-import-try', removeImportTry],
         ],

package/packages/goldstein/parser.js

@@ -11,6 +11,7 @@ import keywordFreeze from '../keyword-freeze/index.js';
 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';
 
 const defaultKeywords = {
     keywordFn,
@@ -23,6 +24,7 @@ const defaultKeywords = {
     keywordIf,
     keywordImport,
     keywordArrow,
+    keywordAddArray,
     stringInterpolation,
 };
 

package/packages/keyword-add-array/index.js

@@ -0,0 +1,121 @@
+import {types} from 'putout';
+import {tokTypes as tt} from 'acorn';
+import {DestructuringErrors} from '../operator/index.js';
+
+const {assign} = Object;
+
+const {
+    identifier,
+    isArrayExpression,
+    memberExpression,
+    spreadElement,
+} = types;
+
+export default function keywordAddArray(Parser) {
+    return class extends Parser {
+        parseMaybeAssign(forInit, refDestructuringErrors, afterLeftParse) {
+            if (this.isContextual('yield')) {
+                if (this.inGenerator) {
+                    return this.parseYield(forInit);
+                }
+                
+                // The tokenizer will assume an expression is allowed after
+                // `yield`, but this isn't that kind of yield
+                this.exprAllowed = false;
+            }
+            
+            let ownDestructuringErrors = false;
+            let oldParenAssign = -1;
+            let oldTrailingComma = -1;
+            let oldDoubleProto = -1;
+            
+            if (refDestructuringErrors) {
+                oldParenAssign = refDestructuringErrors.parenthesizedAssign;
+                oldTrailingComma = refDestructuringErrors.trailingComma;
+                oldDoubleProto = refDestructuringErrors.doubleProto;
+                refDestructuringErrors.parenthesizedAssign = refDestructuringErrors.trailingComma = -1;
+            } else {
+                refDestructuringErrors = new DestructuringErrors();
+                ownDestructuringErrors = true;
+            }
+            
+            const startPos = this.start;
+            const {startLoc} = this;
+            
+            if (this.type === tt.parenL || this.type === tt.name) {
+                this.potentialArrowAt = this.start;
+                this.potentialArrowInForAwait = forInit === 'await';
+            }
+            
+            let left = this.parseMaybeConditional(forInit, refDestructuringErrors);
+            
+            if (afterLeftParse) {
+                left = afterLeftParse.call(this, left, startPos, startLoc);
+            }
+            
+            if (this.type.isAssign) {
+                const node = this.startNodeAt(startPos, startLoc);
+                
+                node.operator = this.value;
+                
+                if (this.type === tt.eq) {
+                    left = this.toAssignable(left, false, refDestructuringErrors);
+                }
+                
+                if (!ownDestructuringErrors) {
+                    refDestructuringErrors.parenthesizedAssign = refDestructuringErrors.trailingComma = refDestructuringErrors.doubleProto = -1;
+                }
+                
+                if (refDestructuringErrors.shorthandAssign >= left.start) {
+                    refDestructuringErrors.shorthandAssign = -1;
+                }
+                
+                // reset because shorthand default was used correctly
+                if (this.type === tt.eq) {
+                    this.checkLValPattern(left);
+                } else {
+                    this.checkLValSimple(left);
+                }
+                
+                node.left = left;
+                this.next();
+                node.right = this.parseMaybeAssign(forInit);
+                
+                if (oldDoubleProto > -1) {
+                    refDestructuringErrors.doubleProto = oldDoubleProto;
+                }
+                
+                if (node.operator === '+=' && isArrayExpression(node.right))
+                    return createAppendNode(this, node);
+                
+                return this.finishNode(node, 'AssignmentExpression');
+            }
+            
+            if (ownDestructuringErrors) {
+                this.checkExpressionErrors(refDestructuringErrors, true);
+            }
+            
+            if (oldParenAssign > -1) {
+                refDestructuringErrors.parenthesizedAssign = oldParenAssign;
+            }
+            
+            if (oldTrailingComma > -1) {
+                refDestructuringErrors.trailingComma = oldTrailingComma;
+            }
+            
+            return left;
+        }
+    };
+}
+
+function createAppendNode(context, node) {
+    const {left, right} = node;
+    
+    assign(node, {
+        a: 'x',
+        callee: memberExpression(left, identifier('push')),
+        arguments: [spreadElement(right)],
+    });
+    
+    return context.finishNode(node, 'CallExpression');
+}

package/packages/operator/index.js

@@ -9,3 +9,10 @@ export function addKeyword(keyword, keywords) {
     return RegExp(str);
 }
 
+export class DestructuringErrors {
+    shorthandAssign = -1;
+    trailingComma = -1;
+    parenthesizedAssign = -1;
+    parenthesizedBind = -1;
+    doubleProto = -1;
+}