goldstein 5.17.0 → 5.19.0

package/ChangeLog

@@ -1,3 +1,17 @@
+2024.10.27, v5.19.0
+
+feature:
+- 76cb57d goldstein: @putout/printer v10.0.1
+- ee20f4e goldstein: estree-to-babel v10.0.0
+- ebd230e goldstein: esbuild v0.24.0
+
+2024.09.06, v5.18.0
+
+feature:
+- 641db76 goldstein: eslint-plugin-putout v23.1.0
+- 84be18f goldstein: @putout/plugin-try-catch v4.0.0
+- b2b030b goldstein: add support of safe assignment operator (https://github.com/arthurfiorette/proposal-safe-assignment-operator/issues/41)
+
 2024.07.27, v5.17.0
 
 feature:

package/README.md

@@ -299,6 +299,36 @@ import tryToCatch from 'try-catch';
 const [error, result] = await tryToCatch(hello, 'world');
 ```
 
+### [`operator-safe-assignment`](https://github.com/arthurfiorette/proposal-safe-assignment-operator)
+
+You can use `?=` instead of [`try`](#try):
+
+```gs
+const [error, result] ?= hello('world');
+```
+
+Is the same as:
+
+```js
+import tryCatch from 'try-catch';
+
+const [error, result] = tryCatch(hello, 'world');
+```
+
+and
+
+```gs
+const [error, result] ?= await hello('world');
+```
+
+Is the same as:
+
+```js
+import tryToCatch from 'try-catch';
+
+const [error, result] = await tryToCatch(hello, 'world');
+```
+
 ### `should`
 
 `should` can be used as an expression (just like [`try`](https://github.com/coderaiser/goldstein/edit/master/README.md#try)).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "goldstein",
-  "version": "5.17.0",
+  "version": "5.19.0",
   "type": "module",
   "author": "coderaiser <mnemonic.enemy@gmail.com> (https://github.com/coderaiser)",
   "description": "JavaScript with no limits",
@@ -12,7 +12,7 @@
   },
   "repository": {
     "type": "git",
-    "url": "git://github.com/coderaiser/goldstein.git"
+    "url": "git+https://github.com/coderaiser/goldstein.git"
   },
   "keywords": [
     "JavaScript",
@@ -29,11 +29,11 @@
   "dependencies": {
     "@putout/plugin-declare": "^4.0.0",
     "@putout/plugin-logical-expressions": "^6.0.0",
-    "@putout/plugin-try-catch": "^3.0.0",
-    "@putout/printer": "^9.0.1",
+    "@putout/plugin-try-catch": "^4.0.0",
+    "@putout/printer": "^10.0.1",
     "acorn": "^8.7.1",
     "acorn-typescript": "^1.4.13",
-    "estree-to-babel": "^9.0.0",
+    "estree-to-babel": "^10.0.0",
     "estree-util-attach-comments": "^3.0.0",
     "putout": "^36.0.3",
     "try-catch": "^3.0.1"
@@ -46,10 +46,10 @@
     "@putout/test": "^11.0.0",
     "c8": "^10.0.0",
     "check-dts": "^0.8.0",
-    "esbuild": "^0.23.0",
+    "esbuild": "^0.24.0",
     "esbuild-node-builtins": "^0.1.0",
     "eslint": "^9.2.0",
-    "eslint-plugin-putout": "^22.0.0",
+    "eslint-plugin-putout": "^23.1.0",
     "madrun": "^10.0.0",
     "mock-require": "^3.0.3",
     "montag": "^1.2.1",

package/packages/goldstein/parser.js

@@ -19,6 +19,7 @@ import keywordUselessComma from '../keyword-useless-comma/index.js';
 import keywordUselessSemicolon from '../keyword-useless-semicolon/index.js';
 import keywordAssignFrom from '../keyword-assign-from/index.js';
 import internalParseMaybeAssign from '../internal-parse-maybe-assign/index.js';
+import operatorSafeAssignment from '../operator-safe-assignment/index.js';
 
 const {values} = Object;
 
@@ -40,6 +41,7 @@ const defaultKeywords = {
     keywordUselessComma,
     keywordUselessSemicolon,
     keywordAssignFrom,
+    operatorSafeAssignment,
 };
 
 const internals = [

package/packages/keyword-missing-initializer/index.js

@@ -9,14 +9,21 @@ export default function keywordMissingInitializer(Parser) {
                 const decl = this.startNode();
                 this.parseVarId(decl, kind);
                 
-                if (this.eat(tt.eq))
+                /* c8 ignore start */
+                if (this.eat(tt.question) && this.eat(tt.eq)) {
+                    if (!this.parseSafeAssignment)
+                        this.raise(this.lastTokEnd, `Enable 'operator-safe-assignment' to have ability to use '?='`);
+                    
+                    decl.init = this.parseSafeAssignment(); /* c8 ignore start */
+                } else if (this.eat(tt.eq)) {
                     decl.init = this.parseMaybeAssign(isFor);
-                else if (!allowMissingInitializer && kind === 'const' && !(this.type === tt._in || this.options.ecmaVersion >= 6 && this.isContextual('of')))
-                    decl.init = this.parseMaybeAssign(isFor); /* c8 ignore start */
-                else if (!allowMissingInitializer && decl.id.type !== 'Identifier' && !(isFor && (this.type === tt._in || this.isContextual('of'))))
+                } else if (!allowMissingInitializer && kind === 'const' && !(this.type === tt._in || this.options.ecmaVersion >= 6 && this.isContextual('of'))) {
+                    decl.init = MissingInitializer.missInitializer.call(this, isFor);
+                } else if (!allowMissingInitializer && decl.id.type !== 'Identifier' && !(isFor && (this.type === tt._in || this.isContextual('of')))) {
                     this.raise(this.lastTokEnd, 'Complex binding patterns require an initialization value');
-                else
+                } else {
                     decl.init = null;
+                }
                 
                 /* c8 ignore end */
                 node.declarations.push(this.finishNode(decl, 'VariableDeclarator'));
@@ -29,3 +36,9 @@ export default function keywordMissingInitializer(Parser) {
         }
     };
 }
+
+export const MissingInitializer = {
+    missInitializer(isFor) {
+        return this.parseMaybeAssign(isFor);
+    },
+};

package/packages/operator-safe-assignment/index.js

@@ -0,0 +1,81 @@
+import {types} from 'putout';
+import {setGoldsteinTry} from '../types/try.js';
+import {MissingInitializer} from '../keyword-missing-initializer/index.js';
+import {tokTypes as tt} from '../operator/index.js';
+
+const {assign} = Object;
+
+const {
+    isCallExpression,
+    isAwaitExpression,
+} = types;
+
+export default function operatorSafeAssignment(Parser) {
+    return class extends Parser {
+        parseVar(node, isFor, kind, allowMissingInitializer) {
+            node.declarations = [];
+            node.kind = kind;
+            for (;;) {
+                const decl = this.startNode();
+                this.parseVarId(decl, kind);
+                
+                if (this.eat(tt.question) && this.eat(tt.eq))
+                    decl.init = this.parseSafeAssignment(); /* c8 ignore start */
+                else if (this.eat(tt.eq))
+                    decl.init = this.parseMaybeAssign(isFor);
+                else if (!allowMissingInitializer && kind === 'const' && !(this.type === tt._in || this.options.ecmaVersion >= 6 && this.isContextual('of')))
+                    decl.init = MissingInitializer.missInitializer.call(this, isFor);
+                else if (!allowMissingInitializer && decl.id.type !== 'Identifier' && !(isFor && (this.type === tt._in || this.isContextual('of'))))
+                    this.raise(this.lastTokEnd, 'Complex binding patterns require an initialization value');
+                else
+                    decl.init = null;
+                
+                /* c8 ignore end */
+                node.declarations.push(this.finishNode(decl, 'VariableDeclarator'));
+                
+                if (!this.eat(tt.comma))
+                    break;
+            }
+            
+            return node;
+        }
+        
+        parseSafeAssignment() {
+            const node = super.startNode();
+            const expression = this.parseExpression();
+            
+            if (isCallExpression(expression))
+                assign(node, {
+                    type: 'CallExpression',
+                    callee: {
+                        type: 'Identifier',
+                        name: 'tryCatch',
+                    },
+                    arguments: [
+                        expression.callee,
+                        ...expression.arguments,
+                    ],
+                });
+            else if (isAwaitExpression(expression))
+                assign(node, {
+                    type: 'AwaitExpression',
+                    argument: {
+                        type: 'CallExpression',
+                        callee: {
+                            type: 'Identifier',
+                            name: 'tryToCatch',
+                        },
+                        arguments: [
+                            expression.argument.callee,
+                            ...expression.argument.arguments,
+                        ],
+                    },
+                });
+            else
+                this.raise(this.start, `After '?=' only 'await' and 'function call' can come`);
+            
+            setGoldsteinTry(node);
+            return super.finishNode(node, node.type);
+        }
+    };
+}

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

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