Implement the first half of SE-0109: Remove the Boolean protocol

This removes conformance of DarwinBool and ObjCBool to the Boolean protocol,
and makes the &&/||/! operators be concrete w.r.t. Bool instead of abstract
on Boolean.

This fixes some outstanding bugs w.r.t diagnostics, but exposes some cases
where an existing diagnostic is not great.  I'll fix that in a later patch
(tracked by rdar://27391581).

Author: lattner

include/swift/AST/Types.h

@@ -585,6 +585,9 @@ class alignas(1 << TypeAlignInBits) TypeBase {
   /// \brief Check if this type is equal to the empty tuple type.
   bool isVoid();
 
+  /// \brief Check if this type is equal to Swift.Bool.
+  bool isBool();
+
   /// \brief Check if this type is equal to Builtin.IntN.
   bool isBuiltinIntegerType(unsigned bitWidth);
 

lib/AST/Type.cpp

@@ -510,9 +510,20 @@ bool TypeBase::isLegalSILType() {
 }
 
 bool TypeBase::isVoid() {
-  return isEqual(getASTContext().TheEmptyTupleType);
+  if (auto TT = getAs<TupleType>())
+    return TT->getNumElements() == 0;
+  return false;
 }
 
+/// \brief Check if this type is equal to Swift.Bool.
+bool TypeBase::isBool() {
+  if (auto NTD = getAnyNominal())
+    if (isa<StructDecl>(NTD))
+      return getASTContext().getBoolDecl() == NTD;
+  return false;
+}
+
+
 bool TypeBase::isAssignableType() {
   if (isLValueType()) return true;
   if (auto tuple = getAs<TupleType>()) {

lib/Sema/CSDiag.cpp

@@ -3491,7 +3491,32 @@ bool FailureDiagnosis::diagnoseContextualConversionError() {
       .highlight(expr->getSourceRange());
     return true;
   }
-
+  
+  // If we're trying to convert something from optional type to Bool, then a
+  // comparision against nil was probably expected.
+  // TODO: It would be nice to handle "!x" --> x == false, but we have no way to
+  // get to the parent expr at present.
+  if (contextualType->isBool())
+    if (exprType->getAnyOptionalObjectType()) {
+      StringRef prefix = "((";
+      StringRef suffix = ") != nil)";
+      
+      // Check if we need the inner parentheses.
+      // Technically we only need them if there's something in 'expr' with
+      // lower precedence than '!=', but the code actually comes out nicer
+      // in most cases with parens on anything non-trivial.
+      if (expr->canAppendCallParentheses()) {
+        prefix = prefix.drop_back();
+        suffix = suffix.drop_front();
+      }
+      // FIXME: The outer parentheses may be superfluous too.
+      
+      diagnose(expr->getLoc(), diag::optional_used_as_boolean, exprType)
+        .fixItInsert(expr->getStartLoc(), prefix)
+        .fixItInsertAfter(expr->getEndLoc(), suffix);
+      return true;
+    }
+  
   exprType = exprType->getRValueType();
 
   // Special case of some common conversions involving Swift.String

lib/Sema/CSSimplify.cpp

@@ -2303,7 +2303,7 @@ ConstraintSystem::SolutionKind ConstraintSystem::simplifyConformsToConstraint(
 
   if (!shouldAttemptFixes())
     return SolutionKind::Error;
-
+#if 1
   // See if there's anything we can do to fix the conformance:
   OptionalTypeKind optionalKind;
   if (auto optionalObjectType = type->getAnyOptionalObjectType(optionalKind)) {
@@ -2326,6 +2326,7 @@ ConstraintSystem::SolutionKind ConstraintSystem::simplifyConformsToConstraint(
       return result;
     }
   }
+#endif
 
   // There's nothing more we can do; fail.
   return SolutionKind::Error;

stdlib/private/StdlibUnittest/StdlibUnittest.swift.gyb

@@ -450,7 +450,7 @@ public func expectRandomAccessCollectionAssociatedTypes<X : RandomAccessCollecti
 
 public func expectIsBooleanType<X : Boolean>(_ x: inout X) -> X { return x }
 
-public struct AssertionResult : CustomStringConvertible, Boolean {
+public struct AssertionResult : CustomStringConvertible {
   init(isPass: Bool) {
     self._isPass = isPass
   }
@@ -490,13 +490,13 @@ public func expectUnreachableCatch(_ error: Error, ${TRACE}) {
 %for BoolType in ['Bool', 'AssertionResult']:
 
 public func expectTrue(_ actual: ${BoolType}, ${TRACE}) {
-  if !actual {
+  if !actual.boolValue {
     expectationFailure("expected: true", trace: ${trace})
   }
 }
 
 public func expectFalse(_ actual: ${BoolType}, ${TRACE}) {
-  if actual {
+  if actual.boolValue {
     expectationFailure("expected: false", trace: ${trace})
   }
 }

stdlib/public/Platform/Platform.swift

@@ -22,7 +22,7 @@ public var noErr: OSStatus { return 0 }
 ///
 /// The C type is a typedef for `unsigned char`.
 @_fixed_layout
-public struct DarwinBoolean : Boolean, ExpressibleByBooleanLiteral {
+public struct DarwinBoolean : ExpressibleByBooleanLiteral {
   var _value: UInt8
 
   public init(_ value: Bool) {
@@ -66,26 +66,7 @@ func _convertBoolToDarwinBoolean(_ x: Bool) -> DarwinBoolean {
 }
 public // COMPILER_INTRINSIC
 func _convertDarwinBooleanToBool(_ x: DarwinBoolean) -> Bool {
-  return Bool(x)
-}
-
-// FIXME: We can't make the fully-generic versions @_transparent due to
-// rdar://problem/19418937, so here are some @_transparent overloads
-// for DarwinBoolean.
-@_transparent
-public func && <T : Boolean>(
-  lhs: T,
-  rhs: @autoclosure () -> DarwinBoolean
-) -> Bool {
-  return lhs.boolValue ? rhs().boolValue : false
-}
-
-@_transparent
-public func || <T : Boolean>(
-  lhs: T,
-  rhs: @autoclosure () -> DarwinBoolean
-) -> Bool {
-  return lhs.boolValue ? true : rhs().boolValue
+  return x.boolValue
 }
 
 #endif

stdlib/public/SDK/ObjectiveC/ObjectiveC.swift

@@ -17,14 +17,13 @@ import ObjectiveC
 // Objective-C Primitive Types
 //===----------------------------------------------------------------------===//
 
-public typealias Boolean = Swift.Boolean
 /// The Objective-C BOOL type.
 ///
 /// On 64-bit iOS, the Objective-C BOOL type is a typedef of C/C++
 /// bool. Elsewhere, it is "signed char". The Clang importer imports it as
 /// ObjCBool.
 @_fixed_layout
-public struct ObjCBool : Boolean, ExpressibleByBooleanLiteral {
+public struct ObjCBool : ExpressibleByBooleanLiteral {
 #if os(OSX) || (os(iOS) && (arch(i386) || arch(arm)))
   // On OS X and 32-bit iOS, Objective-C's BOOL type is a "signed char".
   var _value: Int8
@@ -85,7 +84,7 @@ func _convertBoolToObjCBool(_ x: Bool) -> ObjCBool {
 
 public // COMPILER_INTRINSIC
 func _convertObjCBoolToBool(_ x: ObjCBool) -> Bool {
-  return Bool(x)
+  return x.boolValue
 }
 
 /// The Objective-C SEL type.
@@ -210,23 +209,6 @@ public var NO: ObjCBool {
   fatalError("can't retrieve unavailable property")
 }
 
-// FIXME: We can't make the fully-generic versions @_transparent due to
-// rdar://problem/19418937, so here are some @_transparent overloads
-// for ObjCBool
-@_transparent
-public func && <T : Boolean>(
-  lhs: T, rhs: @autoclosure () -> ObjCBool
-) -> Bool {
-  return lhs.boolValue ? rhs().boolValue : false
-}
-
-@_transparent
-public func || <T : Boolean>(
-  lhs: T, rhs: @autoclosure () -> ObjCBool
-) -> Bool {
-  return lhs.boolValue ? true : rhs().boolValue
-}
-
 //===----------------------------------------------------------------------===//
 // NSObject
 //===----------------------------------------------------------------------===//

stdlib/public/core/Bool.swift

@@ -174,3 +174,79 @@ public prefix func !(a: Bool) -> Bool {
 public func ==(lhs: Bool, rhs: Bool) -> Bool {
   return Bool(Builtin.cmp_eq_Int1(lhs._value, rhs._value))
 }
+
+
+/// Performs a logical AND operation on two Bool values.
+///
+/// The logical AND operator (`&&`) combines two Bool values and returns
+/// `true` if both of the values are `true`. If either of the values is
+/// `false`, the operator returns `false`.
+///
+/// This operator uses short-circuit evaluation: The left-hand side (`lhs`) is
+/// evaluated first, and the right-hand side (`rhs`) is evaluated only if
+/// `lhs` evaluates to `true`. For example:
+///
+///     let measurements = [7.44, 6.51, 4.74, 5.88, 6.27, 6.12, 7.76]
+///     let sum = measurements.reduce(0, combine: +)
+///
+///     if measurements.count > 0 && sum / Double(measurements.count) < 6.5 {
+///         print("Average measurement is less than 6.5")
+///     }
+///     // Prints "Average measurement is less than 6.5"
+///
+/// In this example, `lhs` tests whether `measurements.count` is greater than
+/// zero. Evaluation of the `&&` operator is one of the following:
+///
+/// - When `measurements.count` is equal to zero, `lhs` evaluates to `false`
+///   and `rhs` is not evaluated, preventing a divide-by-zero error in the
+///   expression `sum / Double(measurements.count)`. The result of the
+///   operation is `false`.
+/// - When `measurements.count` is greater than zero, `lhs` evaluates to `true`
+///   and `rhs` is evaluated. The result of evaluating `rhs` is the result of
+///   the `&&` operation.
+///
+/// - Parameters:
+///   - lhs: The left-hand side of the operation.
+///   - rhs: The right-hand side of the operation.
+@inline(__always)
+public func &&(lhs: Bool, rhs: @autoclosure () throws -> Bool) rethrows -> Bool{
+  return lhs ? try rhs() : false
+}
+
+/// Performs a logical OR operation on two Bool values.
+///
+/// The logical OR operator (`||`) combines two Bool values and returns
+/// `true` if at least one of the values is `true`. If both values are
+/// `false`, the operator returns `false`.
+///
+/// This operator uses short-circuit evaluation: The left-hand side (`lhs`) is
+/// evaluated first, and the right-hand side (`rhs`) is evaluated only if
+/// `lhs` evaluates to `false`. For example:
+///
+///     let majorErrors: Set = ["No first name", "No last name", ...]
+///     let error = ""
+///
+///     if error.isEmpty || !majorErrors.contains(error) {
+///         print("No major errors detected")
+///     } else {
+///         print("Major error: \(error)")
+///     }
+///     // Prints "No major errors detected")
+///
+/// In this example, `lhs` tests whether `error` is an empty string. Evaluation
+/// of the `||` operator is one of the following:
+///
+/// - When `error` is an empty string, `lhs` evaluates to `true` and `rhs` is
+///   not evaluated, skipping the call to `majorErrors.contains(_:)`. The
+///   result of the operation is `true`.
+/// - When `error` is not an empty string, `lhs` evaluates to `false` and `rhs`
+///   is evaluated. The result of evaluating `rhs` is the result of the `||`
+///   operation.
+///
+/// - Parameters:
+///   - lhs: The left-hand side of the operation.
+///   - rhs: The right-hand side of the operation.
+@inline(__always)
+public func ||(lhs: Bool, rhs: @autoclosure () throws -> Bool) rethrows -> Bool{
+  return lhs ? true : try rhs()
+}