fix(string): cleanup code in String.prototype.repeat (#5017)

Overview
This PR refactors the String.prototype.repeat implementation to strictly
align with Section 22.1.3.16 of the ECMA-262 specification. The previous
implementation used a generic error handling match; this update
introduces explicit checks for Infinity and negative values as required
by the abstract operations.

Spec Compliance Audit
I have mapped the implementation to the following specification steps:

Step 3: Let n be ? ToIntegerOrInfinity(count).

Step 4: If n < 0, throw a RangeError exception. (Implemented via
explicit match)

Step 5: If n is +∞, throw a RangeError exception. (Implemented via
PositiveInfinity check)

Changes
Replaced the catch-all error handling with an exhaustive match on the
IntegerOrInfinity enum.

Added specific RangeError messages that distinguish between negative
counts and infinite counts.

Used variable shadowing to simplify the logic flow from an Enum to a
primitive i64 after validation.

Verification
I have verified the fix using a local test script across the following
edge cases:

JavaScript
"abc".repeat(0);        // Returns "" (Success)
"abc".repeat(-1); // Throws RangeError: count must be non-negative
(Success)
"abc".repeat(Infinity); // Throws RangeError: count must be less than
infinity (Success)
Note to Maintainers
I am a prospective GSoC 2026 applicant interested in the ECMAScript
Conformance project. I chose this task to demonstrate my ability to
translate ECMA-262 algorithms into idiomatic Rust using Boa's internal
types. I am eager to contribute more to the engine's compliance suite!

---------

Co-authored-by: José Julián Espina <jedel@startmail.com>

Author: Tanush576

core/engine/src/builtins/string/mod.rs

@@ -1,4 +1,4 @@
-//! Boa's implementation of ECMAScript's global `String` object.
+//! This module implements the global `String` object.
 //!
 //! The `String` global object is a constructor for strings or a sequence of characters.
 //!
@@ -689,41 +689,59 @@ impl String {
         // 2. Let S be ? ToString(O).
         let string = this.to_string(context)?;
 
-        let len = string.len();
-
         // 3. Let n be ? ToIntegerOrInfinity(count).
-        match args.get_or_undefined(0).to_integer_or_infinity(context)? {
-            IntegerOrInfinity::Integer(n)
-                if u64::try_from(n)
-                    .ok()
-                    .and_then(|n| n.checked_mul(len as u64))
-                    .is_some_and(|total_len| total_len <= (Self::MAX_STRING_LENGTH as u64)) =>
-            {
-                if string.is_empty() {
-                    return Ok(js_string!().into());
-                }
-                let n = n as usize;
+        let n = args.get_or_undefined(0).to_integer_or_infinity(context)?;
 
-                // Charge each repetition against the VM loop-iteration limit.
-                let mut result = Vec::with_capacity(n);
-                for _ in 0..n {
-                    crate::vm::opcode::IncrementLoopIteration::operation((), context)?;
-                    result.push(string.as_str());
-                }
-
-                // 6. Return the String value that is made from n copies of S appended together.
-                Ok(JsString::concat_array(&result).into())
+        // 4. If n < 0 or n is +∞, throw a RangeError exception.
+        let n = match n {
+            IntegerOrInfinity::Integer(i) if i < 0 => {
+                return Err(JsNativeError::range()
+                    .with_message("String.prototype.repeat: count must be non-negative")
+                    .into());
+            }
+            IntegerOrInfinity::PositiveInfinity => {
+                return Err(JsNativeError::range()
+                    .with_message("String.prototype.repeat: count must be less than infinity")
+                    .into());
+            }
+            IntegerOrInfinity::NegativeInfinity => {
+                return Err(JsNativeError::range()
+                    .with_message("String.prototype.repeat: count must be non-negative")
+                    .into());
             }
-            // 5. If n is 0, return the empty String.
-            IntegerOrInfinity::Integer(0) => Ok(js_string!().into()),
-            // 4. If n < 0 or n is +∞, throw a RangeError exception.
-            _ => Err(JsNativeError::range()
+            IntegerOrInfinity::Integer(i) => i,
+        };
+
+        let len = string.len();
+
+        if n == 0 || string.is_empty() {
+            return Ok(js_string!().into());
+        }
+
+        if u64::try_from(n)
+            .ok()
+            .and_then(|n| n.checked_mul(len as u64))
+            .is_none_or(|total_len| total_len > (Self::MAX_STRING_LENGTH as u64))
+        {
+            return Err(JsNativeError::range()
                 .with_message(
                     "repeat count must be a positive finite number \
                         that doesn't overflow the maximum string length (2^32 - 1)",
                 )
-                .into()),
+                .into());
+        }
+
+        let n = n as usize;
+
+        // Charge each repetition against the VM loop-iteration limit.
+        let mut result = Vec::with_capacity(n);
+        for _ in 0..n {
+            crate::vm::opcode::IncrementLoopIteration::operation((), context)?;
+            result.push(string.as_str());
         }
+
+        // 6. Return the String value that is made from n copies of S appended together.
+        Ok(JsString::concat_array(&result).into())
     }
 
     /// `String.prototype.slice( beginIndex [, endIndex] )`

core/engine/src/builtins/string/tests.rs

@@ -142,8 +142,7 @@ fn repeat_throws_when_count_is_negative() {
     run_test_actions([TestAction::assert_native_error(
         "'x'.repeat(-1)",
         JsNativeErrorKind::Range,
-        "repeat count must be a positive finite number \
-                  that doesn't overflow the maximum string length (2^32 - 1)",
+        "String.prototype.repeat: count must be non-negative",
     )]);
 }
 
@@ -152,8 +151,7 @@ fn repeat_throws_when_count_is_infinity() {
     run_test_actions([TestAction::assert_native_error(
         "'x'.repeat(Infinity)",
         JsNativeErrorKind::Range,
-        "repeat count must be a positive finite number \
-                  that doesn't overflow the maximum string length (2^32 - 1)",
+        "String.prototype.repeat: count must be less than infinity",
     )]);
 }