Make _resultDependsOn available on SILFunctionArgument

meg-gupta · meg-gupta · commit d3e921dc477f · 2023-12-29T01:57:19.000-08:00
diff --git a/include/swift/AST/Decl.h b/include/swift/AST/Decl.h
@@ -6396,9 +6396,11 @@ class ParamDecl : public VarDecl {
 
     /// Whether or not this parameter is '_const'.
     IsCompileTimeConst = 1 << 1,
+
+    HasResultDependsOn = 1 << 2,
   };
 
-  llvm::PointerIntPair<Identifier, 2, OptionSet<ArgumentNameFlags>>
+  llvm::PointerIntPair<Identifier, 3, OptionSet<ArgumentNameFlags>>
       ArgumentNameAndFlags;
   SourceLoc ParameterNameLoc;
   SourceLoc ArgumentNameLoc;
@@ -6650,13 +6652,15 @@ class ParamDecl : public VarDecl {
   }
 
   bool hasResultDependsOn() const {
-    return DefaultValueAndFlags.getInt().contains(Flags::IsResultDependsOn);
+    return ArgumentNameAndFlags.getInt().contains(
+        ArgumentNameFlags::HasResultDependsOn);
   }
 
   void setResultDependsOn(bool value = true) {
-    auto flags = DefaultValueAndFlags.getInt();
-    DefaultValueAndFlags.setInt(value ? flags | Flags::IsResultDependsOn
-                                      : flags - Flags::IsResultDependsOn);
+    auto flags = ArgumentNameAndFlags.getInt();
+    flags = value ? flags | ArgumentNameFlags::HasResultDependsOn
+                  : flags - ArgumentNameFlags::HasResultDependsOn;
+    ArgumentNameAndFlags.setInt(flags);
   }
 
   /// Does this parameter reject temporary pointer conversions?
diff --git a/include/swift/AST/TypeRepr.h b/include/swift/AST/TypeRepr.h
@@ -1092,7 +1092,8 @@ class SpecifierTypeRepr : public TypeRepr {
   static bool classof(const TypeRepr *T) {
     return T->getKind() == TypeReprKind::Ownership ||
            T->getKind() == TypeReprKind::Isolated ||
-           T->getKind() == TypeReprKind::CompileTimeConst;
+           T->getKind() == TypeReprKind::CompileTimeConst ||
+           T->getKind() == TypeReprKind::ResultDependsOn;
   }
   static bool classof(const SpecifierTypeRepr *T) { return true; }
   
diff --git a/include/swift/AST/Types.h b/include/swift/AST/Types.h
@@ -2241,20 +2241,20 @@ class ParameterTypeFlags {
 
   ParameterTypeFlags(bool variadic, bool autoclosure, bool nonEphemeral,
                      ParamSpecifier specifier, bool isolated, bool noDerivative,
-                     bool compileTimeConst)
+                     bool compileTimeConst, bool hasResultDependsOn)
       : value((variadic ? Variadic : 0) | (autoclosure ? AutoClosure : 0) |
               (nonEphemeral ? NonEphemeral : 0) |
-              uint8_t(specifier) << SpecifierShift |
-              (isolated ? Isolated : 0) |
+              uint8_t(specifier) << SpecifierShift | (isolated ? Isolated : 0) |
               (noDerivative ? NoDerivative : 0) |
-              (compileTimeConst ? CompileTimeConst : 0)){}
+              (compileTimeConst ? CompileTimeConst : 0) |
+              (hasResultDependsOn ? ResultDependsOn : 0)) {}
 
   /// Create one from what's present in the parameter type
   inline static ParameterTypeFlags
   fromParameterType(Type paramTy, bool isVariadic, bool isAutoClosure,
                     bool isNonEphemeral, ParamSpecifier ownership,
-                    bool isolated, bool isNoDerivative,
-                    bool compileTimeConst);
+                    bool isolated, bool isNoDerivative, bool compileTimeConst,
+                    bool hasResultDependsOn);
 
   bool isNone() const { return !value; }
   bool isVariadic() const { return value.contains(Variadic); }
@@ -2421,7 +2421,8 @@ class YieldTypeFlags {
                               /*autoclosure*/ false,
                               /*nonEphemeral*/ false, getOwnershipSpecifier(),
                               /*isolated*/ false, /*noDerivative*/ false,
-                              /*compileTimeConst*/false);
+                              /*compileTimeConst*/ false,
+                              /*hasResultDependsOn*/ false);
   }
 
   bool operator ==(const YieldTypeFlags &other) const {
@@ -7517,7 +7518,7 @@ inline TupleTypeElt TupleTypeElt::getWithType(Type T) const {
 inline ParameterTypeFlags ParameterTypeFlags::fromParameterType(
     Type paramTy, bool isVariadic, bool isAutoClosure, bool isNonEphemeral,
     ParamSpecifier ownership, bool isolated, bool isNoDerivative,
-    bool compileTimeConst) {
+    bool compileTimeConst, bool hasResultDependsOn) {
   // FIXME(Remove InOut): The last caller that needs this is argument
   // decomposition.  Start by enabling the assertion there and fixing up those
   // callers, then remove this, then remove
@@ -7527,8 +7528,8 @@ inline ParameterTypeFlags ParameterTypeFlags::fromParameterType(
            ownership == ParamSpecifier::InOut);
     ownership = ParamSpecifier::InOut;
   }
-  return {isVariadic, isAutoClosure, isNonEphemeral, ownership, isolated,
-          isNoDerivative, compileTimeConst};
+  return {isVariadic, isAutoClosure,  isNonEphemeral,   ownership,
+          isolated,   isNoDerivative, compileTimeConst, hasResultDependsOn};
 }
 
 inline const Type *BoundGenericType::getTrailingObjectsPointer() const {
diff --git a/include/swift/Parse/Parser.h b/include/swift/Parse/Parser.h
@@ -1449,9 +1449,9 @@ class Parser {
 
   TypeRepr *applyAttributeToType(TypeRepr *Ty, const TypeAttributes &Attr,
                                  ParamDecl::Specifier Specifier,
-                                 SourceLoc SpecifierLoc,
-                                 SourceLoc IsolatedLoc,
-                                 SourceLoc ConstLoc);
+                                 SourceLoc SpecifierLoc, SourceLoc IsolatedLoc,
+                                 SourceLoc ConstLoc,
+                                 SourceLoc ResultDependsOnLoc);
 
   //===--------------------------------------------------------------------===//
   // Pattern Parsing
diff --git a/include/swift/SIL/SILArgument.h b/include/swift/SIL/SILArgument.h
@@ -367,13 +367,14 @@ class SILFunctionArgument : public SILArgument {
       bool isNoImplicitCopy = false,
       LifetimeAnnotation lifetimeAnnotation = LifetimeAnnotation::None,
       bool isCapture = false,
-      bool isParameterPack = false)
+      bool isParameterPack = false, bool hasResultDependsOn = false)
       : SILArgument(ValueKind::SILFunctionArgument, parentBlock, type,
                     ownershipKind, decl) {
     sharedUInt32().SILFunctionArgument.noImplicitCopy = isNoImplicitCopy;
     sharedUInt32().SILFunctionArgument.lifetimeAnnotation = lifetimeAnnotation;
     sharedUInt32().SILFunctionArgument.closureCapture = isCapture;
     sharedUInt32().SILFunctionArgument.parameterPack = isParameterPack;
+    sharedUInt32().SILFunctionArgument.hasResultDependsOn = hasResultDependsOn;
   }
 
   // A special constructor, only intended for use in
@@ -425,6 +426,14 @@ class SILFunctionArgument : public SILArgument {
     sharedUInt32().SILFunctionArgument.lifetimeAnnotation = newValue;
   }
 
+  bool hasResultDependsOn() const {
+    return sharedUInt32().SILFunctionArgument.hasResultDependsOn;
+  }
+
+  void setHasResultDependsOn(bool flag = true) {
+    sharedUInt32().SILFunctionArgument.hasResultDependsOn = flag;
+  }
+
   Lifetime getLifetime() const {
     return getType()
         .getLifetime(*getFunction())
diff --git a/include/swift/SIL/SILNode.h b/include/swift/SIL/SILNode.h
@@ -306,7 +306,7 @@ class alignas(8) SILNode :
     SHARED_FIELD(PointerToAddressInst, uint32_t alignment);
     SHARED_FIELD(SILFunctionArgument, uint32_t noImplicitCopy : 1,
                  lifetimeAnnotation : 2, closureCapture : 1,
-                 parameterPack : 1);
+                 parameterPack : 1, hasResultDependsOn : 1);
 
     // Do not use `_sharedUInt32_private` outside of SILNode.
   } _sharedUInt32_private;
diff --git a/lib/AST/ASTPrinter.cpp b/lib/AST/ASTPrinter.cpp
@@ -4529,7 +4529,7 @@ static void printParameterFlags(ASTPrinter &printer,
     printer.printKeyword("isolated", options, " ");
 
   if (flags.hasResultDependsOn())
-    printer.printKeyword("resultDependsOn", options, " ");
+    printer.printKeyword("_resultDependsOn", options, " ");
 
   if (!options.excludeAttrKind(TAK_escaping) && escaping)
     printer.printKeyword("@escaping", options, " ");
diff --git a/lib/AST/Decl.cpp b/lib/AST/Decl.cpp
@@ -8364,9 +8364,9 @@ AnyFunctionType::Param ParamDecl::toFunctionParam(Type type) const {
   auto label = getArgumentName();
   auto internalLabel = getParameterName();
   auto flags = ParameterTypeFlags::fromParameterType(
-      type, isVariadic(), isAutoClosure(), isNonEphemeral(),
-      getSpecifier(), isIsolated(), /*isNoDerivative*/ false,
-      isCompileTimeConst());
+      type, isVariadic(), isAutoClosure(), isNonEphemeral(), getSpecifier(),
+      isIsolated(), /*isNoDerivative*/ false, isCompileTimeConst(),
+      hasResultDependsOn());
   return AnyFunctionType::Param(type, label, flags, internalLabel);
 }
 
diff --git a/lib/Parse/ParsePattern.cpp b/lib/Parse/ParsePattern.cpp
@@ -580,7 +580,8 @@ mapParsedParameters(Parser &parser,
               param->setIsolated(true);
             else if (isa<CompileTimeConstTypeRepr>(STR))
               param->setCompileTimeConst(true);
-
+            else if (isa<ResultDependsOnTypeRepr>(STR))
+              param->setResultDependsOn(true);
             unwrappedType = STR->getBase();
             continue;
           }
diff --git a/lib/Parse/ParseType.cpp b/lib/Parse/ParseType.cpp
@@ -31,12 +31,11 @@
 
 using namespace swift;
 
-TypeRepr *Parser::applyAttributeToType(TypeRepr *ty,
-                                       const TypeAttributes &attrs,
-                                       ParamDecl::Specifier specifier,
-                                       SourceLoc specifierLoc,
-                                       SourceLoc isolatedLoc,
-                                       SourceLoc constLoc) {
+TypeRepr *
+Parser::applyAttributeToType(TypeRepr *ty, const TypeAttributes &attrs,
+                             ParamDecl::Specifier specifier,
+                             SourceLoc specifierLoc, SourceLoc isolatedLoc,
+                             SourceLoc constLoc, SourceLoc resultDependsOnLoc) {
   // Apply those attributes that do apply.
   if (!attrs.empty()) {
     ty = new (Context) AttributedTypeRepr(attrs, ty);
@@ -57,6 +56,10 @@ TypeRepr *Parser::applyAttributeToType(TypeRepr *ty,
     ty = new (Context) CompileTimeConstTypeRepr(ty, constLoc);
   }
 
+  if (resultDependsOnLoc.isValid()) {
+    ty = new (Context) ResultDependsOnTypeRepr(ty, resultDependsOnLoc);
+  }
+
   return ty;
 }
 
@@ -385,10 +388,9 @@ ParserResult<TypeRepr> Parser::parseSILBoxType(GenericParamList *generics,
   auto repr = SILBoxTypeRepr::create(Context, generics,
                                      LBraceLoc, Fields, RBraceLoc,
                                      LAngleLoc, Args, RAngleLoc);
-  return makeParserResult(applyAttributeToType(repr, attrs,
-                                               ParamDecl::Specifier::LegacyOwned,
-                                               SourceLoc(), SourceLoc(),
-                                               SourceLoc()));
+  return makeParserResult(
+      applyAttributeToType(repr, attrs, ParamDecl::Specifier::LegacyOwned,
+                           SourceLoc(), SourceLoc(), SourceLoc(), SourceLoc()));
 }
 
 
@@ -594,9 +596,8 @@ ParserResult<TypeRepr> Parser::parseTypeScalar(
   }
 
   return makeParserResult(
-      status,
-      applyAttributeToType(tyR, attrs, specifier, specifierLoc, isolatedLoc,
-                           constLoc));
+      status, applyAttributeToType(tyR, attrs, specifier, specifierLoc,
+                                   isolatedLoc, constLoc, resultDependsOnLoc));
 }
 
 /// parseType
diff --git a/lib/SIL/IR/SILPrinter.cpp b/lib/SIL/IR/SILPrinter.cpp
@@ -164,6 +164,7 @@ struct SILValuePrinterInfo {
   bool IsCapture = false;
   bool IsReborrow = false;
   bool IsEscaping = false;
+  bool HasResultDependsOn = false;
 
   SILValuePrinterInfo(ID ValueID) : ValueID(ValueID), Type(), OwnershipKind() {}
   SILValuePrinterInfo(ID ValueID, SILType Type)
@@ -174,10 +175,11 @@ struct SILValuePrinterInfo {
   SILValuePrinterInfo(ID ValueID, SILType Type,
                       ValueOwnershipKind OwnershipKind, bool IsNoImplicitCopy,
                       LifetimeAnnotation Lifetime, bool IsCapture,
-                      bool IsReborrow, bool IsEscaping)
+                      bool IsReborrow, bool IsEscaping, bool HasResultDependsOn)
       : ValueID(ValueID), Type(Type), OwnershipKind(OwnershipKind),
         IsNoImplicitCopy(IsNoImplicitCopy), Lifetime(Lifetime),
-        IsCapture(IsCapture), IsReborrow(IsReborrow), IsEscaping(IsEscaping) {}
+        IsCapture(IsCapture), IsReborrow(IsReborrow), IsEscaping(IsEscaping),
+        HasResultDependsOn(HasResultDependsOn) {}
   SILValuePrinterInfo(ID ValueID, SILType Type, bool IsNoImplicitCopy,
                       LifetimeAnnotation Lifetime, bool IsCapture,
                       bool IsReborrow, bool IsEscaping)
@@ -686,6 +688,8 @@ class SILPrinter : public SILInstructionVisitor<SILPrinter> {
       *this << "@reborrow ";
     if (i.IsEscaping)
       *this << "@pointer_escape ";
+    if (i.HasResultDependsOn)
+      *this << "@_resultDependsOn ";
     if (i.OwnershipKind && *i.OwnershipKind != OwnershipKind::None) {
       *this << "@" << i.OwnershipKind.value() << " ";
     }
@@ -736,7 +740,8 @@ class SILPrinter : public SILInstructionVisitor<SILPrinter> {
             arg->getLifetimeAnnotation(),
             arg->isClosureCapture(),
             arg->isReborrow(),
-            arg->hasPointerEscape()};
+            arg->hasPointerEscape(),
+            arg->hasResultDependsOn()};
   }
   SILValuePrinterInfo getIDAndTypeAndOwnership(SILArgument *arg) {
     return {Ctx.getID(arg), arg->getType(), arg->getOwnershipKind(),
diff --git a/lib/SIL/Parser/ParseSIL.cpp b/lib/SIL/Parser/ParseSIL.cpp
@@ -1158,8 +1158,8 @@ bool SILParser::parseSILType(SILType &Result,
   
   // Apply attributes to the type.
   auto *attrRepr =
-      P.applyAttributeToType(
-        TyR.get(), attrs, specifier, specifierLoc, isolatedLoc, constLoc);
+      P.applyAttributeToType(TyR.get(), attrs, specifier, specifierLoc,
+                             isolatedLoc, constLoc, resultDependsOnLoc);
   auto Ty = performTypeResolution(attrRepr, /*IsSILType=*/true, OuterGenericSig,
                                   OuterGenericParams);
   if (OuterGenericSig) {
diff --git a/lib/SILGen/SILGenBuilder.cpp b/lib/SILGen/SILGenBuilder.cpp
@@ -534,6 +534,9 @@ static ManagedValue createInputFunctionArgument(
       isNoImplicitCopy |= pd->getSpecifier() == ParamSpecifier::Borrowing;
       isNoImplicitCopy |= pd->getSpecifier() == ParamSpecifier::Consuming;
     }
+    if (pd->hasResultDependsOn()) {
+      arg->setHasResultDependsOn();
+    }
   }
   if (isNoImplicitCopy)
     arg->setNoImplicitCopy(isNoImplicitCopy);
diff --git a/lib/Sema/TypeCheckType.cpp b/lib/Sema/TypeCheckType.cpp
@@ -3482,6 +3482,7 @@ TypeResolver::resolveASTFunctionTypeParams(TupleTypeRepr *inputRepr,
 
     bool isolated = false;
     bool compileTimeConst = false;
+    bool hasResultDependsOn = false;
     while (true) {
       if (auto *specifierRepr = dyn_cast<SpecifierTypeRepr>(nestedRepr)) {
         switch (specifierRepr->getKind()) {
@@ -3497,6 +3498,10 @@ TypeResolver::resolveASTFunctionTypeParams(TupleTypeRepr *inputRepr,
           compileTimeConst = true;
           nestedRepr = specifierRepr->getBase();
           continue;
+        case TypeReprKind::ResultDependsOn:
+          hasResultDependsOn = true;
+          nestedRepr = specifierRepr->getBase();
+          continue;
         default:
           break;
         }
@@ -3593,7 +3598,7 @@ TypeResolver::resolveASTFunctionTypeParams(TupleTypeRepr *inputRepr,
 
     auto paramFlags = ParameterTypeFlags::fromParameterType(
         ty, variadic, autoclosure, /*isNonEphemeral*/ false, ownership,
-        isolated, noDerivative, compileTimeConst);
+        isolated, noDerivative, compileTimeConst, hasResultDependsOn);
     elements.emplace_back(ty, argumentLabel, paramFlags, parameterName);
   }
 
diff --git a/lib/Serialization/Deserialization.cpp b/lib/Serialization/Deserialization.cpp
@@ -6658,13 +6658,13 @@ detail::function_deserializer::deserialize(ModuleFile &MF,
     IdentifierID internalLabelID;
     TypeID typeID;
     bool isVariadic, isAutoClosure, isNonEphemeral, isIsolated,
-        isCompileTimeConst;
+        isCompileTimeConst, hasResultDependsOn;
     bool isNoDerivative;
     unsigned rawOwnership;
     decls_block::FunctionParamLayout::readRecord(
         scratch, labelID, internalLabelID, typeID, isVariadic, isAutoClosure,
         isNonEphemeral, rawOwnership, isIsolated, isNoDerivative,
-        isCompileTimeConst);
+        isCompileTimeConst, hasResultDependsOn);
 
     auto ownership = getActualParamDeclSpecifier(
       (serialization::ParamDeclSpecifier)rawOwnership);
@@ -6675,12 +6675,12 @@ detail::function_deserializer::deserialize(ModuleFile &MF,
     if (!paramTy)
       return paramTy.takeError();
 
-    params.emplace_back(paramTy.get(), MF.getIdentifier(labelID),
-                        ParameterTypeFlags(isVariadic, isAutoClosure,
-                                           isNonEphemeral, *ownership,
-                                           isIsolated, isNoDerivative,
-                                           isCompileTimeConst),
-                        MF.getIdentifier(internalLabelID));
+    params.emplace_back(
+        paramTy.get(), MF.getIdentifier(labelID),
+        ParameterTypeFlags(isVariadic, isAutoClosure, isNonEphemeral,
+                           *ownership, isIsolated, isNoDerivative,
+                           isCompileTimeConst, hasResultDependsOn),
+        MF.getIdentifier(internalLabelID));
   }
 
   if (!isGeneric) {
diff --git a/lib/Serialization/ModuleFormat.h b/lib/Serialization/ModuleFormat.h
diff --git a/lib/Serialization/Serialization.cpp b/lib/Serialization/Serialization.cpp

Original file line number	Diff line number	Diff line change
`@@ -1092,7 +1092,8 @@ class SpecifierTypeRepr : public TypeRepr {`
`1092`	`1092`	`static bool classof(const TypeRepr *T) {`
`1093`	`1093`	`return T->getKind() == TypeReprKind::Ownership \|\|`
`1094`	`1094`	`T->getKind() == TypeReprKind::Isolated \|\|`
`1095`		`- T->getKind() == TypeReprKind::CompileTimeConst;`
	`1095`	`+ T->getKind() == TypeReprKind::CompileTimeConst \|\|`
	`1096`	`+ T->getKind() == TypeReprKind::ResultDependsOn;`
`1096`	`1097`	`}`
`1097`	`1098`	`static bool classof(const SpecifierTypeRepr *T) { return true; }`
`1098`	`1099`