[move-only] Rename some of the SILType move only wrapper methods to be explicitly about move only wrapper and not move only itself.

Specifically:

* isMoveOnly() -> isMoveOnlyWrapped()
* asMoveOnly() -> addingMoveOnlyWrapper()
* withoutMoveOnly() -> removingMoveOnlyWrapper()
* copyMoveOnly() -> copyingMoveOnlyWrapper()

This is just pure renaming to resolve confusion from the reader.

Author: gottesmm

include/swift/SIL/SILType.h

@@ -188,7 +188,9 @@ class SILType {
   ///    type. This is done under the assumption that in all cases where we are
   ///    performing these AST queries on SILType, we are not interested in the
   ///    move only-ness of the value (which we can query separately anyways).
-  CanType getASTType() const { return withoutMoveOnly().getRawASTType(); }
+  CanType getASTType() const {
+    return removingMoveOnlyWrapper().getRawASTType();
+  }
 
 private:
   /// Returns the canonical AST type references by this SIL type without looking
@@ -602,33 +604,34 @@ class SILType {
   ///
   /// Canonical way to check if a SILType is move only. Using is/getAs/castTo
   /// will look through moveonly-ness.
-  bool isMoveOnly() const { return getRawASTType()->is<SILMoveOnlyType>(); }
+  bool isMoveOnlyWrapped() const {
+    return getRawASTType()->is<SILMoveOnlyType>();
+  }
 
-  /// Return *this if already move only... otherwise, wrap the current type
-  /// within a move only type wrapper and return that. Idempotent!
-  SILType asMoveOnly() const {
-    if (isMoveOnly())
+  /// 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());
     return SILType::getPrimitiveType(newType, getCategory());
   }
 
-  /// Return this SILType, removing moveonly-ness.
-  ///
-  /// Is idempotent.
-  SILType withoutMoveOnly() const {
-    if (!isMoveOnly())
+  /// If this is already a copyable type, just return *this. Otherwise, if this
+  /// is a move only wrapped copyable type, return the inner type.
+  SILType removingMoveOnlyWrapper() const {
+    if (!isMoveOnlyWrapped())
       return *this;
     auto moveOnly = getRawASTType()->castTo<SILMoveOnlyType>();
     return SILType::getPrimitiveType(moveOnly->getInnerType(), getCategory());
   }
 
-  /// If \p otherType is move only, return this type that is move only as
-  /// well. Otherwise, returns self. Useful for propagating "move only"-ness
+  /// If \p otherType is move only wrapped, return this type that is move only
+  /// as well. Otherwise, returns self. Useful for propagating "move only"-ness
   /// from a parent type to a subtype.
-  SILType copyMoveOnly(SILType otherType) const {
-    if (otherType.isMoveOnly()) {
-      return asMoveOnly();
+  SILType copyingMoveOnlyWrapper(SILType otherType) const {
+    if (otherType.isMoveOnlyWrapped()) {
+      return addingMoveOnlyWrapper();
     }
     return *this;
   }

lib/SIL/IR/SILType.cpp

@@ -92,7 +92,7 @@ SILType SILType::getOptionalType(SILType type) {
   auto optType = BoundGenericEnumType::get(ctx.getOptionalDecl(), Type(),
                                            { type.getASTType() });
   return getPrimitiveType(CanType(optType), type.getCategory())
-      .copyMoveOnly(type);
+      .copyingMoveOnlyWrapper(type);
 }
 
 SILType SILType::getEmptyTupleType(const ASTContext &C) {
@@ -296,7 +296,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() && isMoveOnly())
+  if (!getClassOrBoundGenericClass() && isMoveOnlyWrapped())
     loweredTy = SILMoveOnlyType::get(loweredTy);
 
   if (isAddress() || getClassOrBoundGenericClass() != nullptr) {
@@ -318,7 +318,7 @@ SILType SILType::getEnumElementType(EnumElementDecl *elt, TypeConverter &TC,
 
   if (auto objectType = getASTType().getOptionalObjectType()) {
     assert(elt == TC.Context.getOptionalSomeDecl());
-    return SILType(objectType, getCategory()).copyMoveOnly(*this);
+    return SILType(objectType, getCategory()).copyingMoveOnlyWrapper(*this);
   }
 
   // If the case is indirect, then the payload is boxed.
@@ -333,7 +333,7 @@ SILType SILType::getEnumElementType(EnumElementDecl *elt, TypeConverter &TC,
   auto loweredTy = TC.getLoweredRValueType(
       context, TC.getAbstractionPattern(elt), substEltTy);
 
-  return SILType(loweredTy, getCategory()).copyMoveOnly(*this);
+  return SILType(loweredTy, getCategory()).copyingMoveOnlyWrapper(*this);
 }
 
 SILType SILType::getEnumElementType(EnumElementDecl *elt, SILModule &M,
@@ -438,15 +438,15 @@ bool SILType::aggregateHasUnreferenceableStorage() const {
 
 SILType SILType::getOptionalObjectType() const {
   if (auto objectTy = getASTType().getOptionalObjectType()) {
-    return SILType(objectTy, getCategory()).copyMoveOnly(*this);
+    return SILType(objectTy, getCategory()).copyingMoveOnlyWrapper(*this);
   }
 
   return SILType();
 }
 
 SILType SILType::unwrapOptionalType() const {
-  if (auto objectTy = withoutMoveOnly().getOptionalObjectType()) {
-    return objectTy.copyMoveOnly(*this);
+  if (auto objectTy = removingMoveOnlyWrapper().getOptionalObjectType()) {
+    return objectTy.copyingMoveOnlyWrapper(*this);
   }
 
   return *this;