SILGen: Provide compatibility with prior BorrowingSwitch behavior.

To avoid breaking early adopters of this feature, accept attempts to `return`
a `let` binding in a noncopyable `switch` when it would be treated as a
borrow normally, with a warning that this behavior will change soon.
rdar://126775241

Author: jckarter

include/swift/AST/DiagnosticsSIL.def

@@ -21,6 +21,12 @@
 #include "DefineDiagnosticMacros.h"
 
 // SILGen issues.
+WARNING(return_borrowing_switch_binding,none,
+        "returning the non-'Copyable' value of a pattern binding from a "
+        "switch that borrows by default; the switch will be performed as a "
+        "consume for compatibility for now, but this will require an explicit "
+        "'switch consume' in the future", ())
+
 ERROR(bridging_module_missing,none,
       "unable to find module '%0' for implicit conversion function '%0.%1'",
       (StringRef, StringRef))

lib/SILGen/SILGenPattern.cpp

@@ -3366,6 +3366,32 @@ void SILGenFunction::emitSwitchStmt(SwitchStmt *S) {
       for (auto item : caseLabel->getCaseLabelItems()) {
         ownership = std::max(ownership, item.getPattern()->getOwnership());
       }
+      // To help migrate early adopters of the feature, if the case body is
+      // obviously trying to return out one of the pattern bindings, which
+      // would necessitate a consuming switch, perform the switch as a consume,
+      // and warn that this will need to be made explicit in the future.
+      if (ownership == ValueOwnership::Shared) {
+        if (auto ret = dyn_cast_or_null<ReturnStmt>(
+              caseLabel->getBody()->getSingleActiveElement()
+                       .dyn_cast<Stmt*>())) {
+          Expr *result = ret->getResult()->getSemanticsProvidingExpr();
+          if (result->getType()->isNoncopyable()) {
+            while (auto conv = dyn_cast<ImplicitConversionExpr>(result)) {
+              result = conv->getSubExpr()->getSemanticsProvidingExpr();
+            }
+            if (auto dr = dyn_cast<DeclRefExpr>(result)) {
+              if (std::find(caseLabel->getCaseBodyVariables().begin(),
+                            caseLabel->getCaseBodyVariables().end(),
+                            dr->getDecl())
+                    != caseLabel->getCaseBodyVariables().end()) {
+                SGM.diagnose(result->getLoc(),
+                             diag::return_borrowing_switch_binding);
+                ownership = ValueOwnership::Owned;
+              }
+            }
+          }
+        }
+      }
     }
   }
 

test/SILGen/borrowing_switch_return_binding_compat.swift

@@ -0,0 +1,12 @@
+// RUN: %target-swift-emit-silgen -enable-experimental-feature NoncopyableGenerics -enable-experimental-feature BorrowingSwitch -verify %s
+func orElse<T: ~Copyable>(
+    x: consuming T?,
+    defaultValue: @autoclosure () throws -> T?
+) rethrows -> T? {
+  switch x {
+  case .some(let value):
+    return value // expected-warning{{returning the non-'Copyable' value of a pattern binding from a switch that borrows by default}}
+  case .none:
+    return try defaultValue()
+  }
+}