[Wasm] replace internal StringBuilder usages(KT-83156 K/Wasm)

libraries/stdlib/wasm/src/kotlin/text/FloatingPointParser.kt

diff --git a/libraries/stdlib/wasm/src/kotlin/text/FloatingPointParser.kt b/libraries/stdlib/wasm/src/kotlin/text/FloatingPointParser.kt
index 90235fe..94b5125 100644
--- a/libraries/stdlib/wasm/src/kotlin/text/FloatingPointParser.kt
+++ b/libraries/stdlib/wasm/src/kotlin/text/FloatingPointParser.kt
@@ -17,13 +17,14 @@
         }
     }
 
-    fun parseNumber(sb: StringBuilder) {
+    fun parseNumber(): String {
+        val startIndex = index
         while (index <= string.lastIndex) {
             val ch = string[index]
             if (ch !in '0'..'9') break
-            sb.append(string[index])
             index++
         }
+        return string.substring(startIndex, index)
     }
 
     fun parseSign(): Boolean {
@@ -85,17 +86,17 @@
         return if (!isNegative) Double.POSITIVE_INFINITY else Double.NEGATIVE_INFINITY
     }
 
-    val numberBuilder = StringBuilder()
-    parseNumber(numberBuilder)
+    var numberBuilder = parseNumber()
     var scale = numberBuilder.length
-    if (parseDot()) parseNumber(numberBuilder)
+    if (parseDot()) {
+        numberBuilder = numberBuilder.plus(parseNumber())
+    }
     if (numberBuilder.isEmpty()) numberFormatError(string)
-    val numberString = numberBuilder.toString()
+    val numberString = numberBuilder
 
     if (parseE()) {
-        numberBuilder.clear()
         val isExponentNegative = parseSign()
-        parseNumber(numberBuilder)
+        numberBuilder = parseNumber()
         if (numberBuilder.isEmpty()) numberFormatError(string)
         parseUnsignificants()
         if (index != string.length) numberFormatError(string)
@@ -104,7 +105,7 @@
             return if (isNegative) -0.0 else 0.0
         }
 
-        val exponentScale = numberBuilder.toString().toIntOrNull() ?: run {
+        val exponentScale = numberBuilder.toIntOrNull() ?: run {
             return if (isExponentNegative) {
                 if (isNegative) -0.0 else 0.0
             } else {

libraries/stdlib/wasm/src/kotlin/text/StringsWasm.kt

diff --git a/libraries/stdlib/wasm/src/kotlin/text/StringsWasm.kt b/libraries/stdlib/wasm/src/kotlin/text/StringsWasm.kt
index 172fe4d..05d5f48 100644
--- a/libraries/stdlib/wasm/src/kotlin/text/StringsWasm.kt
+++ b/libraries/stdlib/wasm/src/kotlin/text/StringsWasm.kt
@@ -369,18 +369,16 @@
 
         val oldValueLength = oldValue.length
         val searchStep = oldValueLength.coerceAtLeast(1)
-        val newLengthHint = length - oldValueLength + newValue.length
-        if (newLengthHint < 0) throw OutOfMemoryError()
-        val stringBuilder = StringBuilder(newLengthHint)
+        var stringBuilder = ""
 
         var i = 0
         do {
-            stringBuilder.append(this, i, occurrenceIndex).append(newValue)
+            stringBuilder = stringBuilder.plus(this.substring(i, occurrenceIndex)).plus(newValue)
             i = occurrenceIndex + oldValueLength
             if (occurrenceIndex >= length) break
             occurrenceIndex = indexOf(oldValue, occurrenceIndex + searchStep, ignoreCase)
         } while (occurrenceIndex > 0)
-        return stringBuilder.append(this, i, length).toString()
+        return stringBuilder.plus(this.substring(i, length))
     }
 }
 

libraries/stdlib/wasm/src/kotlin/text/utf8Encoding.kt

diff --git a/libraries/stdlib/wasm/src/kotlin/text/utf8Encoding.kt b/libraries/stdlib/wasm/src/kotlin/text/utf8Encoding.kt
index c20dac6..8e5582d 100644
--- a/libraries/stdlib/wasm/src/kotlin/text/utf8Encoding.kt
+++ b/libraries/stdlib/wasm/src/kotlin/text/utf8Encoding.kt
@@ -222,52 +222,51 @@
     require(startIndex >= 0 && endIndex <= bytes.size && startIndex <= endIndex)
 
     var byteIndex = startIndex
-    val stringBuilder = StringBuilder()
+    var stringBuilder = ""
 
     while (byteIndex < endIndex) {
         val byte = bytes[byteIndex++].toInt()
         when {
             byte >= 0 ->
-                stringBuilder.append(byte.toChar())
+                stringBuilder = stringBuilder.plus(byte.toChar().toString())
             byte shr 5 == -2 -> {
                 val code = codePointFrom2(bytes, byte, byteIndex, endIndex, throwOnMalformed)
                 if (code <= 0) {
-                    stringBuilder.append(REPLACEMENT_CHAR)
+                    stringBuilder = stringBuilder.plus(REPLACEMENT_CHAR.toString())
                     byteIndex += -code
                 } else {
-                    stringBuilder.append(code.toChar())
+                    stringBuilder = stringBuilder.plus(code.toChar().toString())
                     byteIndex += 1
                 }
             }
             byte shr 4 == -2 -> {
                 val code = codePointFrom3(bytes, byte, byteIndex, endIndex, throwOnMalformed)
                 if (code <= 0) {
-                    stringBuilder.append(REPLACEMENT_CHAR)
+                    stringBuilder = stringBuilder.plus(REPLACEMENT_CHAR.toString())
                     byteIndex += -code
                 } else {
-                    stringBuilder.append(code.toChar())
+                    stringBuilder = stringBuilder.plus(code.toChar().toString())
                     byteIndex += 2
                 }
             }
             byte shr 3 == -2 -> {
                 val code = codePointFrom4(bytes, byte, byteIndex, endIndex, throwOnMalformed)
                 if (code <= 0) {
-                    stringBuilder.append(REPLACEMENT_CHAR)
+                    stringBuilder = stringBuilder.plus(REPLACEMENT_CHAR.toString())
                     byteIndex += -code
                 } else {
                     val high = (code - 0x10000) shr 10 or 0xD800
                     val low = (code and 0x3FF) or 0xDC00
-                    stringBuilder.append(high.toChar())
-                    stringBuilder.append(low.toChar())
+                    stringBuilder = stringBuilder.plus(high.toChar().toString())
+                    stringBuilder = stringBuilder.plus(low.toChar().toString())
                     byteIndex += 3
                 }
             }
             else -> {
                 val _ = malformed(0, byteIndex, throwOnMalformed)
-                stringBuilder.append(REPLACEMENT_CHAR)
+                stringBuilder = stringBuilder.plus(REPLACEMENT_CHAR.toString())
             }
         }
     }
-
-    return stringBuilder.toString()
+    return stringBuilder
 }