Requestify LifetimeDependenceInfo

Query and cache lifetime dependence info via evaluator requests

Author: meg-gupta

include/swift/AST/Decl.h

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

include/swift/AST/TypeCheckRequests.h

@@ -4866,6 +4866,25 @@ class ImportDeclRequest
   bool isCached() const { return true; }
 };
 
+class LifetimeDependenceInfoRequest
+    : public SimpleRequest<LifetimeDependenceInfoRequest,
+                           std::optional<LifetimeDependenceInfo>(
+                               AbstractFunctionDecl *),
+                           RequestFlags::Cached> {
+public:
+  using SimpleRequest::SimpleRequest;
+
+private:
+  friend SimpleRequest;
+
+  std::optional<LifetimeDependenceInfo>
+  evaluate(Evaluator &evaluator, AbstractFunctionDecl *AFD) const;
+
+public:
+  // Caching.
+  bool isCached() const { return true; }
+};
+
 #define SWIFT_TYPEID_ZONE TypeChecker
 #define SWIFT_TYPEID_HEADER "swift/AST/TypeCheckerTypeIDZone.def"
 #include "swift/Basic/DefineTypeIDZone.h"

include/swift/AST/TypeCheckerTypeIDZone.def

@@ -566,3 +566,5 @@ SWIFT_REQUEST(TypeChecker, ImportDeclRequest,
               std::optional<AttributedImport<ImportedModule>>(
                   const SourceFile *sf, const ModuleDecl *mod),
               Cached, NoLocationInfo)
+SWIFT_REQUEST(TypeChecker, LifetimeDependenceInfoRequest,
+              LifetimeDependenceInfo(AbstractFunctionDecl *), Cached, NoLocationInfo)

lib/AST/Decl.cpp

@@ -10007,6 +10007,18 @@ void AbstractFunctionDecl::addDerivativeFunctionConfiguration(
   DerivativeFunctionConfigs->insert(config);
 }
 
+std::optional<LifetimeDependenceInfo>
+AbstractFunctionDecl::getLifetimeDependenceInfo() const {
+  if (!isa<FuncDecl>(this) && !isa<ConstructorDecl>(this)) {
+    return std::nullopt;
+  }
+
+  return evaluateOrDefault(
+      getASTContext().evaluator,
+      LifetimeDependenceInfoRequest{const_cast<AbstractFunctionDecl *>(this)},
+      std::nullopt);
+}
+
 void FuncDecl::setResultInterfaceType(Type type) {
   getASTContext().evaluator.cacheOutput(ResultTypeRequest{this},
                                         std::move(type));

lib/Sema/TypeCheckDecl.cpp

@@ -2550,7 +2550,7 @@ InterfaceTypeRequest::evaluate(Evaluator &eval, ValueDecl *D) const {
       resultTy = TupleType::getEmpty(AFD->getASTContext());
     }
 
-    std::optional<LifetimeDependenceInfo> lifetimeDependenceInfo;
+    auto lifetimeDependenceInfo = AFD->getLifetimeDependenceInfo();
 
     // (Args...) -> Result
     Type funcTy;
@@ -2571,7 +2571,6 @@ InterfaceTypeRequest::evaluate(Evaluator &eval, ValueDecl *D) const {
           infoBuilder = infoBuilder.withTransferringResult();
       }
 
-      lifetimeDependenceInfo = LifetimeDependenceInfo::get(AFD, resultTy);
       if (lifetimeDependenceInfo.has_value()) {
         infoBuilder =
             infoBuilder.withLifetimeDependenceInfo(*lifetimeDependenceInfo);
@@ -3098,3 +3097,18 @@ ImplicitKnownProtocolConformanceRequest::evaluate(Evaluator &evaluator,
     llvm_unreachable("non-implicitly derived KnownProtocol");
   }
 }
+
+std::optional<LifetimeDependenceInfo>
+LifetimeDependenceInfoRequest::evaluate(Evaluator &evaluator,
+                                        AbstractFunctionDecl *decl) const {
+  Type resultTy;
+  if (auto fn = dyn_cast<FuncDecl>(decl)) {
+    resultTy = fn->getResultInterfaceType();
+  } else if (auto ctor = dyn_cast<ConstructorDecl>(decl)) {
+    resultTy = ctor->getResultInterfaceType();
+  } else {
+    return std::nullopt;
+  }
+
+  return LifetimeDependenceInfo::get(decl, resultTy);
+}

lib/Serialization/Deserialization.cpp

@@ -3644,14 +3644,12 @@ class DeclDeserializer {
     assert(bodyParams && "missing parameters for constructor");
     ctor->setParameters(bodyParams);
 
-    SmallVector<LifetimeDependenceSpecifier> specifierList;
-    if (MF.maybeReadLifetimeDependenceSpecifier(specifierList,
-                                                bodyParams->size())) {
-      auto SelfType = ctor->getDeclaredInterfaceType();
-      auto typeRepr = new (ctx) FixedTypeRepr(SelfType, SourceLoc());
-      auto lifetimeTypeRepr =
-          LifetimeDependentReturnTypeRepr::create(ctx, typeRepr, specifierList);
-      ctor->setDeserializedResultTypeLoc(TypeLoc(lifetimeTypeRepr, SelfType));
+    auto lifetimeDependenceInfo =
+        MF.maybeReadLifetimeDependenceInfo(bodyParams->size());
+
+    if (lifetimeDependenceInfo.has_value()) {
+      ctx.evaluator.cacheOutput(LifetimeDependenceInfoRequest{ctor},
+                                std::move(lifetimeDependenceInfo.value()));
     }
 
     if (auto errorConvention = MF.maybeReadForeignErrorConvention())
@@ -4222,13 +4220,13 @@ class DeclDeserializer {
 
     ParameterList *paramList = MF.readParameterList();
     fn->setParameters(paramList);
-    SmallVector<LifetimeDependenceSpecifier> specifierList;
-    if (MF.maybeReadLifetimeDependenceSpecifier(specifierList,
-                                                paramList->size())) {
-      auto typeRepr = new (ctx) FixedTypeRepr(resultType, SourceLoc());
-      auto lifetimeTypeRepr =
-          LifetimeDependentReturnTypeRepr::create(ctx, typeRepr, specifierList);
-      fn->setDeserializedResultTypeLoc(TypeLoc(lifetimeTypeRepr, resultType));
+
+    auto lifetimeDependenceInfo =
+        MF.maybeReadLifetimeDependenceInfo(paramList->size());
+
+    if (lifetimeDependenceInfo.has_value()) {
+      ctx.evaluator.cacheOutput(LifetimeDependenceInfoRequest{fn},
+                                std::move(lifetimeDependenceInfo.value()));
     }
 
     if (auto errorConvention = MF.maybeReadForeignErrorConvention())
@@ -8829,41 +8827,3 @@ ModuleFile::maybeReadLifetimeDependenceInfo(unsigned numParams) {
           ? IndexSubset::get(ctx, scopeLifetimeParamIndices)
           : nullptr);
 }
-
-bool ModuleFile::maybeReadLifetimeDependenceSpecifier(
-    SmallVectorImpl<LifetimeDependenceSpecifier> &specifierList,
-    unsigned numDeclParams) {
-  using namespace decls_block;
-
-  SmallVector<uint64_t, 8> scratch;
-  if (!maybeReadLifetimeDependenceRecord(scratch)) {
-    return false;
-  }
-
-  bool hasInheritLifetimeParamIndices;
-  bool hasScopeLifetimeParamIndices;
-  ArrayRef<uint64_t> lifetimeDependenceData;
-  LifetimeDependenceLayout::readRecord(scratch, hasInheritLifetimeParamIndices,
-                                       hasScopeLifetimeParamIndices,
-                                       lifetimeDependenceData);
-
-  unsigned startIndex = 0;
-  auto pushData = [&](ParsedLifetimeDependenceKind kind) {
-    for (unsigned i = 0; i < numDeclParams + 1; i++) {
-      if (lifetimeDependenceData[startIndex + i]) {
-        specifierList.push_back(
-            LifetimeDependenceSpecifier::getOrderedLifetimeDependenceSpecifier(
-                SourceLoc(), kind, i));
-      }
-    }
-    startIndex += numDeclParams + 1;
-  };
-
-  if (hasInheritLifetimeParamIndices) {
-    pushData(ParsedLifetimeDependenceKind::Inherit);
-  }
-  if (hasScopeLifetimeParamIndices) {
-    pushData(ParsedLifetimeDependenceKind::Scope);
-  }
-  return true;
-}