🍒[cxx-interop] Add std::set initializer that takes a Swift Sequence

lib/ClangImporter/ClangDerivedConformances.cpp

@@ -565,6 +565,23 @@ void swift::conformToCxxSequenceIfNeeded(
   }
 }
 
+static bool isStdSetType(const clang::CXXRecordDecl *clangDecl) {
+  return isStdDecl(clangDecl, {"set", "unordered_set", "multiset"});
+}
+
+bool swift::isUnsafeStdMethod(const clang::CXXMethodDecl *methodDecl) {
+  auto parentDecl =
+      dyn_cast<clang::CXXRecordDecl>(methodDecl->getDeclContext());
+  if (!parentDecl)
+    return false;
+  if (!isStdSetType(parentDecl))
+    return false;
+  if (methodDecl->getDeclName().isIdentifier() &&
+      methodDecl->getName() == "insert")
+    return true;
+  return false;
+}
+
 void swift::conformToCxxSetIfNeeded(ClangImporter::Implementation &impl,
                                     NominalTypeDecl *decl,
                                     const clang::CXXRecordDecl *clangDecl) {
@@ -576,7 +593,7 @@ void swift::conformToCxxSetIfNeeded(ClangImporter::Implementation &impl,
 
   // Only auto-conform types from the C++ standard library. Custom user types
   // might have a similar interface but different semantics.
-  if (!isStdDecl(clangDecl, {"set", "unordered_set", "multiset"}))
+  if (!isStdSetType(clangDecl))
     return;
 
   auto valueType = lookupDirectSingleWithoutExtensions<TypeAliasDecl>(
@@ -586,10 +603,33 @@ void swift::conformToCxxSetIfNeeded(ClangImporter::Implementation &impl,
   if (!valueType || !sizeType)
     return;
 
+  auto insertId = ctx.getIdentifier("__insertUnsafe");
+  auto inserts = lookupDirectWithoutExtensions(decl, insertId);
+  FuncDecl *insert = nullptr;
+  for (auto candidate : inserts) {
+    if (auto candidateMethod = dyn_cast<FuncDecl>(candidate)) {
+      if (!candidateMethod->hasParameterList())
+        continue;
+      auto params = candidateMethod->getParameters();
+      if (params->size() != 1)
+        continue;
+      auto param = params->front();
+      if (param->getType()->getCanonicalType() !=
+          valueType->getUnderlyingType()->getCanonicalType())
+        continue;
+      insert = candidateMethod;
+      break;
+    }
+  }
+  if (!insert)
+    return;
+
   impl.addSynthesizedTypealias(decl, ctx.Id_Element,
                                valueType->getUnderlyingType());
   impl.addSynthesizedTypealias(decl, ctx.getIdentifier("Size"),
                                sizeType->getUnderlyingType());
+  impl.addSynthesizedTypealias(decl, ctx.getIdentifier("InsertionResult"),
+                               insert->getResultInterfaceType());
   impl.addSynthesizedProtocolAttrs(decl, {KnownProtocolKind::CxxSet});
 }
 

lib/ClangImporter/ClangDerivedConformances.h

@@ -20,6 +20,8 @@ namespace swift {
 
 bool isIterator(const clang::CXXRecordDecl *clangDecl);
 
+bool isUnsafeStdMethod(const clang::CXXMethodDecl *methodDecl);
+
 /// If the decl is a C++ input iterator, synthesize a conformance to the
 /// UnsafeCxxInputIterator protocol, which is defined in the Cxx module.
 void conformToCxxIteratorIfNeeded(ClangImporter::Implementation &impl,

lib/ClangImporter/ClangImporter.cpp

@@ -6747,6 +6747,11 @@ bool IsSafeUseOfCxxDecl::evaluate(Evaluator &evaluator,
         method->getReturnType()->isReferenceType())
       return false;
 
+    // Check if it's one of the known unsafe methods we currently
+    // mark as safe by default.
+    if (isUnsafeStdMethod(method))
+      return false;
+
     // Try to figure out the semantics of the return type. If it's a
     // pointer/iterator, it's unsafe.
     if (auto returnType = dyn_cast<clang::RecordType>(

stdlib/public/Cxx/CxxSet.swift

@@ -13,11 +13,31 @@
 public protocol CxxSet<Element> {
   associatedtype Element
   associatedtype Size: BinaryInteger
+  associatedtype InsertionResult // std::pair<iterator, bool>
+
+  init()
+
+  @discardableResult
+  mutating func __insertUnsafe(_ element: Element) -> InsertionResult
 
   func count(_ element: Element) -> Size
 }
 
 extension CxxSet {
+  /// Creates a C++ set containing the elements of a Swift Sequence.
+  ///
+  /// This initializes the set by copying every element of the sequence.
+  ///
+  /// - Complexity: O(*n*), where *n* is the number of elements in the Swift
+  ///   sequence
+  @inlinable
+  public init<S: Sequence>(_ sequence: __shared S) where S.Element == Element {
+    self.init()
+    for item in sequence {
+      self.__insertUnsafe(item)
+    }
+  }
+
   @inlinable
   public func contains(_ element: Element) -> Bool {
     return count(element) > 0

test/Interop/Cxx/stdlib/use-std-set.swift

@@ -47,4 +47,18 @@ StdSetTestSuite.test("MultisetOfCInt.contains") {
     expectFalse(s.contains(3))
 }
 
+StdSetTestSuite.test("SetOfCInt.init()") {
+    let s = SetOfCInt([1, 3, 5])
+    expectTrue(s.contains(1))
+    expectFalse(s.contains(2))
+    expectTrue(s.contains(3))
+}
+
+StdSetTestSuite.test("UnorderedSetOfCInt.init()") {
+    let s = UnorderedSetOfCInt([1, 3, 5])
+    expectTrue(s.contains(1))
+    expectFalse(s.contains(2))
+    expectTrue(s.contains(3))
+}
+
 runAllTests()