[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.

Author: gottesmm

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());
   }