[TypeChecker] Bool literals in switch

Bool literals are regarded as expr patterns when
switching over Optional<Bool>. Simplify the expr
by converting to their optional counterparts.

Author: jameesbrown

lib/Sema/TypeCheckPattern.cpp

@@ -1015,21 +1015,11 @@ NullablePtr<Pattern> TypeChecker::trySimplifyExprPattern(ExprPattern *EP,
                                                          Type patternTy) {
   auto *subExpr = EP->getSubExpr();
   auto &ctx = EP->getDeclContext()->getASTContext();
-
-  if (patternTy->isBool()) {
-    // The type is Bool.
-    // Check if the pattern is a Bool literal
-    auto *semanticSubExpr = subExpr->getSemanticsProvidingExpr();
-    if (auto *BLE = dyn_cast<BooleanLiteralExpr>(semanticSubExpr)) {
-      auto *BP = new (ctx) BoolPattern(BLE->getLoc(), BLE->getValue());
-      BP->setType(patternTy);
-      return BP;
-    }
-  }
+  const auto wrappedType = patternTy->getOptionalObjectType();
 
   // case nil is equivalent to .none when switching on Optionals.
-  if (auto *NLE = dyn_cast<NilLiteralExpr>(EP->getSubExpr())) {
-    if (patternTy->getOptionalObjectType()) {
+  if (auto *NLE = dyn_cast<NilLiteralExpr>(subExpr)) {
+    if (wrappedType) {
       auto *NoneEnumElement = ctx.getOptionalNoneDecl();
       return EnumElementPattern::createImplicit(
           patternTy, NLE->getLoc(), DeclNameLoc(NLE->getLoc()), NoneEnumElement,
@@ -1045,7 +1035,30 @@ NullablePtr<Pattern> TypeChecker::trySimplifyExprPattern(ExprPattern *EP,
         return nullptr;
     }
   }
-  return nullptr;
+  // Try to simplify a Boolean literal expression to a BoolPattern,
+  // recursively handling multiple levels of optionality if necessary.
+  const auto *BLE = dyn_cast_or_null<BooleanLiteralExpr>(
+      subExpr->getSemanticsProvidingExpr());
+  if (!BLE)
+    return nullptr;
+  // If the type is Bool, return a BoolPattern.
+  if (patternTy->isBool()) {
+    auto *BP = new (ctx) BoolPattern(BLE->getLoc(), BLE->getValue());
+    BP->setType(patternTy);
+    return BP;
+    }
+    // If the pattern type is optional, attempt to simplify the wrapped type.
+    // `true` and `false` are treated as if they had "?" appended
+    // for each level of optionality.
+    if (wrappedType) {
+      auto simplified = trySimplifyExprPattern(EP, wrappedType);
+      if (auto P = simplified.getPtrOrNull()) {
+        auto OP = OptionalSomePattern::createImplicit(ctx, P, P->getEndLoc());
+        OP->setType(patternTy);
+        return OP;
+      }
+    }
+    return nullptr;
 }
 
 /// Perform top-down type coercion on the given pattern.

test/Sema/exhaustive_switch.swift

@@ -1489,3 +1489,30 @@ do {
       case (e: .y, b: true)?: break
   }
 }
+
+// https://github.com/swiftlang/swift/issues/61817
+do {
+  let a: Bool? = true
+  switch a {
+    case true: break
+    case false: break
+    case nil: break
+  }
+
+  let result = {
+    switch a {
+      case true: true
+      case false: true
+      case nil: true
+    }
+  }
+  _ = result()
+
+  let b: Bool?? = true
+  switch b {
+    case true: break
+    case false: break
+    case nil: break
+    case nil?: break
+  }
+}