Introduce a new suppressible experimental feature to guard @_lifetime

Author: meg-gupta

include/swift/AST/PrintOptions.h

@@ -362,6 +362,9 @@ struct PrintOptions {
   /// as public
   bool SuppressIsolatedDeinit = false;
 
+  /// Suppress @_lifetime attribute and emit @lifetime instead.
+  bool SuppressLifetimes = false;
+
   /// Whether to print the \c{/*not inherited*/} comment on factory initializers.
   bool PrintFactoryInitializerComment = true;
 

include/swift/Basic/Features.def

@@ -525,6 +525,9 @@ EXPERIMENTAL_FEATURE(ModuleSelector, false)
 /// in a file scope.
 EXPERIMENTAL_FEATURE(DefaultIsolationPerFile, false)
 
+/// Enable @_lifetime attribute
+SUPPRESSIBLE_EXPERIMENTAL_FEATURE(Lifetimes, true)
+
 #undef EXPERIMENTAL_FEATURE_EXCLUDED_FROM_MODULE_INTERFACE
 #undef EXPERIMENTAL_FEATURE
 #undef UPCOMING_FEATURE

lib/AST/ASTPrinter.cpp

@@ -3252,6 +3252,13 @@ suppressingFeatureIsolatedDeinit(PrintOptions &options,
   action();
 }
 
+static void
+suppressingFeatureLifetimes(PrintOptions &options,
+                                     llvm::function_ref<void()> action) {
+  llvm::SaveAndRestore<bool> scope(options.SuppressLifetimes, true);
+  action();
+}
+
 namespace {
 struct ExcludeAttrRAII {
   std::vector<AnyAttrKind> &ExcludeAttrList;

lib/AST/Attr.cpp

@@ -1689,7 +1689,11 @@ bool DeclAttribute::printImpl(ASTPrinter &Printer, const PrintOptions &Options,
 
   case DeclAttrKind::Lifetime: {
     auto *attr = cast<LifetimeAttr>(this);
-    Printer << attr->getString();
+    if (!attr->isUnderscored() || Options.SuppressLifetimes) {
+      Printer << "@lifetime" << attr->getLifetimeEntry()->getString();
+    } else {
+      Printer << "@_lifetime" << attr->getLifetimeEntry()->getString();
+    }
     break;
   }
 

lib/AST/FeatureSet.cpp

@@ -259,8 +259,10 @@ static bool usesFeatureSendingArgsAndResults(Decl *decl) {
 }
 
 static bool usesFeatureLifetimeDependence(Decl *decl) {
-  if (decl->getAttrs().hasAttribute<LifetimeAttr>()) {
-    return true;
+  for (auto attr : decl->getAttrs().getAttributes<LifetimeAttr>()) {
+    if (!attr->isUnderscored()) {
+      return true;
+    }
   }
   if (auto *afd = dyn_cast<AbstractFunctionDecl>(decl)) {
     return afd->getInterfaceType()
@@ -296,6 +298,26 @@ static bool usesFeatureInoutLifetimeDependence(Decl *decl) {
   }
 }
 
+static bool usesFeatureLifetimes(Decl *decl) {
+  auto hasLifetimes = [](Decl *decl) {
+    for (auto attr : decl->getAttrs().getAttributes<LifetimeAttr>()) {
+      if (attr->isUnderscored()) {
+        return true;
+      }
+    }
+    return false;
+  };
+
+  switch (decl->getKind()) {
+  case DeclKind::Var: {
+    auto *var = cast<VarDecl>(decl);
+    return llvm::any_of(var->getAllAccessors(), hasLifetimes);
+  }
+  default:
+    return hasLifetimes(decl);
+  }
+}
+
 static bool usesFeatureLifetimeDependenceMutableAccessors(Decl *decl) {
   if (!isa<VarDecl>(decl)) {
     return false;

lib/AST/LifetimeDependence.cpp

@@ -300,14 +300,15 @@ class LifetimeDependenceChecker {
     assert(lifetimeDependencies.empty());
 
     // Handle Builtins first because, even though Builtins require
-    // LifetimeDependence, we don't force Feature::LifetimeDependence
+    // LifetimeDependence, we don't force the experimental feature
     // to be enabled when importing the Builtin module.
     if (afd->isImplicit() && afd->getModuleContext()->isBuiltinModule()) {
       inferBuiltin();
       return currentDependencies();
     }
 
     if (!ctx.LangOpts.hasFeature(Feature::LifetimeDependence)
+        && !ctx.LangOpts.hasFeature(Feature::Lifetimes)
         && !ctx.SourceMgr.isImportMacroGeneratedLoc(returnLoc)) {
 
       // Infer inout dependencies without requiring a feature flag. On

lib/Parse/ParseDecl.cpp

@@ -5374,10 +5374,10 @@ ParserStatus Parser::ParsedTypeAttributeList::slowParse(Parser &P) {
     }
 
     if (P.isSILLifetimeDependenceToken()) {
-      if (!P.Context.LangOpts.hasFeature(Feature::LifetimeDependence)) {
+      if (!P.Context.LangOpts.hasFeature(Feature::Lifetimes)) {
         P.diagnose(Tok, diag::requires_experimental_feature,
                    "lifetime dependence specifier", false,
-                   Feature::LifetimeDependence.getName());
+                   Feature::Lifetimes.getName());
       }
       P.consumeToken(); // consume '@'
       auto loc = P.consumeToken(); // consume 'lifetime'

lib/Sema/TypeCheckAttr.cpp

@@ -8226,19 +8226,25 @@ void AttributeChecker::visitWeakLinkedAttr(WeakLinkedAttr *attr) {
 }
 
 void AttributeChecker::visitLifetimeAttr(LifetimeAttr *attr) {
-  // Allow @lifetime only in the stdlib, cxx and backward compatibility modules
-  if (!attr->isUnderscored() &&
-      !(Ctx.MainModule->isStdlibModule() || Ctx.MainModule->isCxxModule() ||
-        Ctx.MainModule->getABIName() == Ctx.StdlibModuleName)) {
-    Ctx.Diags.diagnose(attr->getLocation(), diag::use_lifetime_underscored);
-  }
-  if (!Ctx.LangOpts.hasFeature(Feature::LifetimeDependence) &&
-      !Ctx.SourceMgr.isImportMacroGeneratedLoc(attr->getLocation())) {
-    diagnose(attr->getLocation(), diag::requires_experimental_feature,
-             std::string("@") + (attr->isUnderscored()
-                                     ? std::string("_lifetime")
-                                     : std::string("lifetime")),
-             false, Feature::LifetimeDependence.getName());
+  if (!attr->isUnderscored()) {
+    // Allow @lifetime only in the stdlib, cxx and backward compatibility
+    // modules under -enable-experimental-feature LifetimeDependence
+    if (!Ctx.MainModule->isStdlibModule() && !Ctx.MainModule->isCxxModule() &&
+        Ctx.MainModule->getABIName() != Ctx.StdlibModuleName) {
+      Ctx.Diags.diagnose(attr->getLocation(), diag::use_lifetime_underscored);
+    }
+    if (!Ctx.LangOpts.hasFeature(Feature::LifetimeDependence)) {
+      diagnose(attr->getLocation(), diag::requires_experimental_feature,
+               "@lifetime", false, Feature::LifetimeDependence.getName());
+    }
+  } else {
+    // Allow @_lifetime under -enable-experimental-feature Lifetimes
+    if (!Ctx.LangOpts.hasFeature(Feature::Lifetimes) &&
+        !Ctx.SourceMgr.isImportMacroGeneratedLoc(attr->getLocation())) {
+      diagnose(attr->getLocation(), diag::requires_experimental_feature,
+               "@_lifetime",
+               false, Feature::Lifetimes.getName());
+    }
   }
 }