Fix the build.

This reverts commit 4242af7.
This reverts commit 76cf339.
This reverts commit e97ed13.
This reverts commit 66961fc.

Author: gottesmm

include/swift/AST/Types.h

@@ -585,9 +585,6 @@ 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,20 +510,9 @@ bool TypeBase::isLegalSILType() {
 }
 
 bool TypeBase::isVoid() {
-  if (auto TT = getAs<TupleType>())
-    return TT->getNumElements() == 0;
-  return false;
+  return isEqual(getASTContext().TheEmptyTupleType);
 }
 
-/// \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,32 +3491,7 @@ 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

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 {
+public struct AssertionResult : CustomStringConvertible, Boolean {
   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.boolValue {
+  if !actual {
     expectationFailure("expected: true", trace: ${trace})
   }
 }
 
 public func expectFalse(_ actual: ${BoolType}, ${TRACE}) {
-  if actual.boolValue {
+  if actual {
     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 : ExpressibleByBooleanLiteral {
+public struct DarwinBoolean : Boolean, ExpressibleByBooleanLiteral {
   var _value: UInt8
 
   public init(_ value: Bool) {
@@ -66,7 +66,26 @@ func _convertBoolToDarwinBoolean(_ x: Bool) -> DarwinBoolean {
 }
 public // COMPILER_INTRINSIC
 func _convertDarwinBooleanToBool(_ x: DarwinBoolean) -> Bool {
-  return x.boolValue
+  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
 }
 
 #endif

stdlib/public/SDK/ObjectiveC/ObjectiveC.swift

@@ -17,13 +17,14 @@ 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 : ExpressibleByBooleanLiteral {
+public struct ObjCBool : Boolean, 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
@@ -84,7 +85,7 @@ func _convertBoolToObjCBool(_ x: Bool) -> ObjCBool {
 
 public // COMPILER_INTRINSIC
 func _convertObjCBoolToBool(_ x: ObjCBool) -> Bool {
-  return x.boolValue
+  return Bool(x)
 }
 
 /// The Objective-C SEL type.
@@ -209,6 +210,23 @@ 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,79 +174,3 @@ 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()
-}