Merge pull request #41815 from CodaFi/switch-hitter

Author: CodaFi

lib/Sema/TypeCheckPattern.cpp

@@ -1269,10 +1269,10 @@ Pattern *TypeChecker::coercePatternToType(ContextualPattern pattern,
   case PatternKind::Expr: {
     assert(cast<ExprPattern>(P)->isResolved()
            && "coercing unresolved expr pattern!");
+    auto *EP = cast<ExprPattern>(P);
     if (type->isBool()) {
       // The type is Bool.
       // Check if the pattern is a Bool literal
-      auto EP = cast<ExprPattern>(P);
       if (auto *BLE = dyn_cast<BooleanLiteralExpr>(
               EP->getSubExpr()->getSemanticsProvidingExpr())) {
         P = new (Context) BoolPattern(BLE->getLoc(), BLE->getValue());
@@ -1282,20 +1282,27 @@ Pattern *TypeChecker::coercePatternToType(ContextualPattern pattern,
     }
 
     // case nil is equivalent to .none when switching on Optionals.
-    if (type->getOptionalObjectType()) {
-      auto EP = cast<ExprPattern>(P);
-      if (auto *NLE = dyn_cast<NilLiteralExpr>(EP->getSubExpr())) {
+    if (auto *NLE = dyn_cast<NilLiteralExpr>(EP->getSubExpr())) {
+      if (type->getOptionalObjectType()) {
         auto *NoneEnumElement = Context.getOptionalNoneDecl();
         auto *BaseTE = TypeExpr::createImplicit(type, Context);
         P = new (Context) EnumElementPattern(
             BaseTE, NLE->getLoc(), DeclNameLoc(NLE->getLoc()),
             NoneEnumElement->createNameRef(), NoneEnumElement, nullptr);
         return TypeChecker::coercePatternToType(
             pattern.forSubPattern(P, /*retainTopLevel=*/true), type, options);
+      } else {
+        // ...but for non-optional types it can never match! Diagnose it.
+        diags.diagnose(NLE->getLoc(),
+                       diag::value_type_comparison_with_nil_illegal, type)
+             .warnUntilSwiftVersion(6);
+
+        if (type->getASTContext().isSwiftVersionAtLeast(6))
+          return nullptr;
       }
     }
 
-    if (TypeChecker::typeCheckExprPattern(cast<ExprPattern>(P), dc, type))
+    if (TypeChecker::typeCheckExprPattern(EP, dc, type))
       return nullptr;
 
     return P;

test/Constraints/result_builder_diags.swift

@@ -811,3 +811,30 @@ func test_redeclations() {
     let (foo, foo) = (5, 6) // expected-error {{invalid redeclaration of 'foo'}} expected-note {{'foo' previously declared here}}
   }
 }
+
+func test_rdar89742267() {
+  @resultBuilder
+  struct Builder {
+    static func buildBlock<T>(_ t: T) -> T { t }
+    static func buildEither<T>(first: T) -> T { first }
+    static func buildEither<T>(second: T) -> T { second }
+  }
+
+  struct S {}
+
+  enum Hey {
+    case listen
+  }
+
+  struct MyView {
+    var entry: Hey
+
+    @Builder var body: S {
+      switch entry {
+      case .listen: S()
+      case nil: S() // expected-warning {{type 'Hey' is not optional, value can never be nil; this is an error in Swift 6}}
+      default: S()
+      }
+    }
+  }
+}

test/stmt/switch_nil.swift

@@ -0,0 +1,14 @@
+// RUN: %target-typecheck-verify-swift
+
+enum Hey {
+  case listen
+}
+
+func test() {
+  switch Hey.listen {
+  case nil: // expected-warning {{type 'Hey' is not optional, value can never be nil}}
+    break
+  default:
+    break
+  }
+}