[noImplicitCopy] Add support for marking a SILArgument as being a NoImplicitCopy argument.

I am purposely doing this in SILGen rather than at the type system level to
avoid having to have to add a bunch of boilerplate to the type system. Instead
of doing that, I am in SILGen checking for the isNoImplicitCopy bit on the
ParamDecl when we emit arguments. At that point, I set on the specific
SILArgument being emitted the bit that it is no implicit copy. In terms of
printing at the SIL level, I just printed it in front of the function argument
type like @owned, e.x.:

  func myFunc(_ x: @_noImplicitCopy T) -> T {
  ...
  }

becomes:

  bb0(%0 : @noImplicitCopy @owned $T):

Some notes:

* Just to be explicit, I am making it so that no implicit copy parameters by
  default are always passed at +1. The reason why I think this makes sense is
  that this is the natural way of working with a move only value.

* As always, one can not write no implicit copy the attribute without passing
  the flag -enable-experimental-move-only so this is NFC.

rdar://83957088

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

@@ -6040,8 +6040,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/SIL/IR/SILPrinter.cpp

@@ -155,13 +155,21 @@ struct SILValuePrinterInfo {
   ID ValueID;
   SILType Type;
   Optional<ValueOwnershipKind> OwnershipKind;
+  bool IsNoImplicitCopy = false;
 
   SILValuePrinterInfo(ID ValueID) : ValueID(ValueID), Type(), OwnershipKind() {}
   SILValuePrinterInfo(ID ValueID, SILType Type)
       : ValueID(ValueID), Type(Type), OwnershipKind() {}
   SILValuePrinterInfo(ID ValueID, SILType Type,
                       ValueOwnershipKind OwnershipKind)
       : ValueID(ValueID), Type(Type), OwnershipKind(OwnershipKind) {}
+  SILValuePrinterInfo(ID ValueID, SILType Type,
+                      ValueOwnershipKind OwnershipKind, bool IsNoImplicitCopy)
+      : ValueID(ValueID), Type(Type), OwnershipKind(OwnershipKind),
+        IsNoImplicitCopy(IsNoImplicitCopy) {}
+  SILValuePrinterInfo(ID ValueID, SILType Type, bool IsNoImplicitCopy)
+      : ValueID(ValueID), Type(Type), OwnershipKind(),
+        IsNoImplicitCopy(IsNoImplicitCopy) {}
 };
 
 /// Return the fully qualified dotted path for DeclContext.
@@ -623,6 +631,8 @@ class SILPrinter : public SILInstructionVisitor<SILPrinter> {
     if (!i.Type)
       return *this;
     *this << " : ";
+    if (i.IsNoImplicitCopy)
+      *this << "@noImplicitCopy ";
     if (i.OwnershipKind && *i.OwnershipKind != OwnershipKind::None) {
       *this << "@" << i.OwnershipKind.getValue() << " ";
     }
@@ -655,9 +665,16 @@ class SILPrinter : public SILInstructionVisitor<SILPrinter> {
   SILValuePrinterInfo getIDAndType(SILValue V) {
     return {Ctx.getID(V), V ? V->getType() : SILType()};
   }
+  SILValuePrinterInfo getIDAndType(SILFunctionArgument *arg) {
+    return {Ctx.getID(arg), arg->getType(), arg->isNoImplicitCopy()};
+  }
   SILValuePrinterInfo getIDAndTypeAndOwnership(SILValue V) {
     return {Ctx.getID(V), V ? V->getType() : SILType(), V.getOwnershipKind()};
   }
+  SILValuePrinterInfo getIDAndTypeAndOwnership(SILFunctionArgument *arg) {
+    return {Ctx.getID(arg), arg->getType(), arg->getOwnershipKind(),
+            arg->isNoImplicitCopy()};
+  }
 
   //===--------------------------------------------------------------------===//
   // Big entrypoints.
@@ -728,20 +745,40 @@ class SILPrinter : public SILInstructionVisitor<SILPrinter> {
     if (BB->args_empty())
       return;
     *this << '(';
-    ArrayRef<SILArgument *> Args = BB->getArguments();
-
     // If SIL ownership is enabled and the given function has not had ownership
     // stripped out, print out ownership of SILArguments.
     if (BB->getParent()->hasOwnership()) {
-      *this << getIDAndTypeAndOwnership(Args[0]);
-      for (SILArgument *Arg : Args.drop_front()) {
-        *this << ", " << getIDAndTypeAndOwnership(Arg);
+      if (BB->isEntry()) {
+        auto Args = BB->getSILFunctionArguments();
+        *this << getIDAndTypeAndOwnership(Args[0]);
+        for (unsigned i : range(1, Args.size())) {
+          SILFunctionArgument *Arg = Args[i];
+          *this << ", " << getIDAndTypeAndOwnership(Arg);
+        }
+        *this << ')';
+      } else {
+        ArrayRef<SILArgument *> Args = BB->getArguments();
+        *this << getIDAndTypeAndOwnership(Args[0]);
+        for (SILArgument *Arg : Args.drop_front()) {
+          *this << ", " << getIDAndTypeAndOwnership(Arg);
+        }
+        *this << ')';
+      }
+      return;
+    }
+
+    if (BB->isEntry()) {
+      auto Args = BB->getSILFunctionArguments();
+      *this << getIDAndType(Args[0]);
+      for (unsigned i : range(1, Args.size())) {
+        SILFunctionArgument *Arg = Args[i];
+        *this << ", " << getIDAndType(Arg);
       }
       *this << ')';
       return;
     }
 
-    // Otherwise, fall back to the old behavior
+    ArrayRef<SILArgument *> Args = BB->getArguments();
     *this << getIDAndType(Args[0]);
     for (SILArgument *Arg : Args.drop_front()) {
       *this << ", " << getIDAndType(Arg);

lib/SIL/Parser/ParseSIL.cpp

@@ -294,6 +294,22 @@ namespace {
       TypeLoc = P.Tok.getLoc();
       return parseASTType(result, genericEnv, genericParams);
     }
+
+    bool parseIsNoImplicitCopy() {
+      // We parse here @ <identifier>.
+      if (P.Tok.getKind() != tok::at_sign)
+        return false;
+
+      // Make sure our text is no implicit copy.
+      if (P.peekToken().getText() != "noImplicitCopy")
+        return false;
+
+      // Ok, we can do this.
+      P.consumeToken(tok::at_sign);
+      P.consumeToken(tok::identifier);
+      return true;
+    }
+
     bool parseSILOwnership(ValueOwnershipKind &OwnershipKind) {
       // We parse here @ <identifier>.
       if (!P.consumeIf(tok::at_sign)) {
@@ -6108,6 +6124,8 @@ bool SILParser::parseSILBasicBlock(SILBuilder &B) {
             P.parseToken(tok::colon, diag::expected_sil_colon_value_ref))
           return true;
 
+        bool foundNoImplicitCopy = parseIsNoImplicitCopy();
+
         // If SILOwnership is enabled and we are not assuming that we are
         // parsing unqualified SIL, look for printed value ownership kinds.
         if (F->hasOwnership() &&
@@ -6119,7 +6137,10 @@ bool SILParser::parseSILBasicBlock(SILBuilder &B) {
 
         SILArgument *Arg;
         if (IsEntry) {
-          Arg = BB->createFunctionArgument(Ty);
+          auto *fArg = BB->createFunctionArgument(Ty);
+          fArg->setNoImplicitCopy(foundNoImplicitCopy);
+          Arg = fArg;
+
           // Today, we construct the ownership kind straight from the function
           // type. Make sure they are in sync, otherwise bail. We want this to
           // be an exact check rather than a compatibility check since we do not

lib/SILGen/SILGenBuilder.cpp

@@ -432,12 +432,14 @@ ManagedValue SILGenBuilder::createLoadCopy(SILLocation loc, ManagedValue v,
 
 static ManagedValue createInputFunctionArgument(SILGenBuilder &B, SILType type,
                                                 SILLocation loc,
-                                                ValueDecl *decl = nullptr) {
+                                                ValueDecl *decl = nullptr,
+                                                bool isNoImplicitCopy = false) {
   auto &SGF = B.getSILGenFunction();
   SILFunction &F = B.getFunction();
   assert((F.isBare() || decl) &&
          "Function arguments of non-bare functions must have a decl");
   auto *arg = F.begin()->createFunctionArgument(type, decl);
+  arg->setNoImplicitCopy(isNoImplicitCopy);
   switch (arg->getArgumentConvention()) {
   case SILArgumentConvention::Indirect_In_Guaranteed:
   case SILArgumentConvention::Direct_Guaranteed:
@@ -469,8 +471,10 @@ static ManagedValue createInputFunctionArgument(SILGenBuilder &B, SILType type,
 }
 
 ManagedValue SILGenBuilder::createInputFunctionArgument(SILType type,
-                                                        ValueDecl *decl) {
-  return ::createInputFunctionArgument(*this, type, SILLocation(decl), decl);
+                                                        ValueDecl *decl,
+                                                        bool isNoImplicitCopy) {
+  return ::createInputFunctionArgument(*this, type, SILLocation(decl), decl,
+                                       isNoImplicitCopy);
 }
 
 ManagedValue

lib/SILGen/SILGenBuilder.h

@@ -223,7 +223,8 @@ class SILGenBuilder : public SILBuilder {
 
   /// Create a SILArgument for an input parameter. Asserts if used to create a
   /// function argument for an out parameter.
-  ManagedValue createInputFunctionArgument(SILType type, ValueDecl *decl);
+  ManagedValue createInputFunctionArgument(SILType type, ValueDecl *decl,
+                                           bool isNoImplicitCopy = false);
 
   /// Create a SILArgument for an input parameter. Uses \p loc to create any
   /// copies necessary. Asserts if used to create a function argument for an out

lib/SILGen/SILGenProlog.cpp

@@ -10,21 +10,28 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "SILGenFunction.h"
+#include "ArgumentSource.h"
 #include "ExecutorBreadcrumb.h"
 #include "Initialization.h"
 #include "ManagedValue.h"
+#include "SILGenFunction.h"
 #include "Scope.h"
-#include "ArgumentSource.h"
-#include "swift/SIL/SILArgument.h"
 #include "swift/AST/CanTypeVisitor.h"
+#include "swift/AST/DiagnosticsSIL.h"
 #include "swift/AST/GenericEnvironment.h"
 #include "swift/AST/ParameterList.h"
 #include "swift/AST/PropertyWrappers.h"
+#include "swift/SIL/SILArgument.h"
 
 using namespace swift;
 using namespace Lowering;
 
+template <typename... T, typename... U>
+static void diagnose(ASTContext &Context, SourceLoc loc, Diag<T...> diag,
+                     U &&...args) {
+  Context.Diags.diagnose(loc, diag, std::forward<U>(args)...);
+}
+
 SILValue SILGenFunction::emitSelfDecl(VarDecl *selfDecl) {
   // Emit the implicit 'self' argument.
   SILType selfType = getLoweredLoadableType(selfDecl->getType());
@@ -49,11 +56,13 @@ class EmitBBArguments : public CanTypeVisitor<EmitBBArguments,
   SILLocation loc;
   CanSILFunctionType fnTy;
   ArrayRef<SILParameterInfo> &parameters;
+  bool isNoImplicitCopy;
 
   EmitBBArguments(SILGenFunction &sgf, SILBasicBlock *parent, SILLocation l,
                   CanSILFunctionType fnTy,
-                  ArrayRef<SILParameterInfo> &parameters)
-    : SGF(sgf), parent(parent), loc(l), fnTy(fnTy), parameters(parameters) {}
+                  ArrayRef<SILParameterInfo> &parameters, bool isNoImplicitCopy)
+      : SGF(sgf), parent(parent), loc(l), fnTy(fnTy), parameters(parameters),
+        isNoImplicitCopy(isNoImplicitCopy) {}
 
   ManagedValue visitType(CanType t, AbstractionPattern orig) {
     return visitType(t, orig, /*isInOut=*/false);
@@ -79,7 +88,7 @@ class EmitBBArguments : public CanTypeVisitor<EmitBBArguments,
     auto paramType =
         SGF.F.mapTypeIntoContext(SGF.getSILType(parameterInfo, fnTy));
     ManagedValue mv = SGF.B.createInputFunctionArgument(
-        paramType, loc.getAsASTNode<ValueDecl>());
+        paramType, loc.getAsASTNode<ValueDecl>(), isNoImplicitCopy);
 
     // This is a hack to deal with the fact that Self.Type comes in as a static
     // metatype, but we have to downcast it to a dynamic Self metatype to get
@@ -98,12 +107,21 @@ class EmitBBArguments : public CanTypeVisitor<EmitBBArguments,
 
     // This can happen if the value is resilient in the calling convention
     // but not resilient locally.
-    if (argType.isLoadable(SGF.F) && argType.isAddress()) {
-      if (mv.isPlusOne(SGF))
-        mv = SGF.B.createLoadTake(loc, mv);
-      else
-        mv = SGF.B.createLoadBorrow(loc, mv);
-      argType = argType.getObjectType();
+    if (argType.isLoadable(SGF.F)) {
+      if (argType.isAddress()) {
+        if (mv.isPlusOne(SGF))
+          mv = SGF.B.createLoadTake(loc, mv);
+        else
+          mv = SGF.B.createLoadBorrow(loc, mv);
+        argType = argType.getObjectType();
+      }
+    } else {
+      if (isNoImplicitCopy) {
+        // We do not support no implicit copy address only types. Emit an error.
+        auto diag = diag::noimplicitcopy_used_on_generic_or_existential;
+        diagnose(SGF.getASTContext(), mv.getValue().getLoc().getSourceLoc(),
+                 diag);
+      }
     }
 
     if (argType.getASTType() != paramType.getASTType()) {
@@ -217,14 +235,14 @@ struct ArgumentInitHelper {
 
   unsigned getNumArgs() const { return ArgNo; }
 
-  ManagedValue makeArgument(Type ty, bool isInOut, SILBasicBlock *parent,
-                            SILLocation l) {
+  ManagedValue makeArgument(Type ty, bool isInOut, bool isNoImplicitCopy,
+                            SILBasicBlock *parent, SILLocation l) {
     assert(ty && "no type?!");
 
     // Create an RValue by emitting destructured arguments into a basic block.
     CanType canTy = ty->getCanonicalType();
-    EmitBBArguments argEmitter(SGF, parent, l,
-                               f.getLoweredFunctionType(), parameters);
+    EmitBBArguments argEmitter(SGF, parent, l, f.getLoweredFunctionType(),
+                               parameters, isNoImplicitCopy);
 
     // Note: inouts of tuples are not exploded, so we bypass visit().
     AbstractionPattern origTy = OrigFnType
@@ -241,7 +259,8 @@ struct ArgumentInitHelper {
     SILLocation loc(pd);
     loc.markAsPrologue();
 
-    ManagedValue argrv = makeArgument(ty, pd->isInOut(), parent, loc);
+    ManagedValue argrv =
+        makeArgument(ty, pd->isInOut(), pd->isNoImplicitCopy(), parent, loc);
 
     if (pd->isInOut()) {
       assert(argrv.getType().isAddress() && "expected inout to be address");
@@ -297,7 +316,8 @@ struct ArgumentInitHelper {
     Scope discardScope(SGF.Cleanups, CleanupLocation(PD));
 
     // Manage the parameter.
-    auto argrv = makeArgument(type, PD->isInOut(), &*f.begin(), paramLoc);
+    auto argrv = makeArgument(type, PD->isInOut(), PD->isNoImplicitCopy(),
+                              &*f.begin(), paramLoc);
 
     // Emit debug information for the argument.
     SILLocation loc(PD);