Skip to content

Commit d6a4bc0

Browse files
gottesmmgottesmm
committed
[no-implicit-copy] Rename SILMoveOnlyType -> SILMoveOnlyWrappedType.
Since I am beginning to prepare for adding real move only types to the language, I am renaming everything that has to do with copyable types "move only wrapped" values instead of move only. The hope is this reduces/prevents any confusion in between the two.
1 parent b9907c6 commit d6a4bc0

22 files changed

+73
-63
lines changed

‎include/swift/AST/TypeDifferenceVisitor.h

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -333,8 +333,8 @@ class CanTypeDifferenceVisitor : public CanTypePairVisitor<Impl, bool> {
333333
return asImpl().visit(type1->getCaptureType(), type2->getCaptureType());
334334
}
335335

336-
bool visitSILMoveOnlyType(CanSILMoveOnlyType type1,
337-
CanSILMoveOnlyType type2) {
336+
bool visitSILMoveOnlyWrappedType(CanSILMoveOnlyWrappedType type1,
337+
CanSILMoveOnlyWrappedType type2) {
338338
return asImpl().visit(type1->getInnerType(), type2->getInnerType());
339339
}
340340

‎include/swift/AST/TypeMatcher.h

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -352,7 +352,7 @@ class TypeMatcher {
352352
TRIVIAL_CASE(SILFunctionType)
353353
TRIVIAL_CASE(SILBlockStorageType)
354354
TRIVIAL_CASE(SILBoxType)
355-
TRIVIAL_CASE(SILMoveOnlyType)
355+
TRIVIAL_CASE(SILMoveOnlyWrappedType)
356356

357357
bool visitProtocolCompositionType(CanProtocolCompositionType firstProtocolComposition,
358358
Type secondType,

‎include/swift/AST/Types.h

Lines changed: 6 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -5002,18 +5002,19 @@ class SILBoxType final : public TypeBase, public llvm::FoldingSetNode
50025002
};
50035003
DEFINE_EMPTY_CAN_TYPE_WRAPPER(SILBoxType, Type)
50045004

5005-
class SILMoveOnlyType;
5005+
class SILMoveOnlyWrappedType;
50065006
class SILModule; // From SIL
5007-
typedef CanTypeWrapper<SILMoveOnlyType> CanMoveOnlyType;
5007+
typedef CanTypeWrapper<SILMoveOnlyWrappedType> CanMoveOnlyType;
50085008

50095009
/// A wrapper type that marks an inner type as being a move only value. Can not
50105010
/// be written directly at the Swift level, instead it is triggered by adding
50115011
/// the type attribute @_moveOnly to a different type. We transform these in
50125012
/// TypeLowering into a moveOnly SILType on the inner type.
5013-
class SILMoveOnlyType final : public TypeBase, public llvm::FoldingSetNode {
5013+
class SILMoveOnlyWrappedType final : public TypeBase,
5014+
public llvm::FoldingSetNode {
50145015
CanType innerType;
50155016

5016-
SILMoveOnlyType(CanType innerType)
5017+
SILMoveOnlyWrappedType(CanType innerType)
50175018
: TypeBase(TypeKind::SILMoveOnly, &innerType->getASTContext(),
50185019
innerType->getRecursiveProperties()),
50195020
innerType(innerType) {}
@@ -5027,7 +5028,7 @@ class SILMoveOnlyType final : public TypeBase, public llvm::FoldingSetNode {
50275028
return T->getKind() == TypeKind::SILMoveOnly;
50285029
}
50295030
};
5030-
DEFINE_EMPTY_CAN_TYPE_WRAPPER(SILMoveOnlyType, Type)
5031+
DEFINE_EMPTY_CAN_TYPE_WRAPPER(SILMoveOnlyWrappedType, Type)
50315032

50325033
class SILBlockStorageType;
50335034
typedef CanTypeWrapper<SILBlockStorageType> CanSILBlockStorageType;

‎include/swift/SIL/SILType.h

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -607,15 +607,15 @@ class SILType {
607607
/// Canonical way to check if a SILType is move only. Using is/getAs/castTo
608608
/// will look through moveonly-ness.
609609
bool isMoveOnlyWrapped() const {
610-
return getRawASTType()->is<SILMoveOnlyType>();
610+
return getRawASTType()->is<SILMoveOnlyWrappedType>();
611611
}
612612

613613
/// If this is already a move only wrapped type, return *this. Otherwise, wrap
614614
/// the copyable type in the mov eonly wrapper.
615615
SILType addingMoveOnlyWrapper() const {
616616
if (isMoveOnlyWrapped())
617617
return *this;
618-
auto newType = SILMoveOnlyType::get(getRawASTType());
618+
auto newType = SILMoveOnlyWrappedType::get(getRawASTType());
619619
return SILType::getPrimitiveType(newType, getCategory());
620620
}
621621

@@ -624,7 +624,7 @@ class SILType {
624624
SILType removingMoveOnlyWrapper() const {
625625
if (!isMoveOnlyWrapped())
626626
return *this;
627-
auto moveOnly = getRawASTType()->castTo<SILMoveOnlyType>();
627+
auto moveOnly = getRawASTType()->castTo<SILMoveOnlyWrappedType>();
628628
return SILType::getPrimitiveType(moveOnly->getInnerType(), getCategory());
629629
}
630630

‎include/swift/SIL/SILValue.h

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -563,7 +563,7 @@ class ValueBase : public SILNode, public SILAllocated<ValueBase> {
563563
/// otherwise.
564564
///
565565
/// NOTE: Please do not use this directly! It is only meant to be used by the
566-
/// optimizer pass: SILMoveOnlyTypeEliminator.
566+
/// optimizer pass: SILMoveOnlyWrappedTypeEliminator.
567567
bool unsafelyEliminateMoveOnlyWrapper() {
568568
if (!Type.isMoveOnlyWrapped())
569569
return false;

‎lib/AST/ASTContext.cpp

Lines changed: 10 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -462,7 +462,7 @@ struct ASTContext::Implementation {
462462
llvm::FoldingSet<GenericFunctionType> GenericFunctionTypes;
463463
llvm::FoldingSet<SILFunctionType> SILFunctionTypes;
464464
llvm::DenseMap<CanType, SILBlockStorageType *> SILBlockStorageTypes;
465-
llvm::DenseMap<CanType, SILMoveOnlyType *> SILMoveOnlyTypes;
465+
llvm::DenseMap<CanType, SILMoveOnlyWrappedType *> SILMoveOnlyWrappedTypes;
466466
llvm::FoldingSet<SILBoxType> SILBoxTypes;
467467
llvm::DenseMap<BuiltinIntegerWidth, BuiltinIntegerType*> IntegerTypes;
468468
llvm::FoldingSet<BuiltinVectorType> BuiltinVectorTypes;
@@ -4074,17 +4074,18 @@ SILFunctionType::SILFunctionType(
40744074
#endif
40754075
}
40764076

4077-
CanSILMoveOnlyType SILMoveOnlyType::get(CanType innerType) {
4077+
CanSILMoveOnlyWrappedType SILMoveOnlyWrappedType::get(CanType innerType) {
40784078
ASTContext &ctx = innerType->getASTContext();
4079-
auto found = ctx.getImpl().SILMoveOnlyTypes.find(innerType);
4080-
if (found != ctx.getImpl().SILMoveOnlyTypes.end())
4081-
return CanSILMoveOnlyType(found->second);
4079+
auto found = ctx.getImpl().SILMoveOnlyWrappedTypes.find(innerType);
4080+
if (found != ctx.getImpl().SILMoveOnlyWrappedTypes.end())
4081+
return CanSILMoveOnlyWrappedType(found->second);
40824082

4083-
void *mem = ctx.Allocate(sizeof(SILMoveOnlyType), alignof(SILMoveOnlyType));
4083+
void *mem = ctx.Allocate(sizeof(SILMoveOnlyWrappedType),
4084+
alignof(SILMoveOnlyWrappedType));
40844085

4085-
auto *storageTy = new (mem) SILMoveOnlyType(innerType);
4086-
ctx.getImpl().SILMoveOnlyTypes.insert({innerType, storageTy});
4087-
return CanSILMoveOnlyType(storageTy);
4086+
auto *storageTy = new (mem) SILMoveOnlyWrappedType(innerType);
4087+
ctx.getImpl().SILMoveOnlyWrappedTypes.insert({innerType, storageTy});
4088+
return CanSILMoveOnlyWrappedType(storageTy);
40884089
}
40894090

40904091
CanSILBlockStorageType SILBlockStorageType::get(CanType captureType) {

‎lib/AST/ASTDumper.cpp

Lines changed: 2 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -3935,7 +3935,8 @@ namespace {
39353935
PrintWithColorRAII(OS, ParenthesisColor) << ')';
39363936
}
39373937

3938-
void visitSILMoveOnlyType(SILMoveOnlyType *T, StringRef label) {
3938+
void visitSILMoveOnlyWrappedType(SILMoveOnlyWrappedType *T,
3939+
StringRef label) {
39393940
printCommon(label, "sil_move_only_type");
39403941
printRec(T->getInnerType());
39413942
PrintWithColorRAII(OS, ParenthesisColor) << ')';

‎lib/AST/ASTPrinter.cpp

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -6203,7 +6203,7 @@ class TypePrinter : public TypeVisitor<TypePrinter> {
62036203
}
62046204
}
62056205

6206-
void visitSILMoveOnlyType(SILMoveOnlyType *T) {
6206+
void visitSILMoveOnlyWrappedType(SILMoveOnlyWrappedType *T) {
62076207
Printer << "@moveOnly ";
62086208
printWithParensIfNotSimple(T->getInnerType());
62096209
}

‎lib/AST/Type.cpp

Lines changed: 9 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -193,8 +193,9 @@ bool CanType::isReferenceTypeImpl(CanType type, const GenericSignatureImpl *sig,
193193
return isReferenceTypeImpl(cast<DynamicSelfType>(type).getSelfType(),
194194
sig, functionsCount);
195195
case TypeKind::SILMoveOnly:
196-
return isReferenceTypeImpl(cast<SILMoveOnlyType>(type)->getInnerType(), sig,
197-
functionsCount);
196+
return isReferenceTypeImpl(
197+
cast<SILMoveOnlyWrappedType>(type)->getInnerType(), sig,
198+
functionsCount);
198199

199200
// Archetypes and existentials are only class references if class-bounded.
200201
case TypeKind::PrimaryArchetype:
@@ -330,7 +331,7 @@ ExistentialLayout CanType::getExistentialLayout() {
330331
CanType ty = *this;
331332

332333
// Always remove one layer of move only ness.
333-
if (auto mv = dyn_cast<SILMoveOnlyType>(ty))
334+
if (auto mv = dyn_cast<SILMoveOnlyWrappedType>(ty))
334335
ty = mv->getInnerType();
335336

336337
if (auto existential = dyn_cast<ExistentialType>(ty))
@@ -5150,14 +5151,14 @@ case TypeKind::Id:
51505151
}
51515152

51525153
case TypeKind::SILMoveOnly: {
5153-
auto *storageTy = cast<SILMoveOnlyType>(base);
5154+
auto *storageTy = cast<SILMoveOnlyWrappedType>(base);
51545155
Type transCap = storageTy->getInnerType().transformWithPosition(
51555156
TypePosition::Invariant, fn);
51565157
if (!transCap)
51575158
return Type();
51585159
CanType canTransCap = transCap->getCanonicalType();
51595160
if (canTransCap != storageTy->getInnerType())
5160-
return SILMoveOnlyType::get(canTransCap);
5161+
return SILMoveOnlyWrappedType::get(canTransCap);
51615162
return storageTy;
51625163
}
51635164

@@ -6072,7 +6073,9 @@ ReferenceCounting TypeBase::getReferenceCounting() {
60726073
return cast<DynamicSelfType>(type).getSelfType()
60736074
->getReferenceCounting();
60746075
case TypeKind::SILMoveOnly:
6075-
return cast<SILMoveOnlyType>(type)->getInnerType()->getReferenceCounting();
6076+
return cast<SILMoveOnlyWrappedType>(type)
6077+
->getInnerType()
6078+
->getReferenceCounting();
60766079

60776080
case TypeKind::PrimaryArchetype:
60786081
case TypeKind::OpenedArchetype:

‎lib/AST/TypeWalker.cpp

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -234,7 +234,7 @@ class Traversal : public TypeVisitor<Traversal, bool>
234234
return doIt(ty->getCaptureType());
235235
}
236236

237-
bool visitSILMoveOnlyType(SILMoveOnlyType *ty) {
237+
bool visitSILMoveOnlyWrappedType(SILMoveOnlyWrappedType *ty) {
238238
return doIt(ty->getInnerType());
239239
}
240240

‎lib/ClangImporter/ImportType.cpp

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1920,7 +1920,7 @@ class GetSendableType :
19201920
NEVER_VISIT(SILBlockStorageType)
19211921
NEVER_VISIT(SILBoxType)
19221922
NEVER_VISIT(SILTokenType)
1923-
NEVER_VISIT(SILMoveOnlyType)
1923+
NEVER_VISIT(SILMoveOnlyWrappedType)
19241924

19251925
VISIT(ProtocolCompositionType, compose)
19261926

‎lib/IRGen/GenType.h

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -158,7 +158,7 @@ class TypeConverter {
158158
const TypeInfo *convertBoxType(SILBoxType *T);
159159
const TypeInfo *convertArchetypeType(ArchetypeType *T);
160160
const TypeInfo *convertInOutType(InOutType *T);
161-
const TypeInfo *convertSILMoveOnlyType(SILMoveOnlyType *T) {
161+
const TypeInfo *convertSILMoveOnlyWrappedType(SILMoveOnlyWrappedType *T) {
162162
return convertType(T->getInnerType());
163163
}
164164
const TypeInfo *convertExistentialMetatypeType(ExistentialMetatypeType *T);

‎lib/IRGen/MetadataRequest.cpp

Lines changed: 3 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -1944,8 +1944,9 @@ namespace {
19441944
DynamicMetadataRequest request) {
19451945
llvm_unreachable("should not be asking for metadata of a SILToken type");
19461946
}
1947-
MetadataResponse visitSILMoveOnlyType(CanSILMoveOnlyType type,
1948-
DynamicMetadataRequest request) {
1947+
MetadataResponse
1948+
visitSILMoveOnlyWrappedType(CanSILMoveOnlyWrappedType type,
1949+
DynamicMetadataRequest request) {
19491950
llvm_unreachable("should not be asking for metadata of a move only type");
19501951
}
19511952
MetadataResponse visitArchetypeType(CanArchetypeType type,

‎lib/SIL/IR/AbstractionPattern.cpp

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -426,7 +426,7 @@ AbstractionPattern AbstractionPattern::removingMoveOnlyWrapper() const {
426426
case Kind::Opaque:
427427
case Kind::Tuple:
428428
case Kind::Type:
429-
if (auto mvi = dyn_cast<SILMoveOnlyType>(getType())) {
429+
if (auto mvi = dyn_cast<SILMoveOnlyWrappedType>(getType())) {
430430
return AbstractionPattern(getGenericSignature(), mvi->getInnerType());
431431
}
432432
return *this;
@@ -460,10 +460,10 @@ AbstractionPattern AbstractionPattern::addingMoveOnlyWrapper() const {
460460
case Kind::Opaque:
461461
case Kind::Tuple:
462462
case Kind::Type:
463-
if (isa<SILMoveOnlyType>(getType()))
463+
if (isa<SILMoveOnlyWrappedType>(getType()))
464464
return *this;
465465
return AbstractionPattern(getGenericSignature(),
466-
SILMoveOnlyType::get(getType()));
466+
SILMoveOnlyWrappedType::get(getType()));
467467
}
468468

469469
llvm_unreachable("bad kind");

‎lib/SIL/IR/SILType.cpp

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -295,7 +295,7 @@ SILType SILType::getFieldType(VarDecl *field, TypeConverter &TC,
295295
// If this type is not a class type, then we propagate "move only"-ness to the
296296
// field. Example:
297297
if (!getClassOrBoundGenericClass() && isMoveOnlyWrapped())
298-
loweredTy = SILMoveOnlyType::get(loweredTy);
298+
loweredTy = SILMoveOnlyWrappedType::get(loweredTy);
299299

300300
if (isAddress() || getClassOrBoundGenericClass() != nullptr) {
301301
return SILType::getPrimitiveAddressType(loweredTy);

‎lib/SIL/IR/TypeLowering.cpp

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -694,9 +694,9 @@ namespace {
694694
type, getReferenceRecursiveProperties(isSensitive));
695695
}
696696

697-
RetTy visitSILMoveOnlyType(CanSILMoveOnlyType type,
698-
AbstractionPattern origType,
699-
IsTypeExpansionSensitive_t isSensitive) {
697+
RetTy visitSILMoveOnlyWrappedType(CanSILMoveOnlyWrappedType type,
698+
AbstractionPattern origType,
699+
IsTypeExpansionSensitive_t isSensitive) {
700700
AbstractionPattern innerAbstraction = origType.removingMoveOnlyWrapper();
701701
CanType innerType = type->getInnerType();
702702
auto &lowering =

‎lib/SILGen/SILGenDecl.cpp

Lines changed: 4 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -447,7 +447,7 @@ class LetValueInitialization : public Initialization {
447447
if (SGF.getASTContext().LangOpts.Features.count(Feature::MoveOnly) &&
448448
vd->getAttrs().hasAttribute<NoImplicitCopyAttr>()) {
449449
lowering = &SGF.getTypeLowering(
450-
SILMoveOnlyType::get(vd->getType()->getCanonicalType()));
450+
SILMoveOnlyWrappedType::get(vd->getType()->getCanonicalType()));
451451
} else {
452452
lowering = &SGF.getTypeLowering(vd->getType());
453453
}
@@ -576,8 +576,9 @@ class LetValueInitialization : public Initialization {
576576
value->getOwnershipKind() == OwnershipKind::Owned) {
577577
assert(wasPlusOne);
578578
// NOTE: If our type is trivial when not wrapped in a
579-
// SILMoveOnlyType, this will return a trivial value. We rely on the
580-
// checker to determine if this is an acceptable use of the value.
579+
// SILMoveOnlyWrappedType, this will return a trivial value. We rely
580+
// on the checker to determine if this is an acceptable use of the
581+
// value.
581582
value = SGF.B.createOwnedMoveOnlyWrapperToCopyableValue(PrologueLoc,
582583
value);
583584
}

‎lib/SILOptimizer/Mandatory/MoveOnlyTypeEliminator.cpp

Lines changed: 14 additions & 13 deletions
Original file line numberDiff line numberDiff line change
@@ -1,4 +1,4 @@
1-
//===--- SILMoveOnlyTypeEliminator.cpp ------------------------------------===//
1+
//===--- SILMoveOnlyWrappedTypeEliminator.cpp -----------------------------===//
22
//
33
// This source file is part of the Swift.org open source project
44
//
@@ -47,11 +47,11 @@ using namespace swift;
4747

4848
namespace {
4949

50-
struct SILMoveOnlyTypeEliminatorVisitor
51-
: SILInstructionVisitor<SILMoveOnlyTypeEliminatorVisitor, bool> {
50+
struct SILMoveOnlyWrappedTypeEliminatorVisitor
51+
: SILInstructionVisitor<SILMoveOnlyWrappedTypeEliminatorVisitor, bool> {
5252
const SmallSetVector<SILArgument *, 8> &touchedArgs;
5353

54-
SILMoveOnlyTypeEliminatorVisitor(
54+
SILMoveOnlyWrappedTypeEliminatorVisitor(
5555
const SmallSetVector<SILArgument *, 8> &touchedArgs)
5656
: touchedArgs(touchedArgs) {}
5757

@@ -194,19 +194,19 @@ struct SILMoveOnlyTypeEliminatorVisitor
194194

195195
namespace {
196196

197-
struct SILMoveOnlyTypeEliminator {
197+
struct SILMoveOnlyWrappedTypeEliminator {
198198
SILFunction *fn;
199199
bool trivialOnly;
200200

201-
SILMoveOnlyTypeEliminator(SILFunction *fn, bool trivialOnly)
201+
SILMoveOnlyWrappedTypeEliminator(SILFunction *fn, bool trivialOnly)
202202
: fn(fn), trivialOnly(trivialOnly) {}
203203

204204
bool process();
205205
};
206206

207207
} // namespace
208208

209-
bool SILMoveOnlyTypeEliminator::process() {
209+
bool SILMoveOnlyWrappedTypeEliminator::process() {
210210
bool madeChange = true;
211211

212212
SmallSetVector<SILArgument *, 8> touchedArgs;
@@ -258,7 +258,7 @@ bool SILMoveOnlyTypeEliminator::process() {
258258
}
259259
}
260260

261-
SILMoveOnlyTypeEliminatorVisitor visitor(touchedArgs);
261+
SILMoveOnlyWrappedTypeEliminatorVisitor visitor(touchedArgs);
262262
while (!touchedInsts.empty()) {
263263
visitor.visit(touchedInsts.pop_back_val());
264264
}
@@ -272,10 +272,10 @@ bool SILMoveOnlyTypeEliminator::process() {
272272

273273
namespace {
274274

275-
struct SILMoveOnlyTypeEliminatorPass : SILFunctionTransform {
275+
struct SILMoveOnlyWrappedTypeEliminatorPass : SILFunctionTransform {
276276
bool trivialOnly;
277277

278-
SILMoveOnlyTypeEliminatorPass(bool trivialOnly)
278+
SILMoveOnlyWrappedTypeEliminatorPass(bool trivialOnly)
279279
: SILFunctionTransform(), trivialOnly(trivialOnly) {}
280280

281281
void run() override {
@@ -289,7 +289,8 @@ struct SILMoveOnlyTypeEliminatorPass : SILFunctionTransform {
289289
assert(fn->getModule().getStage() == SILStage::Raw &&
290290
"Should only run on Raw SIL");
291291

292-
if (SILMoveOnlyTypeEliminator(getFunction(), trivialOnly).process()) {
292+
if (SILMoveOnlyWrappedTypeEliminator(getFunction(), trivialOnly)
293+
.process()) {
293294
invalidateAnalysis(SILAnalysis::InvalidationKind::Instructions);
294295
}
295296
}
@@ -298,9 +299,9 @@ struct SILMoveOnlyTypeEliminatorPass : SILFunctionTransform {
298299
} // anonymous namespace
299300

300301
SILTransform *swift::createTrivialMoveOnlyTypeEliminator() {
301-
return new SILMoveOnlyTypeEliminatorPass(true /*trivial only*/);
302+
return new SILMoveOnlyWrappedTypeEliminatorPass(true /*trivial only*/);
302303
}
303304

304305
SILTransform *swift::createMoveOnlyTypeEliminator() {
305-
return new SILMoveOnlyTypeEliminatorPass(false /*trivial only*/);
306+
return new SILMoveOnlyWrappedTypeEliminatorPass(false /*trivial only*/);
306307
}

‎lib/Sema/TypeCheckType.cpp

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -2853,7 +2853,7 @@ TypeResolver::resolveAttributedType(TypeAttributes &attrs, TypeRepr *repr,
28532853

28542854
// In SIL *only*, allow @moveOnly to specify a moveOnly type.
28552855
if ((options & TypeResolutionFlags::SILType) && attrs.has(TAK_moveOnly)) {
2856-
ty = SILMoveOnlyType::get(ty->getCanonicalType());
2856+
ty = SILMoveOnlyWrappedType::get(ty->getCanonicalType());
28572857
attrs.clearAttribute(TAK_moveOnly);
28582858
}
28592859

0 commit comments

Comments
 (0)