[stdlib] Revert hasNormalizationBoundaryBefore

This property is too specific in that it forces a particular normalization; let's not expose it this way, but instead in the future with a full normalization API.

Author: allevato

stdlib/public/core/StringComparison.swift

@@ -317,8 +317,7 @@ internal func _decodeSurrogatePair(
 
 internal func _hasNormalizationBoundary(before cu: UInt16) -> Bool {
   guard !_isSurrogate(cu) else { return false }
-  return UnicodeScalar(
-    _unchecked: UInt32(cu)).properties.hasNormalizationBoundaryBefore
+  return UnicodeScalar(_unchecked: UInt32(cu))._hasNormalizationBoundaryBefore
 }
 
 //
@@ -862,10 +861,8 @@ private struct _UnicodeScalarExceptions {
       var i = 0
       while i < length {
         let (innerScalar, nextI) = _parseRawScalar(&outBuffer, startingFrom: i)
-        if _slowPath(
-          i != 0 && innerScalar.properties.hasNormalizationBoundaryBefore
-        ) {
-          guard innerScalar.properties.hasNormalizationBoundaryBefore else {
+        if _slowPath(i != 0 && innerScalar._hasNormalizationBoundaryBefore) {
+          guard innerScalar._hasNormalizationBoundaryBefore else {
             fatalError(
               "Unicode invariant violated: non-starter multi-segment expander")
           }
@@ -1051,7 +1048,7 @@ extension _UnmanagedString where CodeUnit == UInt16 {
     var (_, segmentEndIdx) = self._parseRawScalar(startingFrom: idx)
     while segmentEndIdx < count {
       let (scalar, nextIdx) = self._parseRawScalar(startingFrom: segmentEndIdx)
-      if scalar.properties.hasNormalizationBoundaryBefore {
+      if scalar._hasNormalizationBoundaryBefore {
         break
       }
       segmentEndIdx = nextIdx
@@ -1069,7 +1066,7 @@ extension _UnmanagedString where CodeUnit == UInt16 {
     while idx > 0 {
       let (scalar, priorIdx) = _reverseParseRawScalar(endingAt: idx)
       idx = priorIdx
-      if scalar.properties.hasNormalizationBoundaryBefore {
+      if scalar._hasNormalizationBoundaryBefore {
         break
       }
     }
@@ -1095,8 +1092,7 @@ extension _UnmanagedString where CodeUnit == UInt16 {
     }
 
     // Check current scalar
-    let currentScalar = self._parseRawScalar(startingFrom: idx).0
-    if currentScalar.properties.hasNormalizationBoundaryBefore {
+    if self._parseRawScalar(startingFrom: idx).0._hasNormalizationBoundaryBefore {
       return (idx, segmentEnd)
     }
 

stdlib/public/core/StringNormalization.swift

@@ -68,7 +68,29 @@ 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)
+  }
+}
 
+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.

stdlib/public/core/UnicodeScalarProperties.swift

@@ -1421,23 +1421,4 @@ extension Unicode.Scalar.Properties {
   public var isDefined: Bool {
     return __swift_stdlib_u_isdefined(_value) != 0
   }
-
-  /// A Boolean property indicating whether a normalization boundary always
-  /// occurs before this scalar.
-  ///
-  /// A normalization boundary is a position in a string where everything to the
-  /// left of the boundary can be normalized independently of everything to the
-  /// right of the boundary. The concatenation of each such normalization result
-  /// is thus the same as if the entire string had been normalized as a whole.
-  ///
-  /// ```
-  /// print(("A" as Unicode.Scalar).properties.hasNormalizationBoundaryBefore)
-  /// // Prints "true"
-  /// print(("\u{0301}" as Unicode.Scalar).properties.hasNormalizationBoundaryBefore)
-  /// // Prints "false"
-  /// ```
-  public var hasNormalizationBoundaryBefore: Bool {
-    return __swift_stdlib_unorm2_hasBoundaryBefore(
-      _Normalization._nfcNormalizer, _value) != 0
-  }
 }