esupgrade 2025.0.0 → 2025.0.1

package/tests/newlyAvailable.test.js

@@ -0,0 +1,221 @@
+import { describe, test } from "node:test"
+import assert from "node:assert"
+import { transform } from "../src/index.js"
+
+describe("newly-available", () => {
+  describe("Promise.try", () => {
+    test("Promise.try transformation - newly-available", () => {
+      const input = `const p = new Promise((resolve) => resolve(getData()));`
+
+      const result = transform(input, "newly-available")
+
+      assert.strictEqual(result.modified, true)
+      assert.match(result.code, /Promise\.try/)
+    })
+
+    test("Promise.try not in widely-available", () => {
+      const input = `const p = new Promise((resolve) => resolve(getData()));`
+
+      const result = transform(input, "widely-available")
+
+      // Should not transform Promise with widely-available baseline
+      assert.doesNotMatch(result.code, /Promise\.try/)
+    })
+
+    test("Promise.try with function passed to resolve", () => {
+      const input = `const p = new Promise((resolve) => setTimeout(resolve));`
+
+      const result = transform(input, "newly-available")
+
+      assert.strictEqual(result.modified, true)
+      // Should transform to Promise.try(setTimeout) not Promise.try(() => setTimeout(resolve))
+      assert.match(result.code, /Promise\.try\(setTimeout\)/)
+      assert.doesNotMatch(result.code, /resolve/)
+    })
+
+    test("Promise.try should not transform when awaited", () => {
+      const input = `async function foo() {
+  await new Promise((resolve) => setTimeout(resolve, 1000));
+}`
+
+      const result = transform(input, "newly-available")
+
+      // Should NOT transform awaited Promises
+      assert.strictEqual(result.modified, false)
+      assert.match(result.code, /await new Promise/)
+      assert.doesNotMatch(result.code, /Promise\.try/)
+    })
+
+    test("Promise.try should not transform non-Promise constructors", () => {
+      const input = `const p = new MyPromise((resolve) => resolve(getData()));`
+
+      const result = transform(input, "newly-available")
+
+      assert.strictEqual(result.modified, false)
+      assert.match(result.code, /new MyPromise/)
+    })
+
+    test("Promise.try should not transform with 0 arguments", () => {
+      const input = `const p = new Promise();`
+
+      const result = transform(input, "newly-available")
+
+      assert.strictEqual(result.modified, false)
+      assert.match(result.code, /new Promise\(\)/)
+    })
+
+    test("Promise.try should not transform with multiple arguments", () => {
+      const input = `const p = new Promise((resolve) => resolve(1), extraArg);`
+
+      const result = transform(input, "newly-available")
+
+      assert.strictEqual(result.modified, false)
+      assert.match(result.code, /new Promise/)
+    })
+
+    test("Promise.try should not transform with non-function argument", () => {
+      const input = `const p = new Promise(executor);`
+
+      const result = transform(input, "newly-available")
+
+      assert.strictEqual(result.modified, false)
+      assert.match(result.code, /new Promise\(executor\)/)
+    })
+
+    test("Promise.try should not transform with 0 params", () => {
+      const input = `const p = new Promise(() => console.log('test'));`
+
+      const result = transform(input, "newly-available")
+
+      assert.strictEqual(result.modified, false)
+      assert.match(result.code, /new Promise/)
+    })
+
+    test("Promise.try should not transform with more than 2 params", () => {
+      const input = `const p = new Promise((resolve, reject, extra) => resolve(1));`
+
+      const result = transform(input, "newly-available")
+
+      assert.strictEqual(result.modified, false)
+      assert.match(result.code, /new Promise/)
+    })
+
+    test("Promise.try with block statement and resolve call", () => {
+      const input = `const p = new Promise((resolve) => { resolve(getData()); });`
+
+      const result = transform(input, "newly-available")
+
+      assert.strictEqual(result.modified, true)
+      assert.match(result.code, /Promise\.try/)
+    })
+
+    test("Promise.try with arrow function expression body as function call", () => {
+      const input = `const p = new Promise((resolve) => computeValue());`
+
+      const result = transform(input, "newly-available")
+
+      // This should not transform because computeValue() is not calling resolve
+      assert.strictEqual(result.modified, false)
+      assert.match(result.code, /new Promise/)
+    })
+
+    test("Promise.try with arrow function returning a value directly", () => {
+      const input = `const p = new Promise((resolve) => someFunction(arg1, arg2));`
+
+      const result = transform(input, "newly-available")
+
+      // This should not transform - function call that doesn't involve resolve
+      assert.strictEqual(result.modified, false)
+      assert.match(result.code, /new Promise/)
+    })
+
+    test("Promise.try should not transform non-call expression body", () => {
+      const input = `const p = new Promise((resolve) => someValue);`
+
+      const result = transform(input, "newly-available")
+
+      assert.strictEqual(result.modified, false)
+      assert.match(result.code, /new Promise/)
+    })
+
+    test("Promise.try should not transform call with wrong number of arguments to resolve", () => {
+      const input = `const p = new Promise((resolve) => func(resolve, extra));`
+
+      const result = transform(input, "newly-available")
+
+      assert.strictEqual(result.modified, false)
+      assert.match(result.code, /new Promise/)
+    })
+
+    test("Promise.try should not transform call with non-identifier resolve", () => {
+      const input = `const p = new Promise((resolve) => func(123));`
+
+      const result = transform(input, "newly-available")
+
+      assert.strictEqual(result.modified, false)
+      assert.match(result.code, /new Promise/)
+    })
+
+    test("Promise.try should not transform resolve call with 0 arguments", () => {
+      const input = `const p = new Promise((resolve) => resolve());`
+
+      const result = transform(input, "newly-available")
+
+      assert.strictEqual(result.modified, false)
+      assert.match(result.code, /new Promise/)
+    })
+
+    test("Promise.try should not transform block with multiple statements", () => {
+      const input = `const p = new Promise((resolve) => {
+        const data = getData();
+        resolve(data);
+      });`
+
+      const result = transform(input, "newly-available")
+
+      assert.strictEqual(result.modified, false)
+      assert.match(result.code, /new Promise/)
+    })
+
+    test("Promise.try should not transform block with non-expression statement", () => {
+      const input = `const p = new Promise((resolve) => {
+        if (true) resolve(1);
+      });`
+
+      const result = transform(input, "newly-available")
+
+      assert.strictEqual(result.modified, false)
+      assert.match(result.code, /new Promise/)
+    })
+
+    test("Promise.try with function expression", () => {
+      const input = `const p = new Promise(function(resolve) { resolve(getData()); });`
+
+      const result = transform(input, "newly-available")
+
+      assert.strictEqual(result.modified, true)
+      assert.match(result.code, /Promise\.try/)
+    })
+
+    test("Promise.try with both resolve and reject params", () => {
+      const input = `const p = new Promise((resolve, reject) => resolve(getData()));`
+
+      const result = transform(input, "newly-available")
+
+      assert.strictEqual(result.modified, true)
+      assert.match(result.code, /Promise\.try/)
+    })
+
+    test("Promise.try tracks line numbers correctly", () => {
+      const input = `// Line 1
+const p = new Promise((resolve) => resolve(getData()));`
+
+      const result = transform(input, "newly-available")
+
+      assert.strictEqual(result.modified, true)
+      assert.strictEqual(result.changes.length, 1)
+      assert.strictEqual(result.changes[0].type, "promiseTry")
+      assert.strictEqual(result.changes[0].line, 2)
+    })
+  })
+})

package/tests/widelyAvailable.test.js

@@ -0,0 +1,428 @@
+import { describe, test } from "node:test"
+import assert from "node:assert"
+import { transform } from "../src/index.js"
+
+describe("widely-available", () => {
+  describe("for...of loop", () => {
+    test("Array.from().forEach() to for...of", () => {
+      const input = `
+    Array.from(items).forEach(item => {
+      console.log(item);
+    });
+  `
+
+      const result = transform(input)
+
+      assert.strictEqual(result.modified, true)
+      assert.match(result.code, /for \(const item of items\)/)
+      assert.match(result.code, /console\.log\(item\)/)
+    })
+
+    test("Array.from().forEach() with arrow function expression", () => {
+      const input = `Array.from(numbers).forEach(n => console.log(n));`
+
+      const result = transform(input)
+
+      assert.strictEqual(result.modified, true)
+      assert.match(result.code, /for \(const n of numbers\)/)
+    })
+
+    test("forEach should NOT transform plain identifiers (cannot confirm iterable)", () => {
+      const input = `
+    items.forEach(item => {
+      console.log(item);
+    });
+  `
+
+      const result = transform(input)
+
+      // Should not transform because we can't statically confirm 'items' is iterable
+      // It could be a jscodeshift Collection or other object with forEach but not Symbol.iterator
+      assert.strictEqual(result.modified, false)
+      assert.match(result.code, /items\.forEach/)
+    })
+
+    test("forEach should NOT transform plain identifiers with function expression", () => {
+      const input = `numbers.forEach(function(n) { console.log(n); });`
+
+      const result = transform(input)
+
+      // Should not transform because we can't statically confirm 'numbers' is iterable
+      assert.strictEqual(result.modified, false)
+      assert.match(result.code, /numbers\.forEach/)
+    })
+
+    test("for...of Object.keys() to for...in", () => {
+      const input = `
+    for (const key of Object.keys(obj)) {
+      console.log(key);
+    }
+  `
+
+      const result = transform(input)
+
+      assert.strictEqual(result.modified, true)
+      assert.match(result.code, /for \(const key in obj\)/)
+    })
+
+    test("Array.from().forEach() with array destructuring", () => {
+      const input = `
+    Array.from(Object.entries(obj)).forEach(([key, value]) => {
+      console.log(key, value);
+    });
+  `
+
+      const result = transform(input)
+
+      assert.strictEqual(result.modified, true)
+      assert.match(
+        result.code,
+        /for \(const \[key, value\] of Object\.entries\(obj\)\)/,
+      )
+    })
+
+    test("Array.from().forEach() should NOT transform with index parameter", () => {
+      const input = `
+    Array.from(items).forEach((item, index) => {
+      console.log(item, index);
+    });
+  `
+
+      const result = transform(input)
+
+      // Should not transform because callback uses index parameter
+      assert.strictEqual(result.modified, false)
+      assert.match(result.code, /forEach\(\(item, index\)/)
+    })
+
+    test("forEach should NOT transform with index parameter", () => {
+      const input = `
+    items.forEach((item, index) => {
+      console.log(item, index);
+    });
+  `
+
+      const result = transform(input)
+
+      // Should not transform because callback uses index parameter
+      assert.strictEqual(result.modified, false)
+      assert.match(result.code, /forEach\(\(item, index\)/)
+    })
+
+    test("forEach should NOT transform unknown objects", () => {
+      const input = `
+    myCustomObject.forEach(item => {
+      console.log(item);
+    });
+  `
+
+      const result = transform(input)
+
+      // Should not transform because we can't be sure myCustomObject is iterable
+      assert.strictEqual(result.modified, false)
+      assert.match(result.code, /myCustomObject\.forEach/)
+    })
+
+    test("forEach should NOT transform Map (uses different signature)", () => {
+      const input = `
+    myMap.forEach((value, key) => {
+      console.log(key, value);
+    });
+  `
+
+      const result = transform(input)
+
+      // Should not transform Map.forEach because it has 2 parameters (value, key)
+      assert.strictEqual(result.modified, false)
+      assert.match(result.code, /myMap\.forEach/)
+    })
+
+    test("Array.from().forEach() should NOT transform without callback", () => {
+      const input = `Array.from(items).forEach();`
+
+      const result = transform(input)
+
+      assert.strictEqual(result.modified, false)
+      assert.match(result.code, /forEach\(\)/)
+    })
+
+    test("Array.from().forEach() should NOT transform with non-function callback", () => {
+      const input = `Array.from(items).forEach(callback);`
+
+      const result = transform(input)
+
+      assert.strictEqual(result.modified, false)
+      assert.match(result.code, /forEach\(callback\)/)
+    })
+
+    test("Array.from().forEach() with function expression", () => {
+      const input = `Array.from(items).forEach(function(item) {
+        console.log(item);
+      });`
+
+      const result = transform(input)
+
+      assert.strictEqual(result.modified, true)
+      assert.match(result.code, /for \(const item of items\)/)
+    })
+
+    test("for...of Object.keys() should NOT transform non-Object.keys", () => {
+      const input = `
+    for (const item of myArray) {
+      console.log(item);
+    }
+  `
+
+      const result = transform(input)
+
+      assert.strictEqual(result.modified, false)
+      assert.match(result.code, /for \(const item of myArray\)/)
+    })
+
+    test("for...of Object.keys() should NOT transform without arguments", () => {
+      const input = `
+    for (const key of Object.keys()) {
+      console.log(key);
+    }
+  `
+
+      const result = transform(input)
+
+      assert.strictEqual(result.modified, false)
+      assert.match(result.code, /Object\.keys\(\)/)
+    })
+
+    test("Array.from().forEach() tracks line numbers", () => {
+      const input = `// Line 1
+Array.from(items).forEach(item => console.log(item));`
+
+      const result = transform(input)
+
+      assert.strictEqual(result.modified, true)
+      assert.strictEqual(result.changes.length, 1)
+      assert.strictEqual(result.changes[0].type, "arrayFromForEachToForOf")
+      assert.strictEqual(result.changes[0].line, 2)
+    })
+
+    test("for...of Object.keys() tracks line numbers", () => {
+      const input = `// Line 1
+for (const key of Object.keys(obj)) {
+  console.log(key);
+}`
+
+      const result = transform(input)
+
+      assert.strictEqual(result.modified, true)
+      assert.strictEqual(result.changes.length, 1)
+      assert.strictEqual(result.changes[0].type, "forOfKeysToForIn")
+      assert.strictEqual(result.changes[0].line, 2)
+    })
+
+    test("Array.from().forEach() with destructuring and 2+ params transforms if first param is array pattern", () => {
+      const input = `Array.from(items).forEach(([a, b], index) => {
+        console.log(a, b, index);
+      });`
+
+      const result = transform(input)
+
+      // According to the code, this should transform because first param is ArrayPattern
+      // The logic says: params.length === 1 OR (params.length >= 2 AND first is ArrayPattern)
+      assert.strictEqual(result.modified, true)
+      assert.match(result.code, /for \(const \[a, b\] of items\)/)
+    })
+  })
+  describe("const and let", () => {
+    test("var to const when not reassigned", () => {
+      const input = `
+    var x = 1;
+  `
+
+      const result = transform(input)
+
+      assert.strictEqual(result.modified, true)
+      assert.match(result.code, /const x = 1/)
+      assert.doesNotMatch(result.code, /var x/)
+    })
+
+    test("var to const (simplified version)", () => {
+      const input = `
+    var x = 1;
+    x = 2;
+  `
+
+      const result = transform(input)
+
+      assert.strictEqual(result.modified, true)
+      assert.match(result.code, /const x = 1/)
+      assert.doesNotMatch(result.code, /var x/)
+      // Note: This will cause a runtime error due to const reassignment
+      // A more sophisticated version would detect reassignments and use 'let'
+    })
+
+    test("multiple var declarations", () => {
+      const input = `
+    var x = 1;
+    var y = 2;
+    var z = 3;
+  `
+
+      const result = transform(input)
+
+      assert.strictEqual(result.modified, true)
+      assert.match(result.code, /const x = 1/)
+      assert.match(result.code, /const y = 2/)
+      assert.match(result.code, /const z = 3/)
+      assert.strictEqual(result.changes.length, 3)
+    })
+
+    test("var declaration tracks line numbers", () => {
+      const input = `// Line 1
+var x = 1;`
+
+      const result = transform(input)
+
+      assert.strictEqual(result.modified, true)
+      assert.strictEqual(result.changes.length, 1)
+      assert.strictEqual(result.changes[0].type, "varToConst")
+      assert.strictEqual(result.changes[0].line, 2)
+    })
+  })
+
+  describe("template literals", () => {
+    test("string concatenation to template literal", () => {
+      const input = `const greeting = 'Hello ' + name + '!';`
+
+      const result = transform(input)
+
+      assert.strictEqual(result.modified, true)
+      assert.match(result.code, /`Hello \$\{name\}!`/)
+    })
+
+    test("multiple string concatenations", () => {
+      const input = `const msg = 'Hello ' + firstName + ' ' + lastName + '!';`
+
+      const result = transform(input)
+
+      assert.strictEqual(result.modified, true)
+      assert.match(result.code, /`Hello \$\{firstName\} \$\{lastName\}!`/)
+    })
+
+    test("concatenation starting with expression", () => {
+      const input = `const msg = prefix + ' world';`
+
+      const result = transform(input)
+
+      assert.strictEqual(result.modified, true)
+      assert.match(result.code, /`\$\{prefix\} world`/)
+    })
+
+    test("concatenation with only expressions", () => {
+      const input = `const msg = a + b + c;`
+
+      const result = transform(input)
+
+      // Should not transform if no string literals
+      assert.strictEqual(result.modified, false)
+      assert.match(result.code, /a \+ b \+ c/)
+    })
+
+    test("concatenation ending with expression", () => {
+      const input = `const msg = 'Value: ' + value;`
+
+      const result = transform(input)
+
+      assert.strictEqual(result.modified, true)
+      assert.match(result.code, /`Value: \$\{value\}`/)
+    })
+
+    test("complex nested concatenation", () => {
+      const input = `const msg = 'Start ' + (a + 'middle') + ' end';`
+
+      const result = transform(input)
+
+      assert.strictEqual(result.modified, true)
+      assert.match(result.code, /`/)
+    })
+  })
+
+  describe("object spread", () => {
+    test("Object.assign to object spread", () => {
+      const input = `const obj = Object.assign({}, obj1, obj2);`
+
+      const result = transform(input)
+
+      assert.strictEqual(result.modified, true)
+      assert.match(result.code, /\.\.\.obj1/)
+      assert.match(result.code, /\.\.\.obj2/)
+    })
+
+    test("Object.assign should not transform with non-empty first arg", () => {
+      const input = `const obj = Object.assign({ a: 1 }, obj1);`
+
+      const result = transform(input)
+
+      assert.strictEqual(result.modified, false)
+      assert.match(result.code, /Object\.assign/)
+    })
+
+    test("Object.assign should not transform with non-object first arg", () => {
+      const input = `const obj = Object.assign(target, obj1);`
+
+      const result = transform(input)
+
+      assert.strictEqual(result.modified, false)
+      assert.match(result.code, /Object\.assign/)
+    })
+
+    test("Object.assign with only empty object", () => {
+      const input = `const obj = Object.assign({});`
+
+      const result = transform(input)
+
+      assert.strictEqual(result.modified, true)
+      assert.match(result.code, /\{\}/)
+    })
+  })
+
+  test("no changes needed", () => {
+    const input = `
+    const x = 1;
+    const y = 2;
+  `
+
+    const result = transform(input)
+
+    assert.strictEqual(result.modified, false)
+  })
+
+  test("complex transformation", () => {
+    const input = `
+    var userName = 'Alice';
+    var greeting = 'Hello ' + userName;
+  `
+
+    const result = transform(input)
+
+    assert.strictEqual(result.modified, true)
+    assert.match(result.code, /const userName/)
+    assert.match(result.code, /`Hello \$\{userName\}`/)
+  })
+
+  test("baseline option - widely-available", () => {
+    const input = `var x = 1;`
+
+    const result = transform(input)
+
+    assert.strictEqual(result.modified, true)
+    assert.match(result.code, /const x = 1/)
+  })
+
+  test("baseline option - newly-available", () => {
+    const input = `var x = 1;`
+
+    const result = transform(input, "newly-available")
+
+    assert.strictEqual(result.modified, true)
+    assert.match(result.code, /const x = 1/)
+  })
+})

package/.idea/copilot.data.migration.ask2agent.xml

@@ -1,6 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="Ask2AgentMigrationStateService">
-    <option name="migrationStatus" value="COMPLETED" />
-  </component>
-</project>

package/.idea/esupgrade.iml

@@ -1,8 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<module type="PYTHON_MODULE" version="4">
-  <component name="NewModuleRootManager">
-    <content url="file://$MODULE_DIR$" />
-    <orderEntry type="jdk" jdkName="Python 3.9" jdkType="Python SDK" />
-    <orderEntry type="sourceFolder" forTests="false" />
-  </component>
-</module>

package/.idea/inspectionProfiles/Project_Default.xml

@@ -1,28 +0,0 @@
-<component name="InspectionProjectProfileManager">
-  <profile version="1.0">
-    <option name="myName" value="Project Default" />
-    <inspection_tool class="DjangoUnresolvedUrlInspection" enabled="true" level="WEAK WARNING" enabled_by_default="true" />
-    <inspection_tool class="Eslint" enabled="true" level="WARNING" enabled_by_default="true" />
-    <inspection_tool class="JsonSchemaCompliance" enabled="false" level="WARNING" enabled_by_default="false" />
-    <inspection_tool class="PyCompatibilityInspection" enabled="true" level="WARNING" enabled_by_default="true">
-      <option name="ourVersions">
-        <value>
-          <list size="2">
-            <item index="0" class="java.lang.String" itemvalue="3.13" />
-            <item index="1" class="java.lang.String" itemvalue="3.14" />
-          </list>
-        </value>
-      </option>
-    </inspection_tool>
-    <inspection_tool class="PyUnresolvedReferencesInspection" enabled="true" level="WARNING" enabled_by_default="true">
-      <option name="ignoredIdentifiers">
-        <list>
-          <option value="ssdp.lexers.content_callback" />
-        </list>
-      </option>
-    </inspection_tool>
-    <inspection_tool class="StandardJS" enabled="true" level="ERROR" enabled_by_default="true" />
-    <inspection_tool class="Stylelint" enabled="true" level="ERROR" enabled_by_default="true" />
-    <inspection_tool class="TsLint" enabled="true" level="WARNING" enabled_by_default="true" />
-  </profile>
-</component>

package/.idea/inspectionProfiles/profiles_settings.xml

@@ -1,6 +0,0 @@
-<component name="InspectionProjectProfileManager">
-  <settings>
-    <option name="USE_PROJECT_PROFILE" value="false" />
-    <version value="1.0" />
-  </settings>
-</component>