Add '@_requiresConcreteImplementation' and use it

include/swift/AST/Attr.def

@@ -552,6 +552,12 @@ DECL_ATTR(transpose, Transpose,
   ABIStableToAdd | ABIBreakingToRemove | APIStableToAdd | APIBreakingToRemove,
   99)
 
+SIMPLE_DECL_ATTR(_requiresConcreteImplementation, RequiresConcreteImplementation,
+  OnFunc | OnAccessor | OnVar | OnSubscript | OnConstructor |
+  LongAttribute | UserInaccessible | NotSerialized |
+  ABIStableToAdd | ABIStableToRemove | APIStableToAdd | APIStableToRemove,
+  100)
+
 #undef TYPE_ATTR
 #undef DECL_ATTR_ALIAS
 #undef CONTEXTUAL_DECL_ATTR_ALIAS

include/swift/AST/DiagnosticsSema.def

@@ -2116,8 +2116,8 @@ NOTE(declared_protocol_conformance_here,none,
      (Type, unsigned, DeclName, DeclName))
 
 ERROR(witness_unavailable,none,
-        "unavailable %0 %1 was used to satisfy a requirement of protocol %2",
-        (DescriptiveDeclKind, DeclName, DeclName))
+      "unavailable %0 %1 was used to satisfy a requirement of protocol %2",
+      (DescriptiveDeclKind, DeclName, DeclName))
 
 ERROR(redundant_conformance,none,
       "redundant conformance of %0 to protocol %1", (Type, DeclName))
@@ -2900,6 +2900,19 @@ ERROR(implements_attr_non_protocol_type,none,
 ERROR(implements_attr_protocol_not_conformed_to,none,
       "containing type %0 does not conform to protocol %1",
       (DeclName, DeclName))
+
+// @_requiresConcreteImplementation
+ERROR(requires_concrete_implementation_attr_wrong_decl_context,none,
+      "'@_requiresConcreteImplementation' can only be specified on protocol "
+      "requirements", ())
+ERROR(witness_must_be_concrete_implementation,none,
+      "protocol requirement marked '@_requiresConcreteImplementation' cannot "
+      "be satisfied by %0 %1 declared in protocol extension",
+      (DescriptiveDeclKind, DeclName))
+ERROR(override_not_requiring_concrete_implementation,none,
+      "override of protocol requirement marked "
+      "'@_requiresConcreteImplementation' should also be marked "
+      "'@_requiresConcreteImplementation'", ())
 
 // @differentiable
 ERROR(differentiable_attr_no_vjp_or_jvp_when_linear,none,

lib/Sema/TypeCheckAttr.cpp

@@ -254,6 +254,9 @@ class AttributeChecker : public AttributeVisitor<AttributeChecker> {
 
   void visitDifferentiableAttr(DifferentiableAttr *attr);
   void visitDerivativeAttr(DerivativeAttr *attr);
+
+  void visitRequiresConcreteImplementationAttr(
+                                     RequiresConcreteImplementationAttr *attr);
 };
 } // end anonymous namespace
 
@@ -4551,3 +4554,10 @@ void AttributeChecker::visitDerivativeAttr(DerivativeAttr *attr) {
   if (typeCheckDerivativeAttr(Ctx, D, attr))
     attr->setInvalid();
 }
+
+void AttributeChecker::visitRequiresConcreteImplementationAttr(
+                                     RequiresConcreteImplementationAttr *attr) {
+  if (!isa<ProtocolDecl>(D->getDeclContext()))
+    diagnoseAndRemoveAttr(attr,
+                diag::requires_concrete_implementation_attr_wrong_decl_context);
+}

lib/Sema/TypeCheckDeclOverride.cpp

@@ -1539,6 +1539,21 @@ namespace  {
         .fixItInsert(Base->getAttributeInsertionLoc(false),
                      "@objc ");
     }
+
+    void visitRequiresConcreteImplementationAttr(
+                                    RequiresConcreteImplementationAttr *attr) {
+      // Require '@_requiresConcreteImplementation' on the override if it was
+      // there on the base.
+      if (!Base->getAttrs().hasAttribute<RequiresConcreteImplementationAttr>())
+        return;
+
+      if (Override->getAttrs().hasAttribute<RequiresConcreteImplementationAttr>())
+        return;
+
+      Diags.diagnose(Override,
+                     diag::override_not_requiring_concrete_implementation);
+      Diags.diagnose(Base, diag::overridden_here);
+    }
   };
 } // end anonymous namespace
 

lib/Sema/TypeCheckProtocol.cpp

@@ -1377,6 +1377,13 @@ RequirementCheck WitnessChecker::checkWitness(ValueDecl *requirement,
     return CheckKind::WitnessUnavailable;
   }
 
+  // If a requirement has the @_requiresConcreteImplementation attribute, it
+  // cannot be satisfied by a default implementation in a protocol extension.
+  if (requirement->getAttrs().hasAttribute<RequiresConcreteImplementationAttr>()
+      && match.Witness->getDeclContext()->getExtendedProtocolDecl()) {
+    return CheckKind::RequiresConcreteImplementation;
+  }
+
   return CheckKind::Success;
 }
 
@@ -3433,8 +3440,7 @@ ConformanceChecker::resolveWitnessViaLookup(ValueDecl *requirement) {
 
     case CheckKind::WitnessUnavailable:
       diagnoseOrDefer(requirement, /*isError=*/true,
-        [witness, requirement](
-                                    NormalProtocolConformance *conformance) {
+        [witness, requirement](NormalProtocolConformance *conformance) {
           auto &diags = witness->getASTContext().Diags;
           SourceLoc diagLoc = getLocForDiagnosingWitness(conformance, witness);
           diags.diagnose(diagLoc,
@@ -3448,6 +3454,22 @@ ConformanceChecker::resolveWitnessViaLookup(ValueDecl *requirement) {
                          requirement->getFullName());
         });
       break;
+
+    case CheckKind::RequiresConcreteImplementation:
+      diagnoseOrDefer(requirement, /*isError=*/true,
+        [witness, requirement](NormalProtocolConformance *conformance) {
+          auto &diags = witness->getASTContext().Diags;
+          SourceLoc diagLoc = getLocForDiagnosingWitness(conformance, witness);
+          diags.diagnose(diagLoc,
+                         diag::witness_must_be_concrete_implementation,
+                         witness->getDescriptiveKind(),
+                         witness->getFullName());
+          emitDeclaredHereIfNeeded(diags, diagLoc, witness);
+          diags.diagnose(requirement, diag::kind_declname_declared_here,
+                         DescriptiveDeclKind::Requirement,
+                         requirement->getFullName());
+        });
+      break;
     }
 
     if (auto *classDecl = Adoptee->getClassOrBoundGenericClass()) {

lib/Sema/TypeCheckProtocol.h

@@ -278,6 +278,10 @@ enum class CheckKind : unsigned {
 
   /// The witness itself is inaccessible.
   WitnessUnavailable,
+
+  /// The requirement was marked '@_requiresConcreteImplementation', but the
+  /// witness is a default implementation in a protocol extension.
+  RequiresConcreteImplementation,
 };
 
 /// Describes an optional adjustment made to a witness.

lib/Serialization/DeclTypeRecordNodes.def

@@ -134,7 +134,7 @@ DECL(PRECEDENCE_GROUP)
 DECL(ACCESSOR)
 
 #ifndef DECL_ATTR
-#define DECL_ATTR(NAME, CLASS, OPTIONS, CODE) RECORD_VAL(CLASS##_DECL_ATTR, 100+CODE)
+#define DECL_ATTR(NAME, CLASS, OPTIONS, CODE) RECORD_VAL(CLASS##_DECL_ATTR, 90+CODE)
 #endif
 #include "swift/AST/Attr.def"
 

lib/Serialization/ModuleFormat.h

@@ -55,7 +55,7 @@ const uint16_t SWIFTMODULE_VERSION_MAJOR = 0;
 /// describe what change you made. The content of this comment isn't important;
 /// it just ensures a conflict if two people change the module format.
 /// Don't worry about adhering to the 80-column limit for this line.
-const uint16_t SWIFTMODULE_VERSION_MINOR = 546; // Avoid conflict with downstream bump
+const uint16_t SWIFTMODULE_VERSION_MINOR = 547; // Reorder DeclTypeRecordNodes.def
 
 /// A standard hash seed used for all string hashes in a serialized module.
 ///

stdlib/public/core/Random.swift

@@ -60,6 +60,7 @@ public protocol RandomNumberGenerator {
   /// method.
   ///
   /// - Returns: An unsigned 64-bit random value.
+  @_requiresConcreteImplementation
   mutating func next() -> UInt64
 }
 

test/attr/attr_requires_concrete_implementation.swift

@@ -0,0 +1,48 @@
+// RUN: %target-typecheck-verify-swift
+
+protocol P {
+  @_requiresConcreteImplementation
+  func f(_: Int) -> Bool // expected-note {{requirement 'f' declared here}}
+  // expected-note@-1 {{overridden declaration is here}}
+  func f<T: SignedInteger>(_: T) -> Bool
+
+  func g(_: Int) -> Bool
+}
+
+extension P {
+  func f<T: SignedInteger>(_ x: T) -> Bool { // expected-note {{'f' declared here}}
+    return f(Int(x))
+  }
+
+  func g(_ x: Int) -> Bool { // expected-note {{'g' declared here}}
+    return f(x)
+  }
+}
+
+protocol Q: P {
+  override func f(_: Int) -> Bool // expected-error {{override of protocol requirement marked '@_requiresConcreteImplementation' should also be marked }}
+}
+
+protocol R: P {
+  @_requiresConcreteImplementation
+  override func g(_: Int) -> Bool // expected-note {{requirement 'g' declared here}}
+}
+
+struct S: P { // expected-error {{type 'S' does not conform to protocol 'P'}}
+  // expected-error@-1 {{protocol requirement marked '@_requiresConcreteImplementation' cannot be satisfied }}
+}
+
+struct T: P, R { // expected-error {{type 'T' does not conform to protocol 'R'}}
+  // expected-error@-1 {{protocol requirement marked '@_requiresConcreteImplementation' cannot be satisfied }}
+  func f(_: Int) -> Bool { true }
+}
+
+struct U: R {
+  func f(_: Int) -> Bool { true }
+  func g(_: Int) -> Bool { false }
+}
+
+class C {
+  @_requiresConcreteImplementation // expected-error {{'@_requiresConcreteImplementation' can only be specified on protocol requirements}}
+  var x: Int = 42
+}