[stdlib] Migrate normalization usage to public properties

Author: allevato

stdlib/public/core/StringComparison.swift

@@ -122,7 +122,8 @@ internal func _decodeSurrogatePair(
 
 internal func _hasNormalizationBoundary(before cu: UInt16) -> Bool {
   guard !_isSurrogate(cu) else { return false }
-  return UnicodeScalar(_unchecked: UInt32(cu))._hasNormalizationBoundaryBefore
+  return UnicodeScalar(
+    _unchecked: UInt32(cu)).properties.hasNormalizationBoundaryBefore
 }
 
 //
@@ -698,10 +699,10 @@ private struct _UnicodeScalarExceptions {
       guard let scalar = UnicodeScalar(rawValue) else { continue }
 
       // Fast path: skip unassigned code points
-      guard scalar._isDefined else { continue }
+      guard scalar.properties.isDefined else { continue }
 
       // Fast path: skip unless QC_FCD=no
-      if _fastPath(!scalar._hasFullCompExclusion) {
+      if _fastPath(!scalar.properties.isFullCompositionExclusion) {
         continue
       }
 
@@ -717,8 +718,10 @@ private struct _UnicodeScalarExceptions {
       var i = 0
       while i < length {
         let (innerScalar, nextI) = _parseRawScalar(&outBuffer, startingFrom: i)
-        if _slowPath(i != 0 && innerScalar._hasNormalizationBoundaryBefore) {
-          guard innerScalar._hasNormalizationBoundaryBefore else {
+        if _slowPath(
+          i != 0 && innerScalar.properties.hasNormalizationBoundaryBefore
+        ) {
+          guard innerScalar.properties.hasNormalizationBoundaryBefore else {
             fatalError(
               "Unicode invariant violated: non-starter multi-segment expander")
           }
@@ -892,7 +895,7 @@ extension _UnmanagedString where CodeUnit == UInt16 {
     var (_, segmentEndIdx) = self._parseRawScalar(startingFrom: idx)
     while segmentEndIdx < count {
       let (scalar, nextIdx) = self._parseRawScalar(startingFrom: segmentEndIdx)
-      if scalar._hasNormalizationBoundaryBefore {
+      if scalar.properties.hasNormalizationBoundaryBefore {
         break
       }
       segmentEndIdx = nextIdx
@@ -910,7 +913,7 @@ extension _UnmanagedString where CodeUnit == UInt16 {
     while idx > 0 {
       let (scalar, priorIdx) = _reverseParseRawScalar(endingAt: idx)
       idx = priorIdx
-      if scalar._hasNormalizationBoundaryBefore {
+      if scalar.properties.hasNormalizationBoundaryBefore {
         break
       }
     }
@@ -936,7 +939,8 @@ extension _UnmanagedString where CodeUnit == UInt16 {
     }
 
     // Check current scalar
-    if self._parseRawScalar(startingFrom: idx).0._hasNormalizationBoundaryBefore {
+    let currentScalar = self._parseRawScalar(startingFrom: idx).0
+    if currentScalar.properties.hasNormalizationBoundaryBefore {
       return (idx, segmentEnd)
     }
 

stdlib/public/core/StringNormalization.swift

@@ -68,46 +68,7 @@ internal enum _Normalization {
     }
     return length == string.count
   }
-}
-
-extension UnicodeScalar {
-  // Normalization boundary - a place in a string where everything left of the
-  // boundary can be normalized independently from everything right of the
-  // boundary. The concatenation of each result is the same as if the entire
-  // string had been normalized as a whole.
-  //
-  // Normalization segment - a sequence of code units between two normalization
-  // boundaries (without any boundaries in the middle). Note that normalization
-  // segments can, as a process of normalization, expand, contract, and even
-  // produce new sub-segments.
-
-  // Whether this scalar value always has a normalization boundary before it.
-  internal var _hasNormalizationBoundaryBefore: Bool {
-    _sanityCheck(Int32(exactly: self.value) != nil, "top bit shouldn't be set")
-    let value = Int32(bitPattern: self.value)
-    return 0 != __swift_stdlib_unorm2_hasBoundaryBefore(
-      _Normalization._nfcNormalizer, value)
-  }
-
-  // Whether the supported version of Unicode has assigned a code point to this
-  // value.
-  internal var _isDefined: Bool {
-    return __swift_stdlib_u_isdefined(Int32(self.value)) != 0
-  }
-
-  // A property tracked in ICU regarding the scalar's potential non-normality;
-  // this is equivalent to whether quickCheck=NO. A subset of such scalars may
-  // expand under NFC normalization, and a subset of those may expand into
-  // multiple segments.
-  internal var _hasFullCompExclusion: Bool {
-    _sanityCheck(Int32(exactly: self.value) != nil, "top bit shouldn't be set")
-    let value = Int32(bitPattern: self.value)
-    let prop = __swift_stdlib_UCHAR_FULL_COMPOSITION_EXCLUSION
-    return __swift_stdlib_u_hasBinaryProperty(value, prop) != 0
-  }
-}
 
-extension _Normalization {
   // When normalized in NFC, some segments may expand in size (e.g. some non-BMP
   // musical notes). This expansion is capped by the maximum expansion factor of
   // the normal form. For NFC, that is 3x.