Delete dependsOn support

Lifetime dependencies will now be represented with @Lifetime attribute in the language.

dependsOn is a type modifier and was represented as a LifetimeDependentTypeRepr in the AST.

I am deleting dependsOn syntax parsing support and retaining LifetimeDependentTypeRepr support.

We may want to represent lifetime dependencies in a function type with a type attribute in the future.
If we use a decl attribute instead, then support for LifetimeDependentTypeRepr can be deleted.

Author: meg-gupta

include/swift/AST/Decl.h

@@ -8805,8 +8805,6 @@ class ConstructorDecl : public AbstractFunctionDecl {
     Bits.ConstructorDecl.HasStubImplementation = stub;
   }
 
-  bool hasLifetimeDependentReturn() const;
-
   ConstructorDecl *getOverriddenDecl() const {
     return cast_or_null<ConstructorDecl>(
         AbstractFunctionDecl::getOverriddenDecl());

include/swift/AST/LifetimeDependence.h

@@ -157,11 +157,6 @@ class LifetimeDependenceInfo {
   static std::optional<ArrayRef<LifetimeDependenceInfo>>
   fromLifetimeAttribute(AbstractFunctionDecl *afd);
 
-  /// Builds LifetimeDependenceInfo from dependsOn type modifier
-  static std::optional<LifetimeDependenceInfo>
-  fromDependsOn(AbstractFunctionDecl *afd, TypeRepr *targetRepr,
-                Type targetType, unsigned targetIndex);
-
   /// Infer LifetimeDependenceInfo on result
   static std::optional<LifetimeDependenceInfo> infer(AbstractFunctionDecl *afd);
 

include/swift/Parse/Parser.h

@@ -1222,11 +1222,8 @@ class Parser {
   }
 
   bool isLifetimeDependenceToken() {
-    if (!isInSILMode()) {
-      return Tok.isContextualKeyword("dependsOn");
-    }
-    return Tok.isContextualKeyword("_inherit") ||
-           Tok.isContextualKeyword("_scope");
+    return isInSILMode() && (Tok.isContextualKeyword("_inherit") ||
+                             Tok.isContextualKeyword("_scope"));
   }
 
   bool canHaveParameterSpecifierContextualKeyword() {

lib/AST/ASTPrinter.cpp

@@ -4246,16 +4246,6 @@ void PrintAST::visitFuncDecl(FuncDecl *decl) {
 
       Printer.printDeclResultTypePre(decl, ResultTyLoc);
       Printer.callPrintStructurePre(PrintStructureKind::FunctionReturnType);
-      {
-        if (!Options.SuppressNonEscapableTypes) {
-          if (auto *typeRepr = dyn_cast_or_null<LifetimeDependentTypeRepr>(
-                  decl->getResultTypeRepr())) {
-            for (auto &dep : typeRepr->getLifetimeDependencies()) {
-              Printer << " " << dep.getDependsOnString() << " ";
-            }
-          }
-        }
-      }
 
       if (!Options.SuppressSendingArgsAndResults) {
         if (decl->hasSendingResult()) {
@@ -4499,18 +4489,6 @@ void PrintAST::visitConstructorDecl(ConstructorDecl *decl) {
 
       printGenericDeclGenericParams(decl);
       printFunctionParameters(decl);
-      if (!Options.SuppressNonEscapableTypes) {
-        if (decl->hasLifetimeDependentReturn()) {
-          Printer << " -> ";
-          auto *typeRepr =
-              cast<LifetimeDependentTypeRepr>(decl->getResultTypeRepr());
-          for (auto &dep : typeRepr->getLifetimeDependencies()) {
-            Printer << dep.getDependsOnString() << " ";
-          }
-          // TODO: Handle failable initializers with lifetime dependent returns
-          Printer << "Self";
-        }
-      }
     });
 
   printDeclGenericRequirements(decl);

lib/AST/ASTVerifier.cpp

@@ -1109,16 +1109,6 @@ class Verifier : public ASTWalker {
       }
 
       if (S->hasResult()) {
-        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();
         auto returnType = result->getType();
         // Make sure that the return has the same type as the function.

lib/AST/Decl.cpp

@@ -10611,10 +10611,6 @@ bool ConstructorDecl::isObjCZeroParameterWithLongSelector() const {
   return params->get(0)->getInterfaceType()->isVoid();
 }
 
-bool ConstructorDecl::hasLifetimeDependentReturn() const {
-  return isa_and_nonnull<LifetimeDependentTypeRepr>(getResultTypeRepr());
-}
-
 DestructorDecl::DestructorDecl(SourceLoc DestructorLoc, DeclContext *Parent)
   : AbstractFunctionDecl(DeclKind::Destructor, Parent,
                          DeclBaseName::createDestructor(), DestructorLoc,

lib/AST/LifetimeDependence.cpp

@@ -414,48 +414,6 @@ LifetimeDependenceInfo::fromLifetimeAttribute(AbstractFunctionDecl *afd) {
 }
 
 std::optional<LifetimeDependenceInfo>
-LifetimeDependenceInfo::fromDependsOn(AbstractFunctionDecl *afd,
-                                      TypeRepr *targetTypeRepr, Type targetType,
-                                      unsigned targetIndex) {
-  auto *dc = afd->getDeclContext();
-  auto &ctx = dc->getASTContext();
-  auto &diags = ctx.Diags;
-
-  auto *lifetimeDependentRepr =
-      dyn_cast_or_null<LifetimeDependentTypeRepr>(targetTypeRepr);
-  if (!lifetimeDependentRepr) {
-    return std::nullopt;
-  }
-
-  if (targetType->isEscapable()) {
-    diags.diagnose(targetTypeRepr->getLoc(),
-                   diag::lifetime_dependence_invalid_type);
-    return std::nullopt;
-  }
-
-  auto capacity = afd->hasImplicitSelfDecl()
-                      ? (afd->getParameters()->size() + 1)
-                      : afd->getParameters()->size();
-
-  SmallBitVector inheritIndices(capacity);
-  SmallBitVector scopeIndices(capacity);
-  bool isImmortal = false;
-  bool hasError = false;
-
-  for (auto entry : lifetimeDependentRepr->getLifetimeDependencies()) {
-    hasError |= populateLifetimeDependence(afd, entry, inheritIndices,
-                                           scopeIndices, isImmortal);
-  }
-
-  if (hasError) {
-    return std::nullopt;
-  }
-  return LifetimeDependenceInfo(
-      inheritIndices.any() ? IndexSubset::get(ctx, inheritIndices) : nullptr,
-      scopeIndices.any() ? IndexSubset::get(ctx, scopeIndices) : nullptr,
-      targetIndex, isImmortal);
-}
-
 // This utility is similar to its overloaded version that builds the
 // LifetimeDependenceInfo from the swift decl. Reason for duplicated code is
 // the apis on type and ownership is different in SIL compared to Sema.
@@ -735,38 +693,12 @@ LifetimeDependenceInfo::get(AbstractFunctionDecl *afd) {
     return LifetimeDependenceInfo::fromLifetimeAttribute(afd);
   }
 
-  SmallVector<LifetimeDependenceInfo> lifetimeDependencies;
-
-  for (unsigned targetIndex : indices(*afd->getParameters())) {
-    auto *param = (*afd->getParameters())[targetIndex];
-    auto paramType =
-        afd->mapTypeIntoContext(param->toFunctionParam().getParameterType());
-    if (auto result = LifetimeDependenceInfo::fromDependsOn(
-            afd, param->getTypeRepr(), paramType, targetIndex)) {
-      lifetimeDependencies.push_back(*result);
-    }
-  }
-
-  std::optional<LifetimeDependenceInfo> resultDependence;
-
-  if (auto *lifetimeTypeRepr = dyn_cast_or_null<LifetimeDependentTypeRepr>(
-          afd->getResultTypeRepr())) {
-    resultDependence = LifetimeDependenceInfo::fromDependsOn(
-        afd, lifetimeTypeRepr, getResultOrYield(afd),
-        afd->hasImplicitSelfDecl() ? afd->getParameters()->size() + 1
-                                   : afd->getParameters()->size());
-  } else {
-    resultDependence = LifetimeDependenceInfo::infer(afd);
-  }
-
-  if (resultDependence.has_value()) {
-    lifetimeDependencies.push_back(*resultDependence);
-  }
-
-  if (lifetimeDependencies.empty()) {
+  SmallVector<LifetimeDependenceInfo, 1> lifetimeDependencies;
+  auto resultDependence = LifetimeDependenceInfo::infer(afd);
+  if (!resultDependence.has_value()) {
     return std::nullopt;
   }
-
+  lifetimeDependencies.push_back(*resultDependence);
   return afd->getASTContext().AllocateCopy(lifetimeDependencies);
 }
 

lib/Parse/ParseDecl.cpp

@@ -10074,26 +10074,7 @@ Parser::parseDeclInit(ParseDeclOptions Flags, DeclAttributes &Attributes) {
     isAsync = true;
   }
 
-  if (auto *lifetimeTyR =
-          dyn_cast_or_null<LifetimeDependentTypeRepr>(FuncRetTy)) {
-    auto *base = lifetimeTyR->getBase();
-
-    auto isOptionalSimpleUnqualifiedIdentifier = [](TypeRepr *typeRepr,
-                                                    Identifier str) {
-      if (auto *optionalTR = dyn_cast<OptionalTypeRepr>(typeRepr)) {
-        return optionalTR->getBase()->isSimpleUnqualifiedIdentifier(str);
-      }
-      return false;
-    };
-
-    // Diagnose if return type is not Self or Self?
-    if (!base->isSimpleUnqualifiedIdentifier(Context.Id_Self) &&
-        !isOptionalSimpleUnqualifiedIdentifier(base, Context.Id_Self)) {
-      diagnose(FuncRetTy->getStartLoc(),
-               diag::lifetime_dependence_invalid_init_return);
-      return nullptr;
-    }
-  } else if (FuncRetTy) {
+  if (FuncRetTy) {
     diagnose(FuncRetTy->getStartLoc(), diag::initializer_result_type)
       .fixItRemove(FuncRetTy->getSourceRange());
   }

lib/Sema/TypeCheckStmt.cpp

@@ -1726,23 +1726,6 @@ Stmt *PreCheckReturnStmtRequest::evaluate(Evaluator &evaluator, ReturnStmt *RS,
     // 'nil'.
     auto *nilExpr = dyn_cast<NilLiteralExpr>(E->getSemanticsProvidingExpr());
     if (!nilExpr) {
-      if (ctor->hasLifetimeDependentReturn()) {
-        bool isSelf = false;
-        if (auto *UDRE = dyn_cast<UnresolvedDeclRefExpr>(E)) {
-          isSelf = UDRE->getName().isSimpleName(ctx.Id_self);
-          // Result the result expression so that rest of the compilation
-          // pipeline handles initializers with lifetime dependence specifiers
-          // in the same way as other initializers.
-          RS->setResult(nullptr);
-        }
-        if (!isSelf) {
-          ctx.Diags.diagnose(
-              RS->getStartLoc(),
-              diag::lifetime_dependence_ctor_non_self_or_nil_return);
-          RS->setResult(nullptr);
-        }
-        return RS;
-      }
       ctx.Diags.diagnose(RS->getReturnLoc(), diag::return_init_non_nil)
           .highlight(E->getSourceRange());
       RS->setResult(nullptr);