[Strict memory safety] Lift "unsafe" in pattern match expressions

When an "unsafe" expression is used as the case expression, lift it up
so it also covers the synthesized matching expression (`=~`). This
eliminates some unsuppressible strict memory safety warnings.

Fixes rdar://151731850.

Author: DougGregor

lib/Sema/TypeCheckPattern.cpp

@@ -768,13 +768,27 @@ ExprPatternMatchRequest::evaluate(Evaluator &evaluator,
       DeclNameLoc(EP->getLoc()));
   matchOp->setImplicit();
 
+  auto subExpr = EP->getSubExpr();
+
+  // Pull off the outer "unsafe" expression.
+  UnsafeExpr *unsafeExpr = dyn_cast<UnsafeExpr>(subExpr);
+  if (unsafeExpr) {
+    subExpr = unsafeExpr->getSubExpr();
+  }
+
   // Note we use getEndLoc here to have the BinaryExpr source range be the same
   // as the expr pattern source range.
   auto *matchVarRef =
       new (ctx) DeclRefExpr(matchVar, DeclNameLoc(EP->getEndLoc()),
                             /*Implicit=*/true);
-  auto *matchCall = BinaryExpr::create(ctx, EP->getSubExpr(), matchOp,
+  Expr *matchCall = BinaryExpr::create(ctx, subExpr, matchOp,
                                        matchVarRef, /*implicit*/ true);
+
+  // If there was an "unsafe", put it outside of the match call.
+  if (unsafeExpr) {
+    matchCall = UnsafeExpr::createImplicit(ctx, unsafeExpr->getLoc(), matchCall);
+  }
+
   return {matchVar, matchCall};
 }
 

test/Unsafe/safe.swift

@@ -317,3 +317,35 @@ extension Slice {
     }
   }
 }
+
+@unsafe enum SomeEnum {
+  case first
+  case second
+}
+
+@unsafe var someEnumValue: SomeEnum = unsafe .first
+
+func testSwitch(se: SomeEnum) {
+  switch unsafe se {
+  case unsafe someEnumValue: break
+  default: break
+  }
+
+  switch unsafe se {
+  case someEnumValue: break
+    // expected-warning@-1{{expression uses unsafe constructs but is not marked with 'unsafe'}}{{8-8=unsafe }}
+    // expected-note@-2{{argument #0 in call to operator function '~=' has unsafe type 'T'}}
+    // expected-note@-3{{argument #1 in call to operator function '~=' has unsafe type 'T'}}
+    // expected-note@-4{{reference to unsafe type 'SomeEnum'}}
+    // expected-note@-5{{reference to unsafe var 'someEnumValue'}}
+    // expected-note@-6{{reference to let '$match' involves unsafe type 'SomeEnum'}}
+  default: break
+  }
+
+  // expected-note@+2{{reference to parameter 'se' involves unsafe type 'SomeEnum'}}
+  // expected-warning@+1{{expression uses unsafe constructs but is not marked with 'unsafe'}}{{10-10=unsafe }}
+  switch se {
+  case unsafe someEnumValue: break
+  default: break
+  }
+}