[move-only] Add support to SILType for unwrapping move only types and performing basic queries by looking through the move only type wrapper.

This is done by introducing the API SILType::getSemanticASTType(). This can be
used in contexts for type queries like getStructOrBoundGenericStruct() where one
wants to look through the move only wrapper to the underlying type.

Author: gottesmm

include/swift/SIL/SILType.h

@@ -179,10 +179,18 @@ class SILType {
   ///    `@thick AnyObject.Type`.
   ///    More generally, you cannot recover a formal type from
   ///    a lowered type. See docs/SIL.rst for more details.
-  CanType getASTType() const {
-    return CanType(value.getPointer());
-  }
-  
+  /// 3. If the underlying type is move only, the returned CanType will not be
+  ///    pointer equal to the RawASTType since we return the unwrapped inner
+  ///    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(); }
+
+  /// Returns the canonical AST type references by this SIL type without looking
+  /// through move only. Should only be used by internal utilities of SILType.
+  CanType getRawASTType() const { return CanType(value.getPointer()); }
+
+public:
   // FIXME -- Temporary until LLDB adopts getASTType()
   LLVM_ATTRIBUTE_DEPRECATED(CanType getSwiftRValueType() const,
                             "Please use getASTType()") {
@@ -411,9 +419,7 @@ class SILType {
   }
 
   /// True if the type involves any archetypes.
-  bool hasArchetype() const {
-    return getASTType()->hasArchetype();
-  }
+  bool hasArchetype() const { return getASTType()->hasArchetype(); }
 
   /// True if the type involves any opaque archetypes.
   bool hasOpaqueArchetype() const {
@@ -586,7 +592,42 @@ class SILType {
 
   /// Returns true if this is the AnyObject SILType;
   bool isAnyObject() const { return getASTType()->isAnyObject(); }
-  
+
+  /// Returns true if this SILType is a move only wrapper type.
+  ///
+  /// 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>(); }
+
+  /// 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())
+      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())
+      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
+  /// from a parent type to a subtype.
+  SILType copyMoveOnly(SILType otherType) const {
+    if (otherType.isMoveOnly()) {
+      return asMoveOnly();
+    }
+    return *this;
+  }
+
   /// Returns a SILType with any archetypes mapped out of context.
   SILType mapTypeOutOfContext() const;
 

lib/AST/Type.cpp

@@ -322,19 +322,25 @@ ExistentialLayout TypeBase::getExistentialLayout() {
 }
 
 ExistentialLayout CanType::getExistentialLayout() {
-  if (auto existential = dyn_cast<ExistentialType>(*this))
-    return existential.getConstraintType().getExistentialLayout();
+  CanType ty = *this;
+
+  // Always remove one layer of move only ness.
+  if (auto mv = dyn_cast<SILMoveOnlyType>(ty))
+    ty = mv->getInnerType();
+
+  if (auto existential = dyn_cast<ExistentialType>(ty))
+    return existential->getConstraintType()->getExistentialLayout();
 
-  if (auto metatype = dyn_cast<ExistentialMetatypeType>(*this))
-    return metatype.getInstanceType().getExistentialLayout();
+  if (auto metatype = dyn_cast<ExistentialMetatypeType>(ty))
+    return metatype->getInstanceType()->getExistentialLayout();
 
-  if (auto proto = dyn_cast<ProtocolType>(*this))
+  if (auto proto = dyn_cast<ProtocolType>(ty))
     return ExistentialLayout(proto);
 
-  if (auto param = dyn_cast<ParameterizedProtocolType>(*this))
+  if (auto param = dyn_cast<ParameterizedProtocolType>(ty))
     return ExistentialLayout(param);
 
-  auto comp = cast<ProtocolCompositionType>(*this);
+  auto comp = cast<ProtocolCompositionType>(ty);
   return ExistentialLayout(comp);
 }
 

lib/SIL/IR/SILPrinter.cpp

@@ -461,9 +461,12 @@ static void printSILTypeColorAndSigil(raw_ostream &OS, SILType t) {
 
 void SILType::print(raw_ostream &OS, const PrintOptions &PO) const {
   printSILTypeColorAndSigil(OS, *this);
-  
+
   // Print other types as their Swift representation.
-  getASTType().print(OS, PO);
+  //
+  // NOTE: We always print the Raw AST type so we don't look through
+  // move-onlyness.
+  getRawASTType().print(OS, PO);
 }
 
 void SILType::dump() const {
@@ -647,7 +650,7 @@ class SILPrinter : public SILInstructionVisitor<SILPrinter> {
 
   SILPrinter &operator<<(SILType t) {
     printSILTypeColorAndSigil(PrintState.OS, t);
-    t.getASTType().print(PrintState.OS, PrintState.ASTOptions);
+    t.getRawASTType().print(PrintState.OS, PrintState.ASTOptions);
     return *this;
   }
 

lib/SIL/IR/SILType.cpp

@@ -91,7 +91,8 @@ SILType SILType::getOptionalType(SILType type) {
   auto &ctx = type.getASTContext();
   auto optType = BoundGenericEnumType::get(ctx.getOptionalDecl(), Type(),
                                            { type.getASTType() });
-  return getPrimitiveType(CanType(optType), type.getCategory());
+  return getPrimitiveType(CanType(optType), type.getCategory())
+      .copyMoveOnly(type);
 }
 
 SILType SILType::getEmptyTupleType(const ASTContext &C) {
@@ -164,7 +165,7 @@ bool SILType::isNoReturnFunction(SILModule &M,
 
 std::string SILType::getMangledName() const {
   Mangle::ASTMangler mangler;
-  return mangler.mangleTypeWithoutPrefix(getASTType());
+  return mangler.mangleTypeWithoutPrefix(getRawASTType());
 }
 
 std::string SILType::getAsString() const {
@@ -287,11 +288,17 @@ SILType SILType::getFieldType(VarDecl *field, TypeConverter &TC,
     substFieldTy = origFieldTy.getType();
   } else {
     substFieldTy =
-      getASTType()->getTypeOfMember(&TC.M, field)->getCanonicalType();
+        getASTType()->getTypeOfMember(&TC.M, field)->getCanonicalType();
   }
 
   auto loweredTy =
       TC.getLoweredRValueType(context, origFieldTy, substFieldTy);
+
+  // If this type is not a class type, then we propagate "move only"-ness to the
+  // field. Example:
+  if (!getClassOrBoundGenericClass() && isMoveOnly())
+    loweredTy = SILMoveOnlyType::get(loweredTy);
+
   if (isAddress() || getClassOrBoundGenericClass() != nullptr) {
     return SILType::getPrimitiveAddressType(loweredTy);
   } else {
@@ -311,7 +318,7 @@ SILType SILType::getEnumElementType(EnumElementDecl *elt, TypeConverter &TC,
 
   if (auto objectType = getASTType().getOptionalObjectType()) {
     assert(elt == TC.Context.getOptionalSomeDecl());
-    return SILType(objectType, getCategory());
+    return SILType(objectType, getCategory()).copyMoveOnly(*this);
   }
 
   // If the case is indirect, then the payload is boxed.
@@ -321,13 +328,12 @@ SILType SILType::getEnumElementType(EnumElementDecl *elt, TypeConverter &TC,
                    getCategory());
   }
 
-  auto substEltTy =
-    getASTType()->getTypeOfMember(&TC.M, elt,
-                                  elt->getArgumentInterfaceType());
+  auto substEltTy = getASTType()->getTypeOfMember(
+      &TC.M, elt, elt->getArgumentInterfaceType());
   auto loweredTy = TC.getLoweredRValueType(
       context, TC.getAbstractionPattern(elt), substEltTy);
 
-  return SILType(loweredTy, getCategory());
+  return SILType(loweredTy, getCategory()).copyMoveOnly(*this);
 }
 
 SILType SILType::getEnumElementType(EnumElementDecl *elt, SILModule &M,
@@ -432,15 +438,15 @@ bool SILType::aggregateHasUnreferenceableStorage() const {
 
 SILType SILType::getOptionalObjectType() const {
   if (auto objectTy = getASTType().getOptionalObjectType()) {
-    return SILType(objectTy, getCategory());
+    return SILType(objectTy, getCategory()).copyMoveOnly(*this);
   }
 
   return SILType();
 }
 
 SILType SILType::unwrapOptionalType() const {
-  if (auto objectTy = getOptionalObjectType()) {
-    return objectTy;
+  if (auto objectTy = withoutMoveOnly().getOptionalObjectType()) {
+    return objectTy.copyMoveOnly(*this);
   }
 
   return *this;