Remove the last parts of the Boolean protocol, finishing up:

 SE-0109: Remove the Boolean protocol.

We still love you George, even if we forgot your e.

Author: lattner

stdlib/private/StdlibUnittest/StdlibUnittest.swift.gyb

@@ -448,8 +448,6 @@ public func expectRandomAccessCollectionAssociatedTypes<X : RandomAccessCollecti
   X.Indices.Index == X.Index,
   X.Indices.SubSequence == X.Indices {}
 
-public func expectIsBooleanType<X : Boolean>(_ x: inout X) -> X { return x }
-
 public struct AssertionResult : CustomStringConvertible {
   init(isPass: Bool) {
     self._isPass = isPass
@@ -487,21 +485,29 @@ public func expectUnreachableCatch(_ error: Error, ${TRACE}) {
     "error should not be thrown: \"\(error)\"", trace: ${trace})
 }
 
-%for BoolType in ['Bool', 'AssertionResult']:
-
-public func expectTrue(_ actual: ${BoolType}, ${TRACE}) {
+public func expectTrue(_ actual: AssertionResult, ${TRACE}) {
   if !actual.boolValue {
     expectationFailure("expected: true", trace: ${trace})
   }
 }
 
-public func expectFalse(_ actual: ${BoolType}, ${TRACE}) {
+public func expectFalse(_ actual: AssertionResult, ${TRACE}) {
   if actual.boolValue {
     expectationFailure("expected: false", trace: ${trace})
   }
 }
 
-%end
+public func expectTrue(_ actual: Bool, ${TRACE}) {
+  if !actual {
+    expectationFailure("expected: true", trace: ${trace})
+  }
+}
+
+public func expectFalse(_ actual: Bool, ${TRACE}) {
+  if actual {
+    expectationFailure("expected: false", trace: ${trace})
+  }
+}
 
 public func expectEmpty<T>(_ value: T?, ${TRACE}) {
   if value != nil {

stdlib/public/SDK/CoreMedia/CMTimeRange.swift

@@ -52,10 +52,10 @@ extension CMTimeRange {
     return CMTimeRangeGetIntersection(self, otherRange)
   }
   public func containsTime(_ time: CMTime) -> Bool {
-    return CMTimeRangeContainsTime(self, time).boolValue
+    return CMTimeRangeContainsTime(self, time)
   }
   public func containsTimeRange(_ range: CMTimeRange) -> Bool {
-    return CMTimeRangeContainsTimeRange(self, range).boolValue
+    return CMTimeRangeContainsTimeRange(self, range)
   }
 }
 
@@ -76,10 +76,10 @@ extension CMTimeRange : Equatable {}
 
 // CMTimeRangeEqual
 public func == (range1: CMTimeRange, range2: CMTimeRange) -> Bool {
-  return CMTimeRangeEqual(range1, range2).boolValue
+  return CMTimeRangeEqual(range1, range2)
 }
 
 public func != (range1: CMTimeRange, range2: CMTimeRange) -> Bool {
-  return !CMTimeRangeEqual(range1, range2).boolValue
+  return !CMTimeRangeEqual(range1, range2)
 }
 

stdlib/public/SDK/XCTest/XCTest.swift

@@ -171,19 +171,19 @@ public func XCTAssertNotNil(_ expression: @autoclosure () throws -> Any?, _ mess
   }
 }
 
-public func XCTAssert(_ expression: @autoclosure () throws -> Boolean, _ message: @autoclosure () -> String = "", file: StaticString = #file, line: UInt = #line)  -> Void {
+public func XCTAssert(_ expression: @autoclosure () throws -> Bool, _ message: @autoclosure () -> String = "", file: StaticString = #file, line: UInt = #line)  -> Void {
   // XCTAssert is just a cover for XCTAssertTrue.
   XCTAssertTrue(expression, message, file: file, line: line)
 }
 
-public func XCTAssertTrue(_ expression: @autoclosure () throws -> Boolean, _ message: @autoclosure () -> String = "", file: StaticString = #file, line: UInt = #line) -> Void {
+public func XCTAssertTrue(_ expression: @autoclosure () throws -> Bool, _ message: @autoclosure () -> String = "", file: StaticString = #file, line: UInt = #line) -> Void {
   let assertionType = _XCTAssertionType.`true`
 
   // evaluate the expression exactly once
   var expressionValueOptional: Bool?
 
   let result = _XCTRunThrowableBlock {
-    expressionValueOptional = try expression().boolValue
+    expressionValueOptional = try expression()
   }
 
   switch result {
@@ -207,14 +207,14 @@ public func XCTAssertTrue(_ expression: @autoclosure () throws -> Boolean, _ mes
   }
 }
 
-public func XCTAssertFalse(_ expression: @autoclosure () throws -> Boolean, _ message: @autoclosure () -> String = "", file: StaticString = #file, line: UInt = #line)  -> Void {
+public func XCTAssertFalse(_ expression: @autoclosure () throws -> Bool, _ message: @autoclosure () -> String = "", file: StaticString = #file, line: UInt = #line)  -> Void {
   let assertionType = _XCTAssertionType.`false`
 
   // evaluate the expression exactly once
   var expressionValueOptional: Bool?
 
   let result = _XCTRunThrowableBlock {
-    expressionValueOptional = try expression().boolValue
+    expressionValueOptional = try expression()
   }
 
   switch result {

stdlib/public/core/Bool.swift

@@ -14,7 +14,7 @@
 
 /// A value type whose instances are either `true` or `false`.
 ///
-/// `Bool` is the default type for Boolean values in Swift. Create instances of
+/// `Bool` represents Boolean values in Swift. Create instances of
 /// `Bool` by using one of the Boolean literals `true` and `false` or by
 /// assigning the result of a Boolean method or operation to a variable or
 /// constant.
@@ -69,6 +69,10 @@ public struct Bool {
   @_versioned
   @_transparent
   internal init(_ v: Builtin.Int1) { self._value = v }
+  
+  public init(_ value: Bool) {
+    self = value
+  }
 }
 
 extension Bool : _ExpressibleByBuiltinBooleanLiteral, ExpressibleByBooleanLiteral {
@@ -101,22 +105,12 @@ extension Bool : _ExpressibleByBuiltinBooleanLiteral, ExpressibleByBooleanLitera
   }
 }
 
-extension Bool : Boolean {
+extension Bool {
+  // This is a magic entry point known to the compiler.
   @_transparent
   public func _getBuiltinLogicValue() -> Builtin.Int1 {
     return _value
   }
-
-  /// This value expressed as a `Bool` instance; its value is identical to that
-  /// of the current instance.
-  @_transparent public var boolValue: Bool { return self }
-
-  /// Creates an instance representing the given logical value.
-  ///
-  /// - Parameter value: The logical value for the new instance.
-  public init<T : Boolean>(_ value: T) {
-    self = value.boolValue
-  }
 }
 
 extension Bool : CustomStringConvertible {

stdlib/public/core/Builtin.swift

@@ -264,23 +264,22 @@ public func _getUnsafePointerToStoredProperties(_ x: AnyObject)
 @_versioned
 @_transparent
 @_semantics("branchhint")
-internal func _branchHint<C : Boolean>(_ actual: C, expected: Bool)
-  -> Bool {
-  return Bool(Builtin.int_expect_Int1(actual.boolValue._value, expected._value))
+internal func _branchHint(_ actual: Bool, expected: Bool) -> Bool {
+  return Bool(Builtin.int_expect_Int1(actual._value, expected._value))
 }
 
 /// Optimizer hint that `x` is expected to be `true`.
 @_transparent
 @_semantics("fastpath")
-public func _fastPath<C: Boolean>(_ x: C) -> Bool {
-  return _branchHint(x.boolValue, expected: true)
+public func _fastPath(_ x: Bool) -> Bool {
+  return _branchHint(x, expected: true)
 }
 
 /// Optimizer hint that `x` is expected to be `false`.
 @_transparent
 @_semantics("slowpath")
-public func _slowPath<C : Boolean>(_ x: C) -> Bool {
-  return _branchHint(x.boolValue, expected: false)
+public func _slowPath(_ x: Bool) -> Bool {
+  return _branchHint(x, expected: false)
 }
 
 /// Optimizer hint that the code where this function is called is on the fast

stdlib/public/core/CompilerProtocols.swift

@@ -12,46 +12,6 @@
 // Intrinsic protocols shared with the compiler
 //===----------------------------------------------------------------------===//
 
-/// A type that represents a Boolean value.
-///
-/// Types that conform to the `Boolean` protocol can be used as the condition
-/// in control statements, such as `if` and `while`, and in other contexts
-/// that require a logical value, such as the `where` clause of a `case`
-/// statement.
-///
-/// Swift uses only simple Boolean values in conditional contexts to help avoid
-/// accidental programming errors and to help maintain the clarity of each
-/// control statement. Unlike other programming languages, integers or strings
-/// cannot be used where a Boolean value is expected.
-///
-/// For example, the following code sample will not compile, because it
-/// attempts to use the integer `i` in a logical context:
-///
-///     var i = 5
-///     while i {
-///         print(i)
-///         i -= 1
-///     }
-///
-/// The correct approach in Swift is to compare the `i` value with zero in the
-/// `while` statement.
-///
-///     while i != 0 {
-///         print(i)
-///         i -= 1
-///     }
-///
-/// Conforming to the Boolean Protocol
-/// ==================================
-///
-/// To add `Boolean` conformance to your custom type, implement a `boolValue`
-/// property that represents your type as an instance of `Bool`, the default
-/// concrete type for the `Boolean` protocol.
-public protocol Boolean {
-  /// This value expressed as a `Bool` instance.
-  var boolValue: Bool { get }
-}
-
 /// A type that can be converted to and from an associated raw value.
 ///
 /// With a `RawRepresentable` type, you can switch back and forth between a
@@ -701,8 +661,8 @@ public protocol _ExpressibleByFileReferenceLiteral {
 public protocol _DestructorSafeContainer {
 }
 
-@available(*, unavailable, renamed: "Boolean")
-public typealias BooleanType = Boolean
+@available(*, unavailable, renamed: "Bool")
+public typealias BooleanType = Bool
 
 // Deprecated by SE-0115.
 

stdlib/public/core/GroupInfo.json

@@ -25,8 +25,7 @@
     "UnavailableStringAPIs.swift"
   ],
   "Bool": [
-    "Bool.swift",
-    "Boolean.swift"
+    "Bool.swift"
   ],
   "Collection": [
     "Collection.swift",

test/1_stdlib/Renames.swift

@@ -94,7 +94,7 @@ func _CollectionOfOne<T>(i: IteratorOverOne<T>) {
 }
 
 func _CompilerProtocols() {
-  func fn(_: BooleanType) {} // expected-error {{'BooleanType' has been renamed to 'Boolean'}} {{14-25=Boolean}} {{none}}
+  func fn(_: BooleanType) {} // expected-error {{'BooleanType' has been renamed to 'Bool'}} {{14-25=Bool}} {{none}}
 }
 
 func _EmptyCollection<T>(i: EmptyIterator<T>) {

test/1_stdlib/Runtime.swift.gyb

@@ -66,21 +66,29 @@ Runtime.test("_canBeClass") {
 
 //===----------------------------------------------------------------------===//
 
+protocol MyBoolean {
+  var boolValue : Bool { get }
+}
+
+extension Bool : MyBoolean {
+  var boolValue : Bool { return self }
+}
+
 // The protocol should be defined in the standard library, otherwise the cast
 // does not work.
-typealias P1 = Boolean
+typealias P1 = MyBoolean
 typealias P2 = CustomStringConvertible
 protocol Q1 {}
 
 // A small struct that can be stored inline in an opaque buffer.
-struct StructConformsToP1 : Boolean, Q1 {
+struct StructConformsToP1 : MyBoolean, Q1 {
   var boolValue: Bool {
     return true
   }
 }
 
 // A small struct that can be stored inline in an opaque buffer.
-struct Struct2ConformsToP1<T : Boolean> : Boolean, Q1 {
+struct Struct2ConformsToP1<T : MyBoolean> : MyBoolean, Q1 {
   init(_ value: T) {
     self.value = value
   }
@@ -135,13 +143,13 @@ struct Struct4ConformsToP2<T : CustomStringConvertible> : CustomStringConvertibl
 
 struct StructDoesNotConformToP1 : Q1 {}
 
-class ClassConformsToP1 : Boolean, Q1 {
+class ClassConformsToP1 : MyBoolean, Q1 {
   var boolValue: Bool {
     return true
   }
 }
 
-class Class2ConformsToP1<T : Boolean> : Boolean, Q1 {
+class Class2ConformsToP1<T : MyBoolean> : MyBoolean, Q1 {
   init(_ value: T) {
     self.value = [value]
   }

test/Constraints/members.swift

@@ -146,10 +146,6 @@ func goo() {
 
 func id<T>(_ t: T) -> T { return t }
 
-func doGetLogicValue<T : Boolean>(_ t: T) {
-  t.boolValue  // expected-warning {{expression of type 'Bool' is unused}}
-}
-
 protocol P {
   init()
   func bar(_ x: Int)