Merge pull request #74195 from meg-gupta/immortal

Add dependsOn(immortal)

Author: meg-gupta

include/swift/AST/DiagnosticsSema.def

@@ -7981,6 +7981,8 @@ ERROR(lifetime_dependence_cannot_infer_ambiguous_candidate, none,
        "cannot infer lifetime dependence on a self which is BitwiseCopyable & "
        "Escapable",
        ())
+ERROR(lifetime_dependence_immortal_conflict_name, none,
+      "conflict between the parameter name and immortal keyword", ())
 
 //===----------------------------------------------------------------------===//
 //                             MARK: Transferring

include/swift/AST/LifetimeDependence.h

@@ -43,7 +43,7 @@ enum class LifetimeDependenceKind : uint8_t { Inherit = 0, Scope };
 
 class LifetimeDependenceSpecifier {
 public:
-  enum class SpecifierKind { Named, Ordered, Self };
+  enum class SpecifierKind { Named, Ordered, Self, Immortal };
 
 private:
   SourceLoc loc;
@@ -76,6 +76,11 @@ class LifetimeDependenceSpecifier {
     return {loc, SpecifierKind::Named, kind, name};
   }
 
+  static LifetimeDependenceSpecifier
+  getImmortalLifetimeDependenceSpecifier(SourceLoc loc) {
+    return {loc, SpecifierKind::Immortal, {}, {}};
+  }
+
   static LifetimeDependenceSpecifier getOrderedLifetimeDependenceSpecifier(
       SourceLoc loc, ParsedLifetimeDependenceKind kind, unsigned index) {
     return {loc, SpecifierKind::Ordered, kind, index};
@@ -113,6 +118,8 @@ class LifetimeDependenceSpecifier {
       return "self";
     case SpecifierKind::Ordered:
       return std::to_string(value.Ordered.index);
+    case SpecifierKind::Immortal:
+      return "immortal";
     }
     llvm_unreachable("Invalid LifetimeDependenceSpecifier::SpecifierKind");
   }
@@ -134,6 +141,7 @@ class LifetimeDependenceSpecifier {
 class LifetimeDependenceInfo {
   IndexSubset *inheritLifetimeParamIndices;
   IndexSubset *scopeLifetimeParamIndices;
+  bool immortal;
 
   static LifetimeDependenceInfo getForParamIndex(AbstractFunctionDecl *afd,
                                                  unsigned index,
@@ -149,12 +157,15 @@ class LifetimeDependenceInfo {
 public:
   LifetimeDependenceInfo()
       : inheritLifetimeParamIndices(nullptr),
-        scopeLifetimeParamIndices(nullptr) {}
+        scopeLifetimeParamIndices(nullptr), immortal(false) {}
   LifetimeDependenceInfo(IndexSubset *inheritLifetimeParamIndices,
-                         IndexSubset *scopeLifetimeParamIndices)
+                         IndexSubset *scopeLifetimeParamIndices,
+                         bool isImmortal)
       : inheritLifetimeParamIndices(inheritLifetimeParamIndices),
-        scopeLifetimeParamIndices(scopeLifetimeParamIndices) {
-    assert(!empty());
+        scopeLifetimeParamIndices(scopeLifetimeParamIndices),
+        immortal(isImmortal) {
+    assert(isImmortal || inheritLifetimeParamIndices ||
+           scopeLifetimeParamIndices);
     assert(!inheritLifetimeParamIndices ||
            !inheritLifetimeParamIndices->isEmpty());
     assert(!scopeLifetimeParamIndices || !scopeLifetimeParamIndices->isEmpty());
@@ -163,10 +174,12 @@ class LifetimeDependenceInfo {
   operator bool() const { return !empty(); }
 
   bool empty() const {
-    return inheritLifetimeParamIndices == nullptr &&
+    return !immortal && inheritLifetimeParamIndices == nullptr &&
            scopeLifetimeParamIndices == nullptr;
   }
 
+  bool isImmortal() const { return immortal; }
+
   bool hasInheritLifetimeParamIndices() const {
     return inheritLifetimeParamIndices != nullptr;
   }

lib/AST/LifetimeDependence.cpp

@@ -110,10 +110,12 @@ LifetimeDependenceInfo LifetimeDependenceInfo::getForParamIndex(
   auto indexSubset = IndexSubset::get(ctx, capacity, {index});
   if (kind == LifetimeDependenceKind::Scope) {
     return LifetimeDependenceInfo{/*inheritLifetimeParamIndices*/ nullptr,
-                                  /*scopeLifetimeParamIndices*/ indexSubset};
+                                  /*scopeLifetimeParamIndices*/ indexSubset,
+                                  /*isImmortal*/ false};
   }
   return LifetimeDependenceInfo{/*inheritLifetimeParamIndices*/ indexSubset,
-                                /*scopeLifetimeParamIndices*/ nullptr};
+                                /*scopeLifetimeParamIndices*/ nullptr,
+                                /*isImmortal*/ false};
 }
 
 void LifetimeDependenceInfo::getConcatenatedData(
@@ -246,6 +248,18 @@ LifetimeDependenceInfo::fromTypeRepr(AbstractFunctionDecl *afd) {
 
   for (auto specifier : lifetimeDependentRepr->getLifetimeDependencies()) {
     switch (specifier.getSpecifierKind()) {
+    case LifetimeDependenceSpecifier::SpecifierKind::Immortal: {
+      auto immortalParam =
+          std::find_if(afd->getParameters()->begin(), afd->getParameters()->end(), [](ParamDecl *param) {
+            return strcmp(param->getName().get(), "immortal") == 0;
+          });
+      if (immortalParam != afd->getParameters()->end()) {
+        diags.diagnose(*immortalParam,
+                       diag::lifetime_dependence_immortal_conflict_name);
+      }
+
+      return LifetimeDependenceInfo(nullptr, nullptr, /*isImmortal*/ true);
+    }
     case LifetimeDependenceSpecifier::SpecifierKind::Named: {
       bool foundParamName = false;
       unsigned paramIndex = 0;
@@ -315,7 +329,8 @@ LifetimeDependenceInfo::fromTypeRepr(AbstractFunctionDecl *afd) {
           : nullptr,
       scopeLifetimeParamIndices.any()
           ? IndexSubset::get(ctx, scopeLifetimeParamIndices)
-          : nullptr);
+          : nullptr,
+      /*isImmortal*/ false);
 }
 
 // This utility is similar to its overloaded version that builds the
@@ -360,18 +375,29 @@ std::optional<LifetimeDependenceInfo> LifetimeDependenceInfo::fromTypeRepr(
   };
 
   for (auto specifier : lifetimeDependentRepr->getLifetimeDependencies()) {
-    assert(specifier.getSpecifierKind() ==
-           LifetimeDependenceSpecifier::SpecifierKind::Ordered);
-    auto index = specifier.getIndex();
-    if (index > capacity) {
-      diags.diagnose(specifier.getLoc(),
-                     diag::lifetime_dependence_invalid_param_index, index);
-      return std::nullopt;
+    switch (specifier.getSpecifierKind()) {
+    case LifetimeDependenceSpecifier::SpecifierKind::Ordered: {
+      auto index = specifier.getIndex();
+      if (index > capacity) {
+        diags.diagnose(specifier.getLoc(),
+                       diag::lifetime_dependence_invalid_param_index, index);
+        return std::nullopt;
+      }
+      auto param = params[index];
+      auto paramConvention = param.getConvention();
+      if (updateLifetimeDependenceInfo(specifier, index, paramConvention)) {
+        return std::nullopt;
+      }
+      break;
     }
-    auto param = params[index];
-    auto paramConvention = param.getConvention();
-    if (updateLifetimeDependenceInfo(specifier, index, paramConvention)) {
-      return std::nullopt;
+    case LifetimeDependenceSpecifier::SpecifierKind::Immortal: {
+      return LifetimeDependenceInfo(/*inheritLifetimeParamIndices*/ nullptr,
+                                    /*scopeLifetimeParamIndices*/ nullptr,
+                                    /*isImmortal*/ true);
+    }
+    default:
+      llvm_unreachable("SIL can only have ordered or immortal lifetime "
+                       "dependence specifier kind");
     }
   }
 
@@ -381,7 +407,8 @@ std::optional<LifetimeDependenceInfo> LifetimeDependenceInfo::fromTypeRepr(
           : nullptr,
       scopeLifetimeParamIndices.any()
           ? IndexSubset::get(ctx, scopeLifetimeParamIndices)
-          : nullptr);
+          : nullptr,
+      /*isImmortal*/ false);
 }
 
 std::optional<LifetimeDependenceInfo>
@@ -510,18 +537,6 @@ LifetimeDependenceInfo::get(AbstractFunctionDecl *afd) {
   return LifetimeDependenceInfo::infer(afd);
 }
 
-LifetimeDependenceInfo
-LifetimeDependenceInfo::get(ASTContext &ctx,
-                            const SmallBitVector &inheritLifetimeIndices,
-                            const SmallBitVector &scopeLifetimeIndices) {
-  return LifetimeDependenceInfo{
-      inheritLifetimeIndices.any()
-          ? IndexSubset::get(ctx, inheritLifetimeIndices)
-          : nullptr,
-      scopeLifetimeIndices.any() ? IndexSubset::get(ctx, scopeLifetimeIndices)
-                                 : nullptr};
-}
-
 std::optional<LifetimeDependenceKind>
 LifetimeDependenceInfo::getLifetimeDependenceOnParam(unsigned paramIndex) {
   if (inheritLifetimeParamIndices) {

lib/Parse/ParseDecl.cpp

@@ -5122,10 +5122,16 @@ ParserStatus Parser::parseLifetimeDependenceSpecifiers(
             Identifier paramName;
             auto paramLoc =
                 consumeIdentifier(paramName, /*diagnoseDollarPrefix=*/false);
-            specifierList.push_back(
-                LifetimeDependenceSpecifier::
-                    getNamedLifetimeDependenceSpecifier(
-                        paramLoc, lifetimeDependenceKind, paramName));
+            if (paramName.is("immortal")) {
+              specifierList.push_back(
+                  LifetimeDependenceSpecifier::
+                      getImmortalLifetimeDependenceSpecifier(paramLoc));
+            } else {
+              specifierList.push_back(
+                  LifetimeDependenceSpecifier::
+                      getNamedLifetimeDependenceSpecifier(
+                          paramLoc, lifetimeDependenceKind, paramName));
+            }
             break;
           }
           case tok::integer_literal: {

lib/Serialization/Deserialization.cpp

@@ -8857,12 +8857,13 @@ ModuleFile::maybeReadLifetimeDependenceInfo(unsigned numParams) {
     return std::nullopt;
   }
 
+  bool isImmortal;
   bool hasInheritLifetimeParamIndices;
   bool hasScopeLifetimeParamIndices;
   ArrayRef<uint64_t> lifetimeDependenceData;
-  LifetimeDependenceLayout::readRecord(scratch, hasInheritLifetimeParamIndices,
-                                       hasScopeLifetimeParamIndices,
-                                       lifetimeDependenceData);
+  LifetimeDependenceLayout::readRecord(
+      scratch, isImmortal, hasInheritLifetimeParamIndices,
+      hasScopeLifetimeParamIndices, lifetimeDependenceData);
 
   SmallBitVector inheritLifetimeParamIndices(numParams, false);
   SmallBitVector scopeLifetimeParamIndices(numParams, false);
@@ -8891,5 +8892,6 @@ ModuleFile::maybeReadLifetimeDependenceInfo(unsigned numParams) {
           : nullptr,
       hasScopeLifetimeParamIndices
           ? IndexSubset::get(ctx, scopeLifetimeParamIndices)
-          : nullptr);
+          : nullptr,
+      isImmortal);
 }

lib/Serialization/ModuleFormat.h

@@ -58,7 +58,8 @@ const uint16_t SWIFTMODULE_VERSION_MAJOR = 0;
 /// describe what change you made. The content of this comment isn't important;
 /// it just ensures a conflict if two people change the module format.
 /// Don't worry about adhering to the 80-column limit for this line.
-const uint16_t SWIFTMODULE_VERSION_MINOR = 877; // extend_lifetime instruction
+const uint16_t SWIFTMODULE_VERSION_MINOR =
+    878; // immortal bit in LifetimeDependence
 
 /// A standard hash seed used for all string hashes in a serialized module.
 ///
@@ -2212,6 +2213,7 @@ namespace decls_block {
 
   using LifetimeDependenceLayout =
       BCRecordLayout<LIFETIME_DEPENDENCE,
+                     BCFixed<1>,         // isImmortal
                      BCFixed<1>,         // hasInheritLifetimeParamIndices
                      BCFixed<1>,         // hasScopeLifetimeParamIndices
                      BCArray<BCFixed<1>> // concatenated param indices

lib/Serialization/Serialization.cpp

@@ -2579,7 +2579,7 @@ void Serializer::writeLifetimeDependenceInfo(
 
   auto abbrCode = DeclTypeAbbrCodes[LifetimeDependenceLayout::Code];
   LifetimeDependenceLayout::emitRecord(
-      Out, ScratchRecord, abbrCode,
+      Out, ScratchRecord, abbrCode, lifetimeDependenceInfo.isImmortal(),
       lifetimeDependenceInfo.hasInheritLifetimeParamIndices(),
       lifetimeDependenceInfo.hasScopeLifetimeParamIndices(), paramIndices);
 }

test/Parse/explicit_lifetime_dependence_specifiers.swift

@@ -153,3 +153,15 @@ struct Wrapper : ~Escapable {
     return view
   }
 }
+
+enum FakeOptional<Wrapped: ~Escapable>: ~Escapable {
+  case none, some(Wrapped)
+}
+
+extension FakeOptional: Escapable where Wrapped: Escapable {}
+
+extension FakeOptional where Wrapped: ~Escapable {
+  init(nilLiteral: ()) -> dependsOn(immortal) Self {
+    self = .none
+  }
+}

test/SILOptimizer/lifetime_dependence.sil

@@ -7,7 +7,7 @@
 // REQUIRES: asserts
 // REQUIRES: swift_in_compiler
 
-// Test the SIL representation for lifetime depenence.
+// Test the SIL representation for lifetime dependence.
 
 sil_stage raw
 
@@ -18,6 +18,7 @@ class C {}
 struct Nonescapable: ~Escapable {}
 
 sil @c_dependence : $@convention(thin) (@guaranteed C) -> _scope(0) @owned Nonescapable
+sil @immortal_dependence : $@convention(thin) () -> _scope(immortal) @owned Nonescapable
 
 // Test that SILType.isEscpable does not crash on a generic box when NoncopyableGenerics is enabled.
 sil shared [serialized] [ossa] @testLocalFunc : $@convention(thin) <T, U> (@guaranteed <τ_0_0> { var τ_0_0 } <U>) -> () {
@@ -42,3 +43,12 @@ bb0(%0 : @owned $C):
   %28 = tuple ()
   return %28 : $()
 }
+
+sil [ossa] @test_immortal_dependence : $@convention(thin) () -> () {
+bb0:
+  %f = function_ref @immortal_dependence : $@convention(thin) () -> _scope(immortal) @owned Nonescapable
+  %c = apply %f() : $@convention(thin) () -> _scope(immortal) @owned Nonescapable
+  destroy_value %c : $Nonescapable
+  %t = tuple ()
+  return %t : $()
+}

test/Sema/explicit_lifetime_dependence_specifiers1.swift

@@ -231,3 +231,8 @@ extension RawBufferView {
     return BufferView(ptr)
   }
 }
+
+func immortalConflict(immortal: UnsafeRawBufferPointer ) -> dependsOn(immortal) BufferView { // expected-error{{conflict between the parameter name and immortal keyword}}
+  return BufferView(immortal)
+}
+