Add constructor for String that takes span<char8_t>

https://bugs.webkit.org/show_bug.cgi?id=301739
rdar://163764627

Reviewed by Sam Weinig.

* Source/WTF/wtf/Logger.h:
(WTF::LogArgument::toString): Added overload that takes std::span<const char8_t>.

* Source/WTF/wtf/PrintStream.cpp:
(WTF::printInternal): Added overload that takes std::span<const char8_t>.
* Source/WTF/wtf/PrintStream.h: Ditto.

* Source/WTF/wtf/text/StringImpl.cpp:
(WTF::StringImpl::create): Added overload that takes std::span<const char8_t>.
* Source/WTF/wtf/text/StringImpl.h: Ditto.

* Source/WTF/wtf/text/WTFString.cpp:
(WTF::String::String): Added overload that takes std::span<const char8_t>.
(WTF::fromUTF8Impl): Deleted.
(WTF::String::fromUTF8): Changed to call the constructor.
(WTF::String::fromUTF8ReplacingInvalidSequences): Moved code here from the
fromUTF8Impl function.
(WTF::String::fromUTF8WithLatin1Fallback): Call the constructor rather than
the fromUTF8 function.

* Source/WTF/wtf/text/WTFString.h: Added constructor that takes

std::span<const char8_t>.
Canonical link: https://commits.webkit.org/302417@main

Signed-off-by: Xabier Rodriguez Calvar <calvaris@igalia.com>

Author: darinadler

Source/WTF/wtf/Logger.h

@@ -57,6 +57,7 @@ struct LogArgument {
     template<typename U = T> static std::enable_if_t<std::is_same_v<typename std::remove_reference_t<U>, StringBuilder*>, String> toString(StringBuilder* argument) { return argument->toString(); }
     template<typename U = T> static std::enable_if_t<std::is_same_v<U, const char*>, String> toString(const char* argument) { return String::fromLatin1(argument); }
     template<typename U = T> static std::enable_if_t<std::is_same_v<U, ASCIILiteral>, String> toString(ASCIILiteral argument) { return argument; }
+    template<typename U = T> static std::enable_if_t<std::is_same_v<U, std::span<const char8_t>>, String> toString(std::span<const char8_t> argument) { return argument; }
 #ifdef __OBJC__
     template<typename U = T> static std::enable_if_t<std::is_base_of_v<NSError, std::remove_pointer_t<U>>, String> toString(NSError *argument) { return String(argument.localizedDescription); }
     template<typename U = T> static std::enable_if_t<std::is_base_of_v<NSObject, std::remove_pointer_t<U>>, String> toString(NSObject *argument) { return String(argument.description); }

Source/WTF/wtf/PrintStream.cpp

@@ -119,6 +119,11 @@ void printInternal(PrintStream& out, const StringImpl* string)
     printExpectedCStringHelper(out, "StringImpl*", string->tryGetUTF8());
 }
 
+void printInternal(PrintStream& stream, std::span<const char8_t> codeUnits)
+{
+    printInternal(stream, byteCast<char>(codeUnits));
+}
+
 void printInternal(PrintStream& out, bool value)
 {
     out.print(boolForPrinting(value));

Source/WTF/wtf/PrintStream.h

@@ -113,6 +113,7 @@ WTF_EXPORT_PRIVATE void printInternal(PrintStream&, const CString&);
 WTF_EXPORT_PRIVATE void printInternal(PrintStream&, const String&);
 WTF_EXPORT_PRIVATE void printInternal(PrintStream&, const AtomString&);
 WTF_EXPORT_PRIVATE void printInternal(PrintStream&, const StringImpl*);
+WTF_EXPORT_PRIVATE void printInternal(PrintStream&, std::span<const char8_t>);
 inline void printInternal(PrintStream& out, const AtomStringImpl* value) { printInternal(out, std::bit_cast<const StringImpl*>(value)); }
 inline void printInternal(PrintStream& out, const UniquedStringImpl* value) { printInternal(out, std::bit_cast<const StringImpl*>(value)); }
 inline void printInternal(PrintStream& out, const UniquedStringImpl& value) { printInternal(out, &value); }

Source/WTF/wtf/text/StringImpl.cpp

@@ -316,6 +316,28 @@ Ref<StringImpl> StringImpl::create(std::span<const Latin1Character> characters)
     return createInternal(characters);
 }
 
+RefPtr<StringImpl> StringImpl::create(std::span<const char8_t> codeUnits)
+{
+    RELEASE_ASSERT(codeUnits.size() <= String::MaxLength);
+
+    if (!codeUnits.data())
+        return nullptr;
+    if (codeUnits.empty())
+        return empty();
+
+    if (charactersAreAllASCII(codeUnits))
+        return create(byteCast<Latin1Character>(codeUnits));
+
+    Vector<char16_t, 1024> buffer(codeUnits.size());
+
+    auto result = Unicode::convert(codeUnits, buffer.mutableSpan());
+    if (result.code != Unicode::ConversionResultCode::Success)
+        return nullptr;
+
+    RELEASE_ASSERT_WITH_SECURITY_IMPLICATION(result.buffer.size() <= codeUnits.size());
+    return create(result.buffer);
+}
+
 Ref<StringImpl> StringImpl::createStaticStringImpl(std::span<const Latin1Character> characters)
 {
     if (characters.empty())

Source/WTF/wtf/text/StringImpl.h

@@ -261,6 +261,9 @@ class StringImpl : private StringImplShape {
     ALWAYS_INLINE static Ref<StringImpl> create(std::span<const char> characters) { return create(byteCast<Latin1Character>(characters)); }
     WTF_EXPORT_PRIVATE static Ref<StringImpl> create8BitIfPossible(std::span<const char16_t>);
 
+    // Construct a string with UTF-8 data, null if it contains invalid UTF-8 sequences.
+    WTF_EXPORT_PRIVATE static RefPtr<StringImpl> create(std::span<const char8_t>);
+
     // Not using create() naming to encourage developers to call create(ASCIILiteral) when they have a string literal.
     ALWAYS_INLINE static Ref<StringImpl> createFromCString(const char* characters) { return create(WTF::span8(characters)); }
 

Source/WTF/wtf/text/WTFString.cpp

@@ -51,6 +51,12 @@ String::String(std::span<const Latin1Character> characters)
 {
 }
 
+// Construct a string with UTF-8 data.
+String::String(std::span<const char8_t> characters)
+    : m_impl(StringImpl::create(characters))
+{
+}
+
 // Construct a string with Latin-1 data.
 String::String(std::span<const char> characters)
     : m_impl(characters.data() ? RefPtr { StringImpl::create(byteCast<Latin1Character>(characters)) } : nullptr)
@@ -464,9 +470,16 @@ void String::convertTo16Bit()
     *this = WTFMove(convertedString);
 }
 
-template<bool replaceInvalidSequences>
-String fromUTF8Impl(std::span<const char8_t> string)
+String String::fromUTF8(std::span<const char8_t> codeUnits)
+{
+    return codeUnits;
+}
+
+String String::fromUTF8ReplacingInvalidSequences(std::span<const char8_t> string)
 {
+    if (!string.data())
+        return { };
+
     RELEASE_ASSERT(string.size() <= String::MaxLength);
 
     if (string.empty())
@@ -475,35 +488,19 @@ String fromUTF8Impl(std::span<const char8_t> string)
     if (charactersAreAllASCII(string))
         return StringImpl::create(spanReinterpretCast<const Latin1Character>(string));
 
-    Vector<UChar, 1024> buffer(string.size());
- 
-    auto result = replaceInvalidSequences
-        ? Unicode::convertReplacingInvalidSequences(string, buffer.mutableSpan())
-        : Unicode::convert(string, buffer.mutableSpan());
+    Vector<char16_t, 1024> buffer(string.size());
+
+    auto result = Unicode::convertReplacingInvalidSequences(string, buffer.mutableSpan());
     if (result.code != Unicode::ConversionResultCode::Success)
         return { };
 
     RELEASE_ASSERT_WITH_SECURITY_IMPLICATION(result.buffer.size() <= string.size());
     return StringImpl::create(result.buffer);
 }
 
-String String::fromUTF8(std::span<const char8_t> string)
-{
-    if (!string.data())
-        return { };
-    return fromUTF8Impl<false>(string);
-}
-
-String String::fromUTF8ReplacingInvalidSequences(std::span<const char8_t> characters)
-{
-    if (!characters.data())
-        return { };
-    return fromUTF8Impl<true>(characters);
-}
-
 String String::fromUTF8WithLatin1Fallback(std::span<const char8_t> string)
 {
-    String utf8 = fromUTF8(string);
+    String utf8 { string };
     if (!utf8) {
         // Do this assertion before chopping the size_t down to unsigned.
         RELEASE_ASSERT(string.size() <= String::MaxLength);

Source/WTF/wtf/text/WTFString.h

@@ -64,6 +64,9 @@ class String final {
     WTF_EXPORT_PRIVATE String(std::span<const char> characters);
     ALWAYS_INLINE static String fromLatin1(const char* characters) { return String { characters }; }
 
+    // Construct a string with UTF-8 data, null string if it contains invalid UTF-8 sequences.
+    WTF_EXPORT_PRIVATE String(std::span<const char8_t>);
+
     // Construct a string referencing an existing StringImpl.
     String(StringImpl&);
     String(StringImpl*);