[wip] Copyable as a Requirement Against the Machine

Author: kavon

lib/AST/RequirementMachine/RequirementLowering.cpp

@@ -759,6 +759,20 @@ void swift::rewriting::realizeInheritedRequirements(
 
     realizeTypeRequirement(dc, type, inheritedType, loc, result, errors);
   }
+
+  // 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.
+    SmallVector<Requirement, 2> reqs;
+    Requirement sugaredReq(RequirementKind::Conformance, type, copyableType);
+    desugarRequirement(sugaredReq, loc, reqs, errors);
+    for (const auto &req : reqs)
+      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);
@@ -6158,6 +6172,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");
@@ -6171,9 +6186,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())) {
 
@@ -6182,27 +6199,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 be added as a Requirement.
+    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

@@ -1932,15 +1932,15 @@ TypeVariableType *ConstraintSystem::openGenericParameter(
   // 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
   // stdlib itself (which would have `-module-name Swift` too).
-  if (!outerDC->getParentModule()->isBuiltinModule()) {
-    if (auto *copyable = TypeChecker::getProtocol(getASTContext(), SourceLoc(),
-                                                  KnownProtocolKind::Copyable)) {
-      addConstraint(
-          ConstraintKind::ConformsTo, typeVar,
-          copyable->getDeclaredInterfaceType(),
-          locator.withPathElement(LocatorPathElt::GenericParameter(parameter)));
-    }
-  }
+//  if (!outerDC->getParentModule()->isBuiltinModule()) {
+//    if (auto *copyable = TypeChecker::getProtocol(getASTContext(), SourceLoc(),
+//                                                  KnownProtocolKind::Copyable)) {
+//      addConstraint(
+//          ConstraintKind::ConformsTo, typeVar,
+//          copyable->getDeclaredInterfaceType(),
+//          locator.withPathElement(LocatorPathElt::GenericParameter(parameter)));
+//    }
+//  }
 
   return typeVar;
 }

lib/Sema/TypeCheckDeclPrimary.cpp

@@ -1820,6 +1820,11 @@ static void checkProtocolRefinementRequirements(ProtocolDecl *proto) {
     if (otherProto == proto)
       continue;
 
+    // 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;
+
     // 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'