Use std::span more in String code

https://bugs.webkit.org/show_bug.cgi?id=271354

Reviewed by Darin Adler.

* Source/JavaScriptCore/builtins/BuiltinNames.cpp:
(JSC::CharBufferSeacher::equal):
(JSC::BuiltinNames::lookUpPrivateName const):
(JSC::BuiltinNames::lookUpWellKnownSymbol const):
* Source/JavaScriptCore/builtins/BuiltinNames.h:
* Source/JavaScriptCore/jsc.cpp:
(JSC_DEFINE_HOST_FUNCTION):
* Source/JavaScriptCore/parser/Lexer.cpp:
(JSC::Lexer<LChar>::parseIdentifier):
* Source/JavaScriptCore/parser/Lexer.h:
(JSC::Lexer<T>::makeIdentifier):
* Source/JavaScriptCore/runtime/CachedTypes.cpp:
(JSC::CachedUniquedStringImplBase::decode const):
(JSC::CachedUniquedStringImplBase::span8 const):
(JSC::CachedUniquedStringImplBase::span16 const):
* Source/JavaScriptCore/runtime/Identifier.cpp:
(JSC::Identifier::add8):
* Source/JavaScriptCore/runtime/Identifier.h:
(JSC::Identifier::add):
* Source/JavaScriptCore/runtime/JSONAtomStringCache.h:
* Source/JavaScriptCore/runtime/JSONAtomStringCacheInlines.h:
(JSC::JSONAtomStringCache::make):
* Source/JavaScriptCore/runtime/JSString.cpp:
(JSC::JSRopeString::resolveRopeToExistingAtomString const):
* Source/JavaScriptCore/runtime/JSString.h:
(JSC::jsSingleCharacterString):
(JSC::jsString):
* Source/JavaScriptCore/runtime/JSStringInlines.h:
(JSC::jsAtomString):
(JSC::jsSubstringOfResolved):
* Source/JavaScriptCore/runtime/KeyAtomStringCacheInlines.h:
(JSC::KeyAtomStringCache::make):
* Source/JavaScriptCore/runtime/SmallStrings.cpp:
(JSC::SmallStrings::initializeCommonStrings):
(JSC::SmallStrings::singleCharacterStringRep):
* Source/WTF/wtf/Assertions.cpp:
(WTF::createWithFormatAndArguments):
* Source/WTF/wtf/text/AtomString.h:
(WTF::AtomString::AtomString):
* Source/WTF/wtf/text/AtomStringImpl.cpp:
(WTF::UCharBufferTranslator::equal):
(WTF::UCharBufferTranslator::translate):
(WTF::HashAndUTF8CharactersTranslator::translate):
(WTF::AtomStringImpl::add):
(WTF::LCharBufferTranslator::equal):
(WTF::LCharBufferTranslator::translate):
(WTF::BufferFromStaticDataTranslator::equal):
(WTF::BufferFromStaticDataTranslator::translate):
(WTF::AtomStringImpl::addLiteral):
(WTF::addStatic):
(WTF::AtomStringImpl::lookUp):
* Source/WTF/wtf/text/AtomStringImpl.h:
* Source/WTF/wtf/text/StringImpl.cpp:
(WTF::StringImpl::createInternal):
(WTF::StringImpl::create):
(WTF::StringImpl::createStaticStringImpl):
(WTF::StringImpl::create8BitIfPossible):
(WTF::StringImpl::substring):
(WTF::StringImpl::trimMatchedCharacters):
* Source/WTF/wtf/text/StringImpl.h:
(WTF::StringImpl::create):
(WTF::StringImpl::create8BitIfPossible):
(WTF::StringImpl::createFromCString):
(WTF::StringImpl::createWithoutCopying):
(WTF::HashTranslatorCharBuffer::HashTranslatorCharBuffer):
(WTF::equal):
(WTF::StringImpl::isolatedCopy const):
(WTF::StringImpl::createSubstringSharingImpl):
(WTF::StringImpl::adopt):
* Source/WTF/wtf/text/StringView.h:
(WTF::StringView::toExistingAtomString const):
* Source/WTF/wtf/text/WTFString.cpp:
(WTF::String::String):
(WTF::fromUTF8Impl):
* Source/WTF/wtf/text/cf/AtomStringImplCF.cpp:
(WTF::AtomStringImpl::add):
* Tools/TestWebKitAPI/Tests/WTF/StringImpl.cpp:
(TestWebKitAPI::TEST):
* Tools/TestWebKitAPI/Tests/WTF/StringView.cpp:
(TestWebKitAPI::TEST):

Canonical link: https://commits.webkit.org/276458@main

Source/JavaScriptCore/builtins/BuiltinNames.cpp

@@ -111,7 +111,7 @@ struct CharBufferSeacher {
 
     static bool equal(const String& str, const Buffer& buf)
     {
-        return WTF::equal(str.impl(), buf.characters, buf.length);
+        return WTF::equal(str.impl(), buf.characters);
     }
 };
 
@@ -137,47 +137,47 @@ static SymbolImpl* lookUpWellKnownSymbolImpl(const BuiltinNames::WellKnownSymbol
     return iterator->value;
 }
 
-PrivateSymbolImpl* BuiltinNames::lookUpPrivateName(const LChar* characters, unsigned length) const
+PrivateSymbolImpl* BuiltinNames::lookUpPrivateName(std::span<const LChar> characters) const
 {
-    LCharBuffer buffer { characters, length };
+    LCharBuffer buffer { characters };
     return lookUpPrivateNameImpl(m_privateNameSet, buffer);
 }
 
-PrivateSymbolImpl* BuiltinNames::lookUpPrivateName(const UChar* characters, unsigned length) const
+PrivateSymbolImpl* BuiltinNames::lookUpPrivateName(std::span<const UChar> characters) const
 {
-    UCharBuffer buffer { characters, length };
+    UCharBuffer buffer { characters };
     return lookUpPrivateNameImpl(m_privateNameSet, buffer);
 }
 
 PrivateSymbolImpl* BuiltinNames::lookUpPrivateName(const String& string) const
 {
     if (string.is8Bit()) {
-        LCharBuffer buffer { string.characters8(), string.length(), string.hash() };
+        LCharBuffer buffer { string.span8(), string.hash() };
         return lookUpPrivateNameImpl(m_privateNameSet, buffer);
     }
-    UCharBuffer buffer { string.characters16(), string.length(), string.hash() };
+    UCharBuffer buffer { string.span16(), string.hash() };
     return lookUpPrivateNameImpl(m_privateNameSet, buffer);
 }
 
-SymbolImpl* BuiltinNames::lookUpWellKnownSymbol(const LChar* characters, unsigned length) const
+SymbolImpl* BuiltinNames::lookUpWellKnownSymbol(std::span<const LChar> characters) const
 {
-    LCharBuffer buffer { characters, length };
+    LCharBuffer buffer { characters };
     return lookUpWellKnownSymbolImpl(m_wellKnownSymbolsMap, buffer);
 }
 
-SymbolImpl* BuiltinNames::lookUpWellKnownSymbol(const UChar* characters, unsigned length) const
+SymbolImpl* BuiltinNames::lookUpWellKnownSymbol(std::span<const UChar> characters) const
 {
-    UCharBuffer buffer { characters, length };
+    UCharBuffer buffer { characters };
     return lookUpWellKnownSymbolImpl(m_wellKnownSymbolsMap, buffer);
 }
 
 SymbolImpl* BuiltinNames::lookUpWellKnownSymbol(const String& string) const
 {
     if (string.is8Bit()) {
-        LCharBuffer buffer { string.characters8(), string.length(), string.hash() };
+        LCharBuffer buffer { string.span8(), string.hash() };
         return lookUpWellKnownSymbolImpl(m_wellKnownSymbolsMap, buffer);
     }
-    UCharBuffer buffer { string.characters16(), string.length(), string.hash() };
+    UCharBuffer buffer { string.span16(), string.hash() };
     return lookUpWellKnownSymbolImpl(m_wellKnownSymbolsMap, buffer);
 }
 

Source/JavaScriptCore/builtins/BuiltinNames.h

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

Source/JavaScriptCore/jsc.cpp

@@ -3047,9 +3047,9 @@ JSC_DEFINE_HOST_FUNCTION(functionCreateNonRopeNonAtomString, (JSGlobalObject* gl
 
     if (source.impl()->isAtom()) {
         if (source.is8Bit())
-            source = StringImpl::create(source.characters8(), source.length());
+            source = StringImpl::create(source.span8());
         else
-            source = StringImpl::create(source.characters16(), source.length());
+            source = StringImpl::create(source.span16());
     }
 
     RELEASE_ASSERT(!source.impl()->isAtom());

Source/JavaScriptCore/parser/Lexer.cpp

@@ -973,17 +973,16 @@ template <bool shouldCreateIdentifier> ALWAYS_INLINE JSTokenType Lexer<LChar>::p
     const Identifier* ident = nullptr;
 
     if (shouldCreateIdentifier || m_parsingBuiltinFunction) {
-        int identifierLength = currentSourcePtr() - identifierStart;
-        ident = makeIdentifier(identifierStart, identifierLength);
+        std::span identifierSpan { identifierStart, static_cast<size_t>(currentSourcePtr() - identifierStart) };
         if (m_parsingBuiltinFunction && isBuiltinName) {
             if (isWellKnownSymbol)
-                ident = &m_arena->makeIdentifier(m_vm, m_vm.propertyNames->builtinNames().lookUpWellKnownSymbol(identifierStart, identifierLength));
+                ident = &m_arena->makeIdentifier(m_vm, m_vm.propertyNames->builtinNames().lookUpWellKnownSymbol(identifierSpan));
             else
-                ident = &m_arena->makeIdentifier(m_vm, m_vm.propertyNames->builtinNames().lookUpPrivateName(identifierStart, identifierLength));
+                ident = &m_arena->makeIdentifier(m_vm, m_vm.propertyNames->builtinNames().lookUpPrivateName(identifierSpan));
             if (!ident)
                 return INVALID_PRIVATE_NAME_ERRORTOK;
         } else {
-            ident = makeIdentifier(identifierStart, identifierLength);
+            ident = makeIdentifier(identifierSpan);
             if (m_parsingBuiltinFunction) {
                 if (!isSafeBuiltinIdentifier(m_vm, ident)) {
                     m_lexErrorMessage = makeString("The use of '"_s, ident->string(), "' is disallowed in builtin functions."_s);

Source/JavaScriptCore/parser/Lexer.h

@@ -155,8 +155,11 @@ class Lexer {
 
     ALWAYS_INLINE void setCodeStart(StringView);
 
-    ALWAYS_INLINE const Identifier* makeIdentifier(const LChar* characters, size_t length);
-    ALWAYS_INLINE const Identifier* makeIdentifier(const UChar* characters, size_t length);
+    template<typename CharacterType>
+    ALWAYS_INLINE const Identifier* makeIdentifier(const CharacterType* characters, size_t length);
+    template<typename CharacterType>
+    ALWAYS_INLINE const Identifier* makeIdentifier(std::span<const CharacterType> characters);
+
     ALWAYS_INLINE const Identifier* makeLCharIdentifier(const LChar* characters, size_t length);
     ALWAYS_INLINE const Identifier* makeLCharIdentifier(const UChar* characters, size_t length);
     ALWAYS_INLINE const Identifier* makeRightSizedIdentifier(const UChar* characters, size_t length, UChar orAllChars);
@@ -273,16 +276,19 @@ inline UChar Lexer<T>::convertUnicode(int c1, int c2, int c3, int c4)
     return (convertHex(c1, c2) << 8) | convertHex(c3, c4);
 }
 
-template <typename T>
-ALWAYS_INLINE const Identifier* Lexer<T>::makeIdentifier(const LChar* characters, size_t length)
+// FIXME: Port call sites to the overload taking a span and drop this one.
+template<typename T>
+template<typename CharacterType>
+ALWAYS_INLINE const Identifier* Lexer<T>::makeIdentifier(const CharacterType* characters, size_t length)
 {
     return &m_arena->makeIdentifier(m_vm, characters, length);
 }
 
-template <typename T>
-ALWAYS_INLINE const Identifier* Lexer<T>::makeIdentifier(const UChar* characters, size_t length)
+template<typename T>
+template<typename CharacterType>
+ALWAYS_INLINE const Identifier* Lexer<T>::makeIdentifier(std::span<const CharacterType> characters)
 {
-    return &m_arena->makeIdentifier(m_vm, characters, length);
+    return &m_arena->makeIdentifier(m_vm, characters.data(), characters.size());
 }
 
 template <>

Source/JavaScriptCore/runtime/CachedTypes.cpp

@@ -735,22 +735,22 @@ class CachedUniquedStringImplBase : public VariableLengthObject<T> {
 
     UniquedStringImpl* decode(Decoder& decoder) const
     {
-        auto create = [&](const auto* buffer) -> UniquedStringImpl* {
+        auto create = [&](auto buffer) -> UniquedStringImpl* {
             if (!m_isSymbol)
-                return AtomStringImpl::add(buffer, m_length).leakRef();
+                return AtomStringImpl::add(buffer).leakRef();
 
             SymbolImpl* symbol;
             VM& vm = decoder.vm();
             if (m_isRegistered) {
-                String str(buffer, m_length);
+                String str(buffer);
                 if (m_isPrivate)
                     symbol = static_cast<SymbolImpl*>(&vm.privateSymbolRegistry().symbolForKey(str).leakRef());
                 else
                     symbol = static_cast<SymbolImpl*>(&vm.symbolRegistry().symbolForKey(str).leakRef());
             } else if (m_isWellKnownSymbol)
-                symbol = vm.propertyNames->builtinNames().lookUpWellKnownSymbol(buffer, m_length);
+                symbol = vm.propertyNames->builtinNames().lookUpWellKnownSymbol(buffer);
             else
-                symbol = vm.propertyNames->builtinNames().lookUpPrivateName(buffer, m_length);
+                symbol = vm.propertyNames->builtinNames().lookUpPrivateName(buffer);
             RELEASE_ASSERT(symbol);
             String str = symbol;
             StringImpl* impl = str.releaseImpl().get();
@@ -768,11 +768,12 @@ class CachedUniquedStringImplBase : public VariableLengthObject<T> {
             return RefPtr { emptyAtom().impl() }.leakRef();
         }
 
-        if (m_is8Bit)
-            return create(this->template buffer<LChar>());
-        return create(this->template buffer<UChar>());
+        return m_is8Bit ? create(span8()) : create(span16());
     }
 
+    std::span<const LChar> span8() const { return { this->template buffer<LChar>(), m_length }; }
+    std::span<const UChar> span16() const { return { this->template buffer<UChar>(), m_length }; }
+
 private:
     bool m_is8Bit : 1;
     bool m_isSymbol : 1;

Source/JavaScriptCore/runtime/Identifier.cpp

@@ -38,7 +38,7 @@ Ref<AtomStringImpl> Identifier::add8(VM& vm, const UChar* s, int length)
     if (!length)
         return *static_cast<AtomStringImpl*>(StringImpl::empty());
 
-    return *AtomStringImpl::add(s, length);
+    return *AtomStringImpl::add(std::span { s, static_cast<size_t>(length) });
 }
 
 Identifier Identifier::from(VM& vm, unsigned value)

Source/JavaScriptCore/runtime/Identifier.h

@@ -180,8 +180,8 @@ class Identifier {
     static bool equal(const Identifier& a, const Identifier& b) { return a.m_string.impl() == b.m_string.impl(); }
     static bool equal(const Identifier& a, const LChar* b) { return equal(a.m_string.impl(), b); }
 
-    template <typename T> static Ref<AtomStringImpl> add(VM&, const T*, int length);
-    static Ref<AtomStringImpl> add8(VM&, const UChar*, int length);
+    template <typename T> static Ref<AtomStringImpl> add(VM&, const T*, int length); // FIXME: This should take in a span<const T>.
+    static Ref<AtomStringImpl> add8(VM&, const UChar*, int length); // FIXME: This should take in a span<const UChar>.
     template <typename T> ALWAYS_INLINE static constexpr bool canUseSingleCharacterString(T);
 
     static Ref<AtomStringImpl> add(VM&, StringImpl*);
@@ -216,7 +216,7 @@ Ref<AtomStringImpl> Identifier::add(VM& vm, const T* s, int length)
     if (!length)
         return *static_cast<AtomStringImpl*>(StringImpl::empty());
 
-    return *AtomStringImpl::add(s, length);
+    return *AtomStringImpl::add(std::span { s, static_cast<size_t>(length) });
 }
 
 inline Ref<AtomStringImpl> Identifier::add(VM& vm, ASCIILiteral literal)

Source/JavaScriptCore/runtime/JSONAtomStringCache.h

@@ -45,6 +45,7 @@ class JSONAtomStringCache {
 
     using Cache = std::array<Slot, capacity>;
 
+    // FIXME: This should take in a std::span<const CharacterType>.
     template<typename CharacterType>
     ALWAYS_INLINE Ref<AtomStringImpl> makeIdentifier(const CharacterType* characters, unsigned length)
     {
@@ -59,6 +60,7 @@ class JSONAtomStringCache {
     VM& vm() const;
 
 private:
+    // FIXME: This should take in a std::span<const CharacterType>.
     template<typename CharacterType>
     Ref<AtomStringImpl> make(const CharacterType*, unsigned length);
 

Source/JavaScriptCore/runtime/JSONAtomStringCacheInlines.h

@@ -43,12 +43,12 @@ ALWAYS_INLINE Ref<AtomStringImpl> JSONAtomStringCache::make(const CharacterType*
         if (firstCharacter <= maxSingleCharacterString)
             return vm().smallStrings.singleCharacterStringRep(firstCharacter);
     } else if (UNLIKELY(length > maxStringLengthForCache))
-        return AtomStringImpl::add(characters, length).releaseNonNull();
+        return AtomStringImpl::add(std::span { characters, length }).releaseNonNull();
 
     auto lastCharacter = characters[length - 1];
     auto& slot = cacheSlot(firstCharacter, lastCharacter, length);
     if (UNLIKELY(slot.m_length != length || !equal(slot.m_buffer, characters, length))) {
-        auto result = AtomStringImpl::add(characters, length);
+        auto result = AtomStringImpl::add(std::span { characters, length });
         slot.m_impl = result;
         slot.m_length = length;
         WTF::copyElements(slot.m_buffer, characters, length);

Source/JavaScriptCore/runtime/JSString.cpp

@@ -207,11 +207,11 @@ RefPtr<AtomStringImpl> JSRopeString::resolveRopeToExistingAtomString(JSGlobalObj
         if (is8Bit()) {
             LChar buffer[maxLengthForOnStackResolve];
             resolveRopeInternalNoSubstring(buffer, stackLimit);
-            existingAtomString = AtomStringImpl::lookUp(buffer, length());
+            existingAtomString = AtomStringImpl::lookUp(std::span { buffer, length() });
         } else {
             UChar buffer[maxLengthForOnStackResolve];
             resolveRopeInternalNoSubstring(buffer, stackLimit);
-            existingAtomString = AtomStringImpl::lookUp(buffer, length());
+            existingAtomString = AtomStringImpl::lookUp(std::span { buffer, length() });
         }
     } else
         existingAtomString = StringView { substringBase()->valueInternal() }.substring(substringOffset(), length()).toExistingAtomString().releaseImpl();

Source/JavaScriptCore/runtime/JSString.h

@@ -776,7 +776,7 @@ ALWAYS_INLINE JSString* jsSingleCharacterString(VM& vm, UChar c)
         vm.verifyCanGC();
     if (c <= maxSingleCharacterString)
         return vm.smallStrings.singleCharacterString(c);
-    return JSString::create(vm, StringImpl::create(&c, 1));
+    return JSString::create(vm, StringImpl::create(std::span { &c, 1 }));
 }
 
 ALWAYS_INLINE JSString* jsSingleCharacterString(VM& vm, LChar c)
@@ -942,7 +942,7 @@ inline JSString* jsString(VM& vm, StringView s)
         if (auto c = s.characterAt(0); c <= maxSingleCharacterString)
             return vm.smallStrings.singleCharacterString(c);
     }
-    auto impl = s.is8Bit() ? StringImpl::create(s.characters8(), s.length()) : StringImpl::create(s.characters16(), s.length());
+    auto impl = s.is8Bit() ? StringImpl::create(s.span8()) : StringImpl::create(s.span16());
     return JSString::create(vm, WTFMove(impl));
 }
 

Source/JavaScriptCore/runtime/JSStringInlines.h

@@ -282,11 +282,11 @@ inline JSString* jsAtomString(JSGlobalObject* globalObject, VM& vm, JSString* st
         };
 
         if (string->valueInternal().is8Bit()) {
-            WTF::HashTranslatorCharBuffer<LChar> buffer { string->valueInternal().characters8(), length, string->valueInternal().hash() };
+            WTF::HashTranslatorCharBuffer<LChar> buffer { string->valueInternal().span8(), string->valueInternal().hash() };
             return vm.keyAtomStringCache.make(vm, buffer, createFromNonRope);
         }
 
-        WTF::HashTranslatorCharBuffer<UChar> buffer { string->valueInternal().characters16(), length, string->valueInternal().hash() };
+        WTF::HashTranslatorCharBuffer<UChar> buffer { string->valueInternal().span16(), string->valueInternal().hash() };
         return vm.keyAtomStringCache.make(vm, buffer, createFromNonRope);
     }
 
@@ -309,21 +309,21 @@ inline JSString* jsAtomString(JSGlobalObject* globalObject, VM& vm, JSString* st
         if (ropeString->is8Bit()) {
             LChar characters[KeyAtomStringCache::maxStringLengthForCache];
             JSRopeString::resolveToBuffer(fiber0, fiber1, fiber2, characters, length, stackLimit);
-            WTF::HashTranslatorCharBuffer<LChar> buffer { characters, length };
+            WTF::HashTranslatorCharBuffer<LChar> buffer { std::span { characters, length } };
             return vm.keyAtomStringCache.make(vm, buffer, createFromRope);
         }
         UChar characters[KeyAtomStringCache::maxStringLengthForCache];
         JSRopeString::resolveToBuffer(fiber0, fiber1, fiber2, characters, length, stackLimit);
-        WTF::HashTranslatorCharBuffer<UChar> buffer { characters, length };
+        WTF::HashTranslatorCharBuffer<UChar> buffer { std::span { characters, length } };
         return vm.keyAtomStringCache.make(vm, buffer, createFromRope);
     }
 
     auto view = StringView { ropeString->substringBase()->valueInternal() }.substring(ropeString->substringOffset(), length);
     if (view.is8Bit()) {
-        WTF::HashTranslatorCharBuffer<LChar> buffer { view.characters8(), length };
+        WTF::HashTranslatorCharBuffer<LChar> buffer { view.span8() };
         return vm.keyAtomStringCache.make(vm, buffer, createFromRope);
     }
-    WTF::HashTranslatorCharBuffer<UChar> buffer { view.characters16(), length };
+    WTF::HashTranslatorCharBuffer<UChar> buffer { view.span16() };
     return vm.keyAtomStringCache.make(vm, buffer, createFromRope);
 }
 
@@ -400,12 +400,12 @@ inline JSString* jsAtomString(JSGlobalObject* globalObject, VM& vm, JSString* s1
     if (s1->is8Bit() && s2->is8Bit()) {
         LChar characters[KeyAtomStringCache::maxStringLengthForCache];
         resolveWith2Fibers(s1, s2, characters, length);
-        WTF::HashTranslatorCharBuffer<LChar> buffer { characters, length };
+        WTF::HashTranslatorCharBuffer<LChar> buffer { std::span { characters, length } };
         return vm.keyAtomStringCache.make(vm, buffer, createFromFibers);
     }
     UChar characters[KeyAtomStringCache::maxStringLengthForCache];
     resolveWith2Fibers(s1, s2, characters, length);
-    WTF::HashTranslatorCharBuffer<UChar> buffer { characters, length };
+    WTF::HashTranslatorCharBuffer<UChar> buffer { std::span { characters, length } };
     return vm.keyAtomStringCache.make(vm, buffer, createFromFibers);
 }
 
@@ -459,12 +459,12 @@ inline JSString* jsAtomString(JSGlobalObject* globalObject, VM& vm, JSString* s1
     if (s1->is8Bit() && s2->is8Bit() && s3->is8Bit()) {
         LChar characters[KeyAtomStringCache::maxStringLengthForCache];
         resolveWith3Fibers(s1, s2, s3, characters, length);
-        WTF::HashTranslatorCharBuffer<LChar> buffer { characters, length };
+        WTF::HashTranslatorCharBuffer<LChar> buffer { std::span { characters, length } };
         return vm.keyAtomStringCache.make(vm, buffer, createFromFibers);
     }
     UChar characters[KeyAtomStringCache::maxStringLengthForCache];
     resolveWith3Fibers(s1, s2, s3, characters, length);
-    WTF::HashTranslatorCharBuffer<UChar> buffer { characters, length };
+    WTF::HashTranslatorCharBuffer<UChar> buffer { std::span { characters, length } };
     return vm.keyAtomStringCache.make(vm, buffer, createFromFibers);
 }
 
@@ -492,7 +492,7 @@ inline JSString* jsSubstringOfResolved(VM& vm, GCDeferralContext* deferralContex
                 return JSString::create(vm, deferralContext, impl.releaseNonNull());
             };
             LChar buf[] = { static_cast<LChar>(first), static_cast<LChar>(second) };
-            WTF::HashTranslatorCharBuffer<LChar> buffer { buf, length };
+            WTF::HashTranslatorCharBuffer<LChar> buffer { std::span { buf, length } };
             return vm.keyAtomStringCache.make(vm, buffer, createFromSubstring);
         }
     }