Merge pull request #75096 from meg-gupta/lifetimedeparg

Add support for lifetime dependence in parameter position

Author: atrick

SwiftCompilerSources/Sources/SIL/FunctionConvention.swift

@@ -77,13 +77,18 @@ public struct FunctionConvention : CustomStringConvertible {
   /// Collection of LifetimeDependenceConvention indexed on the
   /// function parameter.
   public var resultDependencies: ResultDependencies? {
-    let deps = bridgedFunctionType.SILFunctionType_getLifetimeDependenceInfo()
-    if deps.empty() {
-      return nil
+    let bridgedDependencies = bridgedFunctionType.SILFunctionType_getLifetimeDependencies()
+    let dependencies = LifetimeDependencies(bridged: bridgedDependencies)
+    let targetIndex = parameters.count
+
+    for dependence in dependencies {
+      if dependence.getTargetIndex() == targetIndex {
+        return ResultDependencies(bridged: dependence,
+                                  parameterCount: parameters.count,
+                                  hasSelfParameter: hasSelfParameter)
+      }
     }
-    return ResultDependencies(bridged: deps,
-                                         parameterCount: parameters.count,
-                                         hasSelfParameter: hasSelfParameter)
+    return nil
   }
 
   public var description: String {
@@ -242,6 +247,26 @@ public enum LifetimeDependenceConvention : CustomStringConvertible {
   }
 }
 
+extension FunctionConvention {
+  struct LifetimeDependencies : Collection {
+    let bridged: BridgedLifetimeDependenceInfoArray
+
+    var startIndex: Int { 0 }
+
+    var endIndex: Int { bridged.count() }
+
+    func index(after index: Int) -> Int {
+      return index + 1
+    }
+    // Create a Swift LifetimeDependenceInfo for BridgedLifetimeDependenceInfo if this method needs
+    // to be exposed outside FunctionConvention.
+    // That will likely need bridging IndexSubset to Swift.
+    subscript(_ index: Int) -> BridgedLifetimeDependenceInfo {
+      return bridged.at(index)
+    }
+  }
+}
+
 extension FunctionConvention {
   /// Collection of LifetimeDependenceConvention? that parallels parameters.
   public struct ResultDependencies : Collection, CustomStringConvertible {

docs/ABI/Mangling.rst

@@ -727,7 +727,7 @@ Types
   C-TYPE is mangled according to the Itanium ABI, and prefixed with the length.
   Non-ASCII identifiers are preserved as-is; we do not use Punycode.
 
-  function-signature ::= params-type params-type async? sendable? throws? differentiable? function-isolation? self-lifetime-dependence? // results and parameters
+  function-signature ::= params-type params-type async? sendable? throws? differentiable? function-isolation? // results and parameters
 
   params-type ::= type 'z'? 'h'?             // tuple in case of multiple parameters or a single parameter with a single tuple type
                                              // with optional inout convention, shared convention. parameters don't have labels,
@@ -749,10 +749,8 @@ Types
   differentiable ::= 'Yjd'                   // @differentiable on function type
   differentiable ::= 'Yjl'                   // @differentiable(_linear) on function type
  #if SWIFT_RUNTIME_VERSION >= 5.TBD
-  lifetime-dependence ::= 'Yli'              // inherit lifetime dependence on param
-  lifetime-dependence ::= 'Yls'              // scoped lifetime dependence on param
-  self-lifetime-dependence ::= 'YLi'         // inherit lifetime dependence on self
-  self-lifetime-dependence ::= 'YLs'         // scoped lifetime dependence on self
+  lifetime-dependence ::= 'Yli' INDEX-SUBSET '_'         // inherit lifetime dependence
+  lifetime-dependence ::= 'Yls' INDEX-SUBSET '_'         // scoped lifetime dependence
 #endif
   type-list ::= list-type '_' list-type*     // list of types
   type-list ::= empty-list

include/swift/AST/ASTMangler.h

@@ -91,6 +91,9 @@ class ASTMangler : public Mangler {
   /// a critical role.
   bool AllowTypedThrows = true;
 
+  /// If enabled, lifetime dependencies can be encoded in the mangled name.
+  bool AllowLifetimeDependencies = true;
+
   /// If enabled, declarations annotated with @_originallyDefinedIn are mangled
   /// as if they're part of their original module. Disabled for debug mangling,
   /// because lldb wants to find declarations in the modules they're currently
@@ -556,14 +559,15 @@ class ASTMangler : public Mangler {
                                FunctionManglingKind functionMangling,
                                bool isRecursedInto = true);
 
-  void appendFunctionInputType(ArrayRef<AnyFunctionType::Param> params,
-                               LifetimeDependenceInfo lifetimeDependenceInfo,
+  void appendFunctionInputType(AnyFunctionType *fnType,
+                               ArrayRef<AnyFunctionType::Param> params,
                                GenericSignature sig,
                                const ValueDecl *forDecl = nullptr,
                                bool isRecursedInto = true);
-  void appendFunctionResultType(Type resultType,
-                                GenericSignature sig,
-                                const ValueDecl *forDecl = nullptr);
+  void appendFunctionResultType(
+      Type resultType, GenericSignature sig,
+      std::optional<LifetimeDependenceInfo> lifetimeDependence,
+      const ValueDecl *forDecl = nullptr);
 
   void appendTypeList(Type listTy, GenericSignature sig,
                       const ValueDecl *forDecl = nullptr);
@@ -573,7 +577,7 @@ class ASTMangler : public Mangler {
                              const ValueDecl *forDecl = nullptr);
   void appendParameterTypeListElement(
       Identifier name, Type elementType, ParameterTypeFlags flags,
-      std::optional<LifetimeDependenceKind> lifetimeDependenceKind,
+      std::optional<LifetimeDependenceInfo> lifetimeDependence,
       GenericSignature sig, const ValueDecl *forDecl = nullptr);
   void appendTupleTypeListElement(Identifier name, Type elementType,
                                   GenericSignature sig,
@@ -749,8 +753,7 @@ class ASTMangler : public Mangler {
   void appendConstrainedExistential(Type base, GenericSignature sig,
                                     const ValueDecl *forDecl);
 
-  void appendLifetimeDependenceKind(LifetimeDependenceKind kind,
-                                    bool isSelfDependence);
+  void appendLifetimeDependence(LifetimeDependenceInfo info);
 };
 
 } // end namespace Mangle

include/swift/AST/ASTPrinter.h

@@ -364,6 +364,22 @@ class ASTPrinter {
     return printedClangDecl.insert(d).second;
   }
 
+  void printLifetimeDependence(
+      std::optional<LifetimeDependenceInfo> lifetimeDependence) {
+    if (!lifetimeDependence.has_value()) {
+      return;
+    }
+    *this << lifetimeDependence->getString();
+  }
+
+  void printLifetimeDependenceAt(
+      ArrayRef<LifetimeDependenceInfo> lifetimeDependencies, unsigned index) {
+    if (auto lifetimeDependence =
+            getLifetimeDependenceFor(lifetimeDependencies, index)) {
+      printLifetimeDependence(*lifetimeDependence);
+    }
+  }
+
 private:
   virtual void anchor();
 };

include/swift/AST/Decl.h

@@ -7482,7 +7482,8 @@ class AbstractFunctionDecl : public GenericContext, public ValueDecl {
 
   /// Add the given derivative function configuration.
   void addDerivativeFunctionConfiguration(const AutoDiffConfig &config);
-  std::optional<LifetimeDependenceInfo> getLifetimeDependenceInfo() const;
+  std::optional<llvm::ArrayRef<LifetimeDependenceInfo>>
+  getLifetimeDependencies() const;
 
 protected:
   // If a function has a body at all, we have either a parsed body AST node or

include/swift/AST/DiagnosticsSema.def

@@ -7984,8 +7984,8 @@ ERROR(lifetime_dependence_invalid_self_ownership, none,
 ERROR(lifetime_dependence_only_on_function_method_init_result, none,
       "lifetime dependence specifiers may only be used on result of "
        "functions, methods, initializers", ())
-ERROR(lifetime_dependence_invalid_return_type, none,
-      "lifetime dependence can only be specified on ~Escapable results", ())
+ERROR(lifetime_dependence_invalid_type, none,
+      "lifetime dependence can only be specified on ~Escapable types", ())
 ERROR(lifetime_dependence_cannot_infer_ambiguous_candidate, none,
       "cannot infer lifetime dependence %0, multiple parameters qualifiy as a candidate", (StringRef))
  ERROR(lifetime_dependence_cannot_infer_no_candidates, none,