Merge pull request #70412 from xedin/rdar-113212472

[Concurrency] Teach `Type::stripConcurrency` about tuples, sugared types, and bound generic types

Author: xedin

lib/AST/Type.cpp

@@ -1110,6 +1110,61 @@ Type TypeBase::stripConcurrency(bool recurse, bool dropGlobalActor) {
     return Type(this);
   }
 
+  if (auto *BGT = getAs<BoundGenericType>()) {
+    if (!recurse)
+      return Type(this);
+
+    bool anyChanged = false;
+    SmallVector<Type, 2> genericArgs;
+    llvm::transform(BGT->getGenericArgs(), std::back_inserter(genericArgs),
+                    [&](Type argTy) {
+                      auto newArgTy =
+                          argTy->stripConcurrency(recurse, dropGlobalActor);
+                      anyChanged |= !newArgTy->isEqual(argTy);
+                      return newArgTy;
+                    });
+
+    return anyChanged ? BoundGenericType::get(BGT->getDecl(), BGT->getParent(),
+                                              genericArgs)
+                      : Type(this);
+  }
+
+  if (auto *tuple = getAs<TupleType>()) {
+    if (!recurse)
+      return Type(this);
+
+    bool anyChanged = false;
+    SmallVector<TupleTypeElt, 2> elts;
+    llvm::transform(
+        tuple->getElements(), std::back_inserter(elts), [&](const auto &elt) {
+          auto eltTy = elt.getType();
+          auto strippedTy = eltTy->stripConcurrency(recurse, dropGlobalActor);
+          anyChanged |= !strippedTy->isEqual(eltTy);
+          return elt.getWithType(strippedTy);
+        });
+
+    return anyChanged ? TupleType::get(elts, getASTContext()) : Type(this);
+  }
+
+  if (auto *arrayTy = dyn_cast<ArraySliceType>(this)) {
+    auto newBaseTy =
+        arrayTy->getBaseType()->stripConcurrency(recurse, dropGlobalActor);
+    return newBaseTy->isEqual(arrayTy->getBaseType())
+               ? Type(this)
+               : ArraySliceType::get(newBaseTy);
+  }
+
+  if (auto *dictTy = dyn_cast<DictionaryType>(this)) {
+    auto keyTy = dictTy->getKeyType();
+    auto strippedKeyTy = keyTy->stripConcurrency(recurse, dropGlobalActor);
+    auto valueTy = dictTy->getValueType();
+    auto strippedValueTy = valueTy->stripConcurrency(recurse, dropGlobalActor);
+
+    return keyTy->isEqual(strippedKeyTy) && valueTy->isEqual(strippedValueTy)
+               ? Type(this)
+               : DictionaryType::get(strippedKeyTy, strippedValueTy);
+  }
+
   return Type(this);
 }
 

test/Concurrency/sendable_preconcurrency_erasure.swift

@@ -0,0 +1,38 @@
+// RUN: %target-swift-emit-silgen %s -verify -swift-version 5 | %FileCheck %s
+
+// REQUIRES: concurrency
+
+// Test erasure in generic arguments
+do {
+  struct S<T> {
+  }
+
+  @preconcurrency func test(_: S<any Sendable>) {}
+  // CHECK-LABEL: sil private [ossa] @$s31sendable_preconcurrency_erasure4testL_yyAA1SL_VyypGF
+  @preconcurrency func test(_: S<Array<@Sendable () -> Void>>) {}
+  // CHECK-LABEL: sil private [ossa] @$s31sendable_preconcurrency_erasure4testL0_yyAA1SL_VySayyycGGF
+  @preconcurrency func test(_: Array<(any Sendable, @Sendable () -> Void)>) {}
+  // CHECK-LABEL: sil private [ossa] @$s31sendable_preconcurrency_erasure4testL1_yySayyp_yyctGF
+}
+
+// Test erase in sugared types
+do {
+  @preconcurrency func testArray1(_: [any Sendable]) {}
+  // CHECK-LABEL: sil private [ossa] @$s31sendable_preconcurrency_erasure10testArray1L2_yySayypGF
+  @preconcurrency func testArray2(_: [@Sendable () -> Void]) {}
+  // CHECK-LABEL: sil private [ossa] @$s31sendable_preconcurrency_erasure10testArray2L2_yySayyycGF
+
+  @preconcurrency func testDictionary(_: [Int: (any Sendable, (String, @Sendable (any Sendable) -> Void))]) {}
+  // CHECK-LABEL: sil private [ossa] @$s31sendable_preconcurrency_erasure14testDictionaryL2_yySDySiyp_SS_yypcttGF
+
+  @preconcurrency func testDesugaredDict(_: Dictionary<Int, (any Sendable, (String, @Sendable (any Sendable) -> Void))>) {}
+  // CHECK-LABEL: sil private [ossa] @$s31sendable_preconcurrency_erasure17testDesugaredDictL2_yySDySiyp_SS_yypcttGF
+
+  @preconcurrency func testVariadic(_: (any Sendable)...) {}
+  // CHECK-LABEL: sil private [ossa] @$s31sendable_preconcurrency_erasure12testVariadicL2_yyypd_tF
+}
+
+public struct Data {
+  @preconcurrency var test: (any Sendable, Array<(Int, any Sendable)>)? = nil
+  // CHECK-LABEL: sil [transparent] [ossa] @$s31sendable_preconcurrency_erasure4DataV4testyp_SaySi_yptGtSgvpfi
+}