Sema: ban extensions of known marker protocols

There's no good reason to permit them. Conformances like Copyable and
Sendable are pervasive, so it's as though we are permitting extensions
of `Any`. Until there's a good argument in favor of such extensions,
remove the capability now.

Author: kavon

include/swift/AST/DiagnosticsSema.def

@@ -2537,8 +2537,8 @@ ERROR(invalid_nominal_extension,none,
       (Type, Type))
 NOTE(invalid_extension_rewrite,none,
      "did you mean to extend %0 instead?", (Type))
-ERROR(synthesized_nominal_extension,none,
-      "cannot extend synthesized type %0", (Type))
+ERROR(cannot_extend_nominal,none,
+      "cannot extend %kind0", (const NominalTypeDecl *))
 
 ERROR(retroactive_not_in_extension_inheritance_clause,none,
       "'retroactive' attribute only applies in inheritance clauses in "

lib/Sema/CSBindings.cpp

@@ -625,15 +625,11 @@ bool BindingSet::finalize(
           for (auto *constraint : *TransitiveProtocols) {
             Type protocolTy = constraint->getSecondType();
 
-            // The Copyable/Escapable protocols 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!
+            // Compiler-known marker protocols cannot be extended with members,
+            // so do not consider them.
             if (auto p = protocolTy->getAs<ProtocolType>()) {
               if (ProtocolDecl *decl = p->getDecl())
-                if (decl->isSpecificProtocol(KnownProtocolKind::Copyable) ||
-                    decl->isSpecificProtocol(KnownProtocolKind::Escapable))
+                if (decl->getKnownProtocolKind() && decl->isMarkerProtocol())
                   continue;
             }
 

lib/Sema/TypeCheckDeclPrimary.cpp

@@ -3676,6 +3676,16 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
     return true;
   }
 
+  /// Compiler-known marker protocols cannot be extended with members.
+  static void diagnoseExtensionOfMarkerProtocol(ExtensionDecl *ED) {
+    auto *nominal = ED->getExtendedNominal();
+    if (auto *proto = dyn_cast_or_null<ProtocolDecl>(nominal)) {
+      if (proto->getKnownProtocolKind() && proto->isMarkerProtocol()) {
+        ED->diagnose(diag::cannot_extend_nominal, nominal);
+      }
+    }
+  }
+
   static void checkTupleExtension(ExtensionDecl *ED) {
     auto *nominal = ED->getExtendedNominal();
     if (!nominal || !isa<BuiltinTupleDecl>(nominal))
@@ -3878,6 +3888,7 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
       TypeChecker::checkDistributedActor(SF, nominal);
 
     diagnoseIncompatibleProtocolsForMoveOnlyType(ED);
+    diagnoseExtensionOfMarkerProtocol(ED);
 
     checkTupleExtension(ED);
   }

test/Concurrency/sendable_objc_protocol_attr.swift

@@ -32,13 +32,11 @@ struct MyStruct: Sendable {
   let value: any MyObjCProtocol // Ok
 }
 
-extension Sendable {
-  func compute() {}
-}
+func compute<T: Sendable>(_ t: T) {}
 
 extension MyObjCProtocol {
   func test() {
-    compute() // Ok
+    compute(self) // Ok
   }
 }
 

test/Constraints/static_members_on_protocol_in_generic_context.swift

@@ -350,21 +350,16 @@ func test_leading_dot_syntax_with_typelias() {
   // expected-error@-1 {{generic parameter 'T' could not be inferred}}
 }
 
-extension Copyable where Self == Int {
-  static func answer() -> Int { 42 }
-}
+// User-defined marker protocols do gain the inference for members, since they
+// support extensions.
+@_marker protocol SomeMarkerProto {}
+extension Int: SomeMarkerProto {}
 
-extension Escapable where Self == String {
-  static func question() -> String { "" }
+extension SomeMarkerProto where Self == Int {
+  static func answer() -> Int { 42 }
 }
 
 do {
-  func testCopyable<T: Copyable>(_: T) {}
-  func testEscapable<T: Escapable>(_: T) {}
-
-  testCopyable(.answer())
-  // expected-error@-1 {{cannot infer contextual base in reference to member 'answer'}}
-
-  testEscapable(.question())
-  // expected-error@-1 {{cannot infer contextual base in reference to member 'question'}}
+  func testSomeMarkerProto<T: SomeMarkerProto>(_: T) {}
+  testSomeMarkerProto(.answer())
 }

test/Interpreter/protocol_extensions.swift

@@ -3,6 +3,7 @@
 
 import StdlibUnittest
 
+defer { runAllTests() }
 
 var ProtocolExtensionTestSuite = TestSuite("ProtocolExtensions")
 
@@ -363,4 +364,12 @@ ProtocolExtensionTestSuite.test("WitnessSelf") {
   }
 }
 
-runAllTests()
+@_marker protocol Addable {}
+extension Addable {
+    func increment(this x: Int) -> Int { return x + 100 }
+}
+extension String: Addable {}
+
+ProtocolExtensionTestSuite.test("MarkerProtocolExtensions") {
+    expectTrue("hello".increment(this: 11) == 111)
+}

test/Sema/copyable.swift

@@ -26,3 +26,7 @@ enum namespace {
 
   func Copyable() -> Copyable { return 0 }
 }
+
+extension Copyable { // expected-error {{cannot extend protocol 'Copyable'}}
+  func hello() {}
+}

test/Sema/moveonly_sendable.swift

@@ -150,19 +150,6 @@ func createContainer(_ fd: borrowing FileDescriptor) {
   let _: Container<Sendable> = Container(CopyableStruct())
 }
 
-func takeTwo<T: Sendable>(_ s1: T, _ s2: T) {}
-
-extension Sendable {
-  func doIllegalThings() {
-    return takeTwo(self, self)
-  }
-}
-
-func tryToDupe(_ fd: borrowing FileDescriptor) {
-  // FIXME: this should describe 'Self' as 'any Sendable' or something.
-  fd.doIllegalThings() // expected-error {{noncopyable type 'FileDescriptor' cannot be substituted for copyable generic parameter 'Self' in 'Sendable'}}
-}
-
 @_moveOnly
 struct PaperAirplaneFile {
   var fd: FileDescriptor

test/decl/ext/extensions.swift

@@ -393,3 +393,12 @@ extension B4 {
 // expected-error@-1 {{extension of existential type 'B4' (aka 'any P4') is not supported}}
 // expected-note@-2 {{did you mean to extend 'P4' instead?}} {{11-13=P4}}
 }
+
+
+extension Sendable {} // expected-error {{cannot extend protocol 'Sendable'}}
+extension Copyable {} // expected-error {{cannot extend protocol 'Copyable'}}
+extension Escapable {} // expected-error {{cannot extend protocol 'Escapable'}}
+extension _BitwiseCopyable {} // expected-error {{cannot extend protocol '_BitwiseCopyable'}}
+
+@_marker protocol MyMarkerProto {}
+extension MyMarkerProto {} // OK