Switch back to @_marker protocol to differentiate ASCII literals.

Author: John Holdsworth

include/swift/AST/KnownProtocols.def

@@ -150,6 +150,7 @@ EXPRESSIBLE_BY_LITERAL_PROTOCOL(ExpressibleByStringInterpolation, "StringLiteral
 EXPRESSIBLE_BY_LITERAL_PROTOCOL(ExpressibleByStringLiteral, "StringLiteralType", true)
 EXPRESSIBLE_BY_LITERAL_PROTOCOL(ExpressibleByNilLiteral, nullptr, false)
 EXPRESSIBLE_BY_LITERAL_PROTOCOL(ExpressibleByUnicodeScalarLiteral, "UnicodeScalarType", true)
+EXPRESSIBLE_BY_LITERAL_PROTOCOL(ExpressibleByASCIIScalarLiteral, "UnicodeScalarType", true)
 
 EXPRESSIBLE_BY_LITERAL_PROTOCOL_(ExpressibleByColorLiteral, "_ColorLiteralType", true)
 EXPRESSIBLE_BY_LITERAL_PROTOCOL_(ExpressibleByImageLiteral, "_ImageLiteralType", true)

lib/IRGen/GenMeta.cpp

@@ -6532,6 +6532,7 @@ SpecialProtocol irgen::getSpecialProtocolID(ProtocolDecl *P) {
   case KnownProtocolKind::ExpressibleByStringLiteral:
   case KnownProtocolKind::ExpressibleByNilLiteral:
   case KnownProtocolKind::ExpressibleByUnicodeScalarLiteral:
+  case KnownProtocolKind::ExpressibleByASCIIScalarLiteral:
   case KnownProtocolKind::ExpressibleByColorLiteral:
   case KnownProtocolKind::ExpressibleByImageLiteral:
   case KnownProtocolKind::ExpressibleByFileReferenceLiteral:

lib/Sema/TypeChecker.cpp

@@ -103,7 +103,8 @@ ProtocolDecl *TypeChecker::getLiteralProtocol(ASTContext &Context, Expr *expr) {
   if (const auto *SLE = dyn_cast<StringLiteralExpr>(expr)) {
     if (SLE->isSingleUnicodeScalar())
       return TypeChecker::getProtocol(
-          Context, expr->getLoc(),
+          Context, expr->getLoc(), SLE->getValue().size() == 1 ?
+          KnownProtocolKind::ExpressibleByASCIIScalarLiteral :
           KnownProtocolKind::ExpressibleByUnicodeScalarLiteral);
 
     if (SLE->isSingleExtendedGraphemeCluster())

stdlib/public/core/CompilerProtocols.swift

@@ -394,6 +394,9 @@ public protocol ExpressibleByBooleanLiteral {
   init(booleanLiteral value: BooleanLiteralType)
 }
 
+/// Used to differentiate string literals containing only a single ASCII character
+@_marker public protocol ExpressibleByASCIIScalarLiteral {}
+
 public protocol _ExpressibleByBuiltinUnicodeScalarLiteral {
   init(_builtinUnicodeScalarLiteral value: Builtin.Int32)
 }
@@ -415,7 +418,7 @@ public protocol _ExpressibleByBuiltinUnicodeScalarLiteral {
 ///
 /// To add `ExpressibleByUnicodeScalarLiteral` conformance to your custom type,
 /// implement the required initializer.
-public protocol ExpressibleByUnicodeScalarLiteral {
+public protocol ExpressibleByUnicodeScalarLiteral: ExpressibleByASCIIScalarLiteral {
   /// A type that represents a Unicode scalar literal.
   ///
   /// Valid types for `UnicodeScalarLiteralType` are `Unicode.Scalar`,

stdlib/public/core/UnicodeScalar.swift

@@ -380,72 +380,12 @@ extension UInt64 {
   }
 }
 
-/// Extends `UInt8` to allow direct comparisons with double quoted literals.
-extension UInt8 {
-  /// 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)
-  }
-
-  /// 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)
-  }
-
-  /// 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)
-  }
-}
+extension UInt8: ExpressibleByASCIIScalarLiteral,
+  _ExpressibleByBuiltinUnicodeScalarLiteral {
 
-/// Extends `Optional<UInt8>` to allow direct comparisons with double quoted literals.
-extension UInt8? {
-  /// 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)
-  }
-
-  /// 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)
-  }
-
-  /// 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
+  public init(_builtinUnicodeScalarLiteral value: Builtin.Int32) {
+    self = UInt8(UInt32(value))
   }
 }
 

test/stdlib/UnicodeScalarDiagnostics.swift

@@ -9,9 +9,9 @@ func test_UnicodeScalarDoesNotImplementArithmetic(_ us: UnicodeScalar, i: Int) {
   var a1 = "a" + "b" // OK
   isString(&a1)
   // We don't check for the overload choices list on the overload note match because they may change on different platforms. 
-  let a2 = "a" - "b" // expected-error {{binary operator '-' cannot be applied to two 'String' operands}}
-  let a3 = "a" * "b" // expected-error {{binary operator '*' cannot be applied to two 'String' operands}}
-  let a4 = "a" / "b" // expected-error {{binary operator '/' cannot be applied to two 'String' operands}}
+  let a2 = "a" - "b"
+  let a3 = "a" * "b"
+  let a4 = "a" / "b"
 
   let b1 = us + us // expected-error {{binary operator '+' cannot be applied to two 'UnicodeScalar' (aka 'Unicode.Scalar') operands}}
   let b2 = us - us // expected-error {{binary operator '-' cannot be applied to two 'UnicodeScalar' (aka 'Unicode.Scalar') operands}}

test/stmt/typed_throws.swift

@@ -80,8 +80,8 @@ func testDoCatchMultiErrorType() {
   do {
     try doSomething()
     try doHomework()
-  } catch .failed { // expected-error{{expression pattern of type 'Unicode.Scalar' cannot match values of type 'any Error}}
-    // expected-error@-1{{type 'Unicode.Scalar' has no member 'failed'}}
+  } catch .failed { // expected-error{{type 'any Error' has no member 'failed'}}
+
   } catch {
     let _: Int = error // expected-error{{cannot convert value of type 'any Error' to specified type 'Int'}}
   }