prevent nonescaping closures from being consuming

While these types are also considered Copyable,
thus they're also temporarily banned from being
`consiming`, SE-377 specifically calls out these
kinds of closures as not ever supporting consuming.

rdar://108388132

Author: kavon

include/swift/AST/DiagnosticsSema.def

@@ -7124,6 +7124,8 @@ ERROR(ownership_specifier_copyable,none,
 ERROR(self_ownership_specifier_copyable,none,
       "%0 is not yet valid on %1s in a Copyable type",
       (SelfAccessKind, DescriptiveDeclKind))
+ERROR(ownership_specifier_illegal_nonscape_closure,none,
+      "nonescaping closure %0 cannot be '%1'", (Type, StringRef))
 
 //------------------------------------------------------------------------------
 // MARK: Runtime discoverable attributes (@runtimeMetadata)

lib/Sema/TypeCheckType.cpp

@@ -4284,20 +4284,32 @@ TypeResolver::resolveOwnershipTypeRepr(OwnershipTypeRepr *repr,
   if (result->hasError())
     return result;
 
-  // Unless we have the experimental no-implicit-copy feature enabled, Copyable
-  // types can't use 'consuming' or 'borrowing' ownership specifiers.
-  if (!getASTContext().LangOpts.hasFeature(Feature::NoImplicitCopy)) {
-    if (!result->isPureMoveOnly()) {
-      // Prevent copyable types from using the non-underscored ownership parameter
-      // specifiers, other than 'inout'.
-      switch (ownershipRepr->getSpecifier()) {
-      case ParamSpecifier::Default:
-      case ParamSpecifier::InOut:
-      case ParamSpecifier::LegacyShared:
-      case ParamSpecifier::LegacyOwned:break;
-
-      case ParamSpecifier::Borrowing:
-      case ParamSpecifier::Consuming:
+  // Check for illegal combinations of ownership specifiers and types.
+  switch (ownershipRepr->getSpecifier()) {
+  case ParamSpecifier::Default:
+  case ParamSpecifier::InOut:
+  case ParamSpecifier::LegacyShared:
+  case ParamSpecifier::LegacyOwned:
+    break;
+
+  case ParamSpecifier::Consuming:
+    // consuming cannot be applied to parameters of nonescaping closure type,
+    // which by their nature are always borrowed
+    if (auto fnTy = result->getAs<AnyFunctionType>()) {
+      if (fnTy->isNoEscape()) {
+        diagnoseInvalid(ownershipRepr,
+                        ownershipRepr->getLoc(),
+                        diag::ownership_specifier_illegal_nonscape_closure,
+                        result, ownershipRepr->getSpecifierSpelling());
+        return ErrorType::get(getASTContext());
+      }
+    }
+  SWIFT_FALLTHROUGH;
+  case ParamSpecifier::Borrowing:
+    // Unless we have the experimental no-implicit-copy feature enabled,
+    // Copyable types can't use 'consuming' or 'borrowing' ownership specifiers.
+    if (!getASTContext().LangOpts.hasFeature(Feature::NoImplicitCopy)) {
+      if (!result->isPureMoveOnly()) {
         diagnoseInvalid(ownershipRepr,
                         ownershipRepr->getLoc(),
                         diag::ownership_specifier_copyable);

test/Parse/ownership_modifiers.swift

@@ -101,3 +101,10 @@ enum Exercising {
     __consuming get { 0 }
   }
 }
+
+// you cannot own a nonescaping function.
+func f(_ g: consuming () -> ()) {} // expected-error {{nonescaping closure '() -> ()' cannot be 'consuming'}}
+
+// otherwise, functions are copyable
+func h(_ g: borrowing () -> ()) {} // expected-error {{Copyable types cannot be 'consuming' or 'borrowing' yet}}
+func j(_ g: consuming @escaping () -> ()) {} // expected-error {{Copyable types cannot be 'consuming' or 'borrowing' yet}}