Loop Invariant Code Motion in JavaScript

Loop invariant code motion is an optimization technique where expressions that do not change within a loop are moved outside of the loop. This reduces redundant calculations and improves performance, especially in computationally intensive loops. This challenge asks you to implement a function that identifies and moves loop-invariant expressions in a given JavaScript code snippet.

Problem Description

You are given a JavaScript code snippet containing a for loop. Your task is to analyze the code and identify expressions within the loop that are loop-invariant – meaning their value remains constant throughout all iterations of the loop. You should then move these invariant expressions outside the loop, effectively optimizing the code. The function should return the modified JavaScript code snippet with the loop-invariant expressions moved outside the loop.

Key Requirements:

Loop Identification: The function must correctly identify the for loop within the input code.
Invariant Detection: The function must accurately determine which expressions within the loop are loop-invariant. Assume that variable declarations within the loop are not loop-invariant.
Code Modification: The function must modify the input code snippet by moving the identified invariant expressions outside the loop while preserving the original code's functionality.
Correct Syntax: The modified code must be syntactically valid JavaScript.
No Side Effects: The function should not modify the original input string; it should return a new string.

Expected Behavior:

The function should take a JavaScript code snippet as a string and return a modified string where loop-invariant expressions have been moved outside the loop. If no loop-invariant expressions are found, the function should return the original code snippet unchanged.

Edge Cases to Consider:

Nested loops: The function should only optimize the outermost for loop.
Complex expressions: The function should handle expressions involving multiple variables and operators.
No loop: If the input code doesn't contain a for loop, the function should return the original code.
Empty loop body: If the loop body is empty, the function should return the original code.
Expressions that are only invariant for some iterations: Assume that if an expression is invariant for any iteration, it should be moved.

Examples

Example 1:

Input: `for (let i = 0; i < 10; i++) { const x = 5; let y = i * 2; const z = x + y; console.log(z); }`
Output: `const x = 5; for (let i = 0; i < 10; i++) { let y = i * 2; const z = x + y; console.log(z); }`
Explanation: `x` is loop-invariant and is moved outside the loop. `y` and `z` are not loop invariant because they depend on `i`.

**Example 2:**

Input: for (let i = 0; i < 5; i++) { const a = 10; const b = 20; const c = a + b; console.log(c); } Output: const a = 10; const b = 20; for (let i = 0; i < 5; i++) { const c = a + b; console.log(c); } Explanation: Both a and b are loop-invariant and are moved outside the loop.

Example 3:

Input: `for (let i = 0; i < 3; i++) { console.log(i); }`
Output: `for (let i = 0; i < 3; i++) { console.log(i); }`
Explanation: No loop-invariant expressions are found, so the code remains unchanged.

**Example 4:**

Input: function foo() { for (let i = 0; i < 5; i++) { const PI = 3.14159; console.log(PI * i); } } Output: function foo() { const PI = 3.14159; for (let i = 0; i < 5; i++) { console.log(PI * i); } } Explanation: PI is loop-invariant and is moved outside the loop.


## Constraints

*   The input code snippet will be a string containing a single `for` loop.
*   The loop will have the standard `for (initialization; condition; increment)` structure.
*   The code snippet will be syntactically valid JavaScript.
*   The function must return the modified code snippet as a string.
*   The function should be reasonably efficient; avoid excessively complex parsing or analysis.
*   The input string will be no longer than 500 characters.

## Notes

*   This is a simplified version of loop invariant code motion.  A full implementation would require more sophisticated static analysis.
*   Focus on identifying simple, constant expressions.
*   Consider using regular expressions to identify and move the invariant expressions.
*   Be careful to preserve the original code's structure and functionality.
*   Assume that variable declarations within the loop are *not* loop-invariant.  This simplifies the problem significantly.
*   The goal is to demonstrate the basic principle of loop invariant code motion, not to create a production-ready optimizer.

Loop Invariant Code Motion in JavaScript

Problem Description

Key Requirements:

Loop Identification: The function must correctly identify the for loop within the input code.

Invariant Detection: The function must accurately determine which expressions within the loop are loop-invariant. Assume that variable declarations within the loop are not loop-invariant.

Code Modification: The function must modify the input code snippet by moving the identified invariant expressions outside the loop while preserving the original code's functionality.

Correct Syntax: The modified code must be syntactically valid JavaScript.

No Side Effects: The function should not modify the original input string; it should return a new string.

Expected Behavior:

Edge Cases to Consider:

Nested loops: The function should only optimize the outermost for loop.

Complex expressions: The function should handle expressions involving multiple variables and operators.

No loop: If the input code doesn't contain a for loop, the function should return the original code.

Empty loop body: If the loop body is empty, the function should return the original code.

Expressions that are only invariant for some iterations: Assume that if an expression is invariant for any iteration, it should be moved.

Examples

Example 1:

Input: `for (let i = 0; i < 10; i++) { const x = 5; let y = i * 2; const z = x + y; console.log(z); }` Output: `const x = 5; for (let i = 0; i < 10; i++) { let y = i * 2; const z = x + y; console.log(z); }` Explanation: `x` is loop-invariant and is moved outside the loop. `y` and `z` are not loop invariant because they depend on `i`. **Example 2:**

Example 3:

Input: `for (let i = 0; i < 3; i++) { console.log(i); }` Output: `for (let i = 0; i < 3; i++) { console.log(i); }` Explanation: No loop-invariant expressions are found, so the code remains unchanged. **Example 4:**

## Constraints * The input code snippet will be a string containing a single `for` loop. * The loop will have the standard `for (initialization; condition; increment)` structure. * The code snippet will be syntactically valid JavaScript. * The function must return the modified code snippet as a string. * The function should be reasonably efficient; avoid excessively complex parsing or analysis. * The input string will be no longer than 500 characters. ## Notes * This is a simplified version of loop invariant code motion. A full implementation would require more sophisticated static analysis. * Focus on identifying simple, constant expressions. * Consider using regular expressions to identify and move the invariant expressions. * Be careful to preserve the original code's structure and functionality. * Assume that variable declarations within the loop are *not* loop-invariant. This simplifies the problem significantly. * The goal is to demonstrate the basic principle of loop invariant code motion, not to create a production-ready optimizer.