[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())) {

lib/SIL/Verifier/SILVerifier.cpp

@@ -6128,7 +6128,7 @@ class SILVerifier : public SILVerifierBase<SILVerifier> {
     auto type = ddi->getType();
     require(type == ddi->getOperand()->getType(),
             "Result and operand must have the same type.");
-    require(type.isPureMoveOnly(),
+    require(type.getASTType()->isNoncopyable(),
             "drop_deinit only allowed for move-only types");
     require(type.getNominalOrBoundGenericNominal()
             ->getValueTypeDestructor(), "drop_deinit only allowed for "

lib/SILGen/SILGenApply.cpp

@@ -3144,7 +3144,7 @@ Expr *ArgumentSource::findStorageReferenceExprForMoveOnly(
 
   SILType ty =
       SGF.getLoweredType(type->getWithoutSpecifierType()->getCanonicalType());
-  bool isMoveOnly = ty.isPureMoveOnly();
+  bool isMoveOnly = ty.getASTType()->isNoncopyable();
   if (auto *pd = dyn_cast<ParamDecl>(storage)) {
     isMoveOnly |= pd->getSpecifier() == ParamSpecifier::Borrowing;
     isMoveOnly |= pd->getSpecifier() == ParamSpecifier::Consuming;

lib/SILGen/SILGenBuilder.cpp

@@ -530,7 +530,7 @@ static ManagedValue createInputFunctionArgument(
          "Function arguments of non-bare functions must have a decl");
   auto *arg = F.begin()->createFunctionArgument(type, decl);
   if (auto *pd = dyn_cast_or_null<ParamDecl>(decl)) {
-    if (!arg->getType().isPureMoveOnly()) {
+    if (!arg->getType().getASTType()->isNoncopyable()) {
       isNoImplicitCopy |= pd->getSpecifier() == ParamSpecifier::Borrowing;
       isNoImplicitCopy |= pd->getSpecifier() == ParamSpecifier::Consuming;
     }

lib/SILGen/SILGenDecl.cpp

@@ -517,7 +517,7 @@ class LocalVariableInitialization : public SingleBufferInitialization {
 
     // If we have a no implicit copy param decl, make our instance type
     // @moveOnly.
-    if (!instanceType->isPureMoveOnly()) {
+    if (!instanceType->isNoncopyable()) {
       if (auto *pd = dyn_cast<ParamDecl>(decl)) {
         bool isNoImplicitCopy = pd->isNoImplicitCopy();
         isNoImplicitCopy |= pd->getSpecifier() == ParamSpecifier::Consuming;
@@ -535,7 +535,7 @@ class LocalVariableInitialization : public SingleBufferInitialization {
 
     auto boxType = SGF.SGM.Types.getContextBoxTypeForCapture(
         decl, instanceType, SGF.F.getGenericEnvironment(),
-        /*mutable*/ !instanceType->isPureMoveOnly() || !decl->isLet());
+        /*mutable*/ !instanceType->isNoncopyable() || !decl->isLet());
 
     // The variable may have its lifetime extended by a closure, heap-allocate
     // it using a box.
@@ -689,7 +689,7 @@ class LetValueInitialization : public Initialization {
       // For noncopyable types, we always need to box them.
       needsTemporaryBuffer =
           (lowering->isAddressOnly() && SGF.silConv.useLoweredAddresses()) ||
-        lowering->getLoweredType().isPureMoveOnly();
+              lowering->getLoweredType().getASTType()->isNoncopyable();
     }
 
     // Make sure that we have a non-address only type when binding a
@@ -774,7 +774,7 @@ class LetValueInitialization : public Initialization {
     if (value->getOwnershipKind() == OwnershipKind::None) {
       // Then check if we have a pure move only type. In that case, we need to
       // insert a no implicit copy
-      if (value->getType().isPureMoveOnly()) {
+      if (value->getType().getASTType()->isNoncopyable()) {
         value = SGF.B.createMoveValue(PrologueLoc, value, /*isLexical*/ true);
         return SGF.B.createMarkUnresolvedNonCopyableValueInst(
             PrologueLoc, value,
@@ -824,7 +824,7 @@ class LetValueInitialization : public Initialization {
     // We do this before the begin_borrow "normal" path below since move only
     // types do not have no implicit copy attr on them.
     if (value->getOwnershipKind() == OwnershipKind::Owned &&
-        value->getType().isPureMoveOnly()) {
+        value->getType().getASTType()->isNoncopyable()) {
       value = SGF.B.createMoveValue(PrologueLoc, value, true /*isLexical*/);
       return SGF.B.createMarkUnresolvedNonCopyableValueInst(
           PrologueLoc, value,
@@ -1455,7 +1455,7 @@ SILGenFunction::emitInitializationForVarDecl(VarDecl *vd, bool forceImmutable,
   // If this is a 'let' initialization for a copyable non-global, set up a let
   // binding, which stores the initialization value into VarLocs directly.
   if (forceImmutable && vd->getDeclContext()->isLocalContext() &&
-      !isa<ReferenceStorageType>(varType) && !varType->isPureMoveOnly())
+      !isa<ReferenceStorageType>(varType) && !varType->isNoncopyable())
     return InitializationPtr(new LetValueInitialization(vd, *this));
 
   // If the variable has no initial value, emit a mark_uninitialized instruction

lib/SILGen/SILGenLValue.cpp

@@ -2938,19 +2938,19 @@ class LLVM_LIBRARY_VISIBILITY SILGenBorrowedBaseVisitor
   /// Returns the subexpr
   static bool isNonCopyableBaseBorrow(SILGenFunction &SGF, Expr *e) {
     if (auto *le = dyn_cast<LoadExpr>(e))
-      return le->getType()->isPureMoveOnly();
+      return le->getType()->isNoncopyable();
     if (auto *m = dyn_cast<MemberRefExpr>(e)) {
       // If our m is a pure noncopyable type or our base is, we need to perform
       // a noncopyable base borrow.
       //
       // DISCUSSION: We can have a noncopyable member_ref_expr with a copyable
       // base if the noncopyable member_ref_expr is from a computed method. In
       // such a case, we want to ensure that we wrap things the right way.
-      return m->getType()->isPureMoveOnly() ||
-             m->getBase()->getType()->isPureMoveOnly();
+      return m->getType()->isNoncopyable() ||
+          m->getBase()->getType()->isNoncopyable();
     }
     if (auto *d = dyn_cast<DeclRefExpr>(e))
-      return e->getType()->isPureMoveOnly();
+      return e->getType()->isNoncopyable();
     return false;
   }
 

lib/SILGen/SILGenProlog.cpp

@@ -705,7 +705,7 @@ class ArgumentInitHelper {
     // - @_eagerMove
     // - @_noEagerMove
     bool isNoImplicitCopy = pd->isNoImplicitCopy();
-    if (!argrv.getType().isPureMoveOnly()) {
+    if (!argrv.getType().getASTType()->isNoncopyable()) {
       isNoImplicitCopy |= pd->getSpecifier() == ParamSpecifier::Borrowing;
       isNoImplicitCopy |= pd->getSpecifier() == ParamSpecifier::Consuming;
       if (pd->isSelfParameter()) {
@@ -1168,7 +1168,7 @@ static void emitCaptureArguments(SILGenFunction &SGF,
     // in SIL since it is illegal to capture an inout value in an escaping
     // closure. The later code knows how to handle that we have the
     // mark_unresolved_non_copyable_value here.
-    if (isInOut && ty.isPureMoveOnly()) {
+    if (isInOut && ty.getASTType()->isNoncopyable()) {
       arg = SGF.B.createMarkUnresolvedNonCopyableValueInst(
           Loc, arg,
           MarkUnresolvedNonCopyableValueInst::CheckKind::

lib/SILOptimizer/SILCombiner/SILCombinerMiscVisitors.cpp

@@ -379,7 +379,7 @@ struct AllocStackAnalyzer : SILInstructionVisitor<AllocStackAnalyzer> {
     // analysis assumes memory is deinitialized on all paths, which is not the
     // case for discarded values. Eventually copyable types may also be
     // discarded; to support that, we will leave a drop_deinit_addr in place.
-    if (ASI->getType().isPureMoveOnly()) {
+    if (ASI->getType().getASTType()->isNoncopyable()) {
       LegalUsers = false;
       return;
     }

lib/SILOptimizer/Transforms/MoveOnlyDeinitDevirtualization.cpp

@@ -69,7 +69,7 @@ static bool performTransform(SILFunction &fn) {
 
       if (auto *dvi = dyn_cast<DestroyValueInst>(inst)) {
         auto destroyType = dvi->getOperand()->getType();
-        if (destroyType.isPureMoveOnly() &&
+        if (destroyType.getASTType()->isNoncopyable() &&
             !isa<DropDeinitInst>(lookThroughOwnershipInsts(dvi->getOperand()))) {
           LLVM_DEBUG(llvm::dbgs() << "Handling: " << *dvi);
           auto *nom = destroyType.getNominalOrBoundGenericNominal();
@@ -112,7 +112,8 @@ static bool performTransform(SILFunction &fn) {
 
       if (auto *dai = dyn_cast<DestroyAddrInst>(inst)) {
         auto destroyType = dai->getOperand()->getType();
-        if (destroyType.isLoadable(fn) && destroyType.isPureMoveOnly() &&
+        if (destroyType.isLoadable(fn)
+            && destroyType.getASTType()->isNoncopyable() &&
             !isa<DropDeinitInst>(dai->getOperand())) {
           LLVM_DEBUG(llvm::dbgs() << "Handling: " << *dai);
           auto *nom = destroyType.getNominalOrBoundGenericNominal();

lib/SILOptimizer/Transforms/SILLowerAggregateInstrs.cpp

@@ -52,7 +52,7 @@ static bool shouldExpandShim(SILFunction *fn, SILType type) {
   // shouldExpand returns false for struct-with-deinit types, so bypassing it is
   // incorrect for move-only types
   if (EnableExpandAll) {
-    assert(!type.isPureMoveOnly()
+    assert(!type.getASTType()->isNoncopyable()
            && "sil-lower-agg-instrs-expand-all is incompatible with move-only "
               "types");
     return true;

lib/SILOptimizer/Utils/InstructionDeleter.cpp

@@ -70,7 +70,7 @@ static bool isScopeAffectingInstructionDead(SILInstruction *inst,
   // move_value instructions.  And `move_value %moveOnlyValue` must not be
   // deleted.
   for (auto result : inst->getResults()) {
-    if (result->getType().isPureMoveOnly() &&
+    if (result->getType().getASTType()->isNoncopyable() &&
         result->getOwnershipKind() == OwnershipKind::Owned) {
       return false;
     }

lib/Sema/CSSimplify.cpp

@@ -3865,7 +3865,7 @@ ConstraintSystem::matchExistentialTypes(Type type1, Type type2,
   }
 
   // move-only types (and their metatypes) cannot match with existential types.
-  if (type1->getMetatypeInstanceType()->isPureMoveOnly()) {
+  if (type1->getMetatypeInstanceType()->isNoncopyable()) {
     // tailor error message
     if (shouldAttemptFixes()) {
       auto *fix = MustBeCopyable::create(*this,
@@ -11842,7 +11842,7 @@ ConstraintSystem::simplifyBridgingConstraint(Type type1,
 
   // Move-only types can't be involved in a bridging conversion since a bridged
   // type assumes the ability to copy.
-  if (type1->isPureMoveOnly()) {
+  if (type1->isNoncopyable()) {
     return SolutionKind::Error;
   }