[SILGen] Consuming a param implies it's eager-move

If a parameter is marked consuming and its type is Copyable, that
parameter has eager-move semantics.  Apply that attribute to the
SILFunctionArgument corresponding to the parameter.

rdar://108385761

Author: nate-chandler

include/swift/AST/Decl.h

@@ -1094,14 +1094,7 @@ class alignas(1 << DeclAlignInBits) Decl : public ASTAllocated<Decl> {
   /// Check if this is a declaration defined at the top level of the Swift module
   bool isStdlibDecl() const;
 
-  LifetimeAnnotation getLifetimeAnnotation() const {
-    auto &attrs = getAttrs();
-    if (attrs.hasAttribute<EagerMoveAttr>())
-      return LifetimeAnnotation::EagerMove;
-    if (attrs.hasAttribute<NoEagerMoveAttr>())
-      return LifetimeAnnotation::Lexical;
-    return LifetimeAnnotation::None;
-  }
+  LifetimeAnnotation getLifetimeAnnotation() const;
 
   bool isNoImplicitCopy() const {
     return getAttrs().hasAttribute<NoImplicitCopyAttr>();
@@ -6318,6 +6311,8 @@ class ParamDecl : public VarDecl {
   Specifier getSpecifier() const;
   void setSpecifier(Specifier Spec);
 
+  LifetimeAnnotation getLifetimeAnnotation() const;
+
   /// Is the type of this parameter 'inout'?
   bool isInOut() const { return getSpecifier() == Specifier::InOut; }
 
@@ -7329,6 +7324,8 @@ class FuncDecl : public AbstractFunctionDecl {
 
   SelfAccessKind getSelfAccessKind() const;
 
+  LifetimeAnnotation getLifetimeAnnotation() const;
+
   void setSelfAccessKind(SelfAccessKind mod) {
     Bits.FuncDecl.SelfAccess = static_cast<unsigned>(mod);
     Bits.FuncDecl.SelfAccessComputed = true;

lib/AST/Decl.cpp

@@ -1080,6 +1080,26 @@ bool Decl::isStdlibDecl() const {
          DC->getParentModule()->isStdlibModule();
 }
 
+static LifetimeAnnotation
+getLifetimeAnnotationFromAttributes(const Decl *decl) {
+  auto &attrs = decl->getAttrs();
+  if (attrs.hasAttribute<EagerMoveAttr>())
+    return LifetimeAnnotation::EagerMove;
+  if (attrs.hasAttribute<NoEagerMoveAttr>())
+    return LifetimeAnnotation::Lexical;
+  return LifetimeAnnotation::None;
+}
+
+LifetimeAnnotation Decl::getLifetimeAnnotation() const {
+  if (auto *pd = dyn_cast<ParamDecl>(this)) {
+    return pd->getLifetimeAnnotation();
+  }
+  if (auto *fd = dyn_cast<FuncDecl>(this)) {
+    return fd->getLifetimeAnnotation();
+  }
+  return getLifetimeAnnotationFromAttributes(this);
+}
+
 AvailabilityContext Decl::getAvailabilityForLinkage() const {
   ASTContext &ctx = getASTContext();
 
@@ -7026,6 +7046,15 @@ ParamDecl::Specifier ParamDecl::getSpecifier() const {
                            ParamDecl::Specifier::Default);
 }
 
+LifetimeAnnotation ParamDecl::getLifetimeAnnotation() const {
+  auto specifier = getSpecifier();
+  // Copyable parameters which are consumed have eager-move semantics.
+  if (specifier == ParamDecl::Specifier::Consuming &&
+      !getType()->isPureMoveOnly())
+    return LifetimeAnnotation::EagerMove;
+  return getLifetimeAnnotationFromAttributes(this);
+}
+
 StringRef ParamDecl::getSpecifierSpelling(ParamSpecifier specifier) {
   switch (specifier) {
   case ParamSpecifier::Default:
@@ -9211,6 +9240,16 @@ SelfAccessKind FuncDecl::getSelfAccessKind() const {
                            SelfAccessKind::NonMutating);
 }
 
+LifetimeAnnotation FuncDecl::getLifetimeAnnotation() const {
+  // Copyable parameters which are consumed have eager-move semantics.
+  if (getSelfAccessKind() == SelfAccessKind::Consuming) {
+    auto *selfDecl = getImplicitSelfDecl();
+    if (selfDecl && !selfDecl->getType()->isPureMoveOnly())
+      return LifetimeAnnotation::EagerMove;
+  }
+  return getLifetimeAnnotationFromAttributes(this);
+}
+
 bool FuncDecl::isCallAsFunctionMethod() const {
   return getBaseIdentifier() == getASTContext().Id_callAsFunction &&
          isInstanceMember();

test/SILGen/consuming_parameter.swift

@@ -4,7 +4,7 @@ func bar(_: String) {}
 
 // CHECK-LABEL: sil {{.*}} @${{.*}}3foo
 func foo(y: consuming String, z: String) -> () -> String {
-    // CHECK: bb0(%0 : @owned $String, %1 : @guaranteed $String):
+    // CHECK: bb0(%0 : @_eagerMove @owned $String, %1 : @guaranteed $String):
     // CHECK:   [[BOX:%.*]] = alloc_box ${ var String }
     // CHECK:   [[Y:%.*]] = project_box [[BOX]]
     // CHECK:   store %0 to [init] [[Y]]
@@ -33,7 +33,7 @@ struct Butt {
 
     // CHECK-LABEL: sil {{.*}} @${{.*}}4Butt{{.*}}6merged
     consuming func merged(with other: Butt) -> () -> Butt {
-        // CHECK: bb0(%0 : @guaranteed $Butt, %1 : @owned $Butt):
+        // CHECK: bb0(%0 : @guaranteed $Butt, %1 : @_eagerMove @owned $Butt):
         // CHECK:   [[BOX:%.*]] = alloc_box ${ var Butt }
         // CHECK:   [[SELF:%.*]] = project_box [[BOX]]
         // CHECK:   store %1 to [init] [[SELF]]

test/SILOptimizer/consuming_parameter.swift

@@ -0,0 +1,73 @@
+// RUN: %target-swift-frontend -c -Xllvm --sil-print-final-ossa-module -O -module-name=main -o /dev/null %s 2>&1 | %FileCheck %s
+ 
+// CHECK-LABEL: sil [ossa] @async_dead_arg_call : {{.*}} {
+// CHECK:       {{bb[0-9]+}}([[INSTANCE:%[^,]+]] : @_eagerMove @owned
+// CHECK:         destroy_value [[INSTANCE]]
+// CHECK:         [[EXECUTOR:%[^,]+]] = enum $Optional<Builtin.Executor>, #Optional.none!enumelt 
+// CHECK:         [[CALLEE:%[^,]+]] = function_ref @async_callee
+// CHECK:         apply [[CALLEE]]()
+// CHECK:         hop_to_executor [[EXECUTOR]]
+// CHECK-LABEL: } // end sil function 'async_dead_arg_call'
+@_silgen_name("async_dead_arg_call")
+public func async_dead_arg_call(o: consuming AnyObject) async {
+  // o should be destroyed here
+  await bar()
+}
+ 
+public class C {
+  // CHECK-LABEL: sil [ossa] @async_dead_arg_call_method : {{.*}} {
+  // CHECK:       {{bb[0-9]+}}([[INSTANCE:%[^,]+]] : @_eagerMove @owned
+  // CHECK:         destroy_value [[INSTANCE]]
+  // CHECK:         [[EXECUTOR:%[^,]+]] = enum $Optional<Builtin.Executor>, #Optional.none!enumelt 
+  // CHECK:         [[CALLEE:%[^,]+]] = function_ref @async_callee : $@convention(thin) @async () -> () 
+  // CHECK:         apply [[CALLEE]]() : $@convention(thin) @async () -> () 
+  // CHECK:         hop_to_executor [[EXECUTOR]]
+  // CHECK-LABEL: } // end sil function 'async_dead_arg_call_method'
+  @_silgen_name("async_dead_arg_call_method")
+  consuming
+  public func async_dead_arg_call() async {
+    // self should be destroyed here
+    await bar()
+  }
+}
+
+@inline(never)
+@_silgen_name("async_callee")
+func bar() async {}
+
+// CHECK-LABEL: sil [ossa] @write_to_pointer : {{.*}} {
+// CHECK:       {{bb[0-9]+}}([[CONSUMED_INSTANCE:%[^,]+]] : @_eagerMove @owned $AnyObject, [[UMP:%[^,]+]] :
+// CHECK:         [[PTR:%[^,]+]] = struct_extract [[UMP]]
+// CHECK:         [[ADDR:%[^,]+]] = pointer_to_address [[PTR]]
+// CHECK:         store [[CONSUMED_INSTANCE]] to [assign] [[ADDR]]
+// CHECK:         [[PTR2:%[^,]+]] = struct_extract [[UMP]]
+// CHECK:         [[ADDR2:%[^,]+]] = pointer_to_address [[PTR2]]
+// CHECK:         [[OUT:%[^,]+]] = load [copy] [[ADDR2]]
+// CHECK:         return [[OUT]]
+// CHECK-LABEL: } // end sil function 'write_to_pointer'
+@_silgen_name("write_to_pointer")
+public func write_to_pointer(o: consuming AnyObject, p: UnsafeMutablePointer<AnyObject>) -> AnyObject {
+  // o should be destroyed here
+  p.pointee = o
+  return p.pointee
+}
+
+extension C {
+  // CHECK-LABEL: sil [ossa] @write_to_pointer_method : {{.*}} {
+  // CHECK:       {{bb[0-9]+}}([[UMP:%[^,]+]] : $UnsafeMutablePointer<C>, [[INSTANCE:%[^,]+]] : @_eagerMove @owned
+  // CHECK:         [[PTR:%[^,]+]] = struct_extract [[UMP]]
+  // CHECK:         [[ADDR:%[^,]+]] = pointer_to_address [[PTR]]
+  // CHECK:         store [[INSTANCE]] to [assign] [[ADDR]]
+  // CHECK:         [[ADDR2:%[^,]+]] = struct_extract [[UMP]]
+  // CHECK:         [[PTR2:%[^,]+]] = pointer_to_address [[ADDR2]]
+  // CHECK:         [[OUT:%[^,]+]] = load [copy] [[PTR2]]
+  // CHECK:         return [[OUT]]
+  // CHECK-LABEL: } // end sil function 'write_to_pointer_method'
+  @_silgen_name("write_to_pointer_method")
+  consuming
+  public func write_to_pointer(p: UnsafeMutablePointer<C>) -> C {
+    // o should be destroyed here
+    p.pointee = self
+    return p.pointee
+  }
+}