_Copyable as a Requirement Against the Machine

An initial implementation of a rework in how
we prevent noncopyable types from being
substituted in places they are not permitted.

Instead of generating a constraint for every
generic parameter in the solver, we produce
real Copyable conformance requirements. This
is much better for our longer-term goal of
supporting `~Copyable` in more places.

Author: kavon

include/swift/Basic/Features.def

@@ -235,6 +235,9 @@ EXPERIMENTAL_FEATURE(RawLayout, true)
 /// Enables the "embedded" swift mode (no runtime).
 EXPERIMENTAL_FEATURE(Embedded, true)
 
+/// Enables noncopyable generics
+EXPERIMENTAL_FEATURE(NoncopyableGenerics, false)
+
 #undef EXPERIMENTAL_FEATURE_EXCLUDED_FROM_MODULE_INTERFACE
 #undef EXPERIMENTAL_FEATURE
 #undef UPCOMING_FEATURE

lib/AST/ASTPrinter.cpp

@@ -1,4 +1,3 @@
-//===--- ASTPrinter.cpp - Swift Language AST Printer ----------------------===//
 //
 // This source file is part of the Swift.org open source project
 //
@@ -3385,6 +3384,12 @@ static bool usesFeatureMoveOnlyPartialConsumption(Decl *decl) {
   return false;
 }
 
+static bool usesFeatureNoncopyableGenerics(Decl *decl) {
+  // FIXME: need to look for suppressed entries on generic parameters or
+  // inheritance clauses!
+  return false;
+}
+
 static bool usesFeatureOneWayClosureParameters(Decl *decl) {
   return false;
 }

lib/AST/RequirementMachine/RequirementLowering.cpp

@@ -756,6 +756,21 @@ void swift::rewriting::realizeInheritedRequirements(
 
     realizeTypeRequirement(dc, type, inheritedType, loc, result, errors);
   }
+
+  auto &ctx = dc->getASTContext();
+  if (ctx.LangOpts.hasFeature(Feature::NoncopyableGenerics)) {
+    // All associated types or generic type params are Copyable by default.
+    // TODO: if we saw ~Copyable in the inherited types list earlier, skip this!
+
+    if (auto *copyable = ctx.getProtocol(KnownProtocolKind::Copyable)) {
+      SourceLoc loc = decl->getLoc();
+      Type copyableType = copyable->getDeclaredInterfaceType();
+
+      // Add Copyable as an "inferred" requirement.
+      Requirement req(RequirementKind::Conformance, type, copyableType);
+      result.push_back({req, loc, /*wasInferred=*/true});
+    }
+  }
 }
 
 /// StructuralRequirementsRequest realizes all the user-written requirements

lib/Sema/CSDiagnostics.cpp

@@ -616,6 +616,20 @@ bool MissingConformanceFailure::diagnoseAsError() {
   if (diagnoseAsAmbiguousOperatorRef())
     return true;
 
+  // Use tailored diagnostics for failure to conform to Copyable.
+  if (auto asProtoType = protocolType->getAs<ProtocolType>()) {
+    if (auto *protoDecl = asProtoType->getDecl()) {
+      if (protoDecl->isSpecificProtocol(KnownProtocolKind::Copyable)) {
+        NotCopyableFailure failure(getSolution(),
+                                   nonConformingType,
+                                   NoncopyableMatchFailure::forCopyableConstraint(),
+                                   getLocator());
+        if (failure.diagnoseAsError())
+          return true;
+      }
+    }
+  }
+
   if (nonConformingType->isObjCExistentialType()) {
     emitDiagnostic(diag::protocol_does_not_conform_static, nonConformingType,
                    protocolType);
@@ -6167,6 +6181,7 @@ bool NotCopyableFailure::diagnoseAsError() {
 
   case NoncopyableMatchFailure::CopyableConstraint: {
     auto *loc = getLocator();
+    auto path = loc->getPath();
 
     if (loc->isLastElement<LocatorPathElt::AnyTupleElement>()) {
       assert(!noncopyableTy->is<TupleType>() && "will use poor wording");
@@ -6180,9 +6195,11 @@ bool NotCopyableFailure::diagnoseAsError() {
       return true;
     }
 
-    // a bit paranoid of nulls and such...
-    if (auto *genericParam = loc->getGenericParameter()) {
-      if (auto *paramDecl = genericParam->getDecl()) {
+    auto diagnoseGenericTypeParamType = [&](GenericTypeParamType *typeParam) {
+      if (!typeParam)
+        return false;
+
+      if (auto *paramDecl = typeParam->getDecl()) {
         if (auto *owningDecl =
             dyn_cast_or_null<ValueDecl>(paramDecl->getDeclContext()->getAsDecl())) {
 
@@ -6191,27 +6208,45 @@ bool NotCopyableFailure::diagnoseAsError() {
             emitDiagnostic(diag::noncopyable_generics_generic_param_metatype,
                            noncopyableTy->getMetatypeInstanceType(),
                            paramDecl->getDescriptiveKind(),
-                           genericParam,
+                           typeParam,
                            owningDecl->getName(),
                            noncopyableTy);
           else
             emitDiagnostic(diag::noncopyable_generics_generic_param,
                            noncopyableTy,
                            paramDecl->getDescriptiveKind(),
-                           genericParam,
+                           typeParam,
                            owningDecl->getName());
 
           // If we have a location for the parameter, point it out in a note.
           if (auto loc = paramDecl->getNameLoc()) {
             emitDiagnosticAt(loc,
                              diag::noncopyable_generics_implicit_copyable,
                              paramDecl->getDescriptiveKind(),
-                             genericParam);
+                             typeParam);
           }
 
           return true;
         }
       }
+      return false;
+    };
+
+    // NOTE: a non-requirement constraint locator might now be impossible after
+    // having made Copyable a Requirement in Feature::NoncopyableGenerics
+    if (diagnoseGenericTypeParamType(loc->getGenericParameter()))
+      return true;
+
+    if (auto tpr =
+        loc->getLastElementAs<LocatorPathElt::TypeParameterRequirement>()) {
+      auto signature = path[path.size() - 2]
+          .castTo<LocatorPathElt::OpenedGeneric>()
+          .getSignature();
+      auto requirement = signature.getRequirements()[tpr->getIndex()];
+      auto subject = requirement.getFirstType();
+
+      if (diagnoseGenericTypeParamType(subject->getAs<GenericTypeParamType>()))
+        return true;
     }
     break;
   }

lib/Sema/ConstraintSystem.cpp

@@ -1928,6 +1928,10 @@ TypeVariableType *ConstraintSystem::openGenericParameter(
   assert(result.second);
   (void)result;
 
+  if (Context.LangOpts.hasFeature(Feature::NoncopyableGenerics)) {
+    return typeVar;
+  }
+
   // Add a constraint that generic parameters conform to Copyable.
   // This lookup only can fail if the stdlib (i.e. the Swift module) has not
   // been loaded because you've passed `-parse-stdlib` and are not building the

lib/Sema/TypeCheckDeclPrimary.cpp

@@ -1811,12 +1811,23 @@ static void diagnoseWrittenPlaceholderTypes(ASTContext &Ctx,
 static void checkProtocolRefinementRequirements(ProtocolDecl *proto) {
   auto requiredProtos = proto->getGenericSignature()->getRequiredProtocols(
       proto->getSelfInterfaceType());
+  const bool enabledNoncopyableGenerics =
+      proto->getASTContext().LangOpts.hasFeature(Feature::NoncopyableGenerics);
 
   for (auto *otherProto : requiredProtos) {
     // Every protocol 'P' has an implied requirement 'Self : P'; skip it.
     if (otherProto == proto)
       continue;
 
+    if (enabledNoncopyableGenerics) {
+      // For any protocol 'P', there is an implied requirement 'Self: Copyable',
+      // unless it was suppressed via `Self: ~Copyable`; so skip if present.
+      if (otherProto->isSpecificProtocol(KnownProtocolKind::Copyable))
+        continue;
+
+      // TODO: report that something implied Copyable despite writing ~Copyable
+    }
+
     // GenericSignature::getRequiredProtocols() canonicalizes the protocol
     // list by dropping protocols that are inherited by other protocols in
     // the list. Any protocols that remain in the list other than 'proto'

lib/Sema/TypeCheckType.cpp

@@ -1015,6 +1015,10 @@ static bool didDiagnoseMoveOnlyGenericArgs(ASTContext &ctx,
                                          SourceLoc loc,
                                          Type unboundTy,
                                          ArrayRef<Type> genericArgs) {
+
+  if (ctx.LangOpts.hasFeature(Feature::NoncopyableGenerics))
+    return false;
+
   bool didEmitDiag = false;
   for (auto t: genericArgs) {
     if (!t->isPureMoveOnly())
@@ -2294,6 +2298,9 @@ bool TypeResolver::diagnoseInvalidPlaceHolder(OpaqueReturnTypeRepr *repr) {
 bool TypeResolver::diagnoseMoveOnlyGeneric(TypeRepr *repr,
                                            Type unboundTy,
                                            Type genericArgTy) {
+  if (getASTContext().LangOpts.hasFeature(Feature::NoncopyableGenerics))
+    return false;
+
   if (genericArgTy->isPureMoveOnly()) {
     if (unboundTy) {
       diagnoseInvalid(repr, repr->getLoc(), diag::noncopyable_generics_specific,