temporarily prevent Copyable types from using consuming and borrowing

There is a strong desire for "no-implicit-copy" semantics to be
applied to Copyable values marked with the newer `borrowing` and
`consuming` ownership specifiers. If we lock ourselves into what
SE-390 specifies now for Copyable types in the implementation, then
we'll have to introduce a source break when we want such values to
have the desired semantics.

Before there's wider adoption, I'm making it an error to use those
newer names. If for some reason this is enabling a critical
optimization for your use case, please use the old names instead:

 - `__owned` for `consuming` parameters
 - `__consuming` for `consuming` methods
 - `__shared` for `borrowing` parameters

 NOTE: the older names have their ownership attribute mangled into
 the name of the function itself, so there's a possibility of ABI
 breaks in the future if you move from the old name to the new one.
 There is some consideration being made to allow for a migration to
 the new names in the future without breaking ABI, so do reach out if
 this is an issue for you.

 resolves rdar://108538971

Author: kavon

include/swift/AST/DiagnosticsSema.def

@@ -7119,6 +7119,11 @@ ERROR(moveonly_parameter_missing_ownership, none,
       "noncopyable parameter must specify its ownership", ())
 NOTE(moveonly_parameter_ownership_suggestion, none,
       "add '%0' %1", (StringRef, StringRef))
+ERROR(ownership_specifier_copyable,none,
+      "Copyable types cannot be 'consuming' or 'borrowing' yet", ())
+ERROR(self_ownership_specifier_copyable,none,
+      "%0 is not yet valid on %1s in a Copyable type",
+      (SelfAccessKind, DescriptiveDeclKind))
 
 //------------------------------------------------------------------------------
 // MARK: Runtime discoverable attributes (@runtimeMetadata)

lib/Sema/TypeCheckAttr.cpp

@@ -466,7 +466,7 @@ void AttributeChecker::visitMutationAttr(DeclAttribute *attr) {
   }
 
   auto DC = FD->getDeclContext();
-  // mutation attributes may only appear in type context.
+  // self-ownership attributes may only appear in type context.
   if (auto contextTy = DC->getDeclaredInterfaceType()) {
     // 'mutating' and 'nonmutating' are not valid on types
     // with reference semantics.
@@ -487,6 +487,27 @@ void AttributeChecker::visitMutationAttr(DeclAttribute *attr) {
         break;
       }
     }
+
+    // Unless we have the experimental no-implicit-copy feature enabled, Copyable
+    // types can't use 'consuming' or 'borrowing' ownership specifiers.
+    if (!Ctx.LangOpts.hasFeature(Feature::NoImplicitCopy)) {
+      if (!contextTy->isPureMoveOnly()) {
+        switch (attrModifier) { // check the modifier for the Copyable type.
+        case SelfAccessKind::NonMutating:
+        case SelfAccessKind::Mutating:
+        case SelfAccessKind::LegacyConsuming:
+          // already checked
+          break;
+
+        case SelfAccessKind::Consuming:
+        case SelfAccessKind::Borrowing:
+          diagnoseAndRemoveAttr(attr, diag::self_ownership_specifier_copyable,
+                                attrModifier, FD->getDescriptiveKind());
+          break;
+        }
+      }
+    }
+
   } else {
     diagnoseAndRemoveAttr(attr, diag::mutating_invalid_global_scope,
                           attrModifier);

lib/Sema/TypeCheckType.cpp

@@ -4280,7 +4280,33 @@ TypeResolver::resolveOwnershipTypeRepr(OwnershipTypeRepr *repr,
   // Remember that we've seen an ownership specifier for this base type.
   options |= TypeResolutionFlags::HasOwnership;
 
-  return resolveType(repr->getBase(), options);
+  auto result = resolveType(repr->getBase(), options);
+  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:
+        diagnoseInvalid(ownershipRepr,
+                        ownershipRepr->getLoc(),
+                        diag::ownership_specifier_copyable);
+        return ErrorType::get(getASTContext());
+      }
+    }
+  }
+
+  return result;
 }
 
 NeverNullType

test/Sema/ownership_specifiers_copyable.swift

@@ -0,0 +1,42 @@
+// RUN: %target-typecheck-verify-swift
+
+func chalk(_ a: consuming String, // expected-error{{Copyable types cannot be 'consuming' or 'borrowing' yet}}
+_ b: borrowing [Int], // expected-error{{Copyable types cannot be 'consuming' or 'borrowing' yet}}
+_ c: __shared [String],
+_ d: __owned Int?)
+{}
+
+struct Stepping {
+    consuming func perform() {} // expected-error {{'consuming' is not yet valid on instance methods in a Copyable type}}
+    borrowing func doIt() {} // expected-error {{'borrowing' is not yet valid on instance methods in a Copyable type}}
+  mutating func change() {}
+  var ex: Int {
+    __consuming get { 0 }
+  }
+}
+
+class Clapping {
+    consuming func perform() {} // expected-error {{'consuming' is not yet valid on instance methods in a Copyable type}}
+    borrowing func doIt() {} // expected-error {{'borrowing' is not yet valid on instance methods in a Copyable type}}
+  var ex: Int {
+    __consuming get { 0 }
+  }
+}
+
+protocol Popping {
+    consuming func perform() // expected-error {{'consuming' is not yet valid on instance methods in a Copyable type}}
+    borrowing func doIt() // expected-error {{'borrowing' is not yet valid on instance methods in a Copyable type}}
+  mutating func change()
+  var ex: Int {
+    __consuming get
+  }
+}
+
+enum Exercising {
+    consuming func perform() {} // expected-error {{'consuming' is not yet valid on instance methods in a Copyable type}}
+    borrowing func doIt() {} // expected-error {{'borrowing' is not yet valid on instance methods in a Copyable type}}
+  mutating func change() {}
+  var ex: Int {
+    __consuming get { 0 }
+  }
+}