Support for lifetime dependence specifiers on initializers

include/swift/AST/AnyFunctionRef.h

@@ -116,6 +116,11 @@ class AnyFunctionRef {
     if (auto *AFD = TheFunction.dyn_cast<AbstractFunctionDecl *>()) {
       if (auto *FD = dyn_cast<FuncDecl>(AFD))
         return FD->mapTypeIntoContext(FD->getResultInterfaceType());
+      if (auto *CD = dyn_cast<ConstructorDecl>(AFD)) {
+        if (CD->hasLifetimeDependentReturn()) {
+          return CD->getResultInterfaceType();
+        }
+      }
       return TupleType::getEmpty(AFD->getASTContext());
     }
     return TheFunction.get<AbstractClosureExpr *>()->getResultType();

include/swift/AST/Decl.h

@@ -8299,15 +8299,18 @@ class ConstructorDecl : public AbstractFunctionDecl {
   /// inserted at the end of the initializer by SILGen.
   Expr *CallToSuperInit = nullptr;
 
+  /// Valid when lifetime dependence specifiers are present.
+  TypeLoc InitRetType;
+
 public:
-  ConstructorDecl(DeclName Name, SourceLoc ConstructorLoc, 
+  ConstructorDecl(DeclName Name, SourceLoc ConstructorLoc,
                   bool Failable, SourceLoc FailabilityLoc,
                   bool Async, SourceLoc AsyncLoc,
                   bool Throws, SourceLoc ThrowsLoc,
                   TypeLoc thrownTy,
                   ParameterList *BodyParams,
-                  GenericParamList *GenericParams, 
-                  DeclContext *Parent);
+                  GenericParamList *GenericParams,
+                  DeclContext *Parent, TypeRepr *InitRetTy);
 
   static ConstructorDecl *
   createImported(ASTContext &ctx, ClangNode clangNode, DeclName name,
@@ -8329,6 +8332,10 @@ class ConstructorDecl : public AbstractFunctionDecl {
   /// Get the interface type of the initializing constructor.
   Type getInitializerInterfaceType();
 
+  TypeRepr *getResultTypeRepr() const { return InitRetType.getTypeRepr(); }
+
+  void setDeserializedResultTypeLoc(TypeLoc ResultTyR);
+
   /// Get the typechecked call to super.init expression, which needs to be
   /// inserted at the end of the initializer by SILGen.
   Expr *getSuperInitCall() { return CallToSuperInit; }
@@ -8408,6 +8415,8 @@ class ConstructorDecl : public AbstractFunctionDecl {
     Bits.ConstructorDecl.HasStubImplementation = stub;
   }
 
+  bool hasLifetimeDependentReturn() const;
+
   ConstructorDecl *getOverriddenDecl() const {
     return cast_or_null<ConstructorDecl>(
         AbstractFunctionDecl::getOverriddenDecl());

include/swift/AST/DiagnosticsParse.def

@@ -2179,6 +2179,10 @@ ERROR(requires_experimental_feature, none,
       "%2 is enabled",
       (StringRef, bool, StringRef))
 
+//------------------------------------------------------------------------------
+// MARK: Lifetime dependence
+//------------------------------------------------------------------------------
+
 ERROR(expected_lparen_after_lifetime_dependence, PointsToFirstBadToken,
       "expected '(' after lifetime dependence specifier", ())
 
@@ -2193,5 +2197,9 @@ ERROR(expected_rparen_after_lifetime_dependence, PointsToFirstBadToken,
 ERROR(expected_param_index_lifetime_dependence, PointsToFirstBadToken,
       "expected unsigned parameter index in lifetime dependence specifier", ())
 
+ERROR(lifetime_dependence_invalid_init_return, PointsToFirstBadToken,
+      "expected Self return type for initializers with lifetime dependence "
+      "specifiers",
+      ())
 #define UNDEFINE_DIAGNOSTIC_MACROS
 #include "DefineDiagnosticMacros.h"

include/swift/AST/DiagnosticsSema.def

@@ -7827,5 +7827,9 @@ ERROR(pack_iteration_where_clause_not_supported, none,
        "cannot infer lifetime dependence, no ~Escapable or ~Copyable "
        "parameters with ownership modifiers present",
        ())
+ ERROR(lifetime_dependence_ctor_non_self_or_nil_return, none,
+       "expected nil or self as return values in an initializer with "
+       "lifetime dependent specifiers",
+       ())
 #define UNDEFINE_DIAGNOSTIC_MACROS
 #include "DefineDiagnosticMacros.h"

lib/AST/ASTBridging.cpp

@@ -943,12 +943,13 @@ BridgedConstructorDecl BridgedConstructorDecl_createParsed(
   auto throwsLoc = cThrowsLoc.unbridged();
   auto failabilityMarkLoc = cFailabilityMarkLoc.unbridged();
   // FIXME: rethrows
-
+  // TODO: Handle LifetimeDependentReturnTypeRepr here.
   auto *decl = new (context) ConstructorDecl(
       declName, cInitKeywordLoc.unbridged(), failabilityMarkLoc.isValid(),
       failabilityMarkLoc, asyncLoc.isValid(), asyncLoc, throwsLoc.isValid(),
       throwsLoc, thrownType.unbridged(), parameterList,
-      genericParams.unbridged(), cDeclContext.unbridged());
+      genericParams.unbridged(), cDeclContext.unbridged(),
+      /*InitRetTy*/ nullptr);
   decl->setTrailingWhereClause(genericWhereClause.unbridged());
   decl->setImplicitlyUnwrappedOptional(isIUO);
 

lib/AST/ASTVerifier.cpp

@@ -1075,17 +1075,25 @@ class Verifier : public ASTWalker {
         resultType = FD->mapTypeIntoContext(resultType);
       } else if (auto closure = dyn_cast<AbstractClosureExpr>(func)) {
         resultType = closure->getResultType();
+      } else if (auto *CD = dyn_cast<ConstructorDecl>(func)) {
+        if (CD->hasLifetimeDependentReturn()) {
+          resultType = CD->getResultInterfaceType();
+        } else {
+          resultType = TupleType::getEmpty(Ctx);
+        }
       } else {
         resultType = TupleType::getEmpty(Ctx);
       }
-      
+
       if (S->hasResult()) {
-        if (isa<ConstructorDecl>(func)) {
-          Out << "Expected ReturnStmt not to have a result. A constructor "
-                 "should not return a result. Returned expression: ";
-          S->getResult()->dump(Out);
-          Out << "\n";
-          abort();
+        if (auto *CD = dyn_cast<ConstructorDecl>(func)) {
+          if (!CD->hasLifetimeDependentReturn()) {
+            Out << "Expected ReturnStmt not to have a result. A constructor "
+                   "should not return a result. Returned expression: ";
+            S->getResult()->dump(Out);
+            Out << "\n";
+            abort();
+          }
         }
 
         auto result = S->getResult();

lib/AST/Decl.cpp

@@ -3577,6 +3577,8 @@ TypeRepr *ValueDecl::getResultTypeRepr() const {
     returnRepr = SD->getElementTypeRepr();
   } else if (auto *MD = dyn_cast<MacroDecl>(this)) {
     returnRepr = MD->resultType.getTypeRepr();
+  } else if (auto *CD = dyn_cast<ConstructorDecl>(this)) {
+    returnRepr = CD->getResultTypeRepr();
   }
 
   return returnRepr;
@@ -10383,7 +10385,7 @@ ConstructorDecl::ConstructorDecl(DeclName Name, SourceLoc ConstructorLoc,
                                  TypeLoc ThrownType,
                                  ParameterList *BodyParams,
                                  GenericParamList *GenericParams,
-                                 DeclContext *Parent)
+                                 DeclContext *Parent, TypeRepr *ResultTyR)
   : AbstractFunctionDecl(DeclKind::Constructor, Parent, Name, ConstructorLoc,
                          Async, AsyncLoc, Throws, ThrowsLoc, ThrownType,
                          /*HasImplicitSelfDecl=*/true,
@@ -10393,7 +10395,8 @@ ConstructorDecl::ConstructorDecl(DeclName Name, SourceLoc ConstructorLoc,
 {
   if (BodyParams)
     setParameters(BodyParams);
-
+
+  InitRetType = TypeLoc(ResultTyR);
   Bits.ConstructorDecl.HasStubImplementation = 0;
   Bits.ConstructorDecl.Failable = Failable;
 
@@ -10414,11 +10417,16 @@ ConstructorDecl *ConstructorDecl::createImported(
                       failable, failabilityLoc, 
                       async, asyncLoc,
                       throws, throwsLoc, TypeLoc::withoutLoc(thrownType),
-                      bodyParams, genericParams, parent);
+                      bodyParams, genericParams, parent,
+                      /*LifetimeDependenceTypeRepr*/ nullptr);
   ctor->setClangNode(clangNode);
   return ctor;
 }
 
+void ConstructorDecl::setDeserializedResultTypeLoc(TypeLoc ResultTyR) {
+  InitRetType = ResultTyR;
+}
+
 bool ConstructorDecl::isObjCZeroParameterWithLongSelector() const {
   // The initializer must have a single, non-empty argument name.
   if (getName().getArgumentNames().size() != 1 ||
@@ -10432,6 +10440,10 @@ bool ConstructorDecl::isObjCZeroParameterWithLongSelector() const {
   return params->get(0)->getInterfaceType()->isVoid();
 }
 
+bool ConstructorDecl::hasLifetimeDependentReturn() const {
+  return isa_and_nonnull<LifetimeDependentReturnTypeRepr>(getResultTypeRepr());
+}
+
 DestructorDecl::DestructorDecl(SourceLoc DestructorLoc, DeclContext *Parent)
   : AbstractFunctionDecl(DeclKind::Destructor, Parent,
                          DeclBaseName::createDestructor(), DestructorLoc,

lib/ClangImporter/ImportDecl.cpp

@@ -3646,7 +3646,8 @@ namespace {
             /*failable=*/false, /*FailabilityLoc=*/SourceLoc(),
             /*Async=*/false, /*AsyncLoc=*/SourceLoc(),
             /*Throws=*/false, /*ThrowsLoc=*/SourceLoc(),
-            /*ThrownType=*/TypeLoc(), bodyParams, genericParams, dc);
+            /*ThrownType=*/TypeLoc(), bodyParams, genericParams, dc,
+            /*LifetimeDependentReturnTypeRepr*/ nullptr);
       } else {
         auto resultTy = importedType.getType();
 
@@ -6221,7 +6222,8 @@ Decl *SwiftDeclConverter::importGlobalAsInitializer(
       failable, /*FailabilityLoc=*/SourceLoc(),
       /*Async=*/false, /*AsyncLoc=*/SourceLoc(),
       /*Throws=*/false, /*ThrowsLoc=*/SourceLoc(), /*ThrownType=*/TypeLoc(),
-      parameterList, /*GenericParams=*/nullptr, dc);
+      parameterList, /*GenericParams=*/nullptr, dc,
+      /*LifetimeDependentReturnTypeRepr*/ nullptr);
   result->setImplicitlyUnwrappedOptional(isIUO);
   result->getASTContext().evaluator.cacheOutput(InitKindRequest{result},
                                                 std::move(initKind));
@@ -6735,7 +6737,8 @@ ConstructorDecl *SwiftDeclConverter::importConstructor(
       /*Async=*/false, /*AsyncLoc=*/SourceLoc(),
       /*Throws=*/importedName.getErrorInfo().has_value(),
       /*ThrowsLoc=*/SourceLoc(), /*ThrownType=*/TypeLoc(), bodyParams,
-      /*GenericParams=*/nullptr, const_cast<DeclContext *>(dc));
+      /*GenericParams=*/nullptr, const_cast<DeclContext *>(dc),
+      /*LifetimeDependentReturnTypeRepr*/ nullptr);
 
   addObjCAttribute(result, selector);
   recordMemberInContext(dc, result);

lib/ClangImporter/SwiftDeclSynthesizer.cpp

@@ -493,9 +493,10 @@ SwiftDeclSynthesizer::createDefaultConstructor(NominalTypeDecl *structDecl) {
       ConstructorDecl(name, structDecl->getLoc(),
                       /*Failable=*/false, /*FailabilityLoc=*/SourceLoc(),
                       /*Async=*/false, /*AsyncLoc=*/SourceLoc(),
-                      /*Throws=*/false, /*ThrowsLoc=*/SourceLoc(), 
+                      /*Throws=*/false, /*ThrowsLoc=*/SourceLoc(),
                       /*ThrownType=*/TypeLoc(), emptyPL,
-                      /*GenericParams=*/nullptr, structDecl);
+                      /*GenericParams=*/nullptr, structDecl,
+                      /*LifetimeDependentReturnTypeRepr*/ nullptr);
 
   constructor->setAccess(AccessLevel::Public);
 
@@ -623,9 +624,10 @@ ConstructorDecl *SwiftDeclSynthesizer::createValueConstructor(
       ConstructorDecl(name, structDecl->getLoc(),
                       /*Failable=*/false, /*FailabilityLoc=*/SourceLoc(),
                       /*Async=*/false, /*AsyncLoc=*/SourceLoc(),
-                      /*Throws=*/false, /*ThrowsLoc=*/SourceLoc(), 
+                      /*Throws=*/false, /*ThrowsLoc=*/SourceLoc(),
                       /*ThrownType=*/TypeLoc(), paramList,
-                      /*GenericParams=*/nullptr, structDecl);
+                      /*GenericParams=*/nullptr, structDecl,
+                      /*LifetimeDependentReturnTypeRepr*/ nullptr);
 
   constructor->setAccess(AccessLevel::Public);
 
@@ -1271,13 +1273,14 @@ SwiftDeclSynthesizer::makeEnumRawValueConstructor(EnumDecl *enumDecl) {
   auto paramPL = ParameterList::createWithoutLoc(param);
 
   DeclName name(C, DeclBaseName::createConstructor(), paramPL);
-  auto *ctorDecl = new (C)
-      ConstructorDecl(name, enumDecl->getLoc(),
-                      /*Failable=*/true, /*FailabilityLoc=*/SourceLoc(),
-                      /*Async=*/false, /*AsyncLoc=*/SourceLoc(),
-                      /*Throws=*/false, /*ThrowsLoc=*/SourceLoc(), 
-                      /*ThrownType=*/TypeLoc(), paramPL,
-                      /*GenericParams=*/nullptr, enumDecl);
+  auto *ctorDecl =
+      new (C) ConstructorDecl(name, enumDecl->getLoc(),
+                              /*Failable=*/true, /*FailabilityLoc=*/SourceLoc(),
+                              /*Async=*/false, /*AsyncLoc=*/SourceLoc(),
+                              /*Throws=*/false, /*ThrowsLoc=*/SourceLoc(),
+                              /*ThrownType=*/TypeLoc(), paramPL,
+                              /*GenericParams=*/nullptr, enumDecl,
+                              /*LifetimeDependentReturnTypeRepr*/ nullptr);
   ctorDecl->setImplicit();
   ctorDecl->setAccess(AccessLevel::Public);
   ctorDecl->setBodySynthesizer(synthesizeEnumRawValueConstructorBody, enumDecl);

lib/Parse/ParseDecl.cpp

@@ -9817,7 +9817,16 @@ Parser::parseDeclInit(ParseDeclOptions Flags, DeclAttributes &Attributes) {
     isAsync = true;
   }
 
-  if (FuncRetTy) {
+  if (auto *lifetimeTyR =
+          dyn_cast_or_null<LifetimeDependentReturnTypeRepr>(FuncRetTy)) {
+    auto *identTyR = dyn_cast<SimpleIdentTypeRepr>(lifetimeTyR->getBase());
+    if (!identTyR ||
+        identTyR->getNameRef().getBaseIdentifier() != Context.Id_Self) {
+      diagnose(FuncRetTy->getStartLoc(),
+               diag::lifetime_dependence_invalid_init_return);
+      return nullptr;
+    }
+  } else if (FuncRetTy) {
     diagnose(FuncRetTy->getStartLoc(), diag::initializer_result_type)
       .fixItRemove(FuncRetTy->getSourceRange());
   }
@@ -9836,7 +9845,7 @@ Parser::parseDeclInit(ParseDeclOptions Flags, DeclAttributes &Attributes) {
                                            isAsync, asyncLoc,
                                            throwsLoc.isValid(), throwsLoc,
                                            thrownTy, BodyParams, GenericParams,
-                                           CurDeclContext);
+                                           CurDeclContext, FuncRetTy);
   CD->setImplicitlyUnwrappedOptional(IUO);
   CD->getAttrs() = Attributes;
 

lib/SILGen/SILGenConstructor.cpp

@@ -680,10 +680,13 @@ void SILGenFunction::emitValueConstructor(ConstructorDecl *ctor) {
   // Create a basic block to jump to for the implicit 'self' return.
   // We won't emit this until after we've emitted the body.
   // The epilog takes a void return because the return of 'self' is implicit.
+  // When lifetime dependence specifiers are present, epilog will take the
+  // explicit 'self' return.
   prepareEpilog(ctor,
-                llvm::None,
-                ctor->getEffectiveThrownErrorType(),
-                CleanupLocation(ctor));
+                ctor->hasLifetimeDependentReturn()
+                    ? llvm::Optional<Type>(ctor->getResultInterfaceType())
+                    : llvm::None,
+                ctor->getEffectiveThrownErrorType(), CleanupLocation(ctor));
 
   // If the constructor can fail, set up an alternative epilog for constructor
   // failure.
@@ -767,7 +770,11 @@ void SILGenFunction::emitValueConstructor(ConstructorDecl *ctor) {
   // Emit the constructor body.
   emitStmt(ctor->getTypecheckedBody());
 
-
+  if (ctor->hasLifetimeDependentReturn()) {
+    emitEpilog(ctor, /*UsesCustomEpilog*/ false);
+    return;
+  }
+
   // Build a custom epilog block, since the AST representation of the
   // constructor decl (which has no self in the return type) doesn't match the
   // SIL representation.

lib/Sema/CodeSynthesis.cpp

@@ -330,7 +330,8 @@ static ConstructorDecl *createImplicitConstructor(NominalTypeDecl *decl,
                               /*Async=*/false, /*AsyncLoc=*/SourceLoc(),
                               /*Throws=*/false, /*ThrowsLoc=*/SourceLoc(),
                               /*ThrownType=*/TypeLoc(),
-                              paramList, /*GenericParams=*/nullptr, decl);
+                              paramList, /*GenericParams=*/nullptr, decl,
+							  /*LifetimeDependentReturnTypeRepr*/ nullptr);
 
   // Mark implicit.
   ctor->setImplicit();
@@ -830,7 +831,8 @@ createDesignatedInitOverride(ClassDecl *classDecl,
                               /*Throws=*/superclassCtor->hasThrows(),
                               /*ThrowsLoc=*/SourceLoc(),
                               TypeLoc::withoutLoc(thrownType),
-                              bodyParams, genericParams, implCtx);
+                              bodyParams, genericParams, implCtx,
+							  /*LifetimeDependentReturnTypeRepr*/ nullptr);
 
   ctor->setImplicit();
 

lib/Sema/DerivedConformanceCodable.cpp

@@ -1888,11 +1888,12 @@ static ValueDecl *deriveDecodable_init(DerivedConformance &derived) {
 
   auto *initDecl =
       new (C) ConstructorDecl(name, SourceLoc(),
-                              /*Failable=*/false,SourceLoc(),
+                              /*Failable=*/false, SourceLoc(),
                               /*Async=*/false, /*AsyncLoc=*/SourceLoc(),
                               /*Throws=*/true, SourceLoc(),
                               /*ThrownType=*/TypeLoc(), paramList,
-                              /*GenericParams=*/nullptr, conformanceDC);
+                              /*GenericParams=*/nullptr, conformanceDC,
+                              /*LifetimeDependentReturnTypeRepr*/ nullptr);
   initDecl->setImplicit();
   initDecl->setSynthesized();
 

lib/Sema/DerivedConformanceCodingKey.cpp

@@ -133,7 +133,8 @@ static ValueDecl *deriveInitDecl(DerivedConformance &derived, Type paramType,
                             /*Throws=*/false, /*ThrowsLoc=*/SourceLoc(),
                             /*ThrownType=*/TypeLoc(),
                             paramList,
-                            /*GenericParams=*/nullptr, parentDC);
+                            /*GenericParams=*/nullptr, parentDC,
+                            /*LifetimeDependentReturnTypeRepr*/ nullptr);
 
   initDecl->setImplicit();
 

lib/Sema/DerivedConformanceRawRepresentable.cpp

@@ -423,15 +423,16 @@ deriveRawRepresentable_init(DerivedConformance &derived) {
   auto paramList = ParameterList::createWithoutLoc(rawDecl);
 
   DeclName name(C, DeclBaseName::createConstructor(), paramList);
-  
+
   auto initDecl =
-    new (C) ConstructorDecl(name, SourceLoc(),
-                            /*Failable=*/ true, /*FailabilityLoc=*/SourceLoc(),
-                            /*Async=*/false, /*AsyncLoc=*/SourceLoc(),
-                            /*Throws=*/false, /*ThrowsLoc=*/SourceLoc(),
-                            /*ThrownType=*/TypeLoc(), paramList,
-                            /*GenericParams=*/nullptr, parentDC);
-
+      new (C) ConstructorDecl(name, SourceLoc(),
+                              /*Failable=*/true, /*FailabilityLoc=*/SourceLoc(),
+                              /*Async=*/false, /*AsyncLoc=*/SourceLoc(),
+                              /*Throws=*/false, /*ThrowsLoc=*/SourceLoc(),
+                              /*ThrownType=*/TypeLoc(), paramList,
+                              /*GenericParams=*/nullptr, parentDC,
+                              /*LifetimeDependentReturnTypeRepr*/ nullptr);
+
   initDecl->setImplicit();
   initDecl->setBodySynthesizer(&deriveBodyRawRepresentable_init);
   addNonIsolatedToSynthesized(enumDecl, initDecl);