revise how the Copyable constraint is added

The _Copyable constraint was implemented as a marker protocol.
That protocol is part of the KnownProtocol's in the compiler.
When `ASTContext::getProtocol(KnownProtocolKind kind)` tries
to find the ProtocolDecl for Copyable, it will look in the
stdlib module (i.e., Swift module), which is where I initially
planned to put it.

That created problems initially when some regression tests
use `-parse-stdlib` failed to do that protocol lookup, which is
essential for adding the constraint (given the current implementation).

That led to believe we need to pull Copyable out of the stdlib, but that's
wrong. In fact, when building the Swift module itself, we do `-parse-stdlib`
but we also include `-module-name Swift`. This causes the _Copyable protocol
defined in the Stdlib to be correctly discovered while building the stdlib
itself (see the test case in this commit). So, the only downside of
having the Copyable protocol in the Stdlib is that `-parse-stdlib` tests
in the compiler can't use move-only types correctly, as they'll be
allowed in generic contexts. No real program would build like this.

Until I have time to do a further refactoring, this is an acceptable trade-off.

fixes rdar://104898230

Author: kavon

lib/AST/Module.cpp

@@ -1768,9 +1768,12 @@ LookupConformanceInModuleRequest::evaluate(
       if (nominal->isMoveOnly()) {
         return ProtocolConformanceRef::forInvalid();
       } else {
-        // FIXME: this should probably follow the Sendable case in that
-        // we should synthesize and append a ProtocolConformance to the `conformances` list.
-       return ProtocolConformanceRef(protocol);
+        // Specifically do not create a concrete conformance to Copyable. At
+        // this stage, we don't even want Copyable to appear in swiftinterface
+        // files, which will happen for a marker protocol that's registered
+        // in a nominal type's conformance table. We can reconsider this
+        // decision later once there's a clearer picture of noncopyable generics
+        return ProtocolConformanceRef(protocol);
       }
     } else {
       // Was unable to infer the missing conformance.

lib/AST/ProtocolConformance.cpp

@@ -1241,11 +1241,6 @@ static SmallVector<ProtocolConformance *, 2> findSynthesizedConformances(
   // Concrete types may synthesize some conformances
   if (!isa<ProtocolDecl>(nominal)) {
     trySynthesize(KnownProtocolKind::Sendable);
-
-    // FIXME(kavon): make sure this conformance doesn't show up in swiftinterfaces
-    // before do this synthesis unconditionally.
-    if (dc->getASTContext().LangOpts.hasFeature(Feature::MoveOnly))
-      trySynthesize(KnownProtocolKind::Copyable);
   }
 
   /// Distributed actors can synthesize Encodable/Decodable, so look for those

lib/Sema/CSBindings.cpp

@@ -501,7 +501,19 @@ void BindingSet::finalize(
 
         if (TransitiveProtocols.has_value()) {
           for (auto *constraint : *TransitiveProtocols) {
-            auto protocolTy = constraint->getSecondType();
+            Type protocolTy = constraint->getSecondType();
+
+            // The Copyable protocol can't have members, yet will be a
+            // constraint of basically all type variables, so don't suggest it.
+            //
+            // NOTE: worth considering for all marker protocols, but keep in
+            // mind that you're allowed to extend them with members!
+            if (auto p = protocolTy->getAs<ProtocolType>()) {
+              if (ProtocolDecl *decl = p->getDecl())
+                if (decl->isSpecificProtocol(KnownProtocolKind::Copyable))
+                  continue;
+            }
+
             addBinding({protocolTy, AllowedBindingKind::Exact, constraint});
           }
         }

lib/Sema/ConstraintSystem.cpp

@@ -1828,17 +1828,12 @@ TypeVariableType *ConstraintSystem::openGenericParameter(
   assert(result.second);
   (void)result;
 
-  // When move-only types are available, add a constraint to force generic
-  // parameters to conform to a "Copyable" protocol.
-  if (getASTContext().LangOpts.hasFeature(Feature::MoveOnly)) {
-    ProtocolDecl *copyable = TypeChecker::getProtocol(
-        getASTContext(), SourceLoc(), KnownProtocolKind::Copyable);
-
-    // FIXME(kavon): there's a dependency ordering issues here with the
-    // protocol being defined in the stdlib, because when trying to build
-    // the stdlib itself, or a Swift program with -parse-stdlib, we can't
-    // load the protocol to add this constraint. (rdar://104898230)
-    assert(copyable && "stdlib is missing _Copyable protocol!");
+  // 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
+  // stdlib itself (which would have `-module-name Swift` too).
+  if (auto *copyable = TypeChecker::getProtocol(getASTContext(), SourceLoc(),
+                                                KnownProtocolKind::Copyable)) {
     addConstraint(
         ConstraintKind::ConformsTo, typeVar,
         copyable->getDeclaredInterfaceType(),

lib/Sema/TypeCheckProtocol.cpp

@@ -4618,7 +4618,7 @@ swift::checkTypeWitness(Type type, AssociatedTypeDecl *assocType,
   if (type->isPureMoveOnly()) {
     // describe the failure reason as it not conforming to Copyable
     auto *copyable = ctx.getProtocol(KnownProtocolKind::Copyable);
-    assert(copyable && "missing _Copyable from stdlib!");
+    assert(copyable && "missing _Copyable protocol!");
     return CheckTypeWitnessResult(copyable->getDeclaredInterfaceType());
   }
 

stdlib/public/core/Misc.swift

@@ -155,7 +155,9 @@ public func _unsafePerformance<T>(_ c: () -> T) -> T {
   return c()
 }
 
-
-/// This is not a protocol you can explicitly use in your programs.
-/// It exists for the compiler and type checker for diagnostic purposes.
-@_marker public protocol _Copyable { }
+/// This marker protocol represents types that support copying.
+/// This type is not yet available for use to express explicit
+/// constraints on generics in your programs. It is currently
+/// only used internally by the compiler.
+@available(*, unavailable)
+@_marker public protocol _Copyable {}

test/Concurrency/async_overload_filtering.swift

@@ -17,6 +17,7 @@ func filter_async(_: String) -> Void {}
 var a: String? = nil
 
 // CHECK: attempting disjunction choice $T0 bound to decl async_overload_filtering.(file).filter_async(fn2:)
+// CHECK-NEXT: added constraint: {{.*}} conforms to _Copyable
 // CHECK-NEXT: overload set choice binding $T0 := {{.*}}
 // CHECK-NEXT: (considering -> ({{.*}}) -> {{.*}} applicable fn {{.*}}
 // CHECK: increasing 'sync-in-asynchronous' score by 1

test/Constraints/moveonly_constraints.swift

@@ -150,7 +150,8 @@ func checkCasting(_ b: any Box, _ mo: __shared MO, _ a: Any) {
 
   let _: Sendable = (MO(), MO()) // expected-error {{move-only type '(MO, MO)' cannot be used with generics yet}}
   let _: Sendable = MO() // expected-error {{move-only type 'MO' cannot be used with generics yet}}
-  let _: _Copyable = mo // expected-error {{move-only type 'MO' cannot be used with generics yet}}
+  let _: _Copyable = mo // expected-error {{'_Copyable' is unavailable}}
+                        // expected-error@-1 {{move-only type 'MO' cannot be used with generics yet}}
   let _: AnyObject = MO() // expected-error {{move-only type 'MO' cannot be used with generics yet}}
   let _: Any = mo // expected-error {{move-only type 'MO' cannot be used with generics yet}}
 
@@ -163,8 +164,6 @@ func checkCasting(_ b: any Box, _ mo: __shared MO, _ a: Any) {
   _ = a as MO // expected-error {{cannot convert value of type 'Any' to type 'MO' in coercion}}
   _ = b as MO // expected-error {{cannot convert value of type 'any Box' to type 'MO' in coercion}}
 
-  // FIXME(kavon): make sure at runtime these casts actually fail, or just make them errors? (rdar://104900293)
-
   _ = MO() is AnyHashable // expected-warning {{cast from 'MO' to unrelated type 'AnyHashable' always fails}}
   // expected-error@-1 {{move-only types cannot be conditionally cast}}
   _ = MO() is AnyObject // expected-warning {{cast from 'MO' to unrelated type 'AnyObject' always fails}}

test/ModuleInterface/copyable.swift

@@ -0,0 +1,61 @@
+// RUN: %empty-directory(%t)
+
+// This test checks that conformances to _Copyable do not appear in swiftinterface files
+
+// Generate the parseable interface of the current file via the merge-modules step
+// RUN: %target-build-swift -emit-module -o %t/Test.swiftmodule -emit-module-interface-path %t/TestMerge.swiftinterface -module-name Test %s -enable-library-evolution -swift-version 5
+
+// Generate the parseable interface of the current file via a single frontend invocation
+// RUN: %target-swift-frontend -enable-library-evolution -typecheck -emit-module-interface-path %t/TestSingle.swiftinterface -module-name Test %s -enable-library-evolution -swift-version 5
+
+// Make sure Copyable doesn't appear anywhere in these files!
+// RUN: %FileCheck --implicit-check-not Copyable %s < %t/TestSingle.swiftinterface
+// RUN: %FileCheck --implicit-check-not Copyable %s < %t/TestMerge.swiftinterface
+
+
+// CHECK: forceGenericSubst
+public func forceGenericSubst<T>(_ t: T) {
+  print(t)
+}
+
+public protocol ProtocolWithAssocType {
+  associatedtype SomeType
+  func get() -> SomeType
+}
+
+public class BestClass: ProtocolWithAssocType {
+  public typealias SomeType = BestStruct
+  public func get() -> SomeType { return BestStruct() }
+}
+
+public struct BestStruct { let c = BestClass() }
+
+public enum BestEnum<T> {
+  case nothing
+  case something(T)
+}
+
+public func caller(_ c: BestClass, _ s: BestStruct, _ e: BestEnum<BestStruct>) {
+  forceGenericSubst(c)
+  forceGenericSubst(s)
+  forceGenericSubst(e)
+}
+
+public typealias TheTop = (Int, String)
+
+public struct S<T> {
+  let t: T
+  init(_ t: T) { self.t = t }
+}
+
+public typealias Handler = () -> ()
+
+public func genericFn<T>(_ t: T) -> S<T> {
+  return S(t)
+}
+
+public func maker(_ top: TheTop, withCompletion comp: @escaping Handler) -> S<TheTop> {
+  _ = genericFn(top)
+  _ = genericFn(comp)
+  return S(top)
+}

test/SILOptimizer/opaque_values_Onone_stdlib.swift

@@ -1,4 +1,4 @@
-// RUN: %target-swift-frontend -parse-stdlib -module-name Swift -enable-sil-opaque-values -parse-as-library -emit-sil -Onone %s | %FileCheck %s
+// RUN: %target-swift-frontend -enable-experimental-move-only -parse-stdlib -module-name Swift -enable-sil-opaque-values -parse-as-library -emit-sil -Onone %s | %FileCheck %s
 
 // Like opaque_values_Onone.swift but for code that needs to be compiled with 
 // -parse-stdlib.
@@ -10,6 +10,7 @@ precedencegroup AssignmentPrecedence { assignment: true }
 precedencegroup CastingPrecedence {}
 
 public protocol _ObjectiveCBridgeable {}
+@_marker public protocol _Copyable {}
 
 public protocol _ExpressibleByBuiltinBooleanLiteral {
   init(_builtinBooleanLiteral value: Builtin.Int1)
@@ -32,11 +33,10 @@ public func type<T, Metatype>(of value: T) -> Metatype
 class X {}
 func consume(_ x : __owned X) {}
 
-// FIXME: disabled temporarily until rdar://104898230 is resolved
-//func foo(@_noImplicitCopy _ x: __owned X) {
-//  consume(_copy(x))
-//  consume(x)
-//}
+func foo(@_noImplicitCopy _ x: __owned X) {
+  consume(_copy(x))
+  consume(x)
+}
 
 // CHECK-LABEL: sil [transparent] [_semantics "lifetimemanagement.copy"] @_copy : {{.*}} {
 // CHECK:       {{bb[0-9]+}}([[OUT_ADDR:%[^,]+]] : $*T, [[IN_ADDR:%[^,]+]] : $*T):