[nfc] rename or eliminate isPureMoveOnly APIs

I think from SIL's perspective, it should only worry about whether the
type is move-only. That includes MoveOnlyWrapped SILTypes and regular
types that cannot be copied.

Most of the code querying `SILType::isPureMoveOnly` is in SILGen, where
it's very likely that the original AST type is sitting around already.
In such cases, I think it's fine to ask the AST type if it is
noncopyable. The clarity of only asking the ASTType if it's noncopyable
is beneficial, I think.

Author: kavon

include/swift/AST/Types.h

@@ -634,8 +634,8 @@ class alignas(1 << TypeAlignInBits) TypeBase
 
   bool isPlaceholder();
 
-  /// Returns true if this is a move-only type.
-  bool isPureMoveOnly();
+  /// Returns true if this is a noncopyable type.
+  bool isNoncopyable();
 
   /// Does the type have outer parenthesis?
   bool hasParenSugar() const { return getKind() == TypeKind::Paren; }
@@ -5351,7 +5351,7 @@ class SILMoveOnlyWrappedType final : public TypeBase,
       : TypeBase(TypeKind::SILMoveOnlyWrapped, &innerType->getASTContext(),
                  innerType->getRecursiveProperties()),
         innerType(innerType) {
-    assert(!innerType->isPureMoveOnly() && "Inner type must be copyable");
+    assert(!innerType->isNoncopyable() && "Inner type must be copyable");
   }
 
 public:

include/swift/SIL/SILType.h

@@ -748,10 +748,6 @@ class SILType {
   /// wrapped type.
   bool isMoveOnly() const;
 
-  /// Is this a type that is a first class move only type. This returns false
-  /// for a move only wrapped type.
-  bool isPureMoveOnly() const;
-
   /// Return true if this is a value type (struct/enum) that requires
   /// deinitialization beyond destruction of its members.
   bool isValueTypeWithDeinit() const;

lib/AST/ASTPrinter.cpp

@@ -3337,7 +3337,7 @@ static bool usesFeatureMoveOnly(Decl *decl) {
     // Check for move-only types in the types of this declaration.
     if (Type type = value->getInterfaceType()) {
       bool hasMoveOnly = type.findIf([](Type type) {
-        return type->isPureMoveOnly();
+        return type->isNoncopyable();
       });
 
       if (hasMoveOnly)

lib/AST/Decl.cpp

@@ -7529,7 +7529,7 @@ LifetimeAnnotation ParamDecl::getLifetimeAnnotation() const {
   auto specifier = getSpecifier();
   // Copyable parameters which are consumed have eager-move semantics.
   if (specifier == ParamDecl::Specifier::Consuming &&
-      !getTypeInContext()->isPureMoveOnly()) {
+      !getTypeInContext()->isNoncopyable()) {
     if (getAttrs().hasAttribute<NoEagerMoveAttr>())
       return LifetimeAnnotation::Lexical;
     return LifetimeAnnotation::EagerMove;
@@ -9765,7 +9765,7 @@ LifetimeAnnotation FuncDecl::getLifetimeAnnotation() const {
   // Copyable parameters which are consumed have eager-move semantics.
   if (getSelfAccessKind() == SelfAccessKind::Consuming) {
     auto *selfDecl = getImplicitSelfDecl();
-    if (selfDecl && !selfDecl->getTypeInContext()->isPureMoveOnly()) {
+    if (selfDecl && !selfDecl->getTypeInContext()->isNoncopyable()) {
       if (getAttrs().hasAttribute<NoEagerMoveAttr>())
         return LifetimeAnnotation::Lexical;
       return LifetimeAnnotation::EagerMove;

lib/AST/Module.cpp

@@ -1797,7 +1797,7 @@ static ProtocolConformanceRef getBuiltinMetaTypeTypeConformance(
 
   // Only metatypes of Copyable types are Copyable.
   if (protocol->isSpecificProtocol(KnownProtocolKind::Copyable) &&
-      !metatypeType->getInstanceType()->isPureMoveOnly()) {
+      !metatypeType->getInstanceType()->isNoncopyable()) {
     return ProtocolConformanceRef(
         ctx.getBuiltinConformance(type, protocol,
                                   BuiltinConformanceKind::Synthesized));

lib/AST/Type.cpp

@@ -157,18 +157,18 @@ bool TypeBase::isMarkerExistential() {
   return true;
 }
 
-bool TypeBase::isPureMoveOnly() {
+bool TypeBase::isNoncopyable() {
   if (auto *nom = getAnyNominal())
     return nom->isMoveOnly();
 
   if (auto *expansion = getAs<PackExpansionType>()) {
-    return expansion->getPatternType()->isPureMoveOnly();
+    return expansion->getPatternType()->isNoncopyable();
   }
 
   // if any components of the tuple are move-only, then the tuple is move-only.
   if (auto *tupl = getCanonicalType()->getAs<TupleType>()) {
     for (auto eltTy : tupl->getElementTypes())
-      if (eltTy->isPureMoveOnly())
+      if (eltTy->isNoncopyable())
         return true;
   }
 

lib/IRGen/GenReflection.cpp

@@ -266,7 +266,7 @@ getTypeRefByFunction(IRGenModule &IGM,
 
         // If a type is noncopyable, lie about the resolved type unless the
         // runtime is sufficiently aware of noncopyable types.
-        if (substT->isPureMoveOnly()) {
+        if (substT->isNoncopyable()) {
           // Darwin-based platforms have ABI stability, and we want binaries
           // that use noncopyable types nongenerically today to be forward
           // compatible with a future OS runtime that supports noncopyable
@@ -391,7 +391,7 @@ getTypeRefImpl(IRGenModule &IGM,
     // noncopyable, use a function to emit the type ref which will look for a
     // signal from future runtimes whether they support noncopyable types before
     // exposing their metadata to them.
-    if (type->isPureMoveOnly()) {
+    if (type->isNoncopyable()) {
       IGM.IRGen.noteUseOfTypeMetadata(type);
       return getTypeRefByFunction(IGM, sig, type);
     }

lib/SIL/IR/SIL.cpp

@@ -333,7 +333,7 @@ static bool isUnsupportedKeyPathValueType(Type ty) {
   // They would also need a new ABI that's yet to be implemented in order to
   // be properly supported, so let's suppress the descriptor for now if either
   // the container or storage type of the declaration is non-copyable.
-  if (ty->isPureMoveOnly())
+  if (ty->isNoncopyable())
     return true;
 
   return false;
@@ -345,7 +345,7 @@ bool AbstractStorageDecl::exportsPropertyDescriptor() const {
 
   if (!isStatic()) {
     if (auto contextTy = getDeclContext()->getDeclaredTypeInContext()) {
-      if (contextTy->isPureMoveOnly()) {
+      if (contextTy->isNoncopyable()) {
         return false;
       }
     }

lib/SIL/IR/SILType.cpp

@@ -1036,7 +1036,7 @@ SILType::getSingletonAggregateFieldType(SILModule &M,
 
 bool SILType::isMoveOnly() const {
   // Nominal types are move-only if declared as such.
-  if (isPureMoveOnly())
+  if (getASTType()->isNoncopyable())
     return true;
 
 
@@ -1054,10 +1054,6 @@ bool SILType::isMoveOnly() const {
   return isMoveOnlyWrapped();
 }
 
-bool SILType::isPureMoveOnly() const {
-  return getASTType()->isPureMoveOnly();
-}
-
 
 
 bool SILType::isValueTypeWithDeinit() const {
@@ -1186,7 +1182,7 @@ SILType SILType::addingMoveOnlyWrapperToBoxedType(const SILFunction *fn) {
   auto oldField = oldLayout->getFields()[0];
   if (oldField.getLoweredType()->is<SILMoveOnlyWrappedType>())
     return *this;
-  assert(!oldField.getLoweredType()->isPureMoveOnly() &&
+  assert(!oldField.getLoweredType()->isNoncopyable() &&
          "Cannot moveonlywrapped in a moveonly type");
   auto newField =
       SILField(SILMoveOnlyWrappedType::get(oldField.getLoweredType()),

lib/SIL/IR/TypeLowering.cpp

@@ -123,8 +123,9 @@ CaptureKind TypeConverter::getDeclCaptureKind(CapturedValue capture,
   // If this is a noncopyable 'let' constant that is not a shared paramdecl or
   // used by a noescape capture, then we know it is boxed and want to pass it in
   // its boxed form so we can obey Swift's capture reference semantics.
-  if (!var->supportsMutation() && lowering.getLoweredType().isPureMoveOnly() &&
-      !capture.isNoEscape()) {
+  if (!var->supportsMutation()
+      && lowering.getLoweredType().getASTType()->isNoncopyable()
+      && !capture.isNoEscape()) {
       auto *param = dyn_cast<ParamDecl>(var);
       if (!param || (param->getValueOwnership() != ValueOwnership::Shared &&
                      !param->isSelfParameter())) {