Some tests

Author: johnno1962

stdlib/public/core/UnicodeScalar.swift

@@ -380,53 +380,89 @@ extension UInt64 {
   }
 }
 
-extension FixedWidthInteger {
-  /// Construct with value `v.value`.
-  @inlinable @_alwaysEmitIntoClient
-  public init(unicode v: Unicode.Scalar) {
-    _precondition(v.value <= Self.max,
-        "Code point value does not fit into type")
-    self = Self(v.value)
-  }
-}
-
-/// Allows direct comparisons between UInt8 and double quoted literals.
+/// Extends `UInt8` to allow direct comparisons with double quoted literals.
 extension UInt8 {
-  /// Basic equality operator
+  /// Returns a Boolean indicating whether the `UInt8` is equal to the provided Unicode scalar.
+  ///
+  /// - Parameters:
+  ///   - i: The `UInt8` value to compare.
+  ///   - s: The Unicode scalar to compare against.
+  /// - Returns: `true` when the `UInt8` is equal to the provided Unicode scalar; otherwise, `false`.
   @_transparent @_alwaysEmitIntoClient
   public static func == (i: Self, s: Unicode.Scalar) -> Bool {
     return i == UInt8(ascii: s)
   }
-  /// Basic inequality operator
+
+  /// Returns a Boolean indicating whether the `UInt8` is not equal to the provided Unicode scalar.
   @_transparent @_alwaysEmitIntoClient
   public static func != (i: Self, s: Unicode.Scalar) -> Bool {
     return i != UInt8(ascii: s)
   }
-  /// Used in switch statements
+
+  /// Enables pattern matching of Unicode scalars in switch statements.
   @_transparent @_alwaysEmitIntoClient
   public static func ~= (s: Unicode.Scalar, i: Self) -> Bool {
     return i == UInt8(ascii: s)
   }
 }
 
+/// Extends `Optional<UInt8>` to allow direct comparisons with double quoted literals.
 extension UInt8? {
-  /// Optional equality operator
+  /// Returns a Boolean value indicating whether the optional `UInt8` is equal to the provided Unicode scalar.
+  ///
+  /// - Parameters:
+  ///   - i: The optional `UInt8` value to compare.
+  ///   - s: The Unicode scalar to compare against.
+  /// - Returns: `true` if the optional `UInt8` is equal to the provided Unicode scalar; otherwise, `false`.
   @_transparent @_alwaysEmitIntoClient
   public static func == (i: Self, s: Unicode.Scalar) -> Bool {
     return i == UInt8(ascii: s)
   }
-  /// Optional inequality operator
+
+  /// Returns a Boolean value indicating whether the optional `UInt8` is not equal to the provided Unicode scalar.
   @_transparent @_alwaysEmitIntoClient
   public static func != (i: Self, s: Unicode.Scalar) -> Bool {
     return i != UInt8(ascii: s)
   }
-  /// Used in switch statements
+
+  /// Allows pattern matching of Unicode scalars in switch statements.
   @_transparent @_alwaysEmitIntoClient
   public static func ~= (s: Unicode.Scalar, i: Self) -> Bool {
     return i == UInt8(ascii: s)
   }
 }
 
+/// Extends `Array` where Element is a FixedWidthInteger, providing initialization from a string of Unicode scalars.
+@_unavailableInEmbedded
+extension Array where Element: FixedWidthInteger {
+  /// Initializes an array of Integers with Unicode scalars represented by the provided string.
+  ///
+  /// - Parameter scalars: A string containing Unicode scalars.
+  @inlinable @_alwaysEmitIntoClient @_unavailableInEmbedded
+  public init(scalars: String) {
+    #if os(Linux) || os(iOS) || os(tvOS)
+    // How to avoid the function body being type checked for embedded?
+    self.init(scalars.unicodeScalars.map { Element(unicode: $0) })
+    #else
+    self.init(scalars.utf16.map { Element($0) })
+    #endif
+  }
+}
+
+/// Extends `FixedWidthInteger` providing initialization from a Unicode scalar.
+extension FixedWidthInteger {
+  /// Initializes a FixedWidthInteger with the value of the provided Unicode scalar.
+  ///
+  /// - Parameter unicode: The Unicode scalar to initialize from.
+  /// - Note: Construct with value `v.value`.
+  @inlinable @_alwaysEmitIntoClient
+  public init(unicode v: Unicode.Scalar) {
+    _precondition(v.value <= Self.max,
+                  "Code point value does not fit into type")
+    self = Self(v.value)
+  }
+}
+
 extension Unicode.Scalar: Equatable {
   @inlinable
   public static func == (lhs: Unicode.Scalar, rhs: Unicode.Scalar) -> Bool {

test/Misc/character_ops.swift

@@ -0,0 +1,53 @@
+// RUN: %target-run-simple-swift | %FileCheck %s
+// REQUIRES: executable_test
+
+let c = UInt8(ascii: "a")
+
+// CHECK: OK
+if c == "a" {
+  print("OK")
+}
+
+// CHECK: OK
+if c != "b" {
+  print("OK")
+}
+
+// CHECK: OK
+switch c {
+case "a":
+  print("OK")
+case "b":
+  fallthrough
+default:
+  print("FAIL")
+}
+
+let d: UInt8? = UInt8(ascii: "a")
+
+// CHECK: OK
+if d == "a" {
+  print("OK")
+}
+
+// CHECK: OK
+if d != "b" {
+  print("OK")
+}
+
+// CHECK: OK
+switch d {
+case "a":
+  print("OK")
+case "b":
+  fallthrough
+default:
+  print("FAIL")
+}
+
+if UInt8(unicode: "a") ==  "a" {
+  print("OK")
+}
+
+// CHECK: 128512
+print(UInt64(unicode: "😀"))