Revert "temporarily prevent Copyable types from using consuming and borrowing"

This reverts commit 8899d3b.

(cherry picked from commit 95cdf2a)

Author: gottesmm

lib/Sema/TypeCheckAttr.cpp

@@ -466,7 +466,7 @@ void AttributeChecker::visitMutationAttr(DeclAttribute *attr) {
   }
 
   auto DC = FD->getDeclContext();
-  // self-ownership attributes may only appear in type context.
+  // mutation attributes may only appear in type context.
   if (auto contextTy = DC->getDeclaredInterfaceType()) {
     // 'mutating' and 'nonmutating' are not valid on types
     // with reference semantics.
@@ -487,27 +487,6 @@ 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

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