Generate the Copyable ProtocolDecl instead.

Pulling the explicit decl out the stdlib helps future-proof
us if we decide to define `Swift.Copyable` as some other
"thing" other than a protocol. Older compilers would only
end up emitting `~Swift.Copyable` in interfaces. Newer
compilers can interpret in a different way, such as a
layout constraint.

On the other side, if in the future we do end up writing
`Swift.Copyable` explicitly in the stdlib as a
ProtocolDecl, older compilers will pick-up that decl
instead of synthesizing their own.

Author: kavon

lib/AST/ASTContext.cpp

@@ -1227,6 +1227,7 @@ ProtocolDecl *ASTContext::getProtocol(KnownProtocolKind kind) const {
   case KnownProtocolKind::UnsafeCxxRandomAccessIterator:
     M = getLoadedModule(Id_Cxx);
     break;
+  case KnownProtocolKind::Copyable:
   default:
     M = getStdlibModule();
     break;
@@ -1246,6 +1247,27 @@ ProtocolDecl *ASTContext::getProtocol(KnownProtocolKind kind) const {
     }
   }
 
+  // Fall-back option upon look-up failure: synthesize the protocol decl.
+  if (kind == KnownProtocolKind::Copyable) {
+    assert(M->isStdlibModule());
+    auto *protocol = new(*this) ProtocolDecl(M->getDeclContext(),
+                                        SourceLoc(),
+                                        SourceLoc(),
+                                        getIdentifier("Copyable"),
+                                        /*AssociatedTypeNames*/{},
+                                        /*Inherited*/{},
+                                        /*TrailingWhere*/nullptr);
+    protocol->getAttrs().add(new(*this) MarkerAttr(/*IsImplicit*/true));
+    protocol->setImplicit(true);
+
+    // Save it!
+    getImpl().KnownProtocols[index] = protocol;
+
+    assert(protocol->isMarkerProtocol());
+    assert(protocol->isSpecificProtocol(KnownProtocolKind::Copyable));
+    return protocol;
+  }
+
   return nullptr;
 }
 

stdlib/public/core/CompilerProtocols.swift

@@ -973,18 +973,7 @@ public protocol _ExpressibleByFileReferenceLiteral {
 public protocol _DestructorSafeContainer {
 }
 
-/// This marker protocol describes the category of types that support implicit
-/// copying. By default, all types in Swift implicitly support copying and thus
-/// conformance to `Copyable` is implicitly synthesized. To suppress the
-/// implicit conformance synthesis, write `~Copyable` on the type declaration:
-///
-///     struct FileDescriptor: ~Copyable { /* ... */ }
-///
-/// The reading of this type declaration is "FileDescriptor suppresses implicit
-/// Copyable conformance".
-@_marker public protocol Copyable {}
-
 /// For older compilers interacting with newer stdlibs, define the unavailable
 /// `_Copyable` marker protocol that they expect to find.
 @available(*, unavailable)
-typealias _Copyable = Copyable
+@_marker public protocol _Copyable {}