Merge pull request #39991 from gottesmm/no_implicit_copy_arguments

[moveOnly] Allow the @_noImplicitCopy decl attribute to be applied to parameters

Author: gottesmm

include/swift/AST/Attr.def

@@ -676,7 +676,7 @@ SIMPLE_DECL_ATTR(_noImplicitCopy, NoImplicitCopy,
   UserInaccessible |
   ABIStableToAdd | ABIBreakingToRemove |
   APIStableToAdd | APIBreakingToRemove |
-  OnVar,
+  OnParam | OnVar,
   122)
 
 SIMPLE_DECL_ATTR(_noLocks, NoLocks,

include/swift/AST/Decl.h

@@ -5371,6 +5371,10 @@ class ParamDecl : public VarDecl {
     Bits.ParamDecl.defaultArgumentKind = static_cast<unsigned>(K);
   }
 
+  bool isNoImplicitCopy() const {
+    return getAttrs().hasAttribute<NoImplicitCopyAttr>();
+  }
+
   /// Whether this parameter has a default argument expression available.
   ///
   /// Note that this will return false for deserialized declarations, which only

include/swift/AST/DiagnosticsSema.def

@@ -6047,8 +6047,8 @@ ERROR(experimental_moveonly_feature_can_only_be_used_when_enabled,
       none, "Can not use feature when experimental move only is disabled! Pass"
       " the frontend flag -enable-experimental-move-only to swift to enable "
       "the usage of this language feature", ())
-ERROR(noimplicitcopy_attr_valid_only_on_local_let,
-      none, "'@_noImplicitCopy' attribute can only be applied to local lets", ())
+ERROR(noimplicitcopy_attr_valid_only_on_local_let_params,
+      none, "'@_noImplicitCopy' attribute can only be applied to local lets and params", ())
 ERROR(noimplicitcopy_attr_invalid_in_generic_context,
       none, "'@_noImplicitCopy' attribute cannot be applied to entities in generic contexts", ())
 

include/swift/SIL/SILArgument.h

@@ -111,6 +111,8 @@ class SILArgument : public ValueBase {
            node->getKind() <= SILNodeKind::Last_SILArgument;
   }
 
+  bool isNoImplicitCopy() const;
+
   unsigned getIndex() const;
 
   /// Return true if this block argument is actually a phi argument as
@@ -311,11 +313,15 @@ class SILPhiArgument : public SILArgument {
 class SILFunctionArgument : public SILArgument {
   friend class SILBasicBlock;
 
+  bool noImplicitCopy = false;
+
   SILFunctionArgument(SILBasicBlock *parentBlock, SILType type,
                       ValueOwnershipKind ownershipKind,
-                      const ValueDecl *decl = nullptr)
+                      const ValueDecl *decl = nullptr,
+                      bool isNoImplicitCopy = false)
       : SILArgument(ValueKind::SILFunctionArgument, parentBlock, type,
-                    ownershipKind, decl) {}
+                    ownershipKind, decl),
+        noImplicitCopy(isNoImplicitCopy) {}
   // A special constructor, only intended for use in
   // SILBasicBlock::replaceFunctionArg.
   explicit SILFunctionArgument(SILType type, ValueOwnershipKind ownershipKind,
@@ -324,6 +330,10 @@ class SILFunctionArgument : public SILArgument {
   }
 
 public:
+  bool isNoImplicitCopy() const { return noImplicitCopy; }
+
+  void setNoImplicitCopy(bool newValue) { noImplicitCopy = newValue; }
+
   bool isIndirectResult() const;
 
   SILArgumentConvention getArgumentConvention() const;
@@ -365,6 +375,12 @@ inline bool SILArgument::isPhiArgument() const {
   llvm_unreachable("Covered switch is not covered?!");
 }
 
+inline bool SILArgument::isNoImplicitCopy() const {
+  if (auto *fArg = dyn_cast<SILFunctionArgument>(this))
+    return fArg->isNoImplicitCopy();
+  return false;
+}
+
 inline bool SILArgument::isTerminatorResult() const {
   switch (getKind()) {
   case SILArgumentKind::SILPhiArgument:

lib/AST/ASTDumper.cpp

@@ -17,6 +17,7 @@
 #include "swift/AST/ASTContext.h"
 #include "swift/AST/ASTPrinter.h"
 #include "swift/AST/ASTVisitor.h"
+#include "swift/AST/Attr.h"
 #include "swift/AST/ClangModuleLoader.h"
 #include "swift/AST/ForeignAsyncConvention.h"
 #include "swift/AST/ForeignErrorConvention.h"
@@ -928,6 +929,9 @@ namespace {
       if (P->getAttrs().hasAttribute<NonEphemeralAttr>())
         OS << " nonEphemeral";
 
+      if (P->getAttrs().hasAttribute<NoImplicitCopyAttr>())
+        OS << " noImplicitCopy";
+
       if (P->getDefaultArgumentKind() != DefaultArgumentKind::None) {
         printField("default_arg",
                    getDefaultArgumentKindString(P->getDefaultArgumentKind()));

lib/SIL/IR/SILFunctionType.cpp

@@ -1573,13 +1573,17 @@ class DestructureInputs {
   SmallVectorImpl<SILParameterInfo> &Inputs;
   SubstFunctionTypeCollector &Subst;
   unsigned NextOrigParamIndex = 0;
+  Optional<SmallBitVector> NoImplicitCopyIndices;
+
 public:
   DestructureInputs(TypeExpansionContext expansion, TypeConverter &TC,
                     const Conventions &conventions, const ForeignInfo &foreign,
                     SmallVectorImpl<SILParameterInfo> &inputs,
-                    SubstFunctionTypeCollector &subst)
+                    SubstFunctionTypeCollector &subst,
+                    Optional<SmallBitVector> noImplicitCopyIndices)
       : expansion(expansion), TC(TC), Convs(conventions), Foreign(foreign),
-        Inputs(inputs), Subst(subst) {}
+        Inputs(inputs), Subst(subst),
+        NoImplicitCopyIndices(noImplicitCopyIndices) {}
 
   void destructure(AbstractionPattern origType,
                    CanAnyFunctionType::CanParamArrayRef params,
@@ -1617,14 +1621,18 @@ class DestructureInputs {
     // Add any foreign parameters that are positioned here.
     maybeAddForeignParameters();
 
+    bool hasNoImplicitCopy =
+        NoImplicitCopyIndices.hasValue() && NoImplicitCopyIndices->any();
+
     // Process all the non-self parameters.
     for (unsigned i = 0; i != numNonSelfParams; ++i) {
       auto ty = params[i].getParameterType();
       auto eltPattern = origType.getFunctionParamType(i);
       auto flags = params[i].getParameterFlags();
 
       visit(flags.getValueOwnership(), /*forSelf=*/false, eltPattern, ty,
-            flags.isNoDerivative());
+            flags.isNoDerivative(),
+            hasNoImplicitCopy && (*NoImplicitCopyIndices)[i]);
     }
 
     // Process the self parameter.  Note that we implicitly drop self
@@ -1635,8 +1643,8 @@ class DestructureInputs {
       auto eltPattern = origType.getFunctionParamType(numNonSelfParams);
       auto flags = selfParam.getParameterFlags();
 
-      visit(flags.getValueOwnership(), /*forSelf=*/true,
-            eltPattern, ty);
+      visit(flags.getValueOwnership(), /*forSelf=*/true, eltPattern, ty, false,
+            false);
     }
 
     TopLevelOrigType = AbstractionPattern::getInvalid();
@@ -1645,7 +1653,7 @@ class DestructureInputs {
 
   void visit(ValueOwnership ownership, bool forSelf,
              AbstractionPattern origType, CanType substType,
-             bool isNonDifferentiable = false) {
+             bool isNonDifferentiable, bool isNoImplicitCopy) {
     assert(!isa<InOutType>(substType));
 
     // Tuples get handled specially, in some cases:
@@ -1662,9 +1670,8 @@ class DestructureInputs {
           auto ownership = elt.getParameterFlags().getValueOwnership();
           assert(ownership == ValueOwnership::Default);
           assert(!elt.isVararg());
-          visit(ownership, forSelf,
-                origType.getTupleElementType(i),
-                CanType(elt.getRawType()));
+          visit(ownership, forSelf, origType.getTupleElementType(i),
+                CanType(elt.getRawType()), false, false);
         }
         return;
       case ValueOwnership::InOut:
@@ -1692,6 +1699,9 @@ class DestructureInputs {
     } else if (substTL.isTrivial()) {
       convention = ParameterConvention::Direct_Unowned;
     } else {
+      // If we are no implicit copy, our ownership is always Owned.
+      if (isNoImplicitCopy)
+        ownership = ValueOwnership::Owned;
       convention = Convs.getDirect(ownership, forSelf, origParamIndex, origType,
                                    substTLConv);
       assert(!isIndirectFormalParameter(convention));
@@ -1757,9 +1767,8 @@ class DestructureInputs {
     if (ForeignSelf) {
       // This is a "self", but it's not a Swift self, we handle it differently.
       visit(ForeignSelf->SubstSelfParam.getValueOwnership(),
-            /*forSelf=*/false,
-            ForeignSelf->OrigSelfParam,
-            ForeignSelf->SubstSelfParam.getParameterType());
+            /*forSelf=*/false, ForeignSelf->OrigSelfParam,
+            ForeignSelf->SubstSelfParam.getParameterType(), false, false);
     }
     return true;
   }
@@ -2107,7 +2116,8 @@ static CanSILFunctionType getSILFunctionType(
     SILExtInfoBuilder extInfoBuilder, const Conventions &conventions,
     const ForeignInfo &foreignInfo, Optional<SILDeclRef> origConstant,
     Optional<SILDeclRef> constant, Optional<SubstitutionMap> reqtSubs,
-    ProtocolConformanceRef witnessMethodConformance) {
+    ProtocolConformanceRef witnessMethodConformance,
+    Optional<SmallBitVector> noImplicitCopyIndices) {
   // Find the generic parameters.
   CanGenericSignature genericSig =
     substFnInterfaceType.getOptGenericSignature();
@@ -2197,7 +2207,8 @@ static CanSILFunctionType getSILFunctionType(
   SmallVector<SILParameterInfo, 8> inputs;
   {
     DestructureInputs destructurer(expansionContext, TC, conventions,
-                                   foreignInfo, inputs, subst);
+                                   foreignInfo, inputs, subst,
+                                   noImplicitCopyIndices);
     destructurer.destructure(origType, substFnInterfaceType.getParams(),
                              extInfoBuilder);
   }
@@ -2498,14 +2509,15 @@ static CanSILFunctionType getNativeSILFunctionType(
     AbstractionPattern origType, CanAnyFunctionType substInterfaceType,
     SILExtInfoBuilder extInfoBuilder, Optional<SILDeclRef> origConstant,
     Optional<SILDeclRef> constant, Optional<SubstitutionMap> reqtSubs,
-    ProtocolConformanceRef witnessMethodConformance) {
+    ProtocolConformanceRef witnessMethodConformance,
+    Optional<SmallBitVector> noImplicitCopyIndices) {
   assert(bool(origConstant) == bool(constant));
   auto getSILFunctionTypeForConventions =
       [&](const Conventions &convs) -> CanSILFunctionType {
     return getSILFunctionType(TC, context, origType, substInterfaceType,
                               extInfoBuilder, convs, ForeignInfo(),
                               origConstant, constant, reqtSubs,
-                              witnessMethodConformance);
+                              witnessMethodConformance, noImplicitCopyIndices);
   };
   switch (extInfoBuilder.getRepresentation()) {
   case SILFunctionType::Representation::Block:
@@ -2568,7 +2580,7 @@ CanSILFunctionType swift::getNativeSILFunctionType(
 
   return ::getNativeSILFunctionType(
       TC, context, origType, substType, silExtInfo.intoBuilder(), origConstant,
-      substConstant, reqtSubs, witnessMethodConformance);
+      substConstant, reqtSubs, witnessMethodConformance, None);
 }
 
 //===----------------------------------------------------------------------===//
@@ -2947,7 +2959,7 @@ static CanSILFunctionType getSILFunctionTypeForClangDecl(
     return getSILFunctionType(
         TC, TypeExpansionContext::minimal(), origPattern, substInterfaceType,
         extInfoBuilder, ObjCMethodConventions(method), foreignInfo, constant,
-        constant, None, ProtocolConformanceRef());
+        constant, None, ProtocolConformanceRef(), None);
   }
 
   if (auto method = dyn_cast<clang::CXXMethodDecl>(clangDecl)) {
@@ -2963,7 +2975,7 @@ static CanSILFunctionType getSILFunctionTypeForClangDecl(
     return getSILFunctionType(TC, TypeExpansionContext::minimal(), origPattern,
                               substInterfaceType, extInfoBuilder, conventions,
                               foreignInfo, constant, constant, None,
-                              ProtocolConformanceRef());
+                              ProtocolConformanceRef(), None);
   }
 
   if (auto func = dyn_cast<clang::FunctionDecl>(clangDecl)) {
@@ -2976,7 +2988,7 @@ static CanSILFunctionType getSILFunctionTypeForClangDecl(
     return getSILFunctionType(TC, TypeExpansionContext::minimal(), origPattern,
                               substInterfaceType, extInfoBuilder,
                               CFunctionConventions(func), foreignInfo, constant,
-                              constant, None, ProtocolConformanceRef());
+                              constant, None, ProtocolConformanceRef(), None);
   }
 
   llvm_unreachable("call to unknown kind of C function");
@@ -3004,15 +3016,15 @@ static CanSILFunctionType getSILFunctionTypeForAbstractCFunction(
       return getSILFunctionType(
           TC, TypeExpansionContext::minimal(), origType, substType,
           extInfoBuilder, CFunctionTypeConventions(fnType), ForeignInfo(),
-          constant, constant, None, ProtocolConformanceRef());
+          constant, constant, None, ProtocolConformanceRef(), None);
     }
   }
 
   // TODO: Ought to support captures in block funcs.
   return getSILFunctionType(TC, TypeExpansionContext::minimal(), origType,
                             substType, extInfoBuilder,
                             DefaultBlockConventions(), ForeignInfo(), constant,
-                            constant, None, ProtocolConformanceRef());
+                            constant, None, ProtocolConformanceRef(), None);
 }
 
 /// Try to find a clang method declaration for the given function.
@@ -3180,7 +3192,7 @@ static CanSILFunctionType getSILFunctionTypeForObjCSelectorFamily(
       TC, TypeExpansionContext::minimal(), AbstractionPattern(origType),
       substInterfaceType, extInfoBuilder, ObjCSelectorFamilyConventions(family),
       foreignInfo, constant, constant,
-      /*requirement subs*/ None, ProtocolConformanceRef());
+      /*requirement subs*/ None, ProtocolConformanceRef(), None);
 }
 
 static bool isImporterGeneratedAccessor(const clang::Decl *clangDecl,
@@ -3250,10 +3262,23 @@ static CanSILFunctionType getUncachedSILFunctionTypeForConstant(
       }
     }();
 
+    Optional<SmallBitVector> noImplicitCopyIndices;
+    if (constant.hasDecl()) {
+      auto decl = constant.getDecl();
+      if (auto *funcDecl = dyn_cast<AbstractFunctionDecl>(decl)) {
+        noImplicitCopyIndices.emplace(funcDecl->getParameters()->size());
+        for (auto p : llvm::enumerate(*funcDecl->getParameters())) {
+          if (p.value()->isNoImplicitCopy()) {
+            noImplicitCopyIndices->set(p.index());
+          }
+        }
+      }
+    }
+
     return ::getNativeSILFunctionType(
-        TC, context, origType,
-        origLoweredInterfaceType, extInfoBuilder, constant, constant, None,
-        witnessMethodConformance);
+        TC, context, origType, origLoweredInterfaceType, extInfoBuilder,
+        constant, constant, None, witnessMethodConformance,
+        noImplicitCopyIndices);
   }
 
   ForeignInfo foreignInfo;