Merge pull request #60599 from nate-chandler/eager_move

Add hooks for emitting lifetimes.

Author: nate-chandler

docs/ReferenceGuides/UnderscoredAttributes.md

@@ -131,6 +131,23 @@ library), instead of at an arbitrary point in time.
 For more details, see the forum post on
 [dynamic method replacement](https://forums.swift.org/t/dynamic-method-replacement/16619).
 
+## `@_eagerMove`
+
+When applied to a value, indicates that the value's lifetime is _not_ lexical,
+that releases of the value may be hoisted without respect to deinit barriers.
+
+When applied to a type, indicates that all values which are _statically_
+instances of that type are themselves `@_eagerMove` as above, unless overridden
+with `@_lexical`.
+
+Aggregates all of whose fields are `@_eagerMove` or trivial are inferred to be
+`@_eagerMove`.
+
+Note that a value of an `@_eagerMove` type that is passed to a generic API (to a
+parameter not annotated `@_eagerMove` will, in that generic function's context,
+not be statically an instance of the `@_eagerMove` type.  As a result it will
+have a lexical lifetime in that function.
+
 ## `@_effects(effectname)`
 
 Tells the compiler that the implementation of the defined function is limited
@@ -473,12 +490,28 @@ initializers from its superclass. This implies that all designated initializers
 overridden. This attribute is often printed alongside
 `@_hasMissingDesignatedInitializers` in this case.
 
+## `@_lexical`
+
+When applied to a value, indicates that the value's lifetime is lexical, that
+releases of the value may not be hoisted over deinit barriers.  
+
+This is the default behavior, unless the value's type is annotated
+`@_eagerMove`, in which case this attribute overrides that type-level
+annotation.
+
+When applied to a type, indicates that all values which are instances of that
+type are themselves `@_lexical` as above.
+
+This is the default behavior, unless the type annotated is an aggregate that
+consists entirely of `@_eagerMove` or trivial values, in which case the
+attribute overrides the inferred type-level annotation.
+
 ## `@_marker`
 
 Indicates that a protocol is a marker protocol. Marker protocols represent some
 meaningful property at compile-time but have no runtime representation.
 
-For more details, see [SE-0302](https://github.com/apple/swift-evolution/blob/main/proposals/0302-concurrent-value-and-concurrent-closures.md#marker-protocols), which introduces marker protocols.
+For more details, see [](https://github.com/apple/swift-evolution/blob/main/proposals/0302-concurrent-value-and-concurrent-closures.md#marker-protocols), which introduces marker protocols.
 At the moment, the language only has one marker protocol: `Sendable`.
 
 Fun fact: Rust has a very similar concept called

include/swift/AST/Attr.def

@@ -662,15 +662,25 @@ SIMPLE_DECL_ATTR(_inheritActorContext, InheritActorContext,
   ABIStableToAdd | ABIStableToRemove | APIBreakingToAdd | APIBreakingToRemove,
   116)
 
-// 117 was 'spawn' and is now unused
+SIMPLE_DECL_ATTR(_eagerMove, EagerMove,
+  UserInaccessible |
+  ABIStableToAdd | ABIStableToRemove |
+  APIStableToAdd | APIStableToRemove |
+  OnParam | OnVar | OnNominalType,
+  117)
 
 CONTEXTUAL_SIMPLE_DECL_ATTR(distributed, DistributedActor,
   DeclModifier | OnClass | OnFunc | OnAccessor | OnVar |
   ABIBreakingToAdd | ABIBreakingToRemove |
   APIBreakingToAdd | APIBreakingToRemove,
   118)
 
-// 119 is unused
+SIMPLE_DECL_ATTR(_lexical, Lexical,
+  UserInaccessible |
+  ABIStableToAdd | ABIStableToRemove |
+  APIStableToAdd | APIStableToRemove |
+  OnParam | OnVar | OnNominalType,
+  119)
 
 SIMPLE_DECL_ATTR(_assemblyVision, EmitAssemblyVisionRemarks,
   OnFunc | UserInaccessible | NotSerialized | OnNominalType |

include/swift/AST/Decl.h

@@ -29,6 +29,7 @@
 #include "swift/AST/GenericParamKey.h"
 #include "swift/AST/IfConfigClause.h"
 #include "swift/AST/LayoutConstraint.h"
+#include "swift/AST/LifetimeAnnotation.h"
 #include "swift/AST/ReferenceCounting.h"
 #include "swift/AST/RequirementSignature.h"
 #include "swift/AST/StorageImpl.h"
@@ -2713,6 +2714,15 @@ class ValueDecl : public Decl {
   /// 'func foo(Int) -> () -> Self?'.
   GenericParameterReferenceInfo findExistentialSelfReferences(
       Type baseTy, bool treatNonResultCovariantSelfAsInvariant) const;
+
+  LifetimeAnnotation getLifetimeAnnotation() const {
+    auto &attrs = getAttrs();
+    if (attrs.hasAttribute<EagerMoveAttr>())
+      return LifetimeAnnotation::EagerMove;
+    if (attrs.hasAttribute<LexicalAttr>())
+      return LifetimeAnnotation::Lexical;
+    return LifetimeAnnotation::None;
+  }
 };
 
 /// This is a common base class for declarations which declare a type.

include/swift/AST/DiagnosticsParse.def

@@ -517,6 +517,9 @@ ERROR(silfunc_and_silarg_have_incompatible_sil_value_ownership,none,
       "SILFunction and SILArgument have mismatching ValueOwnershipKinds. "
       "Function type specifies: '@%0'. SIL argument specifies: '@%1'.",
       (StringRef, StringRef))
+ERROR(sil_arg_both_lexical_and_eagerMove,none,
+      "Function argument is annotated both @_eagerMove and @_lexical, "
+      "but these are incompatible alternatives", ())
 ERROR(expected_sil_colon,none,
       "expected ':' before %0", (StringRef))
 ERROR(expected_sil_tuple_index,none,

include/swift/AST/DiagnosticsSema.def

@@ -3209,6 +3209,10 @@ ERROR(reasync_without_async_parameter,none,
 ERROR(inherits_executor_without_async,none,
       "non-async functions cannot inherit an executor", ())
 
+ERROR(eagermove_and_lexical_combined,none,
+      "@_eagerMove and @_lexical attributes are alternate styles of lifetimes "
+      "and can't be combined", ())
+
 ERROR(autoclosure_function_type,none,
       "@autoclosure attribute only applies to function types",
       ())

include/swift/AST/LifetimeAnnotation.h

@@ -0,0 +1,49 @@
+//===--- LifetimeAnnotation.h - Lifetime-affecting attributes ---*- C++ -*-===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2022 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+//
+// Defines a simple type-safe wrapper around the annotations that affect value
+// lifetimes.  Used for both Decls and SILFunctionArguments.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SWIFT_AST_LIFETIMEANNOTATION_H
+#define SWIFT_AST_LIFETIMEANNOTATION_H
+
+#include <cstdint>
+
+namespace swift {
+
+/// The annotation on a value (or type) explicitly indicating the lifetime that
+/// it (or its instances) should have.
+///
+/// A LifetimeAnnotation is one of the following three values:
+///
+/// 1) None: No annotation has been applied.
+/// 2) EagerMove: The @_eagerMove attribute has been applied.
+/// 3) Lexical: The @_lexical attribute has been applied.
+struct LifetimeAnnotation {
+  enum Case : uint8_t {
+    None,
+    EagerMove,
+    Lexical,
+  } value;
+
+  LifetimeAnnotation(Case newValue) : value(newValue) {}
+
+  operator Case() const { return value; }
+
+  bool isSome() { return value != None; }
+};
+
+} // namespace swift
+
+#endif

include/swift/SIL/Lifetime.h

@@ -0,0 +1,71 @@
+//===---- Lifetime.h - How long a value should be kept alive ----*- C++ -*-===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2022 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+//
+// Defines a simple type-safe wrapper type to indicate the kind of lifetime that
+// a value has--whether it is tied to a lexical scope or not.
+//
+//===----------------------------------------------------------------------===//
+
+#include "swift/AST/LifetimeAnnotation.h"
+
+#ifndef SWIFT_SIL_LIFETIME_H
+#define SWIFT_SIL_LIFETIME_H
+
+namespace swift {
+
+/// How long a value (such as instances of a type) should be kept alive--how
+/// aggressively its destroys may be hoisted.
+///
+/// By default, types have lifetimes inferred from their structure, see
+/// TypeLowering::RecursiveProperties::isLexical.  It can be overridden both on
+/// the type level and the value level via attributes.
+struct Lifetime {
+  enum Storage : uint8_t {
+    /// No lifetime.  Applicable to values which aren't destroyed.
+    None,
+    /// A lifetime independent from the lexical scope of the value: its
+    /// releases are hoisted without respect to deinit barriers.
+    EagerMove,
+    /// A lifetime tied to the lexical scope of the value: its releases are
+    /// not hoisted over deinit barriers.
+    Lexical,
+  } value;
+
+  Lifetime(decltype(value) newValue) : value(newValue) {}
+
+  operator Storage() const { return value; }
+
+  bool isLexical() { return value == Lifetime::Lexical; }
+
+  bool isEagerMove() { return value == Lifetime::EagerMove; }
+
+  /// Given a lifetime for a type and the lifetime annotation on a value of that
+  /// type, the lifetime appropriate for that value.
+  ///
+  /// Value annotations override a type's lifetime, so the result is just the
+  /// lifetime indicated by the annotation, if there is one; otherwise its the
+  /// lifetime from the type.
+  Lifetime getLifetimeForAnnotatedValue(LifetimeAnnotation annotation) const {
+    switch (annotation) {
+    case LifetimeAnnotation::None:
+      return *this;
+    case LifetimeAnnotation::EagerMove:
+      return Lifetime::EagerMove;
+    case LifetimeAnnotation::Lexical:
+      return Lifetime::Lexical;
+    }
+  }
+};
+
+} // end swift namespace
+
+#endif

include/swift/SIL/SILArgument.h

@@ -13,10 +13,12 @@
 #ifndef SWIFT_SIL_SILARGUMENT_H
 #define SWIFT_SIL_SILARGUMENT_H
 
+#include "swift/AST/LifetimeAnnotation.h"
 #include "swift/Basic/Compiler.h"
+#include "swift/SIL/Lifetime.h"
 #include "swift/SIL/SILArgumentConvention.h"
-#include "swift/SIL/SILValue.h"
 #include "swift/SIL/SILFunctionConventions.h"
+#include "swift/SIL/SILValue.h"
 
 namespace swift {
 
@@ -113,8 +115,6 @@ class SILArgument : public ValueBase {
            node->getKind() <= SILNodeKind::Last_SILArgument;
   }
 
-  bool isNoImplicitCopy() const;
-
   unsigned getIndex() const;
 
   /// Return non-null if \p value is a phi.
@@ -329,14 +329,17 @@ class SILFunctionArgument : public SILArgument {
   friend class SILBasicBlock;
 
   bool noImplicitCopy = false;
+  LifetimeAnnotation lifetimeAnnotation = LifetimeAnnotation::None;
 
-  SILFunctionArgument(SILBasicBlock *parentBlock, SILType type,
-                      ValueOwnershipKind ownershipKind,
-                      const ValueDecl *decl = nullptr,
-                      bool isNoImplicitCopy = false)
+  SILFunctionArgument(
+      SILBasicBlock *parentBlock, SILType type,
+      ValueOwnershipKind ownershipKind, const ValueDecl *decl = nullptr,
+      bool isNoImplicitCopy = false,
+      LifetimeAnnotation lifetimeAnnotation = LifetimeAnnotation::None)
       : SILArgument(ValueKind::SILFunctionArgument, parentBlock, type,
                     ownershipKind, decl),
-        noImplicitCopy(isNoImplicitCopy) {}
+        noImplicitCopy(isNoImplicitCopy),
+        lifetimeAnnotation(lifetimeAnnotation) {}
   // A special constructor, only intended for use in
   // SILBasicBlock::replaceFunctionArg.
   explicit SILFunctionArgument(SILType type, ValueOwnershipKind ownershipKind,
@@ -349,6 +352,20 @@ class SILFunctionArgument : public SILArgument {
 
   void setNoImplicitCopy(bool newValue) { noImplicitCopy = newValue; }
 
+  LifetimeAnnotation getLifetimeAnnotation() const {
+    return lifetimeAnnotation;
+  }
+
+  void setLifetimeAnnotation(LifetimeAnnotation newValue) {
+    lifetimeAnnotation = newValue;
+  }
+
+  Lifetime getLifetime() const {
+    return getType()
+        .getLifetime(*getFunction())
+        .getLifetimeForAnnotatedValue(getLifetimeAnnotation());
+  }
+
   bool isIndirectResult() const;
 
   SILArgumentConvention getArgumentConvention() const;
@@ -408,12 +425,6 @@ inline SILPhiArgument *SILArgument::isTerminatorResult(SILValue value) {
   return nullptr;
 }
 
-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:

include/swift/SIL/SILFunction.h

@@ -1346,6 +1346,13 @@ class SILFunction
   // Miscellaneous
   //===--------------------------------------------------------------------===//
 
+  /// A value's lifetime, determined by looking at annotations on its decl and
+  /// the default lifetime for the type.
+  Lifetime getLifetime(VarDecl *decl, SILType ty) {
+    return ty.getLifetime(*this).getLifetimeForAnnotatedValue(
+        decl->getLifetimeAnnotation());
+  }
+
   /// verify - Run the IR verifier to make sure that the SILFunction follows
   /// invariants.
   void verify(bool SingleFunction = true) const;