[Runtime] Check function types against suppressible protocols

Form a set of suppressed protocols for a function type based on
the extended flags (where future compilers can start recording
suppressible protocols) and the existing "noescape" bit. Compare
that against the "ignored" suppressible protocol requirements, as we
do for other types.

This involves a behavior change if any client has managed to evade the
static checking for noescape function types, but it's unlikely that
existing code has done so (and it was unsafe anyway).

Author: DougGregor

include/swift/ABI/MetadataValues.h

@@ -25,6 +25,7 @@
 
 #include "swift/ABI/KeyPath.h"
 #include "swift/ABI/ProtocolDispatchStrategy.h"
+#include "swift/ABI/SuppressibleProtocols.h"
 
 // FIXME: this include shouldn't be here, but removing it causes symbol
 // mangling mismatches on Windows for some reason?
@@ -1198,6 +1199,10 @@ class TargetExtendedFunctionTypeFlags {
 
     // Values if we have a transferring result.
     HasTransferringResult  = 0x00000010U,
+
+    /// A SuppressibleProtocolSet in the high bits.
+    SuppressedProtocolShift = 16,
+    SuppressedProtocolMask = 0xFFFFU << SuppressedProtocolShift,
   };
   int_type Data;
 
@@ -1229,6 +1234,13 @@ class TargetExtendedFunctionTypeFlags {
         (newValue ? HasTransferringResult : 0));
   }
 
+  const TargetExtendedFunctionTypeFlags<int_type>
+  withSuppressedProtocols(SuppressibleProtocolSet suppressed) const {
+    return TargetExtendedFunctionTypeFlags<int_type>(
+        (Data & ~SuppressedProtocolMask) |
+        (suppressed.rawBits() << SuppressedProtocolShift));
+  }
+  
   bool isTypedThrows() const { return bool(Data & TypedThrowsMask); }
 
   bool isIsolatedAny() const {
@@ -1243,6 +1255,10 @@ class TargetExtendedFunctionTypeFlags {
     return Data;
   }
 
+  SuppressibleProtocolSet getSuppressedProtocols() const {
+    return SuppressibleProtocolSet(Data >> SuppressedProtocolShift);
+  }
+
   static TargetExtendedFunctionTypeFlags<int_type> fromIntValue(int_type Data) {
     return TargetExtendedFunctionTypeFlags(Data);
   }
@@ -2003,7 +2019,7 @@ class GenericContextDescriptorFlags {
 
   /// Whether this generic context has any conditional conformances to
   /// suppressed protocols, in which case the generic context will have a
-  /// trailing SuppressedProtocolSet and conditional requirements.
+  /// trailing SuppressibleProtocolSet and conditional requirements.
   constexpr bool hasConditionalSuppressedProtocols() const {
     return (Value & 0x2) != 0;
   }

include/swift/ABI/SuppressibleProtocols.h

@@ -19,6 +19,7 @@
 #define SWIFT_ABI_SUPPRESSIBLEPROTOCOLS_H
 
 #include <cstdint>
+#include <iterator>
 
 namespace swift {
 

lib/IRGen/MetadataRequest.cpp

@@ -1416,11 +1416,35 @@ getFunctionTypeFlags(CanFunctionType type) {
     break;
   }
 
+  // Compute the set of suppressed protocols.
+  SuppressibleProtocolSet suppressedProtocols;
+  for (auto suppressibleKind : SuppressibleProtocolSet::allKnown()) {
+    switch (suppressibleKind) {
+    case SuppressibleProtocolKind::Copyable: {
+      // If the function type is noncopyable, note that in the suppressed
+      // protocols.
+      auto proto =
+        type->getASTContext().getProtocol(KnownProtocolKind::Copyable);
+      if (proto &&
+          proto->getParentModule()->lookupConformance(type, proto).isInvalid())
+        suppressedProtocols.insert(suppressibleKind);
+      break;
+    }
+
+    case SuppressibleProtocolKind::Escapable:
+      // We intentionally do not record the "escapable" bit here, because it's
+      // already in the normal function type flags. The runtime will
+      // introduce it as necessary.
+      break;
+    }
+  }
+
   auto isolation = type->getIsolation();
 
   auto extFlags = ExtendedFunctionTypeFlags()
                       .withTypedThrows(!type->getThrownError().isNull())
-                      .withTransferringResult(type->hasTransferringResult());
+                      .withTransferringResult(type->hasTransferringResult())
+                      .withSuppressedProtocols(suppressedProtocols);
 
   if (isolation.isErased())
     extFlags = extFlags.withIsolatedAny();

stdlib/public/runtime/ProtocolConformance.cpp

@@ -1673,7 +1673,43 @@ checkSuppressibleRequirementsStructural(const Metadata *type,
   }
 
   case MetadataKind::Function: {
-    // FIXME: Implement me
+    auto functionMetadata = cast<FunctionTypeMetadata>(type);
+
+    // Determine the set of protocols that are suppressed by the function
+    // type.
+    SuppressibleProtocolSet suppressed;
+    if (functionMetadata->hasExtendedFlags()) {
+      suppressed = functionMetadata->getExtendedFlags()
+          .getSuppressedProtocols();
+    }
+
+    // Map the existing "noescape" bit as a suppressed protocol, when
+    // appropriate.
+    switch (functionMetadata->getConvention()) {
+    case FunctionMetadataConvention::Swift:
+      // Swift function types can be non-escaping, so honor the bit.
+      if (!functionMetadata->isEscaping())
+        suppressed.insert(SuppressibleProtocolKind::Escapable);
+      break;
+
+    case FunctionMetadataConvention::Block:
+      // Objective-C block types don't encode non-escaping-ness in metadata,
+      // so we assume that they are always escaping.
+      break;
+
+    case FunctionMetadataConvention::Thin:
+    case FunctionMetadataConvention::CFunctionPointer:
+      // Thin and C function pointers have no captures, so whether they
+      // escape is irrelevant.
+      break;
+    }
+
+    auto missing = suppressed - ignored;
+    if (!missing.empty()) {
+      return TYPE_LOOKUP_ERROR_FMT(
+          "function type missing suppressible protocols %x", missing.rawBits());
+    }
+
     return std::nullopt;
   }
 

test/Interpreter/escapable_generics_casting.swift

@@ -0,0 +1,50 @@
+// RUN: %target-run-simple-swift(-Xfrontend -sil-verify-all -enable-experimental-feature NoncopyableGenerics -enable-experimental-feature NonescapableTypes) | %FileCheck %s
+// RUN: %target-run-simple-swift(-O -Xfrontend -sil-verify-all -enable-experimental-feature NoncopyableGenerics -enable-experimental-feature NonescapableTypes) | %FileCheck %s
+
+// REQUIRES: executable_test, asserts
+
+protocol P {
+  func speak()
+}
+
+extension P {
+  func speak() { print("hello") }
+}
+
+struct Nonescapable: ~Escapable {}
+struct Ordinary {}
+
+struct Dog<T: ~Escapable>: Escapable {}
+extension Dog: P where T: Escapable {}
+
+func attemptCall(_ a: Any) {
+  if let value = a as? P {
+    value.speak()
+    return
+  }
+  print("failed to cast (attemptCall)")
+}
+
+defer { main({}) }
+func main(_ noEscapeFunc: () -> Void) {
+  // CHECK: hello
+  attemptCall(Dog<Ordinary>())
+
+  // CHECK: failed to cast (attemptCall)
+  attemptCall(Dog<Nonescapable>())
+
+  // CHECK: function types
+  print("function types")
+
+  // CHECK: hello
+  attemptCall(Dog<() -> Void>())
+
+  // CHECK: failed to cast (attemptCall)
+  func doFuncCall<F>(_: F.Type) {
+    attemptCall(Dog<F>())
+  }
+  // This is the mangled name for a non-escaping Swift function type.
+  let fnType = _typeByName("yyXE")!
+  _openExistential(fnType, do: doFuncCall)
+}
+

test/Interpreter/moveonly_generics_casting.swift

@@ -40,6 +40,15 @@ func attemptCall(_ a: Any) {
   print("failed to cast (attemptCall)")
 }
 
+@_silgen_name("swift_getExtendedFunctionTypeMetadata")
+func _getExtendedFunctionTypeMetadata(
+    flags: UInt, differentiabilityKind: UInt,
+    parameterTypes: UnsafePointer<Any.Type>?,
+    parameterFlags: UnsafePointer<UInt32>?,
+    resultType: Any.Type, globalActorType: Any.Type? = nil,
+    extendedFlags: UInt32, thrownErrorType: Any.Type? = nil) -> Any.Type
+
+
 defer { main() }
 func main() {
   // CHECK: hello
@@ -90,6 +99,22 @@ func main() {
 
   attemptCall(Dog<(Ordinary) -> Noncopyable>())
 
+  // This is a nonmovable function type, which cannot currently be
+  // expressed in the language.
+  let noncopyableFnType = _getExtendedFunctionTypeMetadata(
+    flags: 0x04000000 | 0x80000000,
+    differentiabilityKind: 0,
+    parameterTypes: nil,
+    parameterFlags: nil,
+    resultType: Void.self,
+    extendedFlags: 0x1 << 16)
+
+  // CHECK: failed to cast (attemptCall)
+  func doFuncCall<F>(_: F.Type) {
+    attemptCall(Dog<F>())
+  }
+  _openExistential(noncopyableFnType, do: doFuncCall)
+
   // CHECK: existential types
   print("existential types")