Implement native scalar names

Author: Azoy

stdlib/public/SwiftShims/UnicodeData.h

@@ -83,6 +83,10 @@ __swift_int32_t _swift_stdlib_getMapping(__swift_uint32_t scalar,
 SWIFT_RUNTIME_STDLIB_INTERNAL
 const __swift_uint32_t *_swift_stdlib_getSpecialMapping(__swift_uint32_t scalar);
 
+SWIFT_RUNTIME_STDLIB_INTERNAL
+__swift_intptr_t _swift_stdlib_getScalarName(__swift_uint32_t scalar,
+                                             __swift_uint8_t *buffer);
+
 #ifdef __cplusplus
 } // extern "C"
 #endif

stdlib/public/SwiftShims/UnicodeShims.h

@@ -280,13 +280,6 @@ __swift_int32_t
     __swift_stdlib_u_getIntPropertyValue(__swift_stdlib_UChar32,
                                          __swift_stdlib_UProperty);
 
-SWIFT_RUNTIME_STDLIB_API
-__swift_int32_t __swift_stdlib_u_charName(
-    __swift_stdlib_UChar32 code, __swift_stdlib_UCharNameChoice nameChoice,
-    char *_Nullable buffer, __swift_int32_t bufferLength,
-    __swift_stdlib_UErrorCode *pErrorCode);
-
-
 #ifdef __cplusplus
 } // extern "C"
 #endif

stdlib/public/core/UnicodeScalarProperties.swift

@@ -1179,34 +1179,90 @@ extension Unicode.Scalar.Properties {
 }
 
 extension Unicode.Scalar.Properties {
+  internal func _hangulName() -> String {
+    // T = Hangul tail consonants
+    let T: (base: UInt32, count: UInt32) = (base: 0x11A7, count: 28)
+    // N = Number of precomposed Hangul syllables that start with the same
+    //     leading consonant. (There is no base for N).
+    let N: (base: UInt32, count: UInt32) = (base: 0x0, count: 588)
+    // S = Hangul precomposed syllables
+    let S: (base: UInt32, count: UInt32) = (base: 0xAC00, count: 11172)
+
+    let hangulLTable = ["G", "GG", "N", "D", "DD", "R", "M", "B", "BB", "S",
+                        "SS", "", "J", "JJ", "C", "K", "T", "P", "H"]
+
+    let hangulVTable = ["A", "AE", "YA", "YAE", "EO", "E", "YEO", "YE", "O",
+                        "WA", "WAE", "OE", "YO", "U", "WEO", "WE", "WI", "YU",
+                        "EU", "YI", "I"]
+
+    let hangulTTable = ["", "G", "GG", "GS", "N", "NJ", "NH", "D", "L", "LG",
+                        "LM", "LB", "LS", "LT", "LP", "LH", "M", "B", "BS", "S",
+                        "SS", "NG", "J", "C", "K", "T", "P", "H"]
+
+    let sIdx = _scalar.value &- S.base
+    let lIdx = Int(sIdx / N.count)
+    let vIdx = Int((sIdx % N.count) / T.count)
+    let tIdx = Int(sIdx % T.count)
+
+    let scalarName = hangulLTable[lIdx] + hangulVTable[vIdx] + hangulTTable[tIdx]
+    return "HANGUL SYLLABLE \(scalarName)"
+  }
+
+  // Used to potentially return a name who can either be represented in a large
+  // range or algorithmetically. A good example are the Hangul names. Instead of
+  // storing those names, we can define an algorithm to generate the name.
+  internal func _fastScalarName() -> String? {
+    // Define a couple algorithmetic names below.
+
+    // Hangul Syllable *
+    if (0xAC00 ... 0xD7A3).contains(_scalar.value) {
+      return _hangulName()
+    }
 
-  internal func _scalarName(
-    _ choice: __swift_stdlib_UCharNameChoice
-  ) -> String? {
-    var error = __swift_stdlib_U_ZERO_ERROR
-    let count = Int(__swift_stdlib_u_charName(icuValue, choice, nil, 0, &error))
-    guard count > 0 else { return nil }
-
-    // ICU writes a trailing null, so we have to save room for it as well.
-    let array = Array<UInt8>(unsafeUninitializedCapacity: count + 1) {
-      buffer, initializedCount in
-      var error = __swift_stdlib_U_ZERO_ERROR
-      let correctSize = __swift_stdlib_u_charName(
-        icuValue,
-        choice,
-        UnsafeMutableRawPointer(buffer.baseAddress._unsafelyUnwrappedUnchecked)
-          .assumingMemoryBound(to: Int8.self),
-        Int32(buffer.count),
-        &error)
-      guard error.isSuccess else {
-        fatalError("Unexpected error case-converting Unicode scalar.")
-      }
-      _internalInvariant(count == correctSize, "inconsistent ICU behavior")
-      initializedCount = count + 1
+    // Variation Selector-17 through Variation Selector-256
+    if (0xE0100 ... 0xE01EF).contains(_scalar.value) {
+      return "VARIATION SELECTOR-\(_scalar.value - 0xE0100 + 17)"
+    }
+
+    let scalarName = String(_scalar.value, radix: 16, uppercase: true)
+
+    // CJK Unified Ideograph-*
+    if (0x3400 ... 0x4DBF).contains(_scalar.value) ||
+       (0x4E00 ... 0x9FFF).contains(_scalar.value) ||
+       (0x20000 ... 0x2A6DF).contains(_scalar.value) ||
+       (0x2A700 ... 0x2B738).contains(_scalar.value) ||
+       (0x2B740 ... 0x2B81D).contains(_scalar.value) ||
+       (0x2B820 ... 0x2CEA1).contains(_scalar.value) ||
+       (0x2CEB0 ... 0x2EBE0).contains(_scalar.value) ||
+       (0x2F800 ... 0x2FA1D).contains(_scalar.value) ||
+       (0x30000 ... 0x3134A).contains(_scalar.value) {
+      return "CJK UNIFIED IDEOGRAPH-\(scalarName)"
+    }
+
+    // CJK Compatibility Ideograph-*
+    if (0xF900 ... 0xFA6D).contains(_scalar.value) ||
+       (0xFA70 ... 0xFAD9).contains(_scalar.value) {
+      return "CJK COMPATIBILITY IDEOGRAPH-\(scalarName)"
+    }
+
+    // Tangut Ideograph-*
+    if (0x17000 ... 0x187F7).contains(_scalar.value) ||
+       (0x18D00 ... 0x18D08).contains(_scalar.value) {
+      return "TANGUT IDEOGRAPH-\(scalarName)"
     }
-    return array.withUnsafeBufferPointer { buffer in
-      String._fromASCII(UnsafeBufferPointer(rebasing: buffer[..<count]))
+
+    // Khitan Small Script Character-*
+    if (0x18B00 ... 0x18CD5).contains(_scalar.value) {
+      return "KHITAN SMALL SCRIPT CHARACTER-\(scalarName)"
+    }
+
+    // Nushu Character-*
+    if (0x1B170 ... 0x1B2FB).contains(_scalar.value) {
+      return "NUSHU CHARACTER-\(scalarName)"
     }
+
+    // Otherwise, go look it up.
+    return nil
   }
 
   /// The published name of the scalar.
@@ -1218,7 +1274,16 @@ extension Unicode.Scalar.Properties {
   /// This property corresponds to the "Name" property in the
   /// [Unicode Standard](http://www.unicode.org/versions/latest/).
   public var name: String? {
-    return _scalarName(__swift_stdlib_U_UNICODE_CHAR_NAME)
+    if let fastName = _fastScalarName() {
+      return fastName
+    }
+
+    // The longest name that Unicode defines is 88 characters long.
+    let name = String(_uninitializedCapacity: 90) { buffer in
+      _swift_stdlib_getScalarName(_scalar.value, buffer.baseAddress)
+    }
+
+    return name.isEmpty ? nil : name
   }
 
   /// The normative formal alias of the scalar.

stdlib/public/stubs/UnicodeScalarProps.cpp

@@ -189,3 +189,71 @@ const __swift_uint32_t *_swift_stdlib_getSpecialMapping(__swift_uint32_t scalar)
 
   return _swift_stdlib_special_mappings_data + index;
 }
+
+SWIFT_RUNTIME_STDLIB_INTERNAL
+__swift_intptr_t _swift_stdlib_getScalarName(__swift_uint32_t scalar,
+                                             __swift_uint8_t *buffer) {
+  auto setOffset = _swift_stdlib_names_scalar_sets[scalar >> 7];
+
+  if (setOffset == std::numeric_limits<__swift_uint16_t>::max()) {
+    return 0;
+  }
+
+  auto scalarIndex = (setOffset << 7) + (scalar & ((1 << 7) - 1));
+  auto scalarOffset = _swift_stdlib_names_scalars[scalarIndex];
+
+  if (scalarOffset == 0) {
+    return 0;
+  }
+
+  __swift_uint32_t nextScalarOffset = 0;
+  int i = 1;
+
+  // Look for the next scalar who has a name and their position in the names
+  // array. This tells us exactly how many bytes our name takes up.
+  while (nextScalarOffset == 0) {
+    nextScalarOffset = _swift_stdlib_names_scalars[scalarIndex + i];
+    i += 1;
+  }
+
+  auto nameSize = nextScalarOffset - scalarOffset;
+
+  int c = 0;
+
+  for (__swift_uint32_t i = 0; i < nameSize; i += 1) {
+    __swift_uint16_t wordIndex = (__swift_uint16_t) _swift_stdlib_names[
+      scalarOffset + i
+    ];
+
+    // If our word index is 0xFF, then it means our word index is larger than a
+    // byte, so the next two bytes will compose the 16 bit index.
+    if (wordIndex == 0xFF) {
+      i += 1;
+      auto firstPart = _swift_stdlib_names[scalarOffset + i];
+      wordIndex = firstPart;
+
+      i += 1;
+      auto secondPart = _swift_stdlib_names[scalarOffset + i];
+      wordIndex |= secondPart << 8;
+    }
+
+    auto wordOffset = _swift_stdlib_word_indices[wordIndex];
+
+    auto word = _swift_stdlib_words + wordOffset;
+
+    // The last character in a word has the 7th bit set.
+    while (*word < 0x80) {
+      buffer[c++] = *word++;
+    }
+
+    buffer[c++] = *word & 0x7F;
+
+    buffer[c++] = ' ';
+  }
+
+  // Remove the trailing space.
+  c -= 1;
+
+  // The return value is the number of initialized bytes.
+  return c;
+}