[CSSimplify] Extend any Sendable -> Any conversion support to function argument/result positions in generic argument context

Author: xedin

include/swift/AST/Types.h

@@ -675,6 +675,9 @@ class alignas(1 << TypeAlignInBits) TypeBase
   /// Is this an existential containing only marker protocols?
   bool isMarkerExistential();
 
+  /// Is this `any Sendable` type?
+  bool isSendableExistential();
+
   bool isPlaceholder();
 
   /// Returns true if this contextual type does not satisfy a conformance to

lib/AST/Type.cpp

@@ -163,6 +163,17 @@ bool TypeBase::isMarkerExistential() {
   return true;
 }
 
+bool TypeBase::isSendableExistential() {
+  Type constraint = this;
+  if (auto existential = constraint->getAs<ExistentialType>())
+    constraint = existential->getConstraintType();
+
+  if (!constraint->isConstraintType())
+    return false;
+
+  return constraint->getKnownProtocol() == KnownProtocolKind::Sendable;
+}
+
 bool TypeBase::isPlaceholder() {
   return is<PlaceholderType>();
 }

lib/Sema/CSSimplify.cpp

@@ -3670,14 +3670,69 @@ static ConstraintSystem::TypeMatchResult matchDeepTypeArguments(
 /// Note that it's currently impossible to figure out precisely
 /// where `any Sendable` type came from.
 static bool matchSendableExistentialToAnyInGenericArgumentPosition(
-    ConstraintSystem &cs, ConstraintLocatorBuilder locator) {
+    ConstraintSystem &cs, Type lhs, Type rhs,
+    ConstraintLocatorBuilder locator) {
   auto &ctx = cs.getASTContext();
   if (ctx.isSwiftVersionAtLeast(6) ||
       ctx.LangOpts.StrictConcurrencyLevel == StrictConcurrency::Complete)
     return false;
 
+  // Avoid heavier checks if are not `any Sendable` and `Any`.
+  if (!(lhs->isSendableExistential() || lhs->isAny()) ||
+      !(rhs->isSendableExistential() || rhs->isAny()))
+    return false;
+
   auto last = locator.last();
-  if (!last || !last->is<LocatorPathElt::GenericArgument>())
+  // `any Sendable` -> `Any` conversion is allowed for generic arguments
+  // and for function argument/result positions if generic argument is
+  // bound to a function type.
+  if (!last || !(last->is<LocatorPathElt::GenericArgument>() ||
+                 last->is<LocatorPathElt::FunctionArgument>() ||
+                 last->is<LocatorPathElt::FunctionResult>()))
+    return false;
+
+  SmallVector<LocatorPathElt, 4> path;
+  auto anchor = locator.getLocatorParts(path);
+
+  {
+    std::optional<unsigned> dropFromIdx;
+    bool inGenericArgumentContext = false;
+
+    for (unsigned i = 0, n = path.size(); i < n; ++i) {
+      const auto &elt = path[i];
+      if (elt.is<LocatorPathElt::GenericType>()) {
+        if (!dropFromIdx)
+          dropFromIdx = i;
+        continue;
+      }
+
+      if (elt.is<LocatorPathElt::GenericArgument>()) {
+        inGenericArgumentContext = true;
+        continue;
+      }
+
+      // For example: `[(any Sendable) -> Void]` -> `[(Any) -> Void]`
+      if (elt.is<LocatorPathElt::FunctionArgument>()) {
+        if (inGenericArgumentContext) {
+          // `matchFunctionTypes` accounts for contravariance even under
+          // equality constraint (because it shouldn't matter), but it does
+          // in this case.
+          std::swap(lhs, rhs);
+        }
+      }
+    }
+
+    // If we are not in generic argument context,
+    // this conversion don't apply.
+    if (!inGenericArgumentContext || !dropFromIdx)
+      return false;
+
+    // Drop all of the elements that would get in a way of
+    // finding the underlying declaration reference first.
+    path.pop_back_n(path.size() - *dropFromIdx);
+  }
+
+  if (!(lhs->isSendableExistential() && rhs->isAny()))
     return false;
 
   std::function<bool(ConstraintLocator *)> isPreconcurrencyContext =
@@ -3707,21 +3762,6 @@ static bool matchSendableExistentialToAnyInGenericArgumentPosition(
         return true;
       };
 
-  SmallVector<LocatorPathElt> path;
-  auto anchor = locator.getLocatorParts(path);
-
-  // Drop all of the generic type and argument elements
-  // from the locator first.
-  while (!path.empty()) {
-    auto last = path.back();
-    if (last.is<LocatorPathElt::GenericArgument>() ||
-        last.is<LocatorPathElt::GenericType>()) {
-      path.pop_back();
-      continue;
-    }
-    break;
-  }
-
   if (!isPreconcurrencyContext(cs.getConstraintLocator(anchor, path)))
     return false;
 
@@ -3777,22 +3817,18 @@ ConstraintSystem::matchDeepEqualityTypes(Type type1, Type type2,
     return result;
   }
 
+  // `any Sendable` -> `Any`
+  if (matchSendableExistentialToAnyInGenericArgumentPosition(*this, type1,
+                                                             type2, locator))
+    return getTypeMatchSuccess();
+
   // Handle existential types.
   if (auto *existential1 = type1->getAs<ExistentialType>()) {
     auto existential2 = type2->castTo<ExistentialType>();
 
-    auto constraintTy1 = existential1->getConstraintType();
-    auto constraintTy2 = existential2->getConstraintType();
-
-    if (constraintTy1->getKnownProtocol() == KnownProtocolKind::Sendable &&
-        constraintTy2->isAny()) {
-      if (matchSendableExistentialToAnyInGenericArgumentPosition(*this,
-                                                                 locator))
-        return getTypeMatchSuccess();
-    }
-
     auto result = matchTypes(
-        constraintTy1, constraintTy2, ConstraintKind::Bind, subflags,
+        existential1->getConstraintType(), existential2->getConstraintType(),
+        ConstraintKind::Bind, subflags,
         locator.withPathElement(ConstraintLocator::ExistentialConstraintType));
 
     if (result.isFailure())
@@ -4408,10 +4444,8 @@ ConstraintSystem::matchTypesBindTypeVar(
   // with `any Sendable` and other concurrency attributes.
   if (typeVar->getImpl().getGenericParameter() &&
       !flags.contains(TMF_BindingTypeVariable) &&
-      type->isMarkerExistential()) {
-    auto constraintTy = type->castTo<ExistentialType>()->getConstraintType();
-    if (constraintTy->getKnownProtocol() == KnownProtocolKind::Sendable)
-      return formUnsolvedResult();
+      type->isSendableExistential()) {
+    return formUnsolvedResult();
   }
 
   // Attempt to fix situations where type variable can't be bound

test/Concurrency/sendable_to_any_for_generic_arguments.swift

@@ -48,8 +48,13 @@ func test_no_ambiguity_with_Sendable_extension(u: User) {
 
 struct S<T> {
   // expected-note@-1 3 {{arguments to generic parameter 'T' ('any Sendable' and 'Any') are expected to be equal}}
-  // expected-note@-2 4 {{arguments to generic parameter 'T' ('(any Sendable) -> Void' and '(Any) -> Void') are expected to be equal}}
+  // expected-note@-2 2 {{arguments to generic parameter 'T' ('(any Sendable) -> Void' and '(Any) -> Void') are expected to be equal}}
   // expected-swift6-note@-3 3 {{arguments to generic parameter 'T' ('any Sendable' and 'Any') are expected to be equal}}
+  // expected-swift6-note@-4 2 {{arguments to generic parameter 'T' ('(any Sendable) -> Void' and '(Any) -> Void') are expected to be equal}}
+  // expected-note@-5 {{arguments to generic parameter 'T' ('(Any) -> Any' and '(any Sendable) -> Any') are expected to be equal}}
+  // expected-note@-6 {{arguments to generic parameter 'T' ('(Any) -> Any' and '(any Sendable) -> any Sendable') are expected to be equal}}
+  // expected-note@-7 {{arguments to generic parameter 'T' ('(Any) -> Any' and '(Any) -> any Sendable') are expected to be equal}}
+  // expected-swift6-note@-8 {{arguments to generic parameter 'T' ('((any Sendable) -> Void) -> Void' and '((Any) -> Void) -> Void') are expected to be equal}}
 }
 
 extension S where T == Any {
@@ -61,6 +66,9 @@ struct TestGeneral {
   @preconcurrency var optV: S<[(any Sendable)?]>
   @preconcurrency var nonOptV: S<[any Sendable]>
   @preconcurrency var funcV: S<((any Sendable)) -> Void>
+  @preconcurrency var funcWithResult: S<() -> (any Sendable)?>
+  @preconcurrency var anyFunc: S<(Any) -> Any>
+  @preconcurrency var funcInFunc: S<((any Sendable) -> Void) -> Void>
 
   var regularV: S<any Sendable>
   var regularOptV: S<[(any Sendable)?]>
@@ -69,6 +77,7 @@ struct TestGeneral {
   func accepts_any(_: S<Any>) {}
   func accepts_opt_any(_: S<[Any?]>) {}
   func accepts_func_any(_: S<(Any) -> Void>) {}
+  func accepts_func_with_any_result(_: S<() -> Any?>) {}
 
   func test_contextual() -> S<Any> {
     v // Ok with non-strict concurrency
@@ -129,12 +138,37 @@ struct TestGeneral {
   }
 
   func test_no_function_conversions() {
-    let _: S<(Any) -> Void> = funcV // expected-error {{cannot assign value of type 'S<(any Sendable) -> Void>' to type 'S<(Any) -> Void>'}}
+    let _: S<(Any) -> Void> = funcV // Ok with non-strict concurrency
+    // expected-swift6-error@-1 {{cannot assign value of type 'S<(any Sendable) -> Void>' to type 'S<(Any) -> Void>'}}
     let _: S<(Any) -> Void> = regularFuncV // expected-error {{cannot assign value of type 'S<(any Sendable) -> Void>' to type 'S<(Any) -> Void>'}}
 
-    accepts_func_any(funcV)
-    // expected-error@-1 {{cannot convert value of type 'S<(any Sendable) -> Void>' to expected argument type 'S<(Any) -> Void>'}}
+    accepts_func_any(funcV) // Ok with non-strict concurrency
+    // expected-swift6-error@-1 {{cannot convert value of type 'S<(any Sendable) -> Void>' to expected argument type 'S<(Any) -> Void>'}}
     accepts_func_any(regularFuncV)
     // expected-error@-1 {{cannot convert value of type 'S<(any Sendable) -> Void>' to expected argument type 'S<(Any) -> Void>'}}
+
+    accepts_func_with_any_result(funcWithResult) // Ok with non-strict concurrency
+    // expected-swift6-error@-1 {{cannot convert value of type 'S<() -> (any Sendable)?>' to expected argument type 'S<() -> Any?>'}}
+    // expected-swift6-note@-2 {{arguments to generic parameter 'Wrapped' ('any Sendable' and 'Any') are expected to be equal}}
+
+    func sameType<T>(_: S<T>, _: T.Type) {}
+
+    // FIXME: This unfortunately cannot be supported at the momment because it would require delaying bindings to any generic parameter
+    // that has `any Sendable` in some position which has performance implications.
+    sameType(funcV, S<(Any) -> Void>.self)
+    // expected-error@-1 {{cannot convert value of type 'S<(Any) -> Void>.Type' to expected argument type '((any Sendable) -> Void).Type'}}
+    sameType(funcWithResult, S<() -> (any Sendable)?>.self)
+    // expected-error@-1 {{cannot convert value of type 'S<() -> (any Sendable)?>.Type' to expected argument type '(() -> (any Sendable)?).Type'}}
+
+    // Make sure that we don't allow Any -> any Sendable
+    let _: S<(any Sendable) -> Any> = anyFunc
+    // expected-error@-1 {{cannot assign value of type 'S<(Any) -> Any>' to type 'S<(any Sendable) -> Any>'}}
+    let _: S<(Any) -> any Sendable> = anyFunc
+    // expected-error@-1 {{cannot assign value of type 'S<(Any) -> Any>' to type 'S<(Any) -> any Sendable>'}}
+    let _: S<(any Sendable) -> any Sendable> = anyFunc
+    // expected-error@-1 {{cannot assign value of type 'S<(Any) -> Any>' to type 'S<(any Sendable) -> any Sendable>'}}
+
+    let _: S<((Any) -> Void) -> Void> = funcInFunc // Ok with non-strict concurrency
+    // expected-swift6-error@-1 {{cannot assign value of type 'S<((any Sendable) -> Void) -> Void>' to type 'S<((Any) -> Void) -> Void>'}}
   }
 }

test/Interpreter/sendable_erasure_to_any_in_preconcurrency.swift

@@ -24,6 +24,7 @@ struct S<T> {
 
 struct Test {
   @preconcurrency var data: S<any Sendable>
+  @preconcurrency var funcRef: S<([any Sendable]) -> (any Sendable)?> = S(v: { $0.first })
 }
 
 
@@ -53,6 +54,13 @@ func test() {
   // CHECK: 42
   print(sameType(v2.data, with: Any.self))
   // CHECK: ultimate question
+
+  func expectsFuncAny(_ s: S<([Any]) -> Any?>) {
+    print(s.v([42]) ?? 0)
+  }
+
+  expectsFuncAny(v1.funcRef)
+  // CHECK: 42
 }
 
 test()

test/SILGen/sendable_to_any_for_generic_arguments.swift

@@ -62,6 +62,7 @@ extension S where T == Any {
 struct TestGeneral {
   @preconcurrency var v: S<any Sendable>
   @preconcurrency var optV: S<[(any Sendable)?]>
+  @preconcurrency var funcV: S<([any Sendable]) -> (any Sendable)?>
 
   func accepts_any(_: S<Any>) {}
   func accepts_opt_any(_: S<[Any?]>) {}
@@ -154,4 +155,30 @@ struct TestGeneral {
     let test = Test(data: V(v: 42))
     accepts_any(test.data)
   }
+
+  // CHECK-LABEL: sil hidden [ossa] @$s37sendable_to_any_for_generic_arguments11TestGeneralV023test_function_types_as_E5_argsyyF
+  // CHECK: [[FUNCV_REF:%.*]] = struct_extract %0, #TestGeneral.funcV
+  // CHECK-NEXT: %3 = unchecked_trivial_bit_cast [[FUNCV_REF]] to $S<(Array<Any>) -> Optional<Any>>
+  // CHECK: [[DATA_REF:%.*]] = struct_extract %20, #<abstract function>Test.data
+  // CHECK-NEXT: [[DATA_COPY:%.*]] = copy_value [[DATA_REF]]
+  // CHECK-NEXT: [[DATA_ANY:%.*]] = unchecked_value_cast [[DATA_COPY]] to $V<(Array<Any>) -> Any>
+  // CHECK: [[ACCEPTS_ANY:%.*]] = function_ref @$s37sendable_to_any_for_generic_arguments11TestGeneralV023test_function_types_as_E5_argsyyF08accepts_C0L_yyAcDyyF1VL_VyypSayypGcGF : $@convention(thin) (@guaranteed V<(Array<Any>) -> Any>) -> ()
+  // CHECK-NEXT: {{.*}} = apply [[ACCEPTS_ANY]]([[DATA_ANY]]) : $@convention(thin) (@guaranteed V<(Array<Any>) -> Any>) -> ()
+  func test_function_types_as_generic_args() {
+    let _: S<([Any]) -> Any?> = funcV
+
+    struct V<T> {
+      let v: T
+    }
+
+    struct Test {
+      @preconcurrency var data: V<([any Sendable]) -> any Sendable>
+    }
+
+
+    func accepts_any(_: V<([Any]) -> Any>) {}
+
+    let test = Test(data: V(v: { $0.first! }))
+    accepts_any(test.data)
+  }
 }