Merge pull request #64059 from kavon/staging-bootstrap-with-copyable

Turn on the `Copyable` as an inferred generic constraint by default

Author: swift-ci

lib/AST/Module.cpp

@@ -1724,6 +1724,16 @@ LookupConformanceInModuleRequest::evaluate(
     return getBuiltinBuiltinTypeConformance(type, builtinType, protocol);
   }
 
+  // Specific handling of Copyable for pack expansions.
+  if (auto packExpansion = type->getAs<PackExpansionType>()) {
+    if (protocol->isSpecificProtocol(KnownProtocolKind::Copyable)) {
+      auto patternType = packExpansion->getPatternType();
+      return (patternType->isTypeParameter()
+               ? ProtocolConformanceRef(protocol)
+               : mod->lookupConformance(patternType, protocol));
+    }
+  }
+
   auto nominal = type->getAnyNominal();
 
   // If we don't have a nominal type, there are no conformances.
@@ -1768,9 +1778,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());
   }
 

lib/Sema/TypeCheckType.cpp

@@ -2301,7 +2301,6 @@ bool TypeResolver::diagnoseMoveOnlyMissingOwnership(
   diagnose(repr->getLoc(),
            diag::moveonly_parameter_missing_ownership);
 
-  // FIXME: this should be 'borrowing'
   diagnose(repr->getLoc(), diag::moveonly_parameter_ownership_suggestion,
            "borrowing", "for an immutable reference")
       .fixItInsert(repr->getStartLoc(), "borrowing ");
@@ -2310,7 +2309,6 @@ bool TypeResolver::diagnoseMoveOnlyMissingOwnership(
            "inout", "for a mutable reference")
       .fixItInsert(repr->getStartLoc(), "inout ");
 
-  // FIXME: this should be 'consuming'
   diagnose(repr->getLoc(), diag::moveonly_parameter_ownership_suggestion,
            "consuming", "to take the value from the caller")
       .fixItInsert(repr->getStartLoc(), "consuming ");

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/Constraints/rdar68155466.swift

@@ -9,7 +9,8 @@ import Foundation
   }
 }
 
-struct Loop< // expected-note {{required by generic struct 'Loop' where 'ID' = '() -> Int'}}
+// FIXME: the diagnostic below ideally should have been emitted (rdar://106241733)
+struct Loop< // note {{required by generic struct 'Loop' where 'ID' = '() -> Int'}}
   Data : RandomAccessCollection,
   ID : Hashable,
   Content
@@ -25,4 +26,5 @@ func data() -> [A] {
 }
 
 _ = Loop(data(), id: \.uniqueID) { $0 } // expected-error {{key path cannot refer to instance method 'uniqueID()'}}
-// expected-error@-1 {{type '() -> Int' cannot conform to 'Hashable'}} expected-note@-1 {{only concrete types such as structs, enums and classes can conform to protocols}}
+// FIXME: the diagnostics below ideally should have been emitted (rdar://106241733)
+// error@-1 {{type '() -> Int' cannot conform to 'Hashable'}} note@-1 {{only concrete types such as structs, enums and classes can conform to protocols}}