Add support for LifetimeDependence in C++ parser

Author: meg-gupta

include/swift/AST/DiagnosticsParse.def

@@ -2166,5 +2166,19 @@ ERROR(requires_experimental_feature, none,
       "%2 is enabled",
       (StringRef, bool, StringRef))
 
+ERROR(expected_lparen_after_lifetime_dependence, PointsToFirstBadToken,
+      "expected '(' after lifetime dependence specifier", ())
+
+ERROR(expected_identifier_or_index_or_self_after_lifetime_dependence,
+      PointsToFirstBadToken,
+      "expected identifier or index or self in lifetime dependence specifier",
+      ())
+
+ERROR(expected_rparen_after_lifetime_dependence, PointsToFirstBadToken,
+      "expected ')' after param list in lifetime dependence specifier", ())
+
+ERROR(expected_param_index_lifetime_dependence, PointsToFirstBadToken,
+      "expected unsigned parameter index in lifetime dependence specifier", ())
+
 #define UNDEFINE_DIAGNOSTIC_MACROS
 #include "DefineDiagnosticMacros.h"

include/swift/AST/LifetimeDependence.h

@@ -0,0 +1,99 @@
+//===--- LifetimeDependenceSpecifiers.h ------------------------*- C++ -*-===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2024 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+//
+// This file defines types and utilities related to Lifetime Dependence
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SWIFT_AST_LIFETIMEDEPENDENCE_H
+#define SWIFT_AST_LIFETIMEDEPENDENCE_H
+
+#include "swift/AST/Decl.h"
+#include "swift/Basic/Debug.h"
+#include "swift/Basic/OptionSet.h"
+#include "llvm/Support/TrailingObjects.h"
+
+namespace swift {
+
+enum class LifetimeDependenceKind : uint8_t {
+  Copy = 0,
+  Consume,
+  Borrow,
+  Mutate
+};
+
+class LifetimeDependenceSpecifier {
+public:
+  enum class SpecifierKind { Named, Ordered, Self };
+
+private:
+  SourceLoc loc;
+  SpecifierKind specifierKind;
+  LifetimeDependenceKind lifetimeDependenceKind;
+  union Value {
+    struct {
+      Identifier name;
+    } Named;
+    struct {
+      unsigned index;
+    } Ordered;
+    struct {
+    } self;
+    Value(Identifier name) : Named({name}) {}
+    Value(unsigned index) : Ordered({index}) {}
+    Value() {}
+  } value;
+
+  LifetimeDependenceSpecifier(SourceLoc loc, SpecifierKind specifierKind,
+                              LifetimeDependenceKind lifetimeDependenceKind,
+                              Value value)
+      : loc(loc), specifierKind(specifierKind),
+        lifetimeDependenceKind(lifetimeDependenceKind), value(value) {}
+
+public:
+  static LifetimeDependenceSpecifier getNamedLifetimeDependenceSpecifier(
+      SourceLoc loc, LifetimeDependenceKind kind, Identifier name) {
+    return {loc, SpecifierKind::Named, kind, name};
+  }
+
+  static LifetimeDependenceSpecifier getOrderedLifetimeDependenceSpecifier(
+      SourceLoc loc, LifetimeDependenceKind kind, unsigned index) {
+    return {loc, SpecifierKind::Ordered, kind, index};
+  }
+
+  static LifetimeDependenceSpecifier
+  getSelfLifetimeDependenceSpecifier(SourceLoc loc,
+                                     LifetimeDependenceKind kind) {
+    return {loc, SpecifierKind::Self, kind, {}};
+  }
+
+  SourceLoc getLoc() const { return loc; }
+
+  SpecifierKind getSpecifierKind() const { return specifierKind; }
+
+  LifetimeDependenceKind getLifetimeDependenceKind() const {
+    return lifetimeDependenceKind;
+  }
+
+  Identifier getName() const {
+    assert(specifierKind == SpecifierKind::Named);
+    return value.Named.name;
+  }
+
+  unsigned getIndex() const {
+    assert(specifierKind == SpecifierKind::Ordered);
+    return value.Ordered.index;
+  }
+};
+} // namespace swift
+
+#endif

include/swift/Parse/Parser.h

@@ -22,6 +22,7 @@
 #include "swift/AST/DiagnosticsParse.h"
 #include "swift/AST/Expr.h"
 #include "swift/AST/LayoutConstraint.h"
+#include "swift/AST/LifetimeDependence.h"
 #include "swift/AST/ParseRequests.h"
 #include "swift/AST/Pattern.h"
 #include "swift/AST/SourceFile.h"
@@ -1198,6 +1199,7 @@ class Parser {
     SourceLoc ConstLoc;
     SourceLoc ResultDependsOnLoc;
     TypeAttributes Attributes;
+    SmallVector<LifetimeDependenceSpecifier> lifetimeDependenceSpecifiers;
 
     /// Main entry point for parsing.
     ///
@@ -1215,7 +1217,8 @@ class Parser {
             Tok.getRawText().equals("transferring") ||
             Tok.isContextualKeyword("isolated") ||
             Tok.isContextualKeyword("_const") ||
-            Tok.getRawText().equals("_resultDependsOn"))))
+            Tok.getRawText().equals("_resultDependsOn") ||
+            Tok.isLifetimeDependenceToken())))
         return slowParse(P);
       return makeParserSuccess();
     }
@@ -1235,6 +1238,9 @@ class Parser {
                                   PatternBindingInitializer *&initContext,
                                   bool justChecking = false);
 
+  ParserStatus parseLifetimeDependenceSpecifiers(
+      SmallVectorImpl<LifetimeDependenceSpecifier> &specifierList);
+
   ParserResult<ImportDecl> parseDeclImport(ParseDeclOptions Flags,
                                            DeclAttributes &Attributes);
 

include/swift/Parse/Token.h

@@ -266,6 +266,13 @@ class Token {
   bool isMultilineString() const {
     return MultilineString;
   }
+
+  bool isLifetimeDependenceToken() {
+    auto tokenRawText = getRawText();
+    return tokenRawText.equals("_copy") || tokenRawText.equals("_consume") ||
+           tokenRawText.equals("_borrow") || tokenRawText.equals("_mutate");
+  }
+
   /// Count of extending escaping '#'.
   unsigned getCustomDelimiterLen() const {
     return CustomDelimiterLen;

lib/Parse/ParseDecl.cpp

@@ -23,6 +23,7 @@
 #include "swift/AST/GenericParamList.h"
 #include "swift/AST/Initializer.h"
 #include "swift/AST/LazyResolver.h"
+#include "swift/AST/LifetimeDependence.h"
 #include "swift/AST/Module.h"
 #include "swift/AST/ParameterList.h"
 #include "swift/AST/ParseRequests.h"
@@ -4909,6 +4910,104 @@ ParserStatus Parser::parseTypeAttribute(TypeAttributes &Attributes,
   return makeParserSuccess();
 }
 
+static llvm::Optional<LifetimeDependenceKind>
+getLifetimeDependenceKind(const Token &T) {
+  if (T.isContextualKeyword("_copy")) {
+    return LifetimeDependenceKind::Copy;
+  }
+  if (T.isContextualKeyword("_consume")) {
+    return LifetimeDependenceKind::Consume;
+  }
+  if (T.isContextualKeyword("_borrow")) {
+    return LifetimeDependenceKind::Borrow;
+  }
+  if (T.isContextualKeyword("_mutate")) {
+    return LifetimeDependenceKind::Mutate;
+  }
+  return llvm::None;
+}
+
+ParserStatus Parser::parseLifetimeDependenceSpecifiers(
+    SmallVectorImpl<LifetimeDependenceSpecifier> &specifierList) {
+  ParserStatus status;
+  // TODO: Add fixits for diagnostics in this function.
+  do {
+    auto lifetimeDependenceKind = getLifetimeDependenceKind(Tok);
+    if (!lifetimeDependenceKind.has_value()) {
+      break;
+    }
+    // consume the lifetime dependence kind
+    consumeToken();
+
+    if (!Tok.isFollowingLParen()) {
+      diagnose(Tok, diag::expected_lparen_after_lifetime_dependence);
+      status.setIsParseError();
+      continue;
+    }
+    // consume the l_paren
+    auto lParenLoc = consumeToken();
+    SourceLoc rParenLoc;
+    bool foundParamId = false;
+    status = parseList(
+        tok::r_paren, lParenLoc, rParenLoc, /*AllowSepAfterLast*/ false,
+        diag::expected_rparen_after_lifetime_dependence, [&]() -> ParserStatus {
+          ParserStatus listStatus;
+          foundParamId = true;
+          switch (Tok.getKind()) {
+          case tok::identifier: {
+            Identifier paramName;
+            auto paramLoc =
+                consumeIdentifier(paramName, /*diagnoseDollarPrefix=*/false);
+            specifierList.push_back(
+                LifetimeDependenceSpecifier::
+                    getNamedLifetimeDependenceSpecifier(
+                        paramLoc, *lifetimeDependenceKind, paramName));
+            break;
+          }
+          case tok::integer_literal: {
+            SourceLoc paramLoc;
+            unsigned paramNum;
+            if (parseUnsignedInteger(
+                    paramNum, paramLoc,
+                    diag::expected_param_index_lifetime_dependence)) {
+              skipUntil(tok::r_paren);
+              listStatus.setIsParseError();
+              return listStatus;
+            }
+            specifierList.push_back(
+                LifetimeDependenceSpecifier::
+                    getOrderedLifetimeDependenceSpecifier(
+                        paramLoc, *lifetimeDependenceKind, paramNum));
+            break;
+          }
+          case tok::kw_self: {
+            auto paramLoc = consumeToken(tok::kw_self);
+            specifierList.push_back(
+                LifetimeDependenceSpecifier::getSelfLifetimeDependenceSpecifier(
+                    paramLoc, *lifetimeDependenceKind));
+            break;
+          }
+          default:
+            diagnose(
+                Tok,
+                diag::
+                    expected_identifier_or_index_or_self_after_lifetime_dependence);
+            skipUntil(tok::r_paren);
+            listStatus.setIsParseError();
+            return listStatus;
+          }
+          return listStatus;
+        });
+
+      if (!foundParamId) {
+        diagnose(Tok, diag::expected_identifier_or_index_or_self_after_lifetime_dependence);
+        status.setIsParseError();
+      }
+  } while (true);
+
+  return status;
+}
+
 ParserStatus Parser::parseDeclAttributeList(
     DeclAttributes &Attributes, bool ifConfigsAreDeclAttrs,
     PatternBindingInitializer *initContext) {
@@ -5128,6 +5227,7 @@ ParserStatus Parser::parseDeclModifierList(DeclAttributes &Attributes,
 ///     '@' attribute attribute-list-clause
 /// \endverbatim
 ParserStatus Parser::ParsedTypeAttributeList::slowParse(Parser &P) {
+  ParserStatus status;
   PatternBindingInitializer *initContext = nullptr;
   auto &Tok = P.Tok;
   while (Tok.is(tok::kw_inout) ||
@@ -5139,7 +5239,8 @@ ParserStatus Parser::ParsedTypeAttributeList::slowParse(Parser &P) {
            Tok.isContextualKeyword("borrowing") ||
            Tok.isContextualKeyword("transferring") ||
            Tok.isContextualKeyword("_const") ||
-           Tok.isContextualKeyword("_resultDependsOn")))) {
+           Tok.isContextualKeyword("_resultDependsOn") ||
+           Tok.isLifetimeDependenceToken()))) {
 
     if (Tok.isContextualKeyword("isolated")) {
       if (IsolatedLoc.isValid()) {
@@ -5169,11 +5270,22 @@ ParserStatus Parser::ParsedTypeAttributeList::slowParse(Parser &P) {
     // the actual parsing logic below.
     if (Tok.isContextualKeyword("transferring")) {
       if (!P.Context.LangOpts.hasFeature(Feature::TransferringArgsAndResults)) {
-        P.diagnose(Tok, diag::requires_experimental_feature, "transferring",
+        P.diagnose(Tok, diag::requires_experimental_feature, Tok.getRawText(),
                    false, getFeatureName(Feature::TransferringArgsAndResults));
       }
     }
 
+    if (Tok.isLifetimeDependenceToken()) {
+      if (!P.Context.LangOpts.hasFeature(Feature::NonescapableTypes)) {
+        P.diagnose(Tok, diag::requires_experimental_feature,
+                   "lifetime dependence specifier", false,
+                   getFeatureName(Feature::NonescapableTypes));
+      }
+      status |=
+          P.parseLifetimeDependenceSpecifiers(lifetimeDependenceSpecifiers);
+      continue;
+    }
+
     if (SpecifierLoc.isValid()) {
       P.diagnose(Tok, diag::parameter_specifier_repeated)
           .fixItRemove(SpecifierLoc);
@@ -5198,7 +5310,6 @@ ParserStatus Parser::ParsedTypeAttributeList::slowParse(Parser &P) {
     SpecifierLoc = P.consumeToken();
   }
 
-  ParserStatus status;
   while (Tok.is(tok::at_sign)) {
     // Ignore @substituted in SIL mode and leave it for the type parser.
     if (P.isInSILMode() && P.peekToken().getText() == "substituted")