[SILGen] Allow annotating self @_eagerMove.

Allow @_eagerMove (and @_lexical) to be applied to methods.  Applying
it there means that the self argument will have the attribute.

Author: nate-chandler

include/swift/AST/Attr.def

@@ -666,7 +666,7 @@ SIMPLE_DECL_ATTR(_eagerMove, EagerMove,
   UserInaccessible |
   ABIStableToAdd | ABIStableToRemove |
   APIStableToAdd | APIStableToRemove |
-  OnParam | OnVar | OnNominalType,
+  OnFunc | OnParam | OnVar | OnNominalType,
   117)
 
 CONTEXTUAL_SIMPLE_DECL_ATTR(distributed, DistributedActor,
@@ -679,7 +679,7 @@ SIMPLE_DECL_ATTR(_lexical, Lexical,
   UserInaccessible |
   ABIStableToAdd | ABIStableToRemove |
   APIStableToAdd | APIStableToRemove |
-  OnParam | OnVar | OnNominalType,
+  OnFunc | OnParam | OnVar | OnNominalType,
   119)
 
 SIMPLE_DECL_ATTR(_assemblyVision, EmitAssemblyVisionRemarks,

include/swift/AST/DiagnosticsSema.def

@@ -3209,6 +3209,8 @@ ERROR(reasync_without_async_parameter,none,
 ERROR(inherits_executor_without_async,none,
       "non-async functions cannot inherit an executor", ())
 
+ERROR(lifetime_invalid_global_scope,none, "%0 is only valid on methods",
+      (DeclAttribute))
 ERROR(eagermove_and_lexical_combined,none,
       "@_eagerMove and @_lexical attributes are alternate styles of lifetimes "
       "and can't be combined", ())

lib/SILGen/SILGenProlog.cpp

@@ -355,8 +355,19 @@ struct ArgumentInitHelper {
     SILLocation loc(pd);
     loc.markAsPrologue();
 
-    ManagedValue argrv = makeArgument(ty, pd->isInOut(), pd->isNoImplicitCopy(),
-                                      pd->getLifetimeAnnotation(), parent, loc);
+    LifetimeAnnotation lifetimeAnnotation = LifetimeAnnotation::None;
+    bool isNoImplicitCopy = false;
+    if (pd->isSelfParameter()) {
+      if (auto *afd = dyn_cast<AbstractFunctionDecl>(pd->getDeclContext())) {
+        lifetimeAnnotation = afd->getLifetimeAnnotation();
+      }
+    } else {
+      lifetimeAnnotation = pd->getLifetimeAnnotation();
+      isNoImplicitCopy = pd->isNoImplicitCopy();
+    }
+
+    ManagedValue argrv = makeArgument(ty, pd->isInOut(), isNoImplicitCopy,
+                                      lifetimeAnnotation, parent, loc);
 
     if (pd->isInOut()) {
       assert(argrv.getType().isAddress() && "expected inout to be address");

lib/Sema/TypeCheckAttr.cpp

@@ -318,6 +318,7 @@ class AttributeChecker : public AttributeVisitor<AttributeChecker> {
 
   void visitUnsafeInheritExecutorAttr(UnsafeInheritExecutorAttr *attr);
 
+  bool visitLifetimeAttr(DeclAttribute *attr);
   void visitEagerMoveAttr(EagerMoveAttr *attr);
   void visitLexicalAttr(LexicalAttr *attr);
 
@@ -6224,9 +6225,26 @@ void AttributeChecker::visitUnsafeInheritExecutorAttr(
   }
 }
 
-void AttributeChecker::visitEagerMoveAttr(EagerMoveAttr *attr) {}
+bool AttributeChecker::visitLifetimeAttr(DeclAttribute *attr) {
+  if (auto *funcDecl = dyn_cast<FuncDecl>(D)) {
+    auto declContext = funcDecl->getDeclContext();
+    // eagerMove attribute may only appear in type context
+    if (!declContext->getDeclaredInterfaceType()) {
+      diagnoseAndRemoveAttr(attr, diag::lifetime_invalid_global_scope, attr);
+      return true;
+    }
+  }
+  return false;
+}
+
+void AttributeChecker::visitEagerMoveAttr(EagerMoveAttr *attr) {
+  if (visitLifetimeAttr(attr))
+    return;
+}
 
 void AttributeChecker::visitLexicalAttr(LexicalAttr *attr) {
+  if (visitLifetimeAttr(attr))
+    return;
   // @_lexical and @_eagerMove are opposites and can't be combined.
   if (D->getAttrs().hasAttribute<EagerMoveAttr>()) {
     diagnoseAndRemoveAttr(attr, diag::eagermove_and_lexical_combined);

test/SILGen/lexical_lifetime.swift

@@ -129,6 +129,24 @@ func lexical_borrow_arg_trivial(_ trivial: Trivial) {
   use_generic(trivial)
 }
 
+extension C {
+// CHECK-LABEL: sil hidden [ossa] @lexical_method_attr : $@convention(method) (@owned C) -> () {
+// CHECK:       {{bb[0-9]+}}({{%[^,]+}} : @_lexical @owned $C):
+// CHECK-LABEL: } // end sil function 'lexical_method_attr'
+  @_silgen_name("lexical_method_attr")
+  @_lexical
+  __consuming
+  func lexical_method_attr() {}
+
+// CHECK-LABEL: sil hidden [ossa] @eagermove_method_attr : $@convention(method) (@owned C) -> () {
+// CHECK:       {{bb[0-9]+}}({{%[^,]+}} : @_eagerMove @owned $C):
+// CHECK-LABEL: } // end sil function 'eagermove_method_attr'
+  @_silgen_name("eagermove_method_attr")
+  @_eagerMove
+  __consuming
+  func eagermove_method_attr() {}
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // Test                                                                       }}
 ////////////////////////////////////////////////////////////////////////////////

test/attr/lexical.swift

@@ -15,6 +15,20 @@ func bar(@_lexical _ s: S) {} // okay
 
 func baz(@_eagerMove _ c: C) {} // okay
 
+@_eagerMove // expected-error {{@_eagerMove is only valid on methods}}
+func bazzoo(_ c: C) {}
+
+@_lexical // expected-error {{@_lexical is only valid on methods}}
+func bazzoozoo(_ c: C) {}
+
+extension C {
+  @_eagerMove
+  func pazzoo() {}
+
+  @_lexical
+  func pazzoozoo() {}
+}
+
 struct S2 {
   @_eagerMove let c: C // okay
   @_lexical let e: E // okay