goldstein 5.13.2 → 5.15.0

package/ChangeLog

@@ -1,3 +1,13 @@
+2024.06.03, v5.15.0
+
+feature:
+- 5d11929 goldstein: keyword-useless-comma: class methods
+
+2024.06.03, v5.14.0
+
+feature:
+- 7e81e0e goldstein: keyword-assign-from: add
+
 2024.06.03, v5.13.2
 
 fix:

package/README.md

@@ -464,6 +464,23 @@ const a = {
 -    b;
 +    b,
 };
+
+const a = {
+-    b(){},
++    b(){}
+};
+```
+
+### Assign from
+
+```gs
+const a = from 'a';
+```
+
+The same as:
+
+```js
+const a = require('a');
 ```
 
 ## How to contribute?

package/package.json

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

package/packages/goldstein/index.js

@@ -8,7 +8,7 @@ import {parse} from './parser.js';
 export {convert} from '../convert/index.js';
 export {print} from '../printer/index.js';
 export * from './parser.js';
-import * as renameUnnamedIdentifier from '../keyword-useless-comma/rename-unnamed-identifier/index.js';
+import * as removeUnnamedObjectProperty from '../keyword-useless-comma/remove-unnamed-object-property/index.js';
 
 export const compile = (source, options = {}) => {
     const ast = parse(source, options);
@@ -21,7 +21,7 @@ export const compile = (source, options = {}) => {
             ['try-catch', tryCatchPlugin],
             ['declare', declarePlugin],
             ['logical-expressions', logicalExpressionsPlugin],
-            ['remove-unnamed-identifiers', renameUnnamedIdentifier],
+            ['remove-unnamed-identifiers', removeUnnamedObjectProperty],
         ],
     });
     

package/packages/goldstein/parser.js

@@ -17,6 +17,8 @@ import keywordBrokenString from '../keyword-broken-string/index.js';
 import keywordMissingInitializer from '../keyword-missing-initializer/index.js';
 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';
 
 const {values} = Object;
 
@@ -37,8 +39,13 @@ const defaultKeywords = {
     keywordMissingInitializer,
     keywordUselessComma,
     keywordUselessSemicolon,
+    keywordAssignFrom,
 };
 
+const internals = [
+    internalParseMaybeAssign,
+];
+
 export const keywords = defaultKeywords;
 
 export const parse = (source, options = {}) => {
@@ -47,6 +54,7 @@ export const parse = (source, options = {}) => {
     
     const {parse} = extendParser([
         typescript(),
+        ...internals,
         ...extensions,
     ]);
     

package/packages/internal-parse-maybe-assign/index.js

@@ -0,0 +1,114 @@
+import {tokTypes as tt} from 'acorn';
+import {types} from 'putout';
+import {DestructuringErrors} from '../operator/index.js';
+
+const {isArrayExpression} = types;
+
+export default function internalParseMaybeAssign(Parser) {
+    return class extends Parser {
+        parseMaybeAssign(forInit, refDestructuringErrors, afterLeftParse) {
+            return parseMaybeAssign.call(this, forInit, refDestructuringErrors, afterLeftParse);
+        }
+        
+        goldsteinParseFrom() {
+            throw Error(`☝️Looks like 'keyword-assign-from' is missing.`);
+        }
+        
+        goldsteinCreateAddArray() {
+            throw Error(`☝️Looks like 'keyword-add-array' is missing.`);
+        }
+    };
+}
+
+export function parseMaybeAssign(forInit, refDestructuringErrors, afterLeftParse) {
+    /* c8 ignore start */
+    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; /* c8 ignore end */
+    }
+    
+    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 = -1;
+        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);
+    
+    /* c8 ignore start */
+    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 = -1;
+            refDestructuringErrors.trailingComma = -1;
+            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 this.goldsteinCreateAddArray(node);
+        
+        return this.finishNode(node, 'AssignmentExpression');
+    }
+    
+    /* c8 ignore end */
+    if (ownDestructuringErrors)
+        this.checkExpressionErrors(refDestructuringErrors, true);
+    
+    if (oldParenAssign > -1)
+        refDestructuringErrors.parenthesizedAssign = oldParenAssign;
+    
+    if (oldTrailingComma > -1)
+        refDestructuringErrors.trailingComma = oldTrailingComma;
+    
+    if (left.name === 'from')
+        return this.goldsteinParseFrom(left);
+    
+    return left;
+}

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

@@ -1,12 +1,10 @@
 import {types} from 'putout';
-import {tokTypes as tt} from 'acorn';
-import {DestructuringErrors} from '../operator/index.js';
+import {parseMaybeAssign} from '../internal-parse-maybe-assign/index.js';
 
 const {assign} = Object;
 
 const {
     identifier,
-    isArrayExpression,
     memberExpression,
     spreadElement,
 } = types;
@@ -14,103 +12,18 @@ const {
 export default function keywordAddArray(Parser) {
     return class extends Parser {
         parseMaybeAssign(forInit, refDestructuringErrors, afterLeftParse) {
-            /* c8 ignore start */
-            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;
-            }
-            
-            /* c8 ignore end */
-            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 = -1;
-                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 = -1;
-                    refDestructuringErrors.trailingComma = -1;
-                    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;
+            return parseMaybeAssign.call(this, forInit, refDestructuringErrors, afterLeftParse);
+        }
+        
+        goldsteinCreateAddArray(node) {
+            const {left, right} = node;
             
-            if (oldTrailingComma > -1)
-                refDestructuringErrors.trailingComma = oldTrailingComma;
+            assign(node, {
+                callee: memberExpression(left, identifier('push')),
+                arguments: [spreadElement(right)],
+            });
             
-            return left;
+            return this.finishNode(node, 'CallExpression');
         }
     };
 }
-
-function createAppendNode(context, node) {
-    const {left, right} = node;
-    
-    assign(node, {
-        callee: memberExpression(left, identifier('push')),
-        arguments: [spreadElement(right)],
-    });
-    
-    return context.finishNode(node, 'CallExpression');
-}

package/packages/keyword-assign-from/index.js

@@ -0,0 +1,26 @@
+import {tokTypes as tt} from '../operator/index.js';
+import {parseMaybeAssign} from '../internal-parse-maybe-assign/index.js';
+
+export default function fn(Parser) {
+    return class extends Parser {
+        parseMaybeAssign(forInit, refDestructuringErrors, afterLeftParse) {
+            return parseMaybeAssign.call(this, forInit, refDestructuringErrors, afterLeftParse);
+        }
+        
+        goldsteinParseFrom(node) {
+            if (this.type === tt.semi)
+                return node;
+            
+            const arg = this.parseExprAtom();
+            
+            return {
+                type: 'CallExpression',
+                callee: {
+                    type: 'Identifier',
+                    name: 'require',
+                },
+                arguments: [arg],
+            };
+        }
+    };
+}

package/packages/keyword-useless-comma/{rename-unnamed-identifier → remove-unnamed-object-property}/index.js

@@ -1,7 +1,7 @@
 export const report = () => {};
 export const fix = (path) => path.remove();
 export const traverse = ({push}) => ({
-    ObjectProperty(path) {
+    'ObjectProperty|ClassProperty'(path) {
         const keyPath = path.get('key');
         
         if (keyPath.isIdentifier() && !keyPath.node.name)