[no-implicit-copy] Rename SILMoveOnlyType -> SILMoveOnlyWrappedType.

include/swift/AST/TypeDifferenceVisitor.h

@@ -333,8 +333,8 @@ class CanTypeDifferenceVisitor : public CanTypePairVisitor<Impl, bool> {
     return asImpl().visit(type1->getCaptureType(), type2->getCaptureType());
   }
 
-  bool visitSILMoveOnlyType(CanSILMoveOnlyType type1,
-                            CanSILMoveOnlyType type2) {
+  bool visitSILMoveOnlyWrappedType(CanSILMoveOnlyWrappedType type1,
+                                   CanSILMoveOnlyWrappedType type2) {
     return asImpl().visit(type1->getInnerType(), type2->getInnerType());
   }
 

include/swift/AST/TypeMatcher.h

@@ -352,7 +352,7 @@ class TypeMatcher {
     TRIVIAL_CASE(SILFunctionType)
     TRIVIAL_CASE(SILBlockStorageType)
     TRIVIAL_CASE(SILBoxType)
-    TRIVIAL_CASE(SILMoveOnlyType)
+    TRIVIAL_CASE(SILMoveOnlyWrappedType)
 
     bool visitProtocolCompositionType(CanProtocolCompositionType firstProtocolComposition,
                                       Type secondType,

include/swift/AST/TypeNodes.def

@@ -159,7 +159,7 @@ ABSTRACT_TYPE(AnyFunction, Type)
 ARTIFICIAL_TYPE(SILFunction, Type)
 ARTIFICIAL_TYPE(SILBlockStorage, Type)
 ARTIFICIAL_TYPE(SILBox, Type)
-ARTIFICIAL_TYPE(SILMoveOnly, Type)
+ARTIFICIAL_TYPE(SILMoveOnlyWrapped, Type)
 ARTIFICIAL_TYPE(SILToken, Type)
 TYPE(ProtocolComposition, Type)
 TYPE(ParameterizedProtocol, Type)

include/swift/AST/Types.h

@@ -5002,19 +5002,20 @@ class SILBoxType final : public TypeBase, public llvm::FoldingSetNode
 };
 DEFINE_EMPTY_CAN_TYPE_WRAPPER(SILBoxType, Type)
 
-class SILMoveOnlyType;
+class SILMoveOnlyWrappedType;
 class SILModule; // From SIL
-typedef CanTypeWrapper<SILMoveOnlyType> CanMoveOnlyType;
+typedef CanTypeWrapper<SILMoveOnlyWrappedType> CanMoveOnlyType;
 
 /// A wrapper type that marks an inner type as being a move only value. Can not
 /// be written directly at the Swift level, instead it is triggered by adding
 /// the type attribute @_moveOnly to a different type. We transform these in
 /// TypeLowering into a moveOnly SILType on the inner type.
-class SILMoveOnlyType final : public TypeBase, public llvm::FoldingSetNode {
+class SILMoveOnlyWrappedType final : public TypeBase,
+                                     public llvm::FoldingSetNode {
   CanType innerType;
 
-  SILMoveOnlyType(CanType innerType)
-      : TypeBase(TypeKind::SILMoveOnly, &innerType->getASTContext(),
+  SILMoveOnlyWrappedType(CanType innerType)
+      : TypeBase(TypeKind::SILMoveOnlyWrapped, &innerType->getASTContext(),
                  innerType->getRecursiveProperties()),
         innerType(innerType) {}
 
@@ -5024,10 +5025,10 @@ class SILMoveOnlyType final : public TypeBase, public llvm::FoldingSetNode {
   static CanMoveOnlyType get(CanType innerType);
 
   static bool classof(const TypeBase *T) {
-    return T->getKind() == TypeKind::SILMoveOnly;
+    return T->getKind() == TypeKind::SILMoveOnlyWrapped;
   }
 };
-DEFINE_EMPTY_CAN_TYPE_WRAPPER(SILMoveOnlyType, Type)
+DEFINE_EMPTY_CAN_TYPE_WRAPPER(SILMoveOnlyWrappedType, Type)
 
 class SILBlockStorageType;
 typedef CanTypeWrapper<SILBlockStorageType> CanSILBlockStorageType;

include/swift/SIL/SILType.h

@@ -607,15 +607,15 @@ class SILType {
   /// Canonical way to check if a SILType is move only. Using is/getAs/castTo
   /// will look through moveonly-ness.
   bool isMoveOnlyWrapped() const {
-    return getRawASTType()->is<SILMoveOnlyType>();
+    return getRawASTType()->is<SILMoveOnlyWrappedType>();
   }
 
   /// If this is already a move only wrapped type, return *this. Otherwise, wrap
   /// the copyable type in the mov eonly wrapper.
   SILType addingMoveOnlyWrapper() const {
     if (isMoveOnlyWrapped())
       return *this;
-    auto newType = SILMoveOnlyType::get(getRawASTType());
+    auto newType = SILMoveOnlyWrappedType::get(getRawASTType());
     return SILType::getPrimitiveType(newType, getCategory());
   }
 
@@ -624,7 +624,7 @@ class SILType {
   SILType removingMoveOnlyWrapper() const {
     if (!isMoveOnlyWrapped())
       return *this;
-    auto moveOnly = getRawASTType()->castTo<SILMoveOnlyType>();
+    auto moveOnly = getRawASTType()->castTo<SILMoveOnlyWrappedType>();
     return SILType::getPrimitiveType(moveOnly->getInnerType(), getCategory());
   }
 

include/swift/SIL/SILValue.h

@@ -563,7 +563,7 @@ class ValueBase : public SILNode, public SILAllocated<ValueBase> {
   /// otherwise.
   ///
   /// NOTE: Please do not use this directly! It is only meant to be used by the
-  /// optimizer pass: SILMoveOnlyTypeEliminator.
+  /// optimizer pass: SILMoveOnlyWrappedTypeEliminator.
   bool unsafelyEliminateMoveOnlyWrapper() {
     if (!Type.isMoveOnlyWrapped())
       return false;

lib/AST/ASTContext.cpp

@@ -462,7 +462,7 @@ struct ASTContext::Implementation {
   llvm::FoldingSet<GenericFunctionType> GenericFunctionTypes;
   llvm::FoldingSet<SILFunctionType> SILFunctionTypes;
   llvm::DenseMap<CanType, SILBlockStorageType *> SILBlockStorageTypes;
-  llvm::DenseMap<CanType, SILMoveOnlyType *> SILMoveOnlyTypes;
+  llvm::DenseMap<CanType, SILMoveOnlyWrappedType *> SILMoveOnlyWrappedTypes;
   llvm::FoldingSet<SILBoxType> SILBoxTypes;
   llvm::DenseMap<BuiltinIntegerWidth, BuiltinIntegerType*> IntegerTypes;
   llvm::FoldingSet<BuiltinVectorType> BuiltinVectorTypes;
@@ -4074,17 +4074,18 @@ SILFunctionType::SILFunctionType(
 #endif
 }
 
-CanSILMoveOnlyType SILMoveOnlyType::get(CanType innerType) {
+CanSILMoveOnlyWrappedType SILMoveOnlyWrappedType::get(CanType innerType) {
   ASTContext &ctx = innerType->getASTContext();
-  auto found = ctx.getImpl().SILMoveOnlyTypes.find(innerType);
-  if (found != ctx.getImpl().SILMoveOnlyTypes.end())
-    return CanSILMoveOnlyType(found->second);
+  auto found = ctx.getImpl().SILMoveOnlyWrappedTypes.find(innerType);
+  if (found != ctx.getImpl().SILMoveOnlyWrappedTypes.end())
+    return CanSILMoveOnlyWrappedType(found->second);
 
-  void *mem = ctx.Allocate(sizeof(SILMoveOnlyType), alignof(SILMoveOnlyType));
+  void *mem = ctx.Allocate(sizeof(SILMoveOnlyWrappedType),
+                           alignof(SILMoveOnlyWrappedType));
 
-  auto *storageTy = new (mem) SILMoveOnlyType(innerType);
-  ctx.getImpl().SILMoveOnlyTypes.insert({innerType, storageTy});
-  return CanSILMoveOnlyType(storageTy);
+  auto *storageTy = new (mem) SILMoveOnlyWrappedType(innerType);
+  ctx.getImpl().SILMoveOnlyWrappedTypes.insert({innerType, storageTy});
+  return CanSILMoveOnlyWrappedType(storageTy);
 }
 
 CanSILBlockStorageType SILBlockStorageType::get(CanType captureType) {

lib/AST/ASTDumper.cpp

@@ -3935,7 +3935,8 @@ namespace {
       PrintWithColorRAII(OS, ParenthesisColor) << ')';
     }
 
-    void visitSILMoveOnlyType(SILMoveOnlyType *T, StringRef label) {
+    void visitSILMoveOnlyWrappedType(SILMoveOnlyWrappedType *T,
+                                     StringRef label) {
       printCommon(label, "sil_move_only_type");
       printRec(T->getInnerType());
       PrintWithColorRAII(OS, ParenthesisColor) << ')';

lib/AST/ASTMangler.cpp

@@ -1451,7 +1451,7 @@ void ASTMangler::appendType(Type type, GenericSignature sig,
 
       return;
     }
-    case TypeKind::SILMoveOnly:
+    case TypeKind::SILMoveOnlyWrapped:
       // If we hit this, we just mangle the underlying name and move on.
       llvm_unreachable("should never be mangled?");
     case TypeKind::SILBlockStorage:

lib/AST/ASTPrinter.cpp

@@ -6203,7 +6203,7 @@ class TypePrinter : public TypeVisitor<TypePrinter> {
     }
   }
 
-  void visitSILMoveOnlyType(SILMoveOnlyType *T) {
+  void visitSILMoveOnlyWrappedType(SILMoveOnlyWrappedType *T) {
     Printer << "@moveOnly ";
     printWithParensIfNotSimple(T->getInnerType());
   }

lib/AST/ExistentialGeneralization.cpp

@@ -175,7 +175,7 @@ class Generalizer : public CanTypeVisitor<Generalizer, Type> {
   INVALID_TO_GENERALIZE(SILBox)
   INVALID_TO_GENERALIZE(SILFunction)
   INVALID_TO_GENERALIZE(SILToken)
-  INVALID_TO_GENERALIZE(SILMoveOnly)
+  INVALID_TO_GENERALIZE(SILMoveOnlyWrapped)
 #undef INVALID_TO_GENERALIZE
 
   /// Generalize the generic arguments of the given generic type.s

lib/AST/Type.cpp

@@ -192,9 +192,10 @@ bool CanType::isReferenceTypeImpl(CanType type, const GenericSignatureImpl *sig,
   case TypeKind::DynamicSelf:
     return isReferenceTypeImpl(cast<DynamicSelfType>(type).getSelfType(),
                                sig, functionsCount);
-  case TypeKind::SILMoveOnly:
-    return isReferenceTypeImpl(cast<SILMoveOnlyType>(type)->getInnerType(), sig,
-                               functionsCount);
+  case TypeKind::SILMoveOnlyWrapped:
+    return isReferenceTypeImpl(
+        cast<SILMoveOnlyWrappedType>(type)->getInnerType(), sig,
+        functionsCount);
 
   // Archetypes and existentials are only class references if class-bounded.
   case TypeKind::PrimaryArchetype:
@@ -330,7 +331,7 @@ ExistentialLayout CanType::getExistentialLayout() {
   CanType ty = *this;
 
   // Always remove one layer of move only ness.
-  if (auto mv = dyn_cast<SILMoveOnlyType>(ty))
+  if (auto mv = dyn_cast<SILMoveOnlyWrappedType>(ty))
     ty = mv->getInnerType();
 
   if (auto existential = dyn_cast<ExistentialType>(ty))
@@ -1685,7 +1686,7 @@ CanType TypeBase::computeCanonicalType() {
   case TypeKind::SILBox:
   case TypeKind::SILFunction:
   case TypeKind::SILToken:
-  case TypeKind::SILMoveOnly:
+  case TypeKind::SILMoveOnlyWrapped:
     llvm_unreachable("SIL-only types are always canonical!");
 
   case TypeKind::ProtocolComposition: {
@@ -5149,15 +5150,15 @@ case TypeKind::Id:
     return storageTy;
   }
 
-  case TypeKind::SILMoveOnly: {
-    auto *storageTy = cast<SILMoveOnlyType>(base);
+  case TypeKind::SILMoveOnlyWrapped: {
+    auto *storageTy = cast<SILMoveOnlyWrappedType>(base);
     Type transCap = storageTy->getInnerType().transformWithPosition(
         TypePosition::Invariant, fn);
     if (!transCap)
       return Type();
     CanType canTransCap = transCap->getCanonicalType();
     if (canTransCap != storageTy->getInnerType())
-      return SILMoveOnlyType::get(canTransCap);
+      return SILMoveOnlyWrappedType::get(canTransCap);
     return storageTy;
   }
 
@@ -6071,8 +6072,10 @@ ReferenceCounting TypeBase::getReferenceCounting() {
   case TypeKind::DynamicSelf:
     return cast<DynamicSelfType>(type).getSelfType()
         ->getReferenceCounting();
-  case TypeKind::SILMoveOnly:
-    return cast<SILMoveOnlyType>(type)->getInnerType()->getReferenceCounting();
+  case TypeKind::SILMoveOnlyWrapped:
+    return cast<SILMoveOnlyWrappedType>(type)
+        ->getInnerType()
+        ->getReferenceCounting();
 
   case TypeKind::PrimaryArchetype:
   case TypeKind::OpenedArchetype:

lib/AST/TypeWalker.cpp

@@ -234,7 +234,7 @@ class Traversal : public TypeVisitor<Traversal, bool>
     return doIt(ty->getCaptureType());
   }
 
-  bool visitSILMoveOnlyType(SILMoveOnlyType *ty) {
+  bool visitSILMoveOnlyWrappedType(SILMoveOnlyWrappedType *ty) {
     return doIt(ty->getInnerType());
   }
 

lib/ClangImporter/ImportType.cpp

@@ -1920,7 +1920,7 @@ class GetSendableType :
   NEVER_VISIT(SILBlockStorageType)
   NEVER_VISIT(SILBoxType)
   NEVER_VISIT(SILTokenType)
-  NEVER_VISIT(SILMoveOnlyType)
+  NEVER_VISIT(SILMoveOnlyWrappedType)
 
   VISIT(ProtocolCompositionType, compose)
 

lib/IRGen/GenType.cpp

@@ -2169,7 +2169,7 @@ const TypeInfo *TypeConverter::convertType(CanType ty) {
   case TypeKind::BoundGenericEnum:
   case TypeKind::BoundGenericStruct:
     return convertAnyNominalType(ty, cast<BoundGenericType>(ty)->getDecl());
-  case TypeKind::SILMoveOnly:
+  case TypeKind::SILMoveOnlyWrapped:
     llvm_unreachable("implement this");
   case TypeKind::InOut:
     return convertInOutType(cast<InOutType>(ty));

lib/IRGen/GenType.h

@@ -158,7 +158,7 @@ class TypeConverter {
   const TypeInfo *convertBoxType(SILBoxType *T);
   const TypeInfo *convertArchetypeType(ArchetypeType *T);
   const TypeInfo *convertInOutType(InOutType *T);
-  const TypeInfo *convertSILMoveOnlyType(SILMoveOnlyType *T) {
+  const TypeInfo *convertSILMoveOnlyWrappedType(SILMoveOnlyWrappedType *T) {
     return convertType(T->getInnerType());
   }
   const TypeInfo *convertExistentialMetatypeType(ExistentialMetatypeType *T);

lib/IRGen/IRGenDebugInfo.cpp

@@ -1725,8 +1725,7 @@ class IRGenDebugInfoImpl : public IRGenDebugInfo {
     case TypeKind::SILToken:
     case TypeKind::BuiltinUnsafeValueBuffer:
     case TypeKind::BuiltinDefaultActorStorage:
-    case TypeKind::SILMoveOnly:
-
+    case TypeKind::SILMoveOnlyWrapped:
       LLVM_DEBUG(llvm::dbgs() << "Unhandled type: ";
                  DbgTy.getType()->dump(llvm::dbgs()); llvm::dbgs() << "\n");
       MangledName = "<unknown>";

lib/IRGen/MetadataRequest.cpp

@@ -1944,8 +1944,9 @@ namespace {
                                           DynamicMetadataRequest request) {
       llvm_unreachable("should not be asking for metadata of a SILToken type");
     }
-    MetadataResponse visitSILMoveOnlyType(CanSILMoveOnlyType type,
-                                          DynamicMetadataRequest request) {
+    MetadataResponse
+    visitSILMoveOnlyWrappedType(CanSILMoveOnlyWrappedType type,
+                                DynamicMetadataRequest request) {
       llvm_unreachable("should not be asking for metadata of a move only type");
     }
     MetadataResponse visitArchetypeType(CanArchetypeType type,

lib/SIL/IR/AbstractionPattern.cpp

@@ -426,7 +426,7 @@ AbstractionPattern AbstractionPattern::removingMoveOnlyWrapper() const {
   case Kind::Opaque:
   case Kind::Tuple:
   case Kind::Type:
-    if (auto mvi = dyn_cast<SILMoveOnlyType>(getType())) {
+    if (auto mvi = dyn_cast<SILMoveOnlyWrappedType>(getType())) {
       return AbstractionPattern(getGenericSignature(), mvi->getInnerType());
     }
     return *this;
@@ -460,10 +460,10 @@ AbstractionPattern AbstractionPattern::addingMoveOnlyWrapper() const {
   case Kind::Opaque:
   case Kind::Tuple:
   case Kind::Type:
-    if (isa<SILMoveOnlyType>(getType()))
+    if (isa<SILMoveOnlyWrappedType>(getType()))
       return *this;
     return AbstractionPattern(getGenericSignature(),
-                              SILMoveOnlyType::get(getType()));
+                              SILMoveOnlyWrappedType::get(getType()));
   }
 
   llvm_unreachable("bad kind");

lib/SIL/IR/SILType.cpp

@@ -295,7 +295,7 @@ SILType SILType::getFieldType(VarDecl *field, TypeConverter &TC,
   // If this type is not a class type, then we propagate "move only"-ness to the
   // field. Example:
   if (!getClassOrBoundGenericClass() && isMoveOnlyWrapped())
-    loweredTy = SILMoveOnlyType::get(loweredTy);
+    loweredTy = SILMoveOnlyWrappedType::get(loweredTy);
 
   if (isAddress() || getClassOrBoundGenericClass() != nullptr) {
     return SILType::getPrimitiveAddressType(loweredTy);

lib/SIL/IR/TypeLowering.cpp

@@ -694,9 +694,9 @@ namespace {
           type, getReferenceRecursiveProperties(isSensitive));
     }
 
-    RetTy visitSILMoveOnlyType(CanSILMoveOnlyType type,
-                               AbstractionPattern origType,
-                               IsTypeExpansionSensitive_t isSensitive) {
+    RetTy visitSILMoveOnlyWrappedType(CanSILMoveOnlyWrappedType type,
+                                      AbstractionPattern origType,
+                                      IsTypeExpansionSensitive_t isSensitive) {
       AbstractionPattern innerAbstraction = origType.removingMoveOnlyWrapper();
       CanType innerType = type->getInnerType();
       auto &lowering =

lib/SILGen/SILGenDecl.cpp

@@ -447,7 +447,7 @@ class LetValueInitialization : public Initialization {
     if (SGF.getASTContext().LangOpts.Features.count(Feature::MoveOnly) &&
         vd->getAttrs().hasAttribute<NoImplicitCopyAttr>()) {
       lowering = &SGF.getTypeLowering(
-          SILMoveOnlyType::get(vd->getType()->getCanonicalType()));
+          SILMoveOnlyWrappedType::get(vd->getType()->getCanonicalType()));
     } else {
       lowering = &SGF.getTypeLowering(vd->getType());
     }
@@ -576,8 +576,9 @@ class LetValueInitialization : public Initialization {
               value->getOwnershipKind() == OwnershipKind::Owned) {
             assert(wasPlusOne);
             // NOTE: If our type is trivial when not wrapped in a
-            // SILMoveOnlyType, this will return a trivial value. We rely on the
-            // checker to determine if this is an acceptable use of the value.
+            // SILMoveOnlyWrappedType, this will return a trivial value. We rely
+            // on the checker to determine if this is an acceptable use of the
+            // value.
             value = SGF.B.createOwnedMoveOnlyWrapperToCopyableValue(PrologueLoc,
                                                                     value);
           }