Fix substitutions for generic requirements

Author: DougGregor

lib/Sema/TypeCheckProtocol.cpp

@@ -2582,10 +2582,7 @@ checkIndividualConformance(NormalProtocolConformance *conformance) {
       // unsafe, then the conformance must be unsafe.
       if (auto witness = conformance->getWitnessUncached(valueRequirement)) {
         if (isUnsafe(witness.getDeclRef()) &&
-            !isUnsafe(
-                ConcreteDeclRef(
-                  valueRequirement,
-                  witness.getRequirementToWitnessThunkSubs()))) {
+            !isUnsafeInConformance(valueRequirement, witness, conformance)) {
           unsafeUses.push_back(
               UnsafeUse::forWitness(
                 witness.getDecl(), requirement, conformance));

lib/Sema/TypeCheckUnsafe.cpp

@@ -300,3 +300,21 @@ bool swift::isUnsafe(ConcreteDeclRef declRef) {
 
   return false;
 }
+
+bool swift::isUnsafeInConformance(const ValueDecl *requirement,
+                                  const Witness &witness,
+                                  NormalProtocolConformance *conformance) {
+  if (requirement->isUnsafe())
+    return true;
+
+  Type requirementType = requirement->getInterfaceType();
+  Type requirementTypeInContext;
+  auto requirementSubs = witness.getRequirementToWitnessThunkSubs();
+  if (auto genericFnType = requirementType->getAs<GenericFunctionType>()) {
+    requirementTypeInContext =
+        genericFnType->substGenericArgs(requirementSubs);
+  } else {
+    requirementTypeInContext = requirementType.subst(requirementSubs);
+  }
+  return requirementTypeInContext->isUnsafe();
+}

lib/Sema/TypeCheckUnsafe.h

@@ -17,6 +17,8 @@
 
 namespace swift {
 
+class Witness;
+
 /// Diagnose the given unsafe use right now.
 void diagnoseUnsafeUse(const UnsafeUse &use, bool asNote = false);
 
@@ -28,6 +30,11 @@ void diagnoseUnsafeUsesIn(const Decl *decl);
 /// either explicitly (@unsafe) or because it references an unsafe type.
 bool isUnsafe(ConcreteDeclRef declRef);
 
+/// Whether the given requirement should be considered unsafe for the given
+/// conformance.
+bool isUnsafeInConformance(const ValueDecl *requirement,
+                           const Witness &witness,
+                           NormalProtocolConformance *conformance);
 }
 
 #endif // SWIFT_SEMA_TYPE_CHECK_UNSAFE_H

test/Unsafe/unsafe.swift

@@ -53,6 +53,18 @@ extension ConformsToMultiP: MultiP {
   @unsafe func f() -> UnsafeSuper { .init() }
 }
 
+protocol GenericP {
+  associatedtype Ptr
+
+  func f<T>(_: T, _: Ptr)
+}
+
+// expected-warning@+1{{conformance of 'ConformsToGenericP' to protocol 'GenericP' involves unsafe code; use '@unsafe' to indicate that the conformance is not memory-safe}}
+struct ConformsToGenericP: GenericP {
+  typealias Ptr = Int
+  @unsafe func f<T>(_: T, _: Ptr) { } // expected-note{{unsafe instance method 'f' cannot satisfy safe requirement}}
+}
+
 // -----------------------------------------------------------------------
 // Overrides
 // -----------------------------------------------------------------------