esupgrade 2025.3.0 → 2025.3.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "esupgrade",
-  "version": "2025.3.0",
+  "version": "2025.3.1",
   "description": "Auto-upgrade your JavaScript syntax",
   "type": "module",
   "main": "src/index.js",

package/src/widelyAvailable.js

@@ -68,17 +68,32 @@ export function concatToTemplateLiteral(j, root) {
         return false
       }
 
-      const addStringPart = (value) => {
+      // Helper to get the raw value of a string literal (preserving escape sequences)
+      const getRawStringValue = (node) => {
+        // In string literals, backslashes are used for escape sequences
+        // In template literals, backslashes in the raw value also need escaping
+        // So we need to double the backslashes: \\ -> \\\\
+        // Note: node.extra.rawValue is always defined for string literals with the current parser
+        return node.extra.rawValue.replace(/\\/g, "\\\\")
+      }
+
+      const addStringPart = (stringNode) => {
+        // Store both the raw and cooked values
+        const rawValue = getRawStringValue(stringNode)
+        const cookedValue = stringNode.value
+
         if (parts.length === 0 || expressions.length >= parts.length) {
-          parts.push(value)
+          parts.push({ raw: rawValue, cooked: cookedValue })
         } else {
-          parts[parts.length - 1] += value
+          const lastPart = parts[parts.length - 1]
+          lastPart.raw += rawValue
+          lastPart.cooked += cookedValue
         }
       }
 
       const addExpression = (expr) => {
         if (parts.length === 0) {
-          parts.push("")
+          parts.push({ raw: "", cooked: "" })
         }
         expressions.push(expr)
       }
@@ -103,8 +118,8 @@ export function concatToTemplateLiteral(j, root) {
               // Left is also a + expression - recurse
               flatten(node.left, stringContext)
             } else if (isStringLiteral(node.left)) {
-              // Left is a string literal
-              addStringPart(node.left.value)
+              // Left is a string literal - use raw value to preserve escape sequences
+              addStringPart(node.left)
             } else {
               // Left is some other expression
               addExpression(node.left)
@@ -121,8 +136,8 @@ export function concatToTemplateLiteral(j, root) {
                 flatten(node.right, rightInStringContext)
               }
             } else if (isStringLiteral(node.right)) {
-              // Right is a string literal
-              addStringPart(node.right.value)
+              // Right is a string literal - use raw value to preserve escape sequences
+              addStringPart(node.right)
             } else {
               // Right is some other expression
               addExpression(node.right)
@@ -135,12 +150,15 @@ export function concatToTemplateLiteral(j, root) {
 
       // Ensure we have the right number of quasis (one more than expressions)
       while (parts.length <= expressions.length) {
-        parts.push("")
+        parts.push({ raw: "", cooked: "" })
       }
 
       // Create template literal
       const quasis = parts.map((part, i) =>
-        j.templateElement({ raw: part, cooked: part }, i === parts.length - 1),
+        j.templateElement(
+          { raw: part.raw, cooked: part.cooked },
+          i === parts.length - 1,
+        ),
       )
 
       const templateLiteral = j.templateLiteral(quasis, expressions)
@@ -913,62 +931,6 @@ export function anonymousFunctionToArrow(j, root) {
     return found
   }
 
-  // Helper to check if a node or its descendants use 'super'
-  const usesSuper = (node) => {
-    let found = false
-
-    const visit = (n) => {
-      if (!n || typeof n !== "object" || found) return
-
-      // If we encounter a nested function, don't traverse into it
-      // as it has its own 'super' binding context
-      if (n.type === "FunctionExpression" || n.type === "FunctionDeclaration") {
-        return
-      }
-
-      // Check if this is a 'super' node
-      if (n.type === "Super") {
-        found = true
-        return
-      }
-
-      // Traverse all child nodes
-      for (const key in n) {
-        if (
-          key === "loc" ||
-          key === "start" ||
-          key === "end" ||
-          key === "tokens" ||
-          key === "comments" ||
-          key === "type"
-        ) {
-          continue
-        }
-        const value = n[key]
-        if (Array.isArray(value)) {
-          for (const item of value) {
-            visit(item)
-            if (found) return
-          }
-        } else if (value && typeof value === "object") {
-          visit(value)
-        }
-      }
-    }
-
-    // Start visiting from the function body's child nodes
-    // Don't check the body node itself, check its contents
-    // Note: FunctionExpression.body is always a BlockStatement
-    if (node.type === "BlockStatement" && node.body) {
-      for (const statement of node.body) {
-        visit(statement)
-        if (found) break
-      }
-    }
-
-    return found
-  }
-
   root
     .find(j.FunctionExpression)
     .filter((path) => {
@@ -996,10 +958,8 @@ export function anonymousFunctionToArrow(j, root) {
         return false
       }
 
-      // Skip if it uses 'super'
-      if (usesSuper(node.body)) {
-        return false
-      }
+      // Note: We don't need to check for 'super' because using super in a
+      // function expression is a syntax error and will never parse successfully
 
       return true
     })

package/tests/cli.test.js

@@ -1,6 +1,6 @@
-import { describe, test, beforeEach, afterEach } from "node:test"
-import assert from "node:assert"
-import { execSync, spawnSync } from "node:child_process"
+import { afterEach, beforeEach, describe, test } from "node:test"
+import assert from "node:assert/strict"
+import { spawnSync } from "node:child_process"
 import fs from "node:fs"
 import path from "node:path"
 import os from "node:os"
@@ -20,50 +20,63 @@ describe("CLI", () => {
     }
   })
 
-  test("should display help when no files specified", () => {
+  test("display help when no files specified", () => {
     const result = spawnSync(process.execPath, [CLI_PATH], {
       encoding: "utf8",
     })
 
-    assert.match(result.stderr, /Error: No files specified/)
-    // Commander shows help and exits with 0
-    assert.strictEqual(result.status, 0)
+    assert.match(
+      result.stderr,
+      /Error: No files specified/,
+      "displays error for no files",
+    )
+    assert.equal(result.status, 0, "exits with 0 when showing help")
   })
 
-  test("should transform a single file with --write", () => {
+  test("transform a single file with --write", () => {
     const testFile = path.join(tempDir, "test.js")
-    const originalCode = `var x = 1;`
-    fs.writeFileSync(testFile, originalCode)
+    fs.writeFileSync(testFile, `var x = 1;`)
 
     const result = spawnSync(process.execPath, [CLI_PATH, testFile, "--write"], {
       encoding: "utf8",
     })
 
-    const transformedCode = fs.readFileSync(testFile, "utf8")
-    assert.match(transformedCode, /const x = 1/)
-    assert.match(result.stdout, /✓ 1 file\(s\) upgraded/)
-    assert.strictEqual(result.status, 0)
+    assert.match(
+      fs.readFileSync(testFile, "utf8"),
+      /const x = 1/,
+      "transforms var to const",
+    )
+    assert.match(result.stdout, /✓ 1 file\(s\) upgraded/, "reports 1 file upgraded")
+    assert.equal(result.status, 0, "exits successfully")
   })
 
-  test("should transform files with widely-available baseline by default", () => {
+  test("transform files with widely-available baseline by default", () => {
     const testFile = path.join(tempDir, "test.js")
-    const originalCode = `var x = 1;\nconst p = new Promise((resolve) => resolve(getData()));`
-    fs.writeFileSync(testFile, originalCode)
+    fs.writeFileSync(
+      testFile,
+      `var x = 1;\nconst p = new Promise((resolve) => resolve(getData()));`,
+    )
 
     const result = spawnSync(process.execPath, [CLI_PATH, testFile, "--write"], {
       encoding: "utf8",
     })
 
     const transformedCode = fs.readFileSync(testFile, "utf8")
-    assert.match(transformedCode, /const x = 1/)
-    assert.doesNotMatch(transformedCode, /Promise\.try/) // Promise.try not in widely-available
-    assert.strictEqual(result.status, 0)
+    assert.match(transformedCode, /const x = 1/, "transforms var to const")
+    assert.doesNotMatch(
+      transformedCode,
+      /Promise\.try/,
+      "excludes Promise.try for widely-available baseline",
+    )
+    assert.equal(result.status, 0, "exits successfully")
   })
 
-  test("should transform files with newly-available baseline", () => {
+  test("transform files with newly-available baseline", () => {
     const testFile = path.join(tempDir, "test.js")
-    const originalCode = `var x = 1;\nconst p = new Promise((resolve) => resolve(getData()));`
-    fs.writeFileSync(testFile, originalCode)
+    fs.writeFileSync(
+      testFile,
+      `var x = 1;\nconst p = new Promise((resolve) => resolve(getData()));`,
+    )
 
     const result = spawnSync(
       process.execPath,
@@ -74,12 +87,16 @@ describe("CLI", () => {
     )
 
     const transformedCode = fs.readFileSync(testFile, "utf8")
-    assert.match(transformedCode, /const x = 1/)
-    assert.match(transformedCode, /Promise\.try/) // Promise.try in newly-available
-    assert.strictEqual(result.status, 0)
+    assert.match(transformedCode, /const x = 1/, "transforms var to const")
+    assert.match(
+      transformedCode,
+      /Promise\.try/,
+      "includes Promise.try for newly-available baseline",
+    )
+    assert.equal(result.status, 0, "exits successfully")
   })
 
-  test("should check files without writing with --check", () => {
+  test("check files without writing with --check", () => {
     const testFile = path.join(tempDir, "test.js")
     const originalCode = `var x = 1;`
     fs.writeFileSync(testFile, originalCode)
@@ -88,14 +105,21 @@ describe("CLI", () => {
       encoding: "utf8",
     })
 
-    const fileContent = fs.readFileSync(testFile, "utf8")
-    assert.strictEqual(fileContent, originalCode) // File unchanged
-    assert.match(result.stdout, /✗/)
-    assert.match(result.stdout, /1 file\(s\) need upgrading/)
-    assert.strictEqual(result.status, 1) // Exit with code 1 when changes needed
+    assert.equal(
+      fs.readFileSync(testFile, "utf8"),
+      originalCode,
+      "leaves file unchanged",
+    )
+    assert.match(result.stdout, /✗/, "indicates changes needed")
+    assert.match(
+      result.stdout,
+      /1 file\(s\) need upgrading/,
+      "reports 1 file needs upgrading",
+    )
+    assert.equal(result.status, 1, "exits with 1 when changes needed")
   })
 
-  test("should exit with 0 when --check and no changes needed", () => {
+  test("exit with 0 when --check and no changes needed", () => {
     const testFile = path.join(tempDir, "test.js")
     const originalCode = `const x = 1;`
     fs.writeFileSync(testFile, originalCode)
@@ -104,16 +128,22 @@ describe("CLI", () => {
       encoding: "utf8",
     })
 
-    const fileContent = fs.readFileSync(testFile, "utf8")
-    assert.strictEqual(fileContent, originalCode) // File unchanged
-    assert.match(result.stdout, /All files are up to date/)
-    assert.strictEqual(result.status, 0)
+    assert.equal(
+      fs.readFileSync(testFile, "utf8"),
+      originalCode,
+      "leaves file unchanged",
+    )
+    assert.match(
+      result.stdout,
+      /All files are up to date/,
+      "reports all files up to date",
+    )
+    assert.equal(result.status, 0, "exits with 0")
   })
 
-  test("should support both --check and --write together", () => {
+  test("support both --check and --write together", () => {
     const testFile = path.join(tempDir, "test.js")
-    const originalCode = `var x = 1;`
-    fs.writeFileSync(testFile, originalCode)
+    fs.writeFileSync(testFile, `var x = 1;`)
 
     const result = spawnSync(
       process.execPath,
@@ -123,14 +153,17 @@ describe("CLI", () => {
       },
     )
 
-    const transformedCode = fs.readFileSync(testFile, "utf8")
-    assert.match(transformedCode, /const x = 1/)
-    assert.match(result.stdout, /✗/)
-    assert.match(result.stdout, /Changes have been written/)
-    assert.strictEqual(result.status, 1) // Still exit 1 with --check
+    assert.match(
+      fs.readFileSync(testFile, "utf8"),
+      /const x = 1/,
+      "transforms var to const",
+    )
+    assert.match(result.stdout, /✗/, "indicates changes needed")
+    assert.match(result.stdout, /Changes have been written/, "reports changes written")
+    assert.equal(result.status, 1, "exits with 1 with --check")
   })
 
-  test("should process directory recursively", () => {
+  test("process directory recursively", () => {
     const subDir = path.join(tempDir, "src")
     fs.mkdirSync(subDir)
 
@@ -143,36 +176,31 @@ describe("CLI", () => {
       encoding: "utf8",
     })
 
-    const transformed1 = fs.readFileSync(file1, "utf8")
-    const transformed2 = fs.readFileSync(file2, "utf8")
-    assert.match(transformed1, /const x = 1/)
-    assert.match(transformed2, /const y = 2/)
-    assert.match(result.stdout, /2 file\(s\) upgraded/)
-    assert.strictEqual(result.status, 0)
+    assert.match(fs.readFileSync(file1, "utf8"), /const x = 1/, "transforms file1")
+    assert.match(fs.readFileSync(file2, "utf8"), /const y = 2/, "transforms file2")
+    assert.match(result.stdout, /2 file\(s\) upgraded/, "reports 2 files upgraded")
+    assert.equal(result.status, 0, "exits successfully")
   })
 
-  test("should skip node_modules and .git directories", () => {
+  test("skip node_modules and .git directories", () => {
     const nodeModules = path.join(tempDir, "node_modules")
     const gitDir = path.join(tempDir, ".git")
     fs.mkdirSync(nodeModules)
     fs.mkdirSync(gitDir)
 
     const file1 = path.join(tempDir, "test.js")
-    const file2 = path.join(nodeModules, "test.js")
-    const file3 = path.join(gitDir, "test.js")
     fs.writeFileSync(file1, `var x = 1;`)
-    fs.writeFileSync(file2, `var y = 2;`)
-    fs.writeFileSync(file3, `var z = 3;`)
+    fs.writeFileSync(path.join(nodeModules, "test.js"), `var y = 2;`)
+    fs.writeFileSync(path.join(gitDir, "test.js"), `var z = 3;`)
 
     const result = spawnSync(process.execPath, [CLI_PATH, tempDir, "--write"], {
       encoding: "utf8",
     })
 
-    // Should only process file1 in tempDir, not in node_modules or .git
-    assert.strictEqual(result.status, 0)
+    assert.equal(result.status, 0, "exits successfully skipping ignored dirs")
   })
 
-  test("should process multiple file extensions", () => {
+  test("process multiple file extensions", () => {
     const jsFile = path.join(tempDir, "test.js")
     const mjsFile = path.join(tempDir, "test.mjs")
     const cjsFile = path.join(tempDir, "test.cjs")
@@ -187,11 +215,11 @@ describe("CLI", () => {
       encoding: "utf8",
     })
 
-    assert.match(result.stdout, /4 file\(s\) upgraded/)
-    assert.strictEqual(result.status, 0)
+    assert.match(result.stdout, /4 file\(s\) upgraded/, "reports 4 files upgraded")
+    assert.equal(result.status, 0, "exits successfully")
   })
 
-  test("should handle TypeScript file extensions", () => {
+  test("handle TypeScript file extensions", () => {
     const tsFile = path.join(tempDir, "test.ts")
     const tsxFile = path.join(tempDir, "test.tsx")
 
@@ -202,10 +230,10 @@ describe("CLI", () => {
       encoding: "utf8",
     })
 
-    assert.strictEqual(result.status, 0)
+    assert.equal(result.status, 0, "exits successfully for TS files")
   })
 
-  test("should error on invalid baseline", () => {
+  test("error on invalid baseline", () => {
     const testFile = path.join(tempDir, "test.js")
     fs.writeFileSync(testFile, `var x = 1;`)
 
@@ -217,11 +245,11 @@ describe("CLI", () => {
       },
     )
 
-    assert.match(result.stderr, /error/)
-    assert.strictEqual(result.status, 1)
+    assert.match(result.stderr, /error/, "displays error for invalid baseline")
+    assert.equal(result.status, 1, "exits with 1")
   })
 
-  test("should error on non-existent file", () => {
+  test("error on non-existent file", () => {
     const result = spawnSync(
       process.execPath,
       [CLI_PATH, path.join(tempDir, "nonexistent.js")],
@@ -230,24 +258,27 @@ describe("CLI", () => {
       },
     )
 
-    assert.match(result.stderr, /Error: Cannot access/)
-    assert.strictEqual(result.status, 1)
+    assert.match(
+      result.stderr,
+      /Error: Cannot access/,
+      "displays error for non-existent file",
+    )
+    assert.equal(result.status, 1, "exits with 1")
   })
 
-  test("should show detailed changes with --check", () => {
+  test("show detailed changes with --check", () => {
     const testFile = path.join(tempDir, "test.js")
-    const originalCode = `var x = 1;\nvar y = 2;`
-    fs.writeFileSync(testFile, originalCode)
+    fs.writeFileSync(testFile, `var x = 1;\nvar y = 2;`)
 
     const result = spawnSync(process.execPath, [CLI_PATH, testFile, "--check"], {
       encoding: "utf8",
     })
 
-    assert.match(result.stdout, /var to const/)
-    assert.strictEqual(result.status, 1)
+    assert.match(result.stdout, /var to const/, "shows var to const changes")
+    assert.equal(result.status, 1, "exits with 1")
   })
 
-  test("should process multiple files specified as arguments", () => {
+  test("process multiple files specified as arguments", () => {
     const file1 = path.join(tempDir, "test1.js")
     const file2 = path.join(tempDir, "test2.js")
     fs.writeFileSync(file1, `var x = 1;`)
@@ -257,15 +288,13 @@ describe("CLI", () => {
       encoding: "utf8",
     })
 
-    const transformed1 = fs.readFileSync(file1, "utf8")
-    const transformed2 = fs.readFileSync(file2, "utf8")
-    assert.match(transformed1, /const x = 1/)
-    assert.match(transformed2, /const y = 2/)
-    assert.match(result.stdout, /2 file\(s\) upgraded/)
-    assert.strictEqual(result.status, 0)
+    assert.match(fs.readFileSync(file1, "utf8"), /const x = 1/, "transforms file1")
+    assert.match(fs.readFileSync(file2, "utf8"), /const y = 2/, "transforms file2")
+    assert.match(result.stdout, /2 file\(s\) upgraded/, "reports 2 files upgraded")
+    assert.equal(result.status, 0, "exits successfully")
   })
 
-  test("should handle files with no changes needed", () => {
+  test("handle files with no changes needed", () => {
     const testFile = path.join(tempDir, "test.js")
     const originalCode = `const x = 1;`
     fs.writeFileSync(testFile, originalCode)
@@ -274,13 +303,20 @@ describe("CLI", () => {
       encoding: "utf8",
     })
 
-    const fileContent = fs.readFileSync(testFile, "utf8")
-    assert.strictEqual(fileContent, originalCode)
-    assert.match(result.stdout, /All files are up to date/)
-    assert.strictEqual(result.status, 0)
+    assert.equal(
+      fs.readFileSync(testFile, "utf8"),
+      originalCode,
+      "leaves file unchanged",
+    )
+    assert.match(
+      result.stdout,
+      /All files are up to date/,
+      "reports all files up to date",
+    )
+    assert.equal(result.status, 0, "exits successfully")
   })
 
-  test("should show no changes message for individual files", () => {
+  test("show no changes message for individual files", () => {
     const testFile = path.join(tempDir, "test.js")
     const originalCode = `const x = 1;`
     fs.writeFileSync(testFile, originalCode)
@@ -289,11 +325,15 @@ describe("CLI", () => {
       encoding: "utf8",
     })
 
-    assert.match(result.stdout, /All files are up to date/)
-    assert.strictEqual(result.status, 0)
+    assert.match(
+      result.stdout,
+      /All files are up to date/,
+      "reports all files up to date",
+    )
+    assert.equal(result.status, 0, "exits successfully")
   })
 
-  test("should handle empty directory", () => {
+  test("handle empty directory", () => {
     const emptyDir = path.join(tempDir, "empty")
     fs.mkdirSync(emptyDir)
 
@@ -301,37 +341,39 @@ describe("CLI", () => {
       encoding: "utf8",
     })
 
-    assert.match(result.stdout, /No JavaScript files found/)
-    assert.strictEqual(result.status, 0)
+    assert.match(
+      result.stdout,
+      /No JavaScript files found/,
+      "reports no JS files found",
+    )
+    assert.equal(result.status, 0, "exits successfully")
   })
 
-  test("should group changes by type in --check output", () => {
+  test("group changes by type in --check output", () => {
     const testFile = path.join(tempDir, "test.js")
-    const originalCode = `var x = 1;\nvar y = 2;\nvar z = 3;`
-    fs.writeFileSync(testFile, originalCode)
+    fs.writeFileSync(testFile, `var x = 1;\nvar y = 2;\nvar z = 3;`)
 
     const result = spawnSync(process.execPath, [CLI_PATH, testFile, "--check"], {
       encoding: "utf8",
     })
 
-    assert.match(result.stdout, /var to const/)
-    assert.strictEqual(result.status, 1)
+    assert.match(result.stdout, /var to const/, "shows var to const changes")
+    assert.equal(result.status, 1, "exits with 1")
   })
 
-  test("should handle syntax errors gracefully", () => {
+  test("handle syntax errors gracefully", () => {
     const testFile = path.join(tempDir, "test.js")
-    const invalidCode = `var x = {{{;`
-    fs.writeFileSync(testFile, invalidCode)
+    fs.writeFileSync(testFile, `var x = {{{;`)
 
     const result = spawnSync(process.execPath, [CLI_PATH, testFile, "--write"], {
       encoding: "utf8",
     })
 
-    assert.match(result.stderr, /✗ Error:/)
-    assert.strictEqual(result.status, 0) // CLI continues despite errors
+    assert.match(result.stderr, /✗ Error:/, "displays error for syntax issues")
+    assert.equal(result.status, 0, "continues despite errors")
   })
 
-  test("should handle mixed directory and file arguments", () => {
+  test("handle mixed directory and file arguments", () => {
     const subDir = path.join(tempDir, "src")
     fs.mkdirSync(subDir)
 
@@ -344,11 +386,9 @@ describe("CLI", () => {
       encoding: "utf8",
     })
 
-    const file1Content = fs.readFileSync(file1, "utf8")
-    const file2Content = fs.readFileSync(file2, "utf8")
-    assert.match(file1Content, /const x = 1/)
-    assert.match(file2Content, /const y = 2/)
-    assert.match(result.stdout, /2 file\(s\) upgraded/)
-    assert.strictEqual(result.status, 0)
+    assert.match(fs.readFileSync(file1, "utf8"), /const x = 1/, "transforms file1")
+    assert.match(fs.readFileSync(file2, "utf8"), /const y = 2/, "transforms file2")
+    assert.match(result.stdout, /2 file\(s\) upgraded/, "reports 2 files upgraded")
+    assert.equal(result.status, 0, "exits successfully")
   })
 })