Add initial support for _resultDependsOn

These attributes are used to establish lifetime dependence between
argument and the result.

Add them under NonEscapableTypes experimental feature

Author: meg-gupta

include/swift/AST/ASTBridging.h

@@ -898,6 +898,7 @@ enum ENUM_EXTENSIBILITY_ATTR(open) BridgedAttributedTypeSpecifier : size_t {
   BridgedAttributedTypeSpecifierLegacyOwned,
   BridgedAttributedTypeSpecifierConst,
   BridgedAttributedTypeSpecifierIsolated,
+  BridgedAttributedTypeSpecifierResultDependsOn,
 };
 
 SWIFT_NAME("BridgedSimpleIdentTypeRepr.createParsed(_:loc:name:)")

include/swift/AST/Attr.def

@@ -545,7 +545,9 @@ SIMPLE_DECL_ATTR(_noExistentials, NoExistentials,
 SIMPLE_DECL_ATTR(_noObjCBridging, NoObjCBridging,
   OnAbstractFunction | OnSubscript | UserInaccessible | ABIStableToAdd | ABIStableToRemove | APIStableToAdd | APIStableToRemove,
   155)
-
+CONTEXTUAL_SIMPLE_DECL_ATTR(_resultDependsOn, ResultDependsOn,
+  OnParam | DeclModifier | UserInaccessible | ABIBreakingToAdd | ABIStableToRemove | APIBreakingToAdd | APIStableToRemove,
+  156)
 #undef TYPE_ATTR
 #undef DECL_ATTR_ALIAS
 #undef CONTEXTUAL_DECL_ATTR_ALIAS

include/swift/AST/Decl.h

@@ -6424,6 +6424,9 @@ class ParamDecl : public VarDecl {
 
     /// Whether or not this parameter is 'isolated'.
     IsIsolated = 1 << 2,
+
+    /// Whether or not this paramater is '_resultDependsOn'
+    IsResultDependsOn = 1 << 3,
   };
 
   /// The default value, if any, along with flags.
@@ -6637,6 +6640,16 @@ class ParamDecl : public VarDecl {
     ArgumentNameAndFlags.setInt(flags);
   }
 
+  bool hasResultDependsOn() const {
+    return DefaultValueAndFlags.getInt().contains(Flags::IsResultDependsOn);
+  }
+
+  void setResultDependsOn(bool value = true) {
+    auto flags = DefaultValueAndFlags.getInt();
+    DefaultValueAndFlags.setInt(value ? flags | Flags::IsResultDependsOn
+                                      : flags - Flags::IsResultDependsOn);
+  }
+
   /// Does this parameter reject temporary pointer conversions?
   bool isNonEphemeral() const;
 

include/swift/AST/TypeRepr.h

@@ -1163,6 +1163,21 @@ class CompileTimeConstTypeRepr : public SpecifierTypeRepr {
   static bool classof(const CompileTimeConstTypeRepr *T) { return true; }
 };
 
+/// A lifetime dependent type.
+/// \code
+///   x : _resultDependsOn Int
+/// \endcode
+class ResultDependsOnTypeRepr : public SpecifierTypeRepr {
+public:
+  ResultDependsOnTypeRepr(TypeRepr *Base, SourceLoc InOutLoc)
+      : SpecifierTypeRepr(TypeReprKind::ResultDependsOn, Base, InOutLoc) {}
+
+  static bool classof(const TypeRepr *T) {
+    return T->getKind() == TypeReprKind::ResultDependsOn;
+  }
+  static bool classof(const ResultDependsOnTypeRepr *T) { return true; }
+};
+
 /// A TypeRepr for a known, fixed type.
 ///
 /// Fixed type representations should be used sparingly, in places
@@ -1522,6 +1537,7 @@ inline bool TypeRepr::isSimple() const {
   case TypeReprKind::Isolated:
   case TypeReprKind::Placeholder:
   case TypeReprKind::CompileTimeConst:
+  case TypeReprKind::ResultDependsOn:
     return true;
   }
   llvm_unreachable("bad TypeRepr kind");

include/swift/AST/TypeReprNodes.def

@@ -73,6 +73,7 @@ ABSTRACT_TYPEREPR(Specifier, TypeRepr)
   SPECIFIER_TYPEREPR(Ownership, SpecifierTypeRepr)
   SPECIFIER_TYPEREPR(Isolated, SpecifierTypeRepr)
   SPECIFIER_TYPEREPR(CompileTimeConst, SpecifierTypeRepr)
+  SPECIFIER_TYPEREPR(ResultDependsOn, SpecifierTypeRepr)
 TYPEREPR(Fixed, TypeRepr)
 TYPEREPR(SILBox, TypeRepr)
 TYPEREPR(Self, TypeRepr)

include/swift/AST/Types.h

@@ -2228,23 +2228,24 @@ enum class ParamSpecifier : uint8_t {
   /// `__shared`, a legacy spelling of `borrowing`.
   LegacyShared = 4,
   /// `__owned`, a legacy spelling of `consuming`.
-  LegacyOwned = 5,
+  LegacyOwned = 5
 };
 
 /// Provide parameter type relevant flags, i.e. variadic, autoclosure, and
 /// escaping.
 class ParameterTypeFlags {
   enum ParameterFlags : uint16_t {
-    None         = 0,
-    Variadic     = 1 << 0,
-    AutoClosure  = 1 << 1,
+    None = 0,
+    Variadic = 1 << 0,
+    AutoClosure = 1 << 1,
     NonEphemeral = 1 << 2,
     SpecifierShift = 3,
-    Specifier    = 7 << SpecifierShift,
+    Specifier = 7 << SpecifierShift,
     NoDerivative = 1 << 6,
-    Isolated     = 1 << 7,
+    Isolated = 1 << 7,
     CompileTimeConst = 1 << 8,
-    NumBits = 9
+    ResultDependsOn = 1 << 9,
+    NumBits = 10
   };
   OptionSet<ParameterFlags> value;
   static_assert(NumBits <= 8*sizeof(OptionSet<ParameterFlags>), "overflowed");
@@ -2284,6 +2285,7 @@ class ParameterTypeFlags {
   bool isIsolated() const { return value.contains(Isolated); }
   bool isCompileTimeConst() const { return value.contains(CompileTimeConst); }
   bool isNoDerivative() const { return value.contains(NoDerivative); }
+  bool hasResultDependsOn() const { return value.contains(ResultDependsOn); }
 
   /// Get the spelling of the parameter specifier used on the parameter.
   ParamSpecifier getOwnershipSpecifier() const {

include/swift/Parse/Parser.h

@@ -1197,6 +1197,7 @@ class Parser {
                                       SourceLoc &SpecifierLoc,
                                       SourceLoc &IsolatedLoc,
                                       SourceLoc &ConstLoc,
+                                      SourceLoc &ResultDependsOnLoc,
                                       TypeAttributes &Attributes) {
     if (Tok.isAny(tok::at_sign, tok::kw_inout) ||
         (canHaveParameterSpecifierContextualKeyword() &&
@@ -1205,16 +1206,19 @@ class Parser {
           Tok.getRawText().equals("consuming") ||
           Tok.getRawText().equals("borrowing") ||
           Tok.isContextualKeyword("isolated") ||
-          Tok.isContextualKeyword("_const"))))
-      return parseTypeAttributeListPresent(
-          Specifier, SpecifierLoc, IsolatedLoc, ConstLoc, Attributes);
+          Tok.isContextualKeyword("_const") ||
+          Tok.getRawText().equals("_resultDependsOn"))))
+      return parseTypeAttributeListPresent(Specifier, SpecifierLoc, IsolatedLoc,
+                                           ConstLoc, ResultDependsOnLoc,
+                                           Attributes);
     return makeParserSuccess();
   }
 
   ParserStatus parseTypeAttributeListPresent(ParamDecl::Specifier &Specifier,
                                              SourceLoc &SpecifierLoc,
                                              SourceLoc &IsolatedLoc,
                                              SourceLoc &ConstLoc,
+                                             SourceLoc &ResultDependsOnLoc,
                                              TypeAttributes &Attributes);
 
   bool parseConventionAttributeInternal(bool justChecking,
@@ -1510,6 +1514,9 @@ class Parser {
     /// The location of the '_const' keyword, if present.
     SourceLoc CompileConstLoc;
 
+    /// The location of the '_resultDependsOn' keyword, if present.
+    SourceLoc ResultDependsOnLoc;
+
     /// The type following the ':'.
     TypeRepr *Type = nullptr;
 

lib/AST/ASTBridging.cpp

@@ -1311,6 +1311,9 @@ BridgedTypeRepr BridgedSpecifierTypeRepr_createParsed(
   case BridgedAttributedTypeSpecifierIsolated: {
     return new (context) IsolatedTypeRepr(baseType, loc);
   }
+  case BridgedAttributedTypeSpecifierResultDependsOn: {
+    return new (context) ResultDependsOnTypeRepr(baseType, loc);
+  }
   }
 }
 

lib/AST/ASTDumper.cpp

@@ -3385,6 +3385,13 @@ class PrintTypeRepr : public TypeReprVisitor<PrintTypeRepr, void, StringRef>,
     printFoot();
   }
 
+  void visitResultDependsOnTypeRepr(ResultDependsOnTypeRepr *T,
+                                    StringRef label) {
+    printCommon("_resultDependsOn", label);
+    printRec(T->getBase());
+    printFoot();
+  }
+
   void visitOptionalTypeRepr(OptionalTypeRepr *T, StringRef label) {
     printCommon("type_optional", label);
     printRec(T->getBase());

lib/AST/ASTPrinter.cpp

@@ -3605,6 +3605,10 @@ static bool usesFeatureNonEscapableTypes(Decl *decl) {
   if (fd && fd->getAttrs().getAttribute(DAK_ResultDependsOnSelf)) {
     return true;
   }
+  auto *pd = dyn_cast<ParamDecl>(decl);
+  if (pd && pd->hasResultDependsOn()) {
+    return true;
+  }
   return false;
 }
 
@@ -4360,6 +4364,9 @@ static void printParameterFlags(ASTPrinter &printer,
   if (flags.isIsolated())
     printer.printKeyword("isolated", options, " ");
 
+  if (flags.hasResultDependsOn())
+    printer.printKeyword("resultDependsOn", options, " ");
+
   if (!options.excludeAttrKind(TAK_escaping) && escaping)
     printer.printKeyword("@escaping", options, " ");