goldstein 4.9.1 → 4.11.0

package/ChangeLog

@@ -1,3 +1,13 @@
+2023.10.19, v4.11.0
+
+feature:
+- 005959d goldstein: convert: if let
+
+2023.10.19, v4.10.0
+
+feature:
+- 0b4756a goldstein: add if let
+
 2023.10.19, v4.9.1
 
 fix:

package/README.md

@@ -344,12 +344,20 @@ Object.freeze({
 
 You can omit parens. But you must use braces in this case.
 
-```rust
+```swift
 if a > 3 {
     hello();
 }
 ```
 
+Also you can use `if let` syntax:
+
+```swift
+if let x = a?.b {
+    print(x);
+}
+```
+
 ### `throw expression`
 
 You can use [throw as expression](https://github.com/tc39/proposal-throw-expressions), just like that:

package/build/parser.cjs

@@ -5837,22 +5837,71 @@ var setGoldsteinIf = (node) => {
 // packages/keyword-if/index.js
 function fn2(Parser3) {
   return class extends Parser3 {
-    parseIfStatement(node) {
+    parseIfStatement() {
       this.next();
       const isParenL = this.eat(types$1.parenL);
-      node.test = this.parseExpression();
-      const isParenR = this.eat(types$1.parenR);
-      if (!isParenL && !isParenR && this.type !== types$1.braceL)
-        this.raise(this.start, `Use braces ('{', '}') when omit parens ('(', ')')`);
-      if (isParenL !== isParenR)
-        this.raise(this.start, `Use both parens ('(', ')') or none`);
-      node.consequent = this.parseStatement("if");
-      node.alternate = this.eat(types$1._else) ? this.parseStatement("if") : null;
-      setGoldsteinIf(node);
-      return this.finishNode(node, "IfStatement");
+      if (this.isContextual("let"))
+        return createIfLet.call(this, {
+          isParenL
+        });
+      const test = this.parseExpression();
+      return createIf.call(this, {
+        test,
+        isParenL
+      });
     }
   };
 }
+function check({ isParenL, isParenR }) {
+  if (!isParenL && !isParenR && this.type !== types$1.braceL)
+    this.raise(this.start, `Use braces ('{', '}') when omit parens ('(', ')')`);
+  if (isParenL !== isParenR)
+    this.raise(this.start, `Use both parens ('(', ')') or none`);
+}
+function createIfLet({ isParenL }) {
+  this.next();
+  this.eat(types$1.assign);
+  const assignmentExpression = this.parseExpression();
+  const isParenR = this.eat(types$1.parenR);
+  check.call(this, {
+    isParenL,
+    isParenR
+  });
+  const ifNode = createIf.call(this, {
+    test: assignmentExpression.left,
+    isParenL
+  });
+  const node = {
+    loc: {},
+    range: [],
+    body: [{
+      type: "VariableDeclaration",
+      kind: "let",
+      declarations: [{
+        type: "VariableDeclarator",
+        id: assignmentExpression.left,
+        init: assignmentExpression.right
+      }]
+    }, ifNode]
+  };
+  return this.finishNode(node, "BlockStatement");
+}
+function createIf({ test, isParenL }) {
+  const node = {
+    test
+  };
+  const isParenR = this.eat(types$1.parenR);
+  check.call(this, {
+    isParenL,
+    isParenR
+  });
+  node.consequent = this.parseStatement("if");
+  node.alternate = this.eat(types$1._else) ? this.parseStatement("if") : null;
+  node.loc = {};
+  node.range = [];
+  setGoldsteinIf(node);
+  return this.finishNode(node, "IfStatement");
+}
 
 // packages/keyword-import/index.js
 var empty2 = [];

package/package.json

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

package/packages/convert/apply-if-let/index.js

@@ -0,0 +1,18 @@
+import {types} from 'putout';
+const {
+    VariableDeclaration,
+    VariableDeclarator,
+} = types;
+
+export const report = () => `Use 'add-array'`;
+export const replace = () => ({
+    '{let __a = __b; if (__c) __d}': ({__a, __b}, path) => {
+        const ifPath = path.get('body.1');
+        ifPath.node.test = VariableDeclaration('let', [
+            VariableDeclarator(__a, __b),
+        ]);
+        
+        return ifPath;
+    },
+});
+

package/packages/convert/index.js

@@ -4,6 +4,7 @@ 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 * as applyIfLet from './apply-if-let/index.js';
 import {
     fixEmpty,
     parse,
@@ -15,6 +16,7 @@ export const convert = (source) => {
     transform(ast, source, {
         plugins: [
             ['add-array', addArray],
+            ['apply-if-let', applyIfLet],
             ['apply-try', applyTry],
             ['remove-import-try', removeImportTry],
         ],

package/packages/keyword-if/index.js

@@ -3,27 +3,85 @@ import {setGoldsteinIf} from '../types/if.js';
 
 export default function fn(Parser) {
     return class extends Parser {
-        parseIfStatement(node) {
+        parseIfStatement() {
             this.next();
-            
             const isParenL = this.eat(tt.parenL);
             
-            node.test = this.parseExpression();
-            const isParenR = this.eat(tt.parenR);
-            
-            if (!isParenL && !isParenR && this.type !== tt.braceL)
-                this.raise(this.start, `Use braces ('{', '}') when omit parens ('(', ')')`);
-            
-            if (isParenL !== isParenR)
-                this.raise(this.start, `Use both parens ('(', ')') or none`);
+            if (this.isContextual('let'))
+                return createIfLet.call(this, {
+                    isParenL,
+                });
             
-            node.consequent = this.parseStatement('if');
-            node.alternate = this.eat(tt._else) ? this.parseStatement('if') : null;
+            const test = this.parseExpression();
             
-            setGoldsteinIf(node);
-            
-            return this.finishNode(node, 'IfStatement');
+            return createIf.call(this, {
+                test,
+                isParenL,
+            });
         }
     };
 }
 
+function check({isParenL, isParenR}) {
+    if (!isParenL && !isParenR && this.type !== tt.braceL)
+        this.raise(this.start, `Use braces ('{', '}') when omit parens ('(', ')')`);
+    
+    if (isParenL !== isParenR)
+        this.raise(this.start, `Use both parens ('(', ')') or none`);
+}
+
+function createIfLet({isParenL}) {
+    this.next();
+    this.eat(tt.assign);
+    
+    const assignmentExpression = this.parseExpression();
+    const isParenR = this.eat(tt.parenR);
+    
+    check.call(this, {
+        isParenL,
+        isParenR,
+    });
+    
+    const ifNode = createIf.call(this, {
+        test: assignmentExpression.left,
+        isParenL,
+    });
+    
+    const node = {
+        loc: {},
+        range: [],
+        body: [{
+            type: 'VariableDeclaration',
+            kind: 'let',
+            declarations: [{
+                type: 'VariableDeclarator',
+                id: assignmentExpression.left,
+                init: assignmentExpression.right,
+            }],
+        }, ifNode],
+    };
+    
+    return this.finishNode(node, 'BlockStatement');
+}
+
+function createIf({test, isParenL}) {
+    const node = {
+        test,
+    };
+    
+    const isParenR = this.eat(tt.parenR);
+    
+    check.call(this, {
+        isParenL,
+        isParenR,
+    });
+    
+    node.consequent = this.parseStatement('if');
+    node.alternate = this.eat(tt._else) ? this.parseStatement('if') : null;
+    node.loc = {};
+    node.range = [];
+    
+    setGoldsteinIf(node);
+    
+    return this.finishNode(node, 'IfStatement');
+}

package/packages/printer/visitors/if-statement.js

@@ -1,12 +1,13 @@
 import {visitors as v} from '@putout/printer';
 
 export const IfStatement = (path, printer, semantics) => {
-    const {print} = printer;
+    const {print, indent} = printer;
     const {node} = path;
     
     if (!node.goldsteinIf)
         return v.IfStatement(path, printer, semantics);
     
+    indent();
     print('if ');
     print('__test');
     print(' ');