goldstein 5.7.2 → 5.9.0

package/ChangeLog

@@ -1,3 +1,15 @@
+2024.05.23, v5.9.0
+
+feature:
+- 1a9585b goldstein: missing-initializer: add
+
+2024.05.22, v5.8.0
+
+feature:
+- 2bd6e8c test: do not fail when update tests
+- f4fb1d6 goldstein: broken strings
+- e80d132 goldstein: check-dts v0.8.0
+
 2024.05.11, v5.7.2
 
 fix:

package/README.md

@@ -408,6 +408,31 @@ That absolutely fine, it will be converted to:
 function hello() {}
 ```
 
+### Broken String
+
+When you accidentally broke string:
+
+```gs
+const a = 'hello
+const b = 'world';
+```
+
+Goldstein will fix it to:
+
+```js
+const a = 'hello';
+const b = 'world';
+```
+
+### Missing Initializer
+
+Forget to add assignment (`=`), not problem!
+
+```gs
+-const {code, places} await samadhi(source);
++const {code, places} = await samadhi(source);
+```
+
 ## How to contribute?
 
 Clone the registry, create a new keyword with a prefix `keyword-`, then create directory `fixture` and put there two files with extensions `.js` and `.gs`. Half way done 🥳!

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "goldstein",
-  "version": "5.7.2",
+  "version": "5.9.0",
   "type": "module",
   "author": "coderaiser <mnemonic.enemy@gmail.com> (https://github.com/coderaiser)",
   "description": "JavaScript with no limits",
@@ -45,10 +45,9 @@
     "@putout/plugin-goldstein": "./rules/goldstein",
     "@putout/test": "^9.0.1",
     "c8": "^9.1.0",
-    "check-dts": "^0.7.1",
+    "check-dts": "^0.8.0",
     "esbuild": "^0.21.1",
     "esbuild-node-builtins": "^0.1.0",
-    "escover": "^4.0.1",
     "eslint": "^9.2.0",
     "eslint-plugin-putout": "^22.0.0",
     "madrun": "^10.0.0",

package/packages/goldstein/parser.js

@@ -12,6 +12,8 @@ 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';
+import keywordBrokenString from '../keyword-broken-string/index.js';
+import keywordMissingInitializer from '../keyword-missing-initializer/index.js';
 
 const {values} = Object;
 
@@ -27,7 +29,9 @@ const defaultKeywords = {
     keywordImport,
     keywordArrow,
     keywordAddArray,
+    keywordBrokenString,
     stringInterpolation,
+    keywordMissingInitializer,
 };
 
 export const keywords = defaultKeywords;

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

@@ -14,6 +14,7 @@ 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);
@@ -23,6 +24,7 @@ export default function keywordAddArray(Parser) {
                 this.exprAllowed = false;
             }
             
+            /* c8 ignore end */
             let ownDestructuringErrors = false;
             let oldParenAssign = -1;
             let oldTrailingComma = -1;

package/packages/keyword-arrow/index.js

@@ -22,9 +22,11 @@ export default function fn(Parser) {
                 node.body.push(stmt);
             }
             
+            /* c8 ignore start */
             if (exitStrict)
                 this.strict = false;
             
+            /* c8 ignore end */
             this.next();
             
             if (createNewLexicalScope)

package/packages/keyword-broken-string/index.js

@@ -0,0 +1,61 @@
+import {tokTypes as tt} from '../operator/index.js';
+
+export default function keywordBrokenString(Parser) {
+    return class extends Parser {
+        parseVarStatement(node, kind, allowMissingInitializer) {
+            this.next();
+            this.parseVar(node, false, kind, allowMissingInitializer);
+            this.eat(tt.semi);
+            
+            return this.finishNode(node, 'VariableDeclaration');
+        }
+        
+        readString(quote) {
+            let out = '';
+            let chunkStart = ++this.pos;
+            
+            for (;;) {
+                const ch = this.input.charCodeAt(this.pos);
+                
+                if (ch === quote)
+                    break;
+                
+                /* c8 ignore start */
+                if (ch === 92) {
+                    // '\'
+                    out += this.input.slice(chunkStart, this.pos);
+                    out += this.readEscapedChar(false);
+                    chunkStart = this.pos;
+                } else if (ch === 0x2028 || ch === 0x2029) {
+                    if (this.options.ecmaVersion < 10)
+                        this.raise(this.start, 'Unterminated string constant');
+                    
+                    ++this.pos;
+                    
+                    if (this.options.locations) {
+                        this.curLine++;
+                        this.lineStart = this.pos;
+                    }
+                    /* c8 ignore end */
+                } else {
+                    if (isNewLine(ch)) {
+                        if (this.input[this.pos - 1] === ';')
+                            --this.pos;
+                        
+                        break;
+                    }
+                    
+                    ++this.pos;
+                }
+            }
+            
+            out += this.input.slice(chunkStart, this.pos++);
+            
+            return this.finishToken(tt.string, out);
+        }
+    };
+}
+
+function isNewLine(code) {
+    return code === 10 || code === 13 || code === 0x2028 || code === 0x2029;
+}

package/packages/keyword-import/index.js

@@ -8,9 +8,10 @@ export default function keywordImport(Parser) {
             this.next();
             
             // import '...'
+            /* c8 ignore start */
             if (this.type === tokTypes.string) {
                 node.specifiers = empty;
-                node.source = this.parseExprAtom();
+                node.source = this.parseExprAtom(); /* c8 ignore end */
             } else {
                 node.specifiers = this.parseImportSpecifiers();
                 this.expectContextual('from');

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

@@ -0,0 +1,31 @@
+import {tokTypes as tt} from '../operator/index.js';
+
+export default function keywordMissingInitializer(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.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'))))
+                    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;
+        }
+    };
+}

package/packages/keyword-should/index.js

@@ -80,8 +80,6 @@ export default function newSpeak(Parser) {
                         },
                     },
                 };
-            else
-                this.raise(this.start, `After 'should' only 'await' and 'function call' can come`);
             
             return super.finishNode(node, 'ExpressionStatement');
         }

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

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