Merge pull request swiftlang#63564 from kavon/noncopyable-conformance-fixes

[move-only] fix conformance synthesis & conformances in extensions

Author: swift-ci

include/swift/AST/DiagnosticsSema.def

@@ -6855,12 +6855,9 @@ ERROR(moveonly_copyable_type_that_contains_moveonly_type, none,
 NOTE(moveonly_copyable_type_that_contains_moveonly_type_location, none,
      "contained move-only %0 '%1.%2'",
      (DescriptiveDeclKind, StringRef, StringRef))
-ERROR(moveonly_cannot_conform_to_protocol, none,
-     "move-only %0 %1 cannot conform yet to any protocols",
-     (DescriptiveDeclKind, DeclName))
-ERROR(moveonly_cannot_conform_to_protocol_with_name, none,
-     "move-only %0 %1 cannot conform to protocol %2",
-     (DescriptiveDeclKind, DeclName, DeclName))
+ERROR(moveonly_cannot_conform_to_type, none,
+     "move-only %0 %1 cannot conform to %2",
+     (DescriptiveDeclKind, DeclName, Type))
 ERROR(moveonly_non_final_class_cannot_contain_moveonly_field, none,
      "non-final classes containing move only fields is not yet supported", ())
 

lib/AST/ProtocolConformance.cpp

@@ -1056,6 +1056,13 @@ void NominalTypeDecl::prepareConformanceTable() const {
     if (!proto)
       return;
 
+    // No synthesized conformances for move-only nominals.
+    if (isMoveOnly()) {
+      // assumption is Sendable gets synthesized elsewhere.
+      assert(!proto->isSpecificProtocol(KnownProtocolKind::Sendable));
+      return;
+    }
+
     if (protocols.count(proto) == 0) {
       ConformanceTable->addSynthesizedConformance(
           mutableThis, proto, mutableThis);

lib/Sema/TypeCheckDeclPrimary.cpp

@@ -2586,7 +2586,7 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
 
     // FIXME(kavon): see if these can be integrated into other parts of Sema
     diagnoseCopyableTypeContainingMoveOnlyType(ED);
-    diagnoseMoveOnlyNominalDeclDoesntConformToProtocols(ED);
+    diagnoseIncompatibleProtocolsForMoveOnlyType(ED);
 
     checkExplicitAvailability(ED);
 
@@ -2645,7 +2645,7 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
     // are not move only.
     diagnoseCopyableTypeContainingMoveOnlyType(SD);
 
-    diagnoseMoveOnlyNominalDeclDoesntConformToProtocols(SD);
+    diagnoseIncompatibleProtocolsForMoveOnlyType(SD);
   }
 
   /// Check whether the given properties can be @NSManaged in this class.
@@ -2747,21 +2747,53 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
     }
   }
 
-  void diagnoseMoveOnlyNominalDeclDoesntConformToProtocols(
-      NominalTypeDecl *nomDecl) {
-    if (!nomDecl->isMoveOnly())
-      return;
+  /// check to see if a move-only type can ever conform to the given type.
+  /// \returns true iff a diagnostic was emitted because it was not compatible
+  static bool diagnoseIncompatibleWithMoveOnlyType(SourceLoc loc,
+                                                 NominalTypeDecl *moveonlyType,
+                                                 Type type) {
+    assert(type && "got an empty type?");
+    assert(moveonlyType->isMoveOnly());
 
-    for (auto *prot : nomDecl->getLocalProtocols()) {
+    auto canType = type->getCanonicalType();
+    if (auto prot = canType->getAs<ProtocolType>()) {
       // Permit conformance to marker protocol Sendable.
-      if (prot->isSpecificProtocol(KnownProtocolKind::Sendable)) {
-        assert(prot->isMarkerProtocol());
-        continue;
+      if (prot->getDecl()->isSpecificProtocol(KnownProtocolKind::Sendable)) {
+        assert(prot->getDecl()->isMarkerProtocol());
+        return false;
       }
+    }
 
-      nomDecl->diagnose(diag::moveonly_cannot_conform_to_protocol_with_name,
-                        nomDecl->getDescriptiveKind(),
-                        nomDecl->getBaseName(), prot->getBaseName());
+    auto &ctx = moveonlyType->getASTContext();
+    ctx.Diags.diagnose(loc,
+                       diag::moveonly_cannot_conform_to_type,
+                       moveonlyType->getDescriptiveKind(),
+                       moveonlyType->getBaseName(),
+                       type);
+    return true;
+  }
+
+  static void diagnoseIncompatibleProtocolsForMoveOnlyType(Decl *decl) {
+    if (auto *nomDecl = dyn_cast<NominalTypeDecl>(decl)) {
+      if (!nomDecl->isMoveOnly())
+        return;
+
+      // go over the all protocols directly conformed-to by this nominal
+      for (auto *prot : nomDecl->getLocalProtocols())
+        diagnoseIncompatibleWithMoveOnlyType(nomDecl->getLoc(), nomDecl,
+                                             prot->getDeclaredInterfaceType());
+
+    } else if (auto *extension = dyn_cast<ExtensionDecl>(decl)) {
+      if (auto *nomDecl = extension->getExtendedNominal()) {
+        if (!nomDecl->isMoveOnly())
+          return;
+
+        // go over the all types directly conformed-to by the extension
+        for (auto entry : extension->getInherited()) {
+          diagnoseIncompatibleWithMoveOnlyType(extension->getLoc(), nomDecl,
+                                               entry.getType());
+        }
+      }
     }
   }
 
@@ -2928,7 +2960,7 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
 
     maybeDiagnoseClassWithoutInitializers(CD);
 
-    diagnoseMoveOnlyNominalDeclDoesntConformToProtocols(CD);
+    diagnoseIncompatibleProtocolsForMoveOnlyType(CD);
 
     // Ban non-final classes from having move only fields.
     if (!CD->isFinal()) {
@@ -3404,11 +3436,7 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
     if (nominal->isDistributedActor())
       TypeChecker::checkDistributedActor(SF, nominal);
 
-    // If we have a move only type and allow it to extend any protocol, error.
-    if (nominal->isMoveOnly() && ED->getInherited().size()) {
-      ED->diagnose(diag::moveonly_cannot_conform_to_protocol,
-                   nominal->getDescriptiveKind(), nominal->getBaseName());
-    }
+    diagnoseIncompatibleProtocolsForMoveOnlyType(ED);
 
     TypeChecker::checkReflectionMetadataAttributes(ED);
   }

test/Sema/copyable.swift

@@ -5,4 +5,4 @@ struct S: P {}
 
 class C: _Copyable {}
 
-@_moveOnly struct MOStruct: _Copyable {} // expected-error {{move-only struct 'MOStruct' cannot conform to protocol '_Copyable'}}
+@_moveOnly struct MOStruct: _Copyable {} // expected-error {{move-only struct 'MOStruct' cannot conform to '_Copyable'}}

test/Sema/moveonly_restrictions.swift

@@ -141,15 +141,32 @@ struct UnsafePointerWithOwner<T> {
 // Make sure we error whenever we attempt to conform a move only type to a
 // protocol.
 protocol P {}
+protocol Q {}
 @_moveOnly class ProtocolCheckMoveOnlyKlass {}
 @_moveOnly struct ProtocolCheckMoveOnlyStruct {
     var k: MoveOnlyKlass
 }
 @_moveOnly enum ProtocolCheckMoveOnlyEnum {}
 
-extension ProtocolCheckMoveOnlyKlass : P {} // expected-error {{move-only class 'ProtocolCheckMoveOnlyKlass' cannot conform yet to any protocols}}
-extension ProtocolCheckMoveOnlyStruct : P {} // expected-error {{move-only struct 'ProtocolCheckMoveOnlyStruct' cannot conform yet to any protocols}}
-extension ProtocolCheckMoveOnlyEnum : P {} // expected-error {{move-only enum 'ProtocolCheckMoveOnlyEnum' cannot conform yet to any protocols}}
+extension ProtocolCheckMoveOnlyKlass : P {} // expected-error {{move-only class 'ProtocolCheckMoveOnlyKlass' cannot conform to 'P'}}
+extension ProtocolCheckMoveOnlyStruct : P, Q {}
+// expected-error@-1 {{move-only struct 'ProtocolCheckMoveOnlyStruct' cannot conform to 'P'}}
+// expected-error@-2 {{move-only struct 'ProtocolCheckMoveOnlyStruct' cannot conform to 'Q'}}
+// expected-note@-3 {{'ProtocolCheckMoveOnlyStruct' declares conformance to protocol 'P' here}}
+
+extension ProtocolCheckMoveOnlyStruct: P {}
+// expected-error@-1 {{redundant conformance of 'ProtocolCheckMoveOnlyStruct' to protocol 'P'}}
+// expected-error@-2 {{move-only struct 'ProtocolCheckMoveOnlyStruct' cannot conform to 'P'}}
+
+extension ProtocolCheckMoveOnlyEnum : P & Q, Sendable {}
+// expected-error@-1 {{move-only enum 'ProtocolCheckMoveOnlyEnum' cannot conform to 'P & Q'}}
+
+extension ProtocolCheckMoveOnlyEnum : Any {}
+// expected-error@-1 {{move-only enum 'ProtocolCheckMoveOnlyEnum' cannot conform to 'Any'}}
+
+extension ProtocolCheckMoveOnlyEnum : AnyHashable {}
+// expected-error@-1 {{move-only enum 'ProtocolCheckMoveOnlyEnum' cannot conform to 'AnyHashable'}}
+// expected-error@-2 {{inheritance from non-protocol type 'AnyHashable'}}
 
 // But a normal extension is ok.
 extension ProtocolCheckMoveOnlyKlass {}
@@ -158,10 +175,40 @@ extension ProtocolCheckMoveOnlyEnum {}
 
 // Check if we define a move only type and make it conform on the base type
 @_moveOnly
-class MoveOnlyKlassP : P {} // expected-error {{move-only class 'MoveOnlyKlassP' cannot conform to protocol 'P'}}
+class MoveOnlyKlassP : P {} // expected-error {{move-only class 'MoveOnlyKlassP' cannot conform to 'P'}}
 @_moveOnly
-struct MoveOnlyStructP : P { // expected-error {{move-only struct 'MoveOnlyStructP' cannot conform to protocol 'P'}}
+struct MoveOnlyStructP : P { // expected-error {{move-only struct 'MoveOnlyStructP' cannot conform to 'P'}}
     var mv: MoveOnlyKlass
 }
 @_moveOnly
-enum MoveOnlyEnumP : P {} // expected-error {{move-only enum 'MoveOnlyEnumP' cannot conform to protocol 'P'}}
+enum MoveOnlyEnumP : P {} // expected-error {{move-only enum 'MoveOnlyEnumP' cannot conform to 'P'}}
+
+// ensure there is no auto-synthesis of Equatable, Hashable, etc, for this move-only enum,
+// because it normally would be synthesized since it only has cases without associated values.
+@_moveOnly
+enum Color {
+    case red
+    case green
+    case blue
+
+    static func same(_ c1: __shared Color, c2: __shared Color) -> Bool {
+        return c1 == c2
+        // expected-error@-1 {{binary operator '==' cannot be applied to two 'Color' operands}}
+    }
+}
+
+@_moveOnly
+enum StrengthLevel: Int { // ensure move-only raw enums do not conform to RawRepresentable
+    case none = 0
+    case low
+    case high
+
+    static func lowEnergy() {
+        _ = StrengthLevel(rawValue: 1)
+        // expected-error@-1 {{'StrengthLevel' cannot be constructed because it has no accessible initializers}}
+    }
+}
+
+
+
+

test/Sema/moveonly_sendable.swift

@@ -161,3 +161,10 @@ extension Sendable {
 func tryToDupe(_ fd: FileDescriptor) {
   fd.doIllegalThings() // expected-error {{move-only type 'FileDescriptor' cannot be used with generics yet}}
 }
+
+@_moveOnly
+struct PaperAirplaneFile {
+  var fd: FileDescriptor
+}
+
+extension PaperAirplaneFile: Sendable {}