goldstein 4.9.0 → 4.10.0

package/ChangeLog

@@ -1,3 +1,13 @@
+2023.10.19, v4.10.0
+
+feature:
+- 0b4756a goldstein: add if let
+
+2023.10.19, v4.9.1
+
+fix:
+- aff82e3 goldstein: simplify
+
 2023.10.19, v4.9.0
 
 feature:

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 = [];
@@ -5993,7 +6042,6 @@ function keywordAddArray(Parser3) {
 function createAppendNode(context, node) {
   const { left, right } = node;
   assign3(node, {
-    a: "x",
     callee: memberExpression(left, identifier("push")),
     arguments: [spreadElement(right)]
   });

package/package.json

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

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

@@ -112,7 +112,6 @@ function createAppendNode(context, node) {
     const {left, right} = node;
     
     assign(node, {
-        a: 'x',
         callee: memberExpression(left, identifier('push')),
         arguments: [spreadElement(right)],
     });

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');
+}