Consume: warn about no-op consumes to be fixed

As of now, SE-366 is not correctly implemented with respect to concrete,
bitwise-copyable types like `Int`. Writing `consume someInt` doesn't
actually consume the variable binding as it should, meaning code that
should be flagged as having a use-after-consume is being silently
permitted:

```swift
let someInt = 10
let y = consume someInt
print(someInt) // no error!
```

This has been a problem since Swift 5.9. Eventually we plan to fix this
issue, which means code previously doing the above would become an
error. To help people get ready for the fix, start warning people that
these consumes are actually no-ops and suggest removing them until the
intended behavior is actually enforced in the future.

resolves rdar://127081103

Author: kavon

include/swift/AST/DiagnosticsSema.def

@@ -7749,6 +7749,9 @@ ERROR(consume_expression_needed_for_cast,none,
       "implicit conversion to %0 is consuming", (Type))
 NOTE(add_consume_to_silence,none,
      "add 'consume' to make consumption explicit", ())
+WARNING(consume_of_bitwisecopyable_noop,none,
+      "'consume' applied to bitwise-copyable type %0 "
+      "has no effect currently, but will in the future", (Type))
 ERROR(consume_expression_not_passed_lvalue,none,
       "'consume' can only be applied to a local binding ('let', 'var', or parameter)", ())
 ERROR(consume_expression_partial_copyable,none,

lib/Sema/MiscDiagnostics.cpp

@@ -437,6 +437,30 @@ static void diagSyntacticUseRestrictions(const Expr *E, const DeclContext *DC,
                                                 consumeExpr->getSubExpr());
       for (auto &diag : diags)
         diag.emit(Ctx);
+
+      // As of now, SE-366 is not correctly implemented (rdar://102780553),
+      // so warn about certain consume's being no-ops today that will no longer
+      // be a no-op in the future once we fix this.
+      if (auto ty = consumeExpr->getType()) {
+        // Only warn about obviously concrete BitwiseCopyable types, since we
+        // know those won't get checked for consumption.
+        //
+        // Generic bitwise-copyable types do get properly checked, since they're
+        // address-only in SIL, so we do not mapTypeIntoContext here.
+        if (diags.empty() &&
+            !ty->hasError() &&
+            !ty->hasTypeParameter() &&
+            !ty->hasUnboundGenericType() &&
+            !ty->hasArchetype()) {
+          auto bitCopy = Ctx.getProtocol(KnownProtocolKind::BitwiseCopyable);
+          if (DC->getParentModule()->checkConformance(ty, bitCopy)) {
+            Ctx.Diags.diagnose(consumeExpr->getLoc(),
+                               diag::consume_of_bitwisecopyable_noop, ty)
+                   .fixItRemoveChars(consumeExpr->getStartLoc(),
+                                     consumeExpr->getSubExpr()->getStartLoc());
+          }
+        }
+      }
     }
 
     void checkCopyExpr(CopyExpr *copyExpr) {

test/Sema/consume_operator_noop_warning.swift

@@ -0,0 +1,34 @@
+// RUN: %target-swift-emit-sil %s -verify -sil-verify-all
+
+struct Point {
+  let x: Float
+  let y: Float
+}
+
+struct ConditionallyBC<T> {
+  var t: T
+}
+extension ConditionallyBC: BitwiseCopyable where T: BitwiseCopyable {}
+
+func test<T, BCG: BitwiseCopyable>(_ t: T, // expected-error {{'t' is borrowed and cannot be consumed}}
+                                   _ bcg: BCG, // expected-error {{'bcg' is borrowed and cannot be consumed}}
+                                   _ cbcg_generic: ConditionallyBC<BCG>, // expected-error {{'cbcg_generic' is borrowed and cannot be consumed}}
+                                   _ maybeBCG: BCG?, // expected-error {{'maybeBCG' is borrowed and cannot be consumed}}
+                                   _ maybeT: T?, // expected-error {{'maybeT' is borrowed and cannot be consumed}}
+                                   _ anyBC: any BitwiseCopyable, // expected-error {{'anyBC' is borrowed and cannot be consumed}}
+                                   _ x: Int,
+                                   _ point: Point,
+                                   _ cbcg_concrete: ConditionallyBC<Int>,
+                                   _ maybeFloat: Float?) {
+  _ = consume t  // expected-note {{consumed here}}
+  _ = consume bcg // expected-note {{consumed here}}
+  _ = consume cbcg_generic // expected-note {{consumed here}}
+  _ = consume maybeBCG // expected-note {{consumed here}}
+  _ = consume maybeT // expected-note {{consumed here}}
+  _ = consume anyBC // expected-note {{consumed here}}
+
+  _ = consume x // expected-warning {{'consume' applied to bitwise-copyable type 'Int' has no effect currently, but will in the future}}{{7-15=}}
+  _ = consume point // expected-warning {{'consume' applied to bitwise-copyable type 'Point' has no effect currently, but will in the future}}{{7-15=}}
+  _ = consume  cbcg_concrete // expected-warning {{'consume' applied to bitwise-copyable type 'ConditionallyBC<Int>' has no effect currently, but will in the future}}{{7-16=}}
+   _ = consume maybeFloat // expected-warning {{'consume' applied to bitwise-copyable type 'Float?' has no effect currently, but will in the future}}{{8-16=}}
+}