fixup! [Wasm] latin1 proper renaming (KT-79357)

alex28sh · Space Team · commit 3742270958f9 · 2025-08-04T08:44:00.000Z
diff --git a/compiler/ir/backend.wasm/src/org/jetbrains/kotlin/backend/wasm/dce/WasmUsefulDeclarationProcessor.kt b/compiler/ir/backend.wasm/src/org/jetbrains/kotlin/backend/wasm/dce/WasmUsefulDeclarationProcessor.kt
@@ -33,7 +33,7 @@ internal class WasmUsefulDeclarationProcessor(
         override fun visitConst(expression: IrConst, data: IrDeclaration) = when (expression.kind) {
             is IrConstKind.Null -> expression.type.enqueueType(data, "expression type")
             is IrConstKind.String -> {
-                if ((expression.value as String).all { it.code in 0..255 }) {
+                if ((expression.value as String).fitsLatin1) {
                     context.wasmSymbols.stringGetLiteralLatin1.owner
                         .enqueue(data, "String literal intrinsic getter stringGetLiteralLatin1")
                 } else {
diff --git a/compiler/ir/backend.wasm/src/org/jetbrains/kotlin/backend/wasm/ir2wasm/ConstantData.kt b/compiler/ir/backend.wasm/src/org/jetbrains/kotlin/backend/wasm/ir2wasm/ConstantData.kt
@@ -78,12 +78,12 @@ class ConstantDataIntArray(val value: List<WasmSymbol<Int>>) : ConstantDataEleme
     override val sizeInBytes: Int = value.size * INT_SIZE_BYTES
 }
 
-class ConstantDataCharArray(val value: List<WasmSymbol<Char>>, val fitsOneByte: Int) : ConstantDataElement() {
-    constructor(value: CharArray, fitsOneByte: Int) : this(value.map { WasmSymbol(it) }, fitsOneByte)
+class ConstantDataCharArray(val value: List<WasmSymbol<Char>>, val fitsLatin1: Int) : ConstantDataElement() {
+    constructor(value: CharArray, fitsLatin1: Int) : this(value.map { WasmSymbol(it) }, fitsLatin1)
 
     override fun toBytes(): ByteArray {
         return value
-            .map { it.owner.toLittleEndianBytes(fitsOneByte != 0) }
+            .map { it.owner.toLittleEndianBytes(fitsLatin1 != 0) }
             .fold(byteArrayOf(), ByteArray::plus)
     }
 
@@ -93,7 +93,7 @@ class ConstantDataCharArray(val value: List<WasmSymbol<Char>>, val fitsOneByte:
     }
 
     override val sizeInBytes: Int = value.size *
-            if (fitsOneByte != 0) BYTE_SIZE_BYTES else CHAR_SIZE_BYTES
+            if (fitsLatin1 != 0) BYTE_SIZE_BYTES else CHAR_SIZE_BYTES
 }
 
 class ConstantDataStruct(val elements: List<ConstantDataElement>) : ConstantDataElement() {
@@ -129,8 +129,8 @@ fun Int.toLittleEndianBytes(): ByteArray {
     }
 }
 
-fun Char.toLittleEndianBytes(fitsOneByte: Boolean): ByteArray {
-    if (fitsOneByte) {
+fun Char.toLittleEndianBytes(fitsLatin1: Boolean): ByteArray {
+    if (fitsLatin1) {
         return byteArrayOf((this.code and 0xFF).toByte())
     }
     return byteArrayOf((this.code and 0xFF).toByte(), (this.code ushr Byte.SIZE_BITS).toByte())
diff --git a/compiler/ir/backend.wasm/src/org/jetbrains/kotlin/backend/wasm/ir2wasm/DeclarationGenerator.kt b/compiler/ir/backend.wasm/src/org/jetbrains/kotlin/backend/wasm/ir2wasm/DeclarationGenerator.kt
@@ -31,8 +31,8 @@ import org.jetbrains.kotlin.wasm.ir.source.location.SourceLocation
 
 private const val TYPE_INFO_FLAG_ANONYMOUS_CLASS = 1
 private const val TYPE_INFO_FLAG_LOCAL_CLASS = 2
-private const val TYPE_INFO_FLAG_FITS_ONE_BIT_QUALIFIER = 4
-private const val TYPE_INFO_FLAG_FITS_ONE_BIT_SIMPLE_NAME = 8
+private const val TYPE_INFO_FLAG_FITS_LATIN1_QUALIFIER = 4
+private const val TYPE_INFO_FLAG_FITS_LATIN1_SIMPLE_NAME = 8
 
 class DeclarationGenerator(
     private val backendContext: WasmBackendContext,
@@ -394,9 +394,9 @@ class DeclarationGenerator(
 
             val isAnonymousFlag = if (klass.isAnonymousObject) TYPE_INFO_FLAG_ANONYMOUS_CLASS else 0
             val isLocalFlag = if (klass.isOriginallyLocalClass) TYPE_INFO_FLAG_LOCAL_CLASS else 0
-            val fitsOneByteQualifier = if (qualifier.all { it.code in 0..255 }) TYPE_INFO_FLAG_FITS_ONE_BIT_QUALIFIER else 0
-            val fitsOneByteSimpleName = if (simpleName.all { it.code in 0..255 }) TYPE_INFO_FLAG_FITS_ONE_BIT_SIMPLE_NAME else 0
-            buildConstI32(isAnonymousFlag or isLocalFlag or fitsOneByteQualifier or fitsOneByteSimpleName, location)
+            val fitsLatin1Qualifier = if (qualifier.fitsLatin1) TYPE_INFO_FLAG_FITS_LATIN1_QUALIFIER else 0
+            val fitsLatin1SimpleName = if (simpleName.fitsLatin1) TYPE_INFO_FLAG_FITS_LATIN1_SIMPLE_NAME else 0
+            buildConstI32(isAnonymousFlag or isLocalFlag or fitsLatin1Qualifier or fitsLatin1SimpleName, location)
 
             buildStructNew(wasmFileCodegenContext.rttiType, location)
         }
@@ -622,10 +622,9 @@ fun generateConstExpression(
         is IrConstKind.String -> {
             val stringValue = expression.value as String
             val (_, literalPoolId) = context.referenceStringLiteralAddressAndId(stringValue)
-            val isLatin = stringValue.all { it.code in 0..255 }
             body.commentGroupStart { "const string: \"$stringValue\"" }
             body.buildConstI32Symbol(literalPoolId, location)
-            if (isLatin) {
+            if (stringValue.fitsLatin1) {
                 body.buildCall(context.referenceFunction(backendContext.wasmSymbols.stringGetLiteralLatin1), location)
             } else {
                 body.buildCall(context.referenceFunction(backendContext.wasmSymbols.stringGetLiteralUtf16), location)
diff --git a/compiler/ir/backend.wasm/src/org/jetbrains/kotlin/backend/wasm/ir2wasm/WasmCompiledModuleFragment.kt b/compiler/ir/backend.wasm/src/org/jetbrains/kotlin/backend/wasm/ir2wasm/WasmCompiledModuleFragment.kt
@@ -9,6 +9,7 @@ import org.jetbrains.kotlin.backend.common.compilationException
 import org.jetbrains.kotlin.backend.common.serialization.Hash128Bits
 import org.jetbrains.kotlin.backend.wasm.WasmBackendContext
 import org.jetbrains.kotlin.backend.wasm.ir2wasm.WasmCompiledModuleFragment.*
+import org.jetbrains.kotlin.backend.wasm.utils.fitsLatin1
 import org.jetbrains.kotlin.ir.backend.js.ic.IrICProgramFragment
 import org.jetbrains.kotlin.ir.declarations.IrDeclarationWithName
 import org.jetbrains.kotlin.ir.declarations.IrExternalPackageFragment
@@ -560,9 +561,9 @@ class WasmCompiledModuleFragment(
                     stringAddressAndId[string] = currentStringAddress to currentStringId
                     addressesAndLengths.add(currentStringAddress.toLong() or (string.length.toLong() shl 32))
 
-                    val fitsOneByte = if (string.all { it.code in 0..255 }) 1 else 0
+                    val fitsLatin1 = if (string.fitsLatin1) 1 else 0
 
-                    val constData = ConstantDataCharArray(string.toCharArray(), fitsOneByte)
+                    val constData = ConstantDataCharArray(string.toCharArray(), fitsLatin1)
                     stringDataSectionBytes += constData.toBytes().toList()
                     stringDataSectionStart += constData.sizeInBytes
                 } else {
diff --git a/compiler/ir/backend.wasm/src/org/jetbrains/kotlin/backend/wasm/serialization/WasmDeserializer.kt b/compiler/ir/backend.wasm/src/org/jetbrains/kotlin/backend/wasm/serialization/WasmDeserializer.kt
@@ -489,8 +489,8 @@ class WasmDeserializer(inputStream: InputStream, private val skipLocalNames: Boo
 
     private fun deserializeConstantDataCharArray(): ConstantDataCharArray {
         val value = deserializeList { deserializeSymbol { Char(deserializeInt()) } }
-        val fitsOneByte = deserializeInt()
-        return ConstantDataCharArray(value, fitsOneByte)
+        val fitsLatin1 = deserializeInt()
+        return ConstantDataCharArray(value, fitsLatin1)
     }
 
     private fun deserializeConstantDataCharField(): ConstantDataCharField {
diff --git a/compiler/ir/backend.wasm/src/org/jetbrains/kotlin/backend/wasm/serialization/WasmSerializer.kt b/compiler/ir/backend.wasm/src/org/jetbrains/kotlin/backend/wasm/serialization/WasmSerializer.kt
@@ -515,7 +515,7 @@ class WasmSerializer(outputStream: OutputStream) {
 
     private fun serializeConstantDataCharArray(constantDataCharArray: ConstantDataCharArray) {
         serializeList(constantDataCharArray.value) { serializeWasmSymbolReadOnly(it) { b.writeUInt32(it.code.toUInt()) } }
-        serializeInt(constantDataCharArray.fitsOneByte)
+        serializeInt(constantDataCharArray.fitsLatin1)
     }
 
     private fun serializeConstantDataCharField(constantDataCharField: ConstantDataCharField) {
diff --git a/compiler/ir/backend.wasm/src/org/jetbrains/kotlin/backend/wasm/utils/Utils.kt b/compiler/ir/backend.wasm/src/org/jetbrains/kotlin/backend/wasm/utils/Utils.kt
@@ -34,4 +34,7 @@ internal val IrClass.isAbstractOrSealed
 internal fun getFunctionalInterfaceSlot(iFace: IrClass): Int {
     check(iFace.symbol.isFunction())
     return if (iFace.defaultType.isFunctionMarker()) return 0 else iFace.typeParameters.size
-}
+}
+
+internal val String.fitsLatin1
+    get() = this.all { it.code in 0..255 }
diff --git a/libraries/stdlib/wasm/internal/kotlin/wasm/internal/TypeInfo.kt b/libraries/stdlib/wasm/internal/kotlin/wasm/internal/TypeInfo.kt
@@ -11,8 +11,8 @@ internal class TypeInfoData(val typeId: Long, val packageName: String, val typeN
 
 private const val TYPE_INFO_FLAG_ANONYMOUS_CLASS = 1
 private const val TYPE_INFO_FLAG_LOCAL_CLASS = 2
-private const val TYPE_INFO_FLAG_FITS_ONE_BIT_QUALIFIER = 4
-private const val TYPE_INFO_FLAG_FITS_ONE_BIT_SIMPLE_NAME = 8
+private const val TYPE_INFO_FLAG_FITS_LATIN1_QUALIFIER = 4
+private const val TYPE_INFO_FLAG_FITS_LATIN1_SIMPLE_NAME = 8
 
 @Suppress("UNUSED_PARAMETER")
 @WasmArrayOf(Long::class, isNullable = false, isMutable = false)
@@ -59,15 +59,15 @@ internal fun getQualifiedName(rtti: kotlin.wasm.internal.reftypes.structref): St
 }
 
 internal fun getPackageName(rtti: kotlin.wasm.internal.reftypes.structref): String {
-    val flagFitsOneBitQualifier = wasmGetRttiIntField(5, rtti) and TYPE_INFO_FLAG_FITS_ONE_BIT_QUALIFIER
+    val flagFitsOneBitQualifier = wasmGetRttiIntField(5, rtti) and TYPE_INFO_FLAG_FITS_LATIN1_QUALIFIER
     return if (flagFitsOneBitQualifier != 0)
         stringLiteralLatin1(wasmGetRttiIntField(2, rtti))
     else
         stringLiteralUtf16(wasmGetRttiIntField(2, rtti))
 }
 
 internal fun getSimpleName(rtti: kotlin.wasm.internal.reftypes.structref): String {
-    val flagFitsOneBitSimpleName = wasmGetRttiIntField(5, rtti) and TYPE_INFO_FLAG_FITS_ONE_BIT_SIMPLE_NAME
+    val flagFitsOneBitSimpleName = wasmGetRttiIntField(5, rtti) and TYPE_INFO_FLAG_FITS_LATIN1_SIMPLE_NAME
     return if (flagFitsOneBitSimpleName != 0)
         stringLiteralLatin1(wasmGetRttiIntField(3, rtti))
     else

Original file line number	Diff line number	Diff line change
`@@ -78,12 +78,12 @@ class ConstantDataIntArray(val value: List<WasmSymbol<Int>>) : ConstantDataEleme`
`78`	`78`	`override val sizeInBytes: Int = value.size * INT_SIZE_BYTES`
`79`	`79`	`}`
`80`	`80`
`81`		`-class ConstantDataCharArray(val value: List<WasmSymbol<Char>>, val fitsOneByte: Int) : ConstantDataElement() {`
`82`		`- constructor(value: CharArray, fitsOneByte: Int) : this(value.map { WasmSymbol(it) }, fitsOneByte)`
	`81`	`+class ConstantDataCharArray(val value: List<WasmSymbol<Char>>, val fitsLatin1: Int) : ConstantDataElement() {`
	`82`	`+ constructor(value: CharArray, fitsLatin1: Int) : this(value.map { WasmSymbol(it) }, fitsLatin1)`
`83`	`83`
`84`	`84`	`override fun toBytes(): ByteArray {`
`85`	`85`	`return value`
`86`		`- .map { it.owner.toLittleEndianBytes(fitsOneByte != 0) }`
	`86`	`+ .map { it.owner.toLittleEndianBytes(fitsLatin1 != 0) }`
`87`	`87`	`.fold(byteArrayOf(), ByteArray::plus)`
`88`	`88`	`}`
`89`	`89`
`@@ -93,7 +93,7 @@ class ConstantDataCharArray(val value: List<WasmSymbol<Char>>, val fitsOneByte:`
`93`	`93`	`}`
`94`	`94`
`95`	`95`	`override val sizeInBytes: Int = value.size *`
`96`		`- if (fitsOneByte != 0) BYTE_SIZE_BYTES else CHAR_SIZE_BYTES`
	`96`	`+ if (fitsLatin1 != 0) BYTE_SIZE_BYTES else CHAR_SIZE_BYTES`
`97`	`97`	`}`
`98`	`98`
`99`	`99`	`class ConstantDataStruct(val elements: List<ConstantDataElement>) : ConstantDataElement() {`
`@@ -129,8 +129,8 @@ fun Int.toLittleEndianBytes(): ByteArray {`
`129`	`129`	`}`
`130`	`130`	`}`
`131`	`131`
`132`		`-fun Char.toLittleEndianBytes(fitsOneByte: Boolean): ByteArray {`
`133`		`- if (fitsOneByte) {`
	`132`	`+fun Char.toLittleEndianBytes(fitsLatin1: Boolean): ByteArray {`
	`133`	`+ if (fitsLatin1) {`
`134`	`134`	`return byteArrayOf((this.code and 0xFF).toByte())`
`135`	`135`	`}`
`136`	`136`	`return byteArrayOf((this.code and 0xFF).toByte(), (this.code ushr Byte.SIZE_BITS).toByte())`
Original file line number	Diff line number	Diff line change
`@@ -489,8 +489,8 @@ class WasmDeserializer(inputStream: InputStream, private val skipLocalNames: Boo`
`489`	`489`
`490`	`490`	`private fun deserializeConstantDataCharArray(): ConstantDataCharArray {`
`491`	`491`	`val value = deserializeList { deserializeSymbol { Char(deserializeInt()) } }`
`492`		`- val fitsOneByte = deserializeInt()`
`493`		`- return ConstantDataCharArray(value, fitsOneByte)`
	`492`	`+ val fitsLatin1 = deserializeInt()`
	`493`	`+ return ConstantDataCharArray(value, fitsLatin1)`
`494`	`494`	`}`
`495`	`495`
`496`	`496`	`private fun deserializeConstantDataCharField(): ConstantDataCharField {`
Original file line number	Diff line number	Diff line change
`@@ -515,7 +515,7 @@ class WasmSerializer(outputStream: OutputStream) {`
`515`	`515`
`516`	`516`	`private fun serializeConstantDataCharArray(constantDataCharArray: ConstantDataCharArray) {`
`517`	`517`	`serializeList(constantDataCharArray.value) { serializeWasmSymbolReadOnly(it) { b.writeUInt32(it.code.toUInt()) } }`
`518`		`- serializeInt(constantDataCharArray.fitsOneByte)`
	`518`	`+ serializeInt(constantDataCharArray.fitsLatin1)`
`519`	`519`	`}`
`520`	`520`
`521`	`521`	`private fun serializeConstantDataCharField(constantDataCharField: ConstantDataCharField) {`