calvaris/289787

Source/JavaScriptCore/API/JSScript.mm

@@ -146,7 +146,7 @@ + (instancetype)scriptOfType:(JSScriptType)type memoryMappedFromASCIIFile:(NSURL
     auto result = adoptNS([[JSScript alloc] init]);
     result->m_virtualMachine = vm;
     result->m_type = type;
-    result->m_source = String(StringImpl::createWithoutCopying(fileData.span()));
+    result->m_source = StringImpl::createWithoutCopying(byteCast<Latin1Character>(fileData.span()));
     result->m_mappedSource = WTFMove(fileData);
     result->m_sourceURL = sourceURL;
     result->m_cachePath = cachePath;

Source/JavaScriptCore/API/JSStringRef.cpp

@@ -38,19 +38,19 @@ WTF_ALLOW_UNSAFE_BUFFER_USAGE_BEGIN
 JSStringRef JSStringCreateWithCharacters(const JSChar* chars, size_t numChars)
 {
     JSC::initialize();
-    return &OpaqueJSString::create({ reinterpret_cast<const UChar*>(chars), numChars }).leakRef();
+    return &OpaqueJSString::create({ reinterpret_cast<const char16_t*>(chars), numChars }).leakRef();
 }
 
 JSStringRef JSStringCreateWithUTF8CString(const char* string)
 {
     JSC::initialize();
     if (string) {
-        auto stringSpan = span8(string);
-        Vector<UChar, 1024> buffer(stringSpan.size());
+        auto stringSpan = byteCast<char8_t>(unsafeSpan(string));
+        Vector<char16_t, 1024> buffer(stringSpan.size());
         auto result = WTF::Unicode::convert(spanReinterpretCast<const char8_t>(stringSpan), buffer.mutableSpan());
         if (result.code == WTF::Unicode::ConversionResultCode::Success) {
             if (result.isAllASCII)
-                return &OpaqueJSString::create(stringSpan).leakRef();
+                return &OpaqueJSString::create(byteCast<Latin1Character>(stringSpan)).leakRef();
             return &OpaqueJSString::create(result.buffer).leakRef();
         }
     }
@@ -61,7 +61,7 @@ JSStringRef JSStringCreateWithUTF8CString(const char* string)
 JSStringRef JSStringCreateWithCharactersNoCopy(const JSChar* chars, size_t numChars)
 {
     JSC::initialize();
-    return OpaqueJSString::tryCreate(StringImpl::createWithoutCopying({ reinterpret_cast<const UChar*>(chars), numChars })).leakRef();
+    return OpaqueJSString::tryCreate(StringImpl::createWithoutCopying({ reinterpret_cast<const char16_t*>(chars), numChars })).leakRef();
 }
 
 JSStringRef JSStringRetain(JSStringRef string)

Source/JavaScriptCore/API/JSStringRefCF.cpp

@@ -45,16 +45,16 @@ JSStringRef JSStringCreateWithCFString(CFStringRef string)
     if (!length)
         return &OpaqueJSString::create(""_span8).leakRef();
 
-    Vector<LChar, 1024> lcharBuffer(length);
+    Vector<Latin1Character, 1024> lcharBuffer(length);
     CFIndex usedBufferLength;
-    CFIndex convertedSize = CFStringGetBytes(string, CFRangeMake(0, length), kCFStringEncodingISOLatin1, 0, false, lcharBuffer.data(), length, &usedBufferLength);
+    CFIndex convertedSize = CFStringGetBytes(string, CFRangeMake(0, length), kCFStringEncodingISOLatin1, 0, false, byteCast<UInt8>(lcharBuffer.data()), length, &usedBufferLength);
     if (static_cast<size_t>(convertedSize) == length && static_cast<size_t>(usedBufferLength) == length)
         return &OpaqueJSString::create(lcharBuffer.span()).leakRef();
 
     Vector<UniChar> buffer(length);
     CFStringGetCharacters(string, CFRangeMake(0, length), buffer.data());
-    static_assert(sizeof(UniChar) == sizeof(UChar), "UniChar and UChar must be same size");
-    return &OpaqueJSString::create({ reinterpret_cast<UChar*>(buffer.data()), length }).leakRef();
+    static_assert(sizeof(UniChar) == sizeof(char16_t), "UniChar and char16_t must be same size");
+    return &OpaqueJSString::create({ reinterpret_cast<const char16_t*>(buffer.data()), length }).leakRef();
 }
 
 CFStringRef JSStringCopyCFString(CFAllocatorRef allocator, JSStringRef string)
@@ -64,7 +64,7 @@ CFStringRef JSStringCopyCFString(CFAllocatorRef allocator, JSStringRef string)
 
     if (string->is8Bit()) {
         auto characters = string->span8();
-        return CFStringCreateWithBytes(allocator, characters.data(), characters.size(), kCFStringEncodingISOLatin1, false);
+        return CFStringCreateWithBytes(allocator, byteCast<UInt8>(characters.data()), characters.size(), kCFStringEncodingISOLatin1, false);
     }
     auto characters = string->span16();
     return CFStringCreateWithCharacters(allocator, reinterpret_cast<const UniChar*>(characters.data()), characters.size());

Source/JavaScriptCore/API/JSValue.mm

@@ -1281,8 +1281,8 @@ - (JSValue *)initWithValue:(JSValueRef)value inContext:(JSContext *)context
         if (strcmp(idType, "@") != 0)
             return;
         {
-            auto type = adoptSystem<char[]>(method_copyArgumentType(method, 2));
-            structHandlers->add(StringImpl::createFromCString(type.get()), (StructTagHandler) { selector, 0 });
+          auto type = adoptSystem<char[]>(method_copyArgumentType(method, 2));
+          structHandlers->add(byteCast<Latin1Character>(unsafeSpan(type.get()), (StructTagHandler) { selector, 0 });
         }
     });
 

Source/JavaScriptCore/API/JSValueRef.cpp

@@ -697,10 +697,10 @@ JSValueRef JSValueMakeFromJSONString(JSContextRef ctx, JSStringRef string)
     JSLockHolder locker(globalObject);
     String str = string->string();
     if (str.is8Bit()) {
-        LiteralParser<LChar, JSONReviverMode::Disabled> parser(globalObject, str.span8(), StrictJSON);
+        LiteralParser<Latin1Character, JSONReviverMode::Disabled> parser(globalObject, str.span8(), StrictJSON);
         return toRef(globalObject, parser.tryLiteralParse());
     }
-    LiteralParser<UChar, JSONReviverMode::Disabled> parser(globalObject, str.span16(), StrictJSON);
+    LiteralParser<char16_t, JSONReviverMode::Disabled> parser(globalObject, str.span16(), StrictJSON);
     return toRef(globalObject, parser.tryLiteralParse());
 }
 

Source/JavaScriptCore/API/OpaqueJSString.cpp

@@ -52,7 +52,7 @@ RefPtr<OpaqueJSString> OpaqueJSString::tryCreate(String&& string)
 OpaqueJSString::~OpaqueJSString()
 {
     // m_characters is put in a local here to avoid an extra atomic load.
-    UChar* characters = m_characters;
+    char16_t* characters = m_characters;
     if (!characters)
         return;
 
@@ -79,17 +79,17 @@ Identifier OpaqueJSString::identifier(VM* vm) const
     return Identifier::fromString(*vm, m_string.span16());
 }
 
-const UChar* OpaqueJSString::characters()
+const char16_t* OpaqueJSString::characters()
 {
     // m_characters is put in a local here to avoid an extra atomic load.
-    UChar* characters = m_characters;
+    char16_t* characters = m_characters;
     if (characters)
         return characters;
 
     if (m_string.isNull())
         return nullptr;
 
-    auto newCharacters = MallocSpan<UChar>::malloc(m_string.length() * sizeof(UChar));
+    auto newCharacters = MallocSpan<char16_t>::malloc(m_string.length() * sizeof(char16_t));
     StringView { m_string }.getCharacters(newCharacters.mutableSpan());
 
     if (!m_characters.compare_exchange_strong(characters, newCharacters.mutableSpan().data()))

Source/JavaScriptCore/API/OpaqueJSString.h

@@ -40,12 +40,12 @@ struct OpaqueJSString : public ThreadSafeRefCounted<OpaqueJSString> {
         return adoptRef(*new OpaqueJSString);
     }
 
-    static Ref<OpaqueJSString> create(std::span<const LChar> characters)
+    static Ref<OpaqueJSString> create(std::span<const Latin1Character> characters)
     {
         return adoptRef(*new OpaqueJSString(characters));
     }
 
-    static Ref<OpaqueJSString> create(std::span<const UChar> characters)
+    static Ref<OpaqueJSString> create(std::span<const char16_t> characters)
     {
         return adoptRef(*new OpaqueJSString(characters));
     }
@@ -56,11 +56,11 @@ struct OpaqueJSString : public ThreadSafeRefCounted<OpaqueJSString> {
     JS_EXPORT_PRIVATE ~OpaqueJSString();
 
     bool is8Bit() { return m_string.is8Bit(); }
-    std::span<const LChar> span8() { return m_string.span8(); }
-    std::span<const UChar> span16() { return m_string.span16(); }
+    std::span<const Latin1Character> span8() LIFETIME_BOUND { return m_string.span8(); }
+    std::span<const char16_t> span16() LIFETIME_BOUND { return m_string.span16(); }
     unsigned length() { return m_string.length(); }
 
-    const UChar* characters();
+    const char16_t* characters() LIFETIME_BOUND;
 
     JS_EXPORT_PRIVATE String string() const;
     JSC::Identifier identifier(JSC::VM*) const;
@@ -77,30 +77,30 @@ struct OpaqueJSString : public ThreadSafeRefCounted<OpaqueJSString> {
 
     OpaqueJSString(const String& string)
         : m_string(string.isolatedCopy())
-        , m_characters(m_string.impl() && m_string.is8Bit() ? nullptr : const_cast<UChar*>(m_string.span16().data()))
+        , m_characters(m_string.impl() && m_string.is8Bit() ? nullptr : const_cast<char16_t*>(m_string.span16().data()))
     {
     }
 
     explicit OpaqueJSString(String&& string)
         : m_string(WTFMove(string))
-        , m_characters(m_string.impl() && m_string.is8Bit() ? nullptr : const_cast<UChar*>(m_string.span16().data()))
+        , m_characters(m_string.impl() && m_string.is8Bit() ? nullptr : const_cast<char16_t*>(m_string.span16().data()))
     {
     }
 
-    OpaqueJSString(std::span<const LChar> characters)
+    OpaqueJSString(std::span<const Latin1Character> characters)
         : m_string(characters)
         , m_characters(nullptr)
     {
     }
 
-    OpaqueJSString(std::span<const UChar> characters)
+    OpaqueJSString(std::span<const char16_t> characters)
         : m_string(characters)
-        , m_characters(m_string.impl() && m_string.is8Bit() ? nullptr : const_cast<UChar*>(m_string.span16().data()))
+        , m_characters(m_string.impl() && m_string.is8Bit() ? nullptr : const_cast<char16_t*>(m_string.span16().data()))
     {
     }
 
     String m_string;
 
     // This will be initialized on demand when characters() is called if the string needs up-conversion.
-    std::atomic<UChar*> m_characters;
+    std::atomic<char16_t*> m_characters;
 };

Source/JavaScriptCore/API/glib/JSCCallbackFunction.cpp

@@ -228,7 +228,7 @@ JSObjectRef JSCCallbackFunction::construct(JSContextRef callerContext, size_t ar
         *exception = toRef(JSC::createTypeError(toJS(jsContext), "constructor returned null"_s));
         break;
     default:
-        *exception = toRef(JSC::createTypeError(toJS(jsContext), makeString("invalid type "_s, span(g_type_name(G_VALUE_TYPE(&returnValue))), " returned by constructor"_s)));
+        *exception = toRef(JSC::createTypeError(toJS(jsContext), makeString("invalid type "_s, unsafeSpan(g_type_name(G_VALUE_TYPE(&returnValue))), " returned by constructor"_s)));
         break;
     }
     g_value_unset(&returnValue);

Source/JavaScriptCore/API/glib/JSCContext.cpp

@@ -467,7 +467,7 @@ JSValueRef jscContextGValueToJSValue(JSCContext* context, const GValue* value, J
         break;
     }
 
-    *exception = toRef(JSC::createTypeError(globalObject, makeString("unsupported type "_s, span(g_type_name(G_VALUE_TYPE(value))))));
+    *exception = toRef(JSC::createTypeError(globalObject, makeString("unsupported type "_s, unsafeSpan(g_type_name(G_VALUE_TYPE(value))))));
     return JSValueMakeUndefined(priv->jsContext.get());
 }
 
@@ -587,7 +587,7 @@ void jscContextJSValueToGValue(JSCContext* context, JSValueRef jsValue, GType ty
     case G_TYPE_INTERFACE:
     case G_TYPE_VARIANT:
     default:
-        *exception = toRef(JSC::createTypeError(globalObject, makeString("unsupported type "_s, span(g_type_name(G_VALUE_TYPE(value))))));
+        *exception = toRef(JSC::createTypeError(globalObject, makeString("unsupported type "_s, unsafeSpan(g_type_name(G_VALUE_TYPE(value))))));
         break;
     }
 }

Source/JavaScriptCore/API/glib/JSCValue.cpp

@@ -503,7 +503,7 @@ JSCValue* jsc_value_new_array(JSCContext* context, GType firstItemType, ...)
         G_VALUE_COLLECT_INIT(&item, itemType, args, G_VALUE_NOCOPY_CONTENTS, &error.outPtr());
         WTF_ALLOW_UNSAFE_BUFFER_USAGE_END
         if (error) {
-            exception = toRef(JSC::createTypeError(globalObject, makeString("failed to collect array item: "_s, span(error.get()))));
+            exception = toRef(JSC::createTypeError(globalObject, makeString("failed to collect array item: "_s, unsafeSpan(error.get()))));
             jscContextHandleExceptionIfNeeded(context, exception);
             jsArray = nullptr;
             break;
@@ -905,7 +905,7 @@ static GRefPtr<JSCValue> jscValueCallFunction(JSCValue* value, JSObjectRef funct
         G_VALUE_COLLECT_INIT(&parameter, parameterType, args, G_VALUE_NOCOPY_CONTENTS, &error.outPtr());
         WTF_ALLOW_UNSAFE_BUFFER_USAGE_END
         if (error) {
-            exception = toRef(JSC::createTypeError(globalObject, makeString("failed to collect function paramater: "_s, span(error.get()))));
+            exception = toRef(JSC::createTypeError(globalObject, makeString("failed to collect function paramater: "_s, unsafeSpan(error.get()))));
             jscContextHandleExceptionIfNeeded(priv->context.get(), exception);
             return adoptGRef(jsc_value_new_undefined(priv->context.get()));
         }
@@ -2093,12 +2093,12 @@ JSCValue* jsc_value_new_from_json(JSCContext* context, const char* json)
     JSC::JSValue jsValue;
     String jsonString = String::fromUTF8(json);
     if (jsonString.is8Bit()) {
-        JSC::LiteralParser<LChar, JSC::JSONReviverMode::Disabled> jsonParser(globalObject, jsonString.span8(), JSC::StrictJSON);
+        JSC::LiteralParser<Latin1Character, JSC::JSONReviverMode::Disabled> jsonParser(globalObject, jsonString.span8(), JSC::StrictJSON);
         jsValue = jsonParser.tryLiteralParse();
         if (!jsValue)
             exception = toRef(JSC::createSyntaxError(globalObject, jsonParser.getErrorMessage()));
     } else {
-        JSC::LiteralParser<UChar, JSC::JSONReviverMode::Disabled> jsonParser(globalObject, jsonString.span16(), JSC::StrictJSON);
+        JSC::LiteralParser<char16_t, JSC::JSONReviverMode::Disabled> jsonParser(globalObject, jsonString.span16(), JSC::StrictJSON);
         jsValue = jsonParser.tryLiteralParse();
         if (!jsValue)
             exception = toRef(JSC::createSyntaxError(globalObject, jsonParser.getErrorMessage()));

Source/JavaScriptCore/API/tests/JSONParseTest.cpp

@@ -48,7 +48,7 @@ int testJSONParse()
     JSValue v0 = JSONParse(globalObject, ""_s);
     JSValue v1 = JSONParse(globalObject, "#$%^"_s);
     JSValue v2 = JSONParse(globalObject, String());
-    UChar emptyUCharArray[1] = { '\0' };
+    char16_t emptyUCharArray[1] = { '\0' };
     unsigned zeroLength = 0;
     JSValue v3 = JSONParse(globalObject, String({ emptyUCharArray, zeroLength }));
     JSValue v4;

Source/JavaScriptCore/KeywordLookupGenerator.py

@@ -185,27 +185,27 @@ def printAsC(self):
         print("")
         print("namespace JSC {")
         print("")
-        print("static ALWAYS_INLINE bool cannotBeIdentPartOrEscapeStart(LChar);")
-        print("static ALWAYS_INLINE bool cannotBeIdentPartOrEscapeStart(UChar);")
+        print("static ALWAYS_INLINE bool cannotBeIdentPartOrEscapeStart(Latin1Character);")
+        print("static ALWAYS_INLINE bool cannotBeIdentPartOrEscapeStart(char16_t);")
         # max length + 1 so we don't need to do any bounds checking at all
         print("static constexpr int maxTokenLength = %d;" % (self.maxLength() + 1))
         print("")
         print("template <>")
-        print("template <bool shouldCreateIdentifier> ALWAYS_INLINE JSTokenType Lexer<UChar>::parseKeyword(JSTokenData* data)")
+        print("template <bool shouldCreateIdentifier> ALWAYS_INLINE JSTokenType Lexer<char16_t>::parseKeyword(JSTokenData* data)")
         print("{")
         print("    ASSERT(m_codeEnd - m_code >= maxTokenLength);")
         print("")
-        print("    const UChar* code = m_code;")
+        print("    const char16_t* code = m_code;")
         self.printSubTreeAsC("UCHAR", 4)
         print("    return IDENT;")
         print("}")
         print("")
         print("template <>")
-        print("template <bool shouldCreateIdentifier> ALWAYS_INLINE JSTokenType Lexer<LChar>::parseKeyword(JSTokenData* data)")
+        print("template <bool shouldCreateIdentifier> ALWAYS_INLINE JSTokenType Lexer<Latin1Character>::parseKeyword(JSTokenData* data)")
         print("{")
         print("    ASSERT(m_codeEnd - m_code >= maxTokenLength);")
         print("")
-        print("    const LChar* code = m_code;")
+        print("    const Latin1Character* code = m_code;")
         self.printSubTreeAsC("CHAR", 4)
         print("    return IDENT;")
         print("}")

Source/JavaScriptCore/builtins/BuiltinExecutables.cpp

@@ -128,7 +128,7 @@ UnlinkedFunctionExecutable* BuiltinExecutables::createExecutable(VM& vm, const S
                 continue;
             } else if (characters[i] == ',')
                 ++commas;
-            else if (!Lexer<LChar>::isWhiteSpace(characters[i]))
+            else if (!Lexer<Latin1Character>::isWhiteSpace(characters[i]))
                 sawOneParam = true;
 
             if (i + 2 < view.length() && characters[i] == '.' && characters[i + 1] == '.' && characters[i + 2] == '.') {

Source/JavaScriptCore/builtins/BuiltinNames.cpp

@@ -93,8 +93,8 @@ BuiltinNames::BuiltinNames(VM& vm, CommonIdentifiers* commonIdentifiers)
 #undef INITIALIZE_WELL_KNOWN_SYMBOL_PUBLIC_TO_PRIVATE_ENTRY
 
 
-using LCharBuffer = WTF::HashTranslatorCharBuffer<LChar>;
-using UCharBuffer = WTF::HashTranslatorCharBuffer<UChar>;
+using LCharBuffer = WTF::HashTranslatorCharBuffer<Latin1Character>;
+using UCharBuffer = WTF::HashTranslatorCharBuffer<char16_t>;
 
 template<typename CharacterType>
 struct CharBufferSeacher {
@@ -132,13 +132,13 @@ static SymbolImpl* lookUpWellKnownSymbolImpl(const BuiltinNames::WellKnownSymbol
     return iterator->value;
 }
 
-PrivateSymbolImpl* BuiltinNames::lookUpPrivateName(std::span<const LChar> characters) const
+PrivateSymbolImpl* BuiltinNames::lookUpPrivateName(std::span<const Latin1Character> characters) const
 {
     LCharBuffer buffer { characters };
     return lookUpPrivateNameImpl(m_privateNameSet, buffer);
 }
 
-PrivateSymbolImpl* BuiltinNames::lookUpPrivateName(std::span<const UChar> characters) const
+PrivateSymbolImpl* BuiltinNames::lookUpPrivateName(std::span<const char16_t> characters) const
 {
     UCharBuffer buffer { characters };
     return lookUpPrivateNameImpl(m_privateNameSet, buffer);
@@ -154,13 +154,13 @@ PrivateSymbolImpl* BuiltinNames::lookUpPrivateName(const String& string) const
     return lookUpPrivateNameImpl(m_privateNameSet, buffer);
 }
 
-SymbolImpl* BuiltinNames::lookUpWellKnownSymbol(std::span<const LChar> characters) const
+SymbolImpl* BuiltinNames::lookUpWellKnownSymbol(std::span<const Latin1Character> characters) const
 {
     LCharBuffer buffer { characters };
     return lookUpWellKnownSymbolImpl(m_wellKnownSymbolsMap, buffer);
 }
 
-SymbolImpl* BuiltinNames::lookUpWellKnownSymbol(std::span<const UChar> characters) const
+SymbolImpl* BuiltinNames::lookUpWellKnownSymbol(std::span<const char16_t> characters) const
 {
     UCharBuffer buffer { characters };
     return lookUpWellKnownSymbolImpl(m_wellKnownSymbolsMap, buffer);

Source/JavaScriptCore/builtins/BuiltinNames.h

@@ -246,13 +246,13 @@ class BuiltinNames {
 
     PrivateSymbolImpl* lookUpPrivateName(const Identifier&) const;
     PrivateSymbolImpl* lookUpPrivateName(const String&) const;
-    PrivateSymbolImpl* lookUpPrivateName(std::span<const LChar>) const;
-    PrivateSymbolImpl* lookUpPrivateName(std::span<const UChar>) const;
+    PrivateSymbolImpl* lookUpPrivateName(std::span<const Latin1Character>) const;
+    PrivateSymbolImpl* lookUpPrivateName(std::span<const char16_t>) const;
 
     SymbolImpl* lookUpWellKnownSymbol(const Identifier&) const;
     SymbolImpl* lookUpWellKnownSymbol(const String&) const;
-    SymbolImpl* lookUpWellKnownSymbol(std::span<const LChar>) const;
-    SymbolImpl* lookUpWellKnownSymbol(std::span<const UChar>) const;
+    SymbolImpl* lookUpWellKnownSymbol(std::span<const Latin1Character>) const;
+    SymbolImpl* lookUpWellKnownSymbol(std::span<const char16_t>) const;
 
     void appendExternalName(const Identifier& publicName, const Identifier& privateName);
 

Source/JavaScriptCore/bytecode/CodeBlockHash.cpp

@@ -66,7 +66,7 @@ CodeBlockHash::CodeBlockHash(const SourceCode& sourceCode, CodeSpecializationKin
 
         sha1.addBytes(std::span { std::bit_cast<uint8_t*>(&length), sizeof(length) });
         do {
-            UChar character = str[index];
+            char16_t character = str[index];
             sha1.addBytes(std::span { std::bit_cast<uint8_t*>(&character), sizeof(character) });
             oldIndex = index;
             index += step;