Skip to content

Commit 963aad3

Browse files
susmonteirosusmonteiro
authored
Merge pull request #84340 from susmonteiro/susmonteiro/stl-non-copyable-types
[cxx-interop] Import STL types as copyable, conditionally
2 parents 6f4c26f + 83a5968 commit 963aad3

11 files changed

+148
-13
lines changed

‎lib/ClangImporter/ClangImporter.cpp‎

Lines changed: 37 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -5267,7 +5267,7 @@ TinyPtrVector<ValueDecl *> CXXNamespaceMemberLookup::evaluate(
52675267
return result;
52685268
}
52695269

5270-
static const llvm::StringMap<std::vector<int>> STLConditionalEscapableParams{
5270+
static const llvm::StringMap<std::vector<int>> STLConditionalParams{
52715271
{"basic_string", {0}},
52725272
{"vector", {0}},
52735273
{"array", {0}},
@@ -5343,10 +5343,10 @@ ClangTypeEscapability::evaluate(Evaluator &evaluator,
53435343
return CxxEscapability::Escapable;
53445344
auto injectedStlAnnotation =
53455345
recordDecl->isInStdNamespace()
5346-
? STLConditionalEscapableParams.find(recordDecl->getName())
5347-
: STLConditionalEscapableParams.end();
5346+
? STLConditionalParams.find(recordDecl->getName())
5347+
: STLConditionalParams.end();
53485348
bool hasInjectedSTLAnnotation =
5349-
injectedStlAnnotation != STLConditionalEscapableParams.end();
5349+
injectedStlAnnotation != STLConditionalParams.end();
53505350
auto conditionalParams = getConditionalEscapableAttrParams(recordDecl);
53515351
if (!conditionalParams.empty() || hasInjectedSTLAnnotation) {
53525352
auto specDecl = cast<clang::ClassTemplateSpecializationDecl>(recordDecl);
@@ -8299,6 +8299,7 @@ CxxValueSemantics::evaluate(Evaluator &evaluator,
82998299
CxxValueSemanticsDescriptor desc) const {
83008300

83018301
const auto *type = desc.type;
8302+
auto *importerImpl = desc.importerImpl;
83028303

83038304
auto desugared = type->getUnqualifiedDesugaredType();
83048305
const auto *recordType = desugared->getAs<clang::RecordType>();
@@ -8310,7 +8311,7 @@ CxxValueSemantics::evaluate(Evaluator &evaluator,
83108311
// When a reference type is copied, the pointer’s value is copied rather than
83118312
// the object’s storage. This means reference types can be imported as
83128313
// copyable to Swift, even when they are non-copyable in C++.
8313-
if (recordHasReferenceSemantics(recordDecl, desc.importerImpl))
8314+
if (recordHasReferenceSemantics(recordDecl, importerImpl))
83148315
return CxxValueSemanticsKind::Copyable;
83158316

83168317
if (recordDecl->isInStdNamespace()) {
@@ -8319,10 +8320,40 @@ CxxValueSemantics::evaluate(Evaluator &evaluator,
83198320
if (recordDecl->getIdentifier() &&
83208321
recordDecl->getName() == "_Optional_construct_base")
83218322
return CxxValueSemanticsKind::Copyable;
8323+
8324+
auto injectedStlAnnotation =
8325+
STLConditionalParams.find(recordDecl->getName());
8326+
8327+
if (injectedStlAnnotation != STLConditionalParams.end()) {
8328+
auto specDecl = cast<clang::ClassTemplateSpecializationDecl>(recordDecl);
8329+
auto &argList = specDecl->getTemplateArgs();
8330+
for (auto argToCheck : injectedStlAnnotation->second) {
8331+
auto arg = argList[argToCheck];
8332+
llvm::SmallVector<clang::TemplateArgument, 1> nonPackArgs;
8333+
if (arg.getKind() == clang::TemplateArgument::Pack) {
8334+
auto pack = arg.getPackAsArray();
8335+
nonPackArgs.assign(pack.begin(), pack.end());
8336+
} else
8337+
nonPackArgs.push_back(arg);
8338+
for (auto nonPackArg : nonPackArgs) {
8339+
8340+
auto argValueSemantics = evaluateOrDefault(
8341+
evaluator,
8342+
CxxValueSemantics(
8343+
{nonPackArg.getAsType()->getUnqualifiedDesugaredType(),
8344+
desc.importerImpl}),
8345+
{});
8346+
if (argValueSemantics != CxxValueSemanticsKind::Copyable)
8347+
return argValueSemantics;
8348+
}
8349+
}
8350+
8351+
return CxxValueSemanticsKind::Copyable;
8352+
}
83228353
}
83238354

83248355
const auto cxxRecordDecl = dyn_cast<clang::CXXRecordDecl>(recordDecl);
8325-
if (!cxxRecordDecl) {
8356+
if (!cxxRecordDecl || !cxxRecordDecl->isCompleteDefinition()) {
83268357
if (hasNonCopyableAttr(recordDecl))
83278358
return CxxValueSemanticsKind::MoveOnly;
83288359
return CxxValueSemanticsKind::Copyable;

‎test/Interop/Cxx/class/noncopyable-typechecker.swift‎

Lines changed: 2 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -1,6 +1,6 @@
11
// RUN: %empty-directory(%t)
22
// RUN: split-file %s %t
3-
// RUN: %target-swift-frontend -cxx-interoperability-mode=default -typecheck -verify - -I %t/Inputs %t/test.swift
3+
// RUN: %target-swift-frontend -cxx-interoperability-mode=default -typecheck -verify -I %t/Inputs %t/test.swift
44
// RUN: %target-swift-frontend -cxx-interoperability-mode=default -Xcc -std=c++20 -verify-additional-prefix cpp20- -D CPP20 -typecheck -verify -I %t/Inputs %t/test.swift
55

66
//--- Inputs/module.modulemap
@@ -45,17 +45,14 @@ using NonCopyableRequires = RequiresCopyableT<NonCopyable>;
4545
import Test
4646
import CxxStdlib
4747

48-
func takeCopyable<T: Copyable>(_ x: T) {}
49-
// expected-note@-1 {{'where T: Copyable' is implicit here}}
50-
// expected-cpp20-note@-2 {{'where T: Copyable' is implicit here}}
48+
func takeCopyable<T: Copyable>(_ x: T) {} // expected-note * {{'where T: Copyable' is implicit here}}
5149

5250
func userDefinedTypes() {
5351
let nCop = NonCopyable()
5452
takeCopyable(nCop) // expected-error {{global function 'takeCopyable' requires that 'NonCopyable' conform to 'Copyable'}}
5553

5654
let ownsT = OwnsNonCopyable()
5755
takeCopyable(ownsT) // no error, OwnsNonCopyable imported as Copyable
58-
5956
}
6057

6158
#if CPP20
@@ -64,4 +61,3 @@ func useOfRequires() {
6461
takeCopyable(nCop) // expected-cpp20-error {{global function 'takeCopyable' requires that 'NonCopyableRequires' (aka 'RequiresCopyableT<NonCopyable>') conform to 'Copyable'}}
6562
}
6663
#endif
67-

‎test/Interop/Cxx/stdlib/Inputs/std-map.h‎

Lines changed: 10 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -17,4 +17,14 @@ inline UnorderedMap initUnorderedMap() { return {{1, 3}, {3, 3}, {2, 2}}; }
1717
inline Map initEmptyMap() { return {}; }
1818
inline UnorderedMap initEmptyUnorderedMap() { return {}; }
1919

20+
struct NonCopyable {
21+
NonCopyable() = default;
22+
NonCopyable(const NonCopyable &other) = delete;
23+
NonCopyable(NonCopyable &&other) = default;
24+
~NonCopyable() {}
25+
};
26+
27+
using MapNonCopyableKey = std::map<NonCopyable, int>;
28+
using MapNonCopyableValue = std::map<int, NonCopyable>;
29+
2030
#endif // TEST_INTEROP_CXX_STDLIB_INPUTS_STD_MAP_H

‎test/Interop/Cxx/stdlib/Inputs/std-set.h‎

Lines changed: 9 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -12,4 +12,13 @@ inline SetOfCInt initSetOfCInt() { return {1, 5, 3}; }
1212
inline UnorderedSetOfCInt initUnorderedSetOfCInt() { return {2, 4, 6}; }
1313
inline MultisetOfCInt initMultisetOfCInt() { return {2, 2, 4, 6}; }
1414

15+
struct NonCopyable {
16+
NonCopyable() = default;
17+
NonCopyable(const NonCopyable &other) = delete;
18+
NonCopyable(NonCopyable &&other) = default;
19+
~NonCopyable() {}
20+
};
21+
22+
using SetOfNonCopyable = std::set<NonCopyable>;
23+
1524
#endif // TEST_INTEROP_CXX_STDLIB_INPUTS_STD_SET_H

‎test/Interop/Cxx/stdlib/Inputs/std-unique-ptr.h‎

Lines changed: 8 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -3,6 +3,7 @@
33

44
#include <memory>
55
#include <string>
6+
#include <vector>
67

78
struct NonCopyable {
89
NonCopyable(int x) : x(x) {}
@@ -26,6 +27,13 @@ struct NonCopyableDerived: public NonCopyable {
2627
inline std::shared_ptr<NonCopyable> getNonCopyableSharedPtr() { return std::make_shared<NonCopyableDerived>(42); }
2728
inline std::unique_ptr<NonCopyable> getNonCopyableUniquePtr() { return std::make_unique<NonCopyableDerived>(42); }
2829

30+
inline std::vector<std::unique_ptr<NonCopyable>>
31+
getVectorNonCopyableUniquePtr() {
32+
std::vector<std::unique_ptr<NonCopyable>> vec;
33+
vec.emplace_back();
34+
return vec;
35+
}
36+
2937
std::unique_ptr<int> makeInt() {
3038
return std::make_unique<int>(42);
3139
}

‎test/Interop/Cxx/stdlib/Inputs/std-vector.h‎

Lines changed: 11 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1,8 +1,8 @@
11
#ifndef TEST_INTEROP_CXX_STDLIB_INPUTS_STD_VECTOR_H
22
#define TEST_INTEROP_CXX_STDLIB_INPUTS_STD_VECTOR_H
33

4-
#include <vector>
54
#include <string>
5+
#include <vector>
66

77
using Vector = std::vector<int>;
88
using VectorOfString = std::vector<std::string>;
@@ -30,4 +30,14 @@ __attribute__((swift_attr("release:immortal"))) ImmortalRef {
3030
};
3131
using VectorOfImmortalRefPtr = std::vector<ImmortalRef *>;
3232

33+
struct NonCopyable {
34+
NonCopyable() = default;
35+
NonCopyable(const NonCopyable &other) = delete;
36+
NonCopyable(NonCopyable &&other) = default;
37+
~NonCopyable() {}
38+
};
39+
40+
using VectorOfNonCopyable = std::vector<NonCopyable>;
41+
using VectorOfPointer = std::vector<NonCopyable *>;
42+
3343
#endif // TEST_INTEROP_CXX_STDLIB_INPUTS_STD_VECTOR_H

‎test/Interop/Cxx/stdlib/use-std-map-typechecker.swift‎

Lines changed: 16 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,16 @@
1+
// RUN: not %target-swift-frontend %s -typecheck -I %S/Inputs -cxx-interoperability-mode=default -diagnostic-style llvm 2>&1 | %FileCheck %s
2+
3+
import StdMap
4+
import CxxStdlib
5+
6+
func takeCopyable<T: Copyable>(_ x: T) {}
7+
8+
let mapNonCopyableKey = MapNonCopyableKey()
9+
takeCopyable(mapNonCopyableKey)
10+
// CHECK: error: global function 'takeCopyable' requires that 'MapNonCopyableKey' {{.*}} conform to 'Copyable'
11+
// CHECK: note: 'where T: Copyable' is implicit here
12+
13+
let mapNonCopyableValue = MapNonCopyableValue()
14+
takeCopyable(mapNonCopyableValue)
15+
// CHECK: error: global function 'takeCopyable' requires that 'MapNonCopyableValue' {{.*}} conform to 'Copyable'
16+
// CHECK: note: 'where T: Copyable' is implicit here

‎test/Interop/Cxx/stdlib/use-std-optional-typechecker.swift‎

Lines changed: 11 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,11 @@
1+
// RUN: not %target-swift-frontend %s -typecheck -I %S/Inputs -cxx-interoperability-mode=default -diagnostic-style llvm 2>&1 | %FileCheck %s
2+
3+
import StdOptional
4+
import CxxStdlib
5+
6+
func takeCopyable<T: Copyable>(_ x: T) {}
7+
8+
let nonNilOptNonCopyable = getNonNilOptionalHasDeletedCopyCtor()
9+
takeCopyable(nonNilOptNonCopyable)
10+
// CHECK: error: global function 'takeCopyable' requires that 'StdOptionalHasDeletedCopyCtor' {{.*}} conform to 'Copyable'
11+
// CHECK: note: 'where T: Copyable' is implicit here

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

Lines changed: 11 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,11 @@
1+
// RUN: not %target-swift-frontend %s -typecheck -I %S/Inputs -cxx-interoperability-mode=default -diagnostic-style llvm 2>&1 | %FileCheck %s
2+
3+
import StdSet
4+
import CxxStdlib
5+
6+
func takeCopyable<T: Copyable>(_ x: T) {}
7+
8+
let setNonCopyable = SetOfNonCopyable()
9+
takeCopyable(setNonCopyable)
10+
// CHECK: error: global function 'takeCopyable' requires that 'SetOfNonCopyable' {{.*}} conform to 'Copyable'
11+
// CHECK: note: 'where T: Copyable' is implicit here

‎test/Interop/Cxx/stdlib/use-std-unique-ptr-typechecker.swift‎

Lines changed: 12 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,12 @@
1+
// RUN: not %target-swift-frontend %s -typecheck -I %S/Inputs -cxx-interoperability-mode=default -diagnostic-style llvm 2>&1 | %FileCheck %s
2+
3+
// UNSUPPORTED: OS=windows-msvc
4+
5+
import StdUniquePtr
6+
import CxxStdlib
7+
8+
func takeCopyable<T: Copyable>(_ x: T) {}
9+
10+
let vecUniquePtr = getVectorNonCopyableUniquePtr()
11+
takeCopyable(vecUniquePtr)
12+
// CHECK: error: global function 'takeCopyable' requires that 'std{{.*}}vector{{.*}}unique_ptr{{.*}}NonCopyable{{.*}}' conform to 'Copyable'

0 commit comments

Comments
 (0)