goldstein 5.7.1 → 5.8.0

package/ChangeLog

@@ -1,3 +1,15 @@
+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:
+- 3fddd10 goldstein: rm unused
+
 2024.05.11, v5.7.1
 
 feature:

package/README.md

@@ -408,6 +408,23 @@ That absolutely fine, it will be converted to:
 function hello() {}
 ```
 
+### Broken String
+
+When you accidentally broke string:
+
+```gs
+const a = 'hello
+const b = 'world';
+```
+
+Golstein will fix it to:
+
+```js
+const a = 'hello';
+const b = 'world';
+```
+
+
 ## 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.1",
+  "version": "5.8.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,7 @@ 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';
 
 const {values} = Object;
 
@@ -27,6 +28,7 @@ const defaultKeywords = {
     keywordImport,
     keywordArrow,
     keywordAddArray,
+    keywordBrokenString,
     stringInterpolation,
 };
 

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-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/keyword-try/index.js

@@ -104,16 +104,3 @@ export default function keywordTry(Parser) {
         }
     };
 }
-
-export function createGoldsteinTry(args) {
-    return {
-        type: 'TryStatement',
-        expression: true,
-        await: args.await,
-        argument: {
-            type: 'CallExpression',
-            callee: args.callee,
-            arguments: args.args,
-        },
-    };
-}

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