Introduce ResultConvention::Guaranteed and ResultConvention::GuaranteedAddress

ResultConvention::Guaranteed will be used by borrow accessors when the storage type can be returned by value.

ResultConvention::GuaranteedAddress will be used by mutate accessors and borrow accessors when the storage type
cannot be returned by value.

Author: meg-gupta

include/swift/AST/Types.h

@@ -4772,7 +4772,7 @@ enum class ResultConvention : uint8_t {
   /// The validity of the return value is dependent on the 'self' parameter,
   /// so it may be invalidated if that parameter is released.
   UnownedInnerPointer,
-  
+
   /// This value has been (or may have been) returned autoreleased.
   /// The caller should make an effort to reclaim the autorelease.
   /// The type must be a class or class existential type, and this
@@ -4784,6 +4784,14 @@ enum class ResultConvention : uint8_t {
   /// depending on the pact type).  The callee is responsible for
   /// leaving an initialized object in each element of the pack.
   Pack,
+
+  /// The caller is responsible for using the returned address within a valid
+  /// scope. This is valid only for borrow and mutate accessors.
+  GuaranteedAddress,
+
+  /// The caller is responsible for using the returned value within a valid
+  /// scope. This is valid only for borrow accessors.
+  Guaranteed,
 };
 
 // Does this result require indirect storage for the purpose of reabstraction?
@@ -4940,6 +4948,14 @@ class SILResultInfo {
     return getConvention() == ResultConvention::Pack;
   }
 
+  bool isGuaranteedAddressResult() const {
+    return getConvention() == ResultConvention::GuaranteedAddress;
+  }
+
+  bool isGuaranteedResult() const {
+    return getConvention() == ResultConvention::Guaranteed;
+  }
+
   /// Transform this SILResultInfo by applying the user-provided
   /// function to its type.
   ///

include/swift/SIL/SILFunctionConventions.h

@@ -637,6 +637,8 @@ inline bool SILModuleConventions::isIndirectSILResult(SILResultInfo result,
   case ResultConvention::Unowned:
   case ResultConvention::UnownedInnerPointer:
   case ResultConvention::Autoreleased:
+  case ResultConvention::GuaranteedAddress:
+  case ResultConvention::Guaranteed:
     return false;
   }
 

lib/AST/ASTMangler.cpp

@@ -2282,6 +2282,10 @@ static char getResultConvention(ResultConvention conv) {
     case ResultConvention::UnownedInnerPointer: return 'u';
     case ResultConvention::Autoreleased: return 'a';
     case ResultConvention::Pack: return 'k';
+    case ResultConvention::GuaranteedAddress:
+      return 'g';
+    case ResultConvention::Guaranteed:
+      return 'G';
   }
   llvm_unreachable("bad result convention");
 }

lib/AST/ASTPrinter.cpp

@@ -7893,6 +7893,10 @@ static StringRef getStringForResultConvention(ResultConvention conv) {
   case ResultConvention::UnownedInnerPointer: return "@unowned_inner_pointer ";
   case ResultConvention::Autoreleased: return "@autoreleased ";
   case ResultConvention::Pack: return "@pack_out ";
+  case ResultConvention::GuaranteedAddress:
+    return "@guaranteed_addr ";
+  case ResultConvention::Guaranteed:
+    return "@guaranteed ";
   }
   llvm_unreachable("bad result convention");
 }

lib/IRGen/GenObjC.cpp

@@ -935,6 +935,8 @@ static llvm::Function *emitObjCPartialApplicationForwarder(IRGenModule &IGM,
     case ResultConvention::Owned:
     case ResultConvention::Autoreleased:
     case ResultConvention::Pack:
+    case ResultConvention::GuaranteedAddress:
+    case ResultConvention::Guaranteed:
       lifetimeExtendsSelf = false;
       break;
     }

lib/SIL/IR/SILFunctionType.cpp

@@ -719,6 +719,9 @@ static CanSILFunctionType getAutoDiffPullbackType(
     case ResultConvention::Indirect:
       conv = ParameterConvention::Indirect_In_Guaranteed;
       break;
+    case ResultConvention::GuaranteedAddress:
+    case ResultConvention::Guaranteed:
+      llvm_unreachable("borrow/mutate accessor not yet implemented");
     }
     return conv;
   };
@@ -1066,6 +1069,9 @@ CanSILFunctionType SILFunctionType::getAutoDiffTransposeFunctionType(
     case ResultConvention::Indirect:
       newConv = ParameterConvention::Indirect_In_Guaranteed;
       break;
+    case ResultConvention::GuaranteedAddress:
+    case ResultConvention::Guaranteed:
+      llvm_unreachable("borrow accessor is not yet implemented");
     }
     return {result.getInterfaceType(), newConv};
   };
@@ -1431,11 +1437,15 @@ class DestructureResults {
         case ResultConvention::Indirect:
         case ResultConvention::Unowned:
         case ResultConvention::UnownedInnerPointer:
+        case ResultConvention::Guaranteed:
           // Leave these as-is.
           break;
 
         case ResultConvention::Pack:
           llvm_unreachable("pack convention for non-pack");
+        case ResultConvention::GuaranteedAddress:
+          llvm_unreachable(
+              "Invalid case of ResultConvention::GuaranteedAddress");
 
         case ResultConvention::Autoreleased:
         case ResultConvention::Owned:

lib/SIL/IR/SILType.cpp

@@ -659,6 +659,10 @@ SILResultInfo::getOwnershipKind(SILFunction &F,
     if (IsTrivial)
       return OwnershipKind::None;
     return OwnershipKind::Unowned;
+  case ResultConvention::GuaranteedAddress:
+    return OwnershipKind::None;
+  case ResultConvention::Guaranteed:
+    return OwnershipKind::Guaranteed;
   }
 
   llvm_unreachable("Unhandled ResultConvention in switch.");

lib/SILGen/SILGenApply.cpp

@@ -6247,6 +6247,11 @@ RValue SILGenFunction::emitApply(
       // Unretained. Retain the value.
       result = resultTL.emitCopyValue(B, loc, result);
       break;
+
+    case ResultConvention::GuaranteedAddress:
+    case ResultConvention::Guaranteed:
+      llvm_unreachable("borrow accessor is not yet implemented");
+      break;
     }
 
     directResults.push_back(emitManagedRValueWithCleanup(result, resultTL));

lib/SILGen/SILGenPoly.cpp

@@ -5302,6 +5302,9 @@ void ResultPlanner::execute(SmallVectorImpl<SILValue> &innerDirectResultStack,
       LLVM_FALLTHROUGH;
     case ResultConvention::Unowned:
       return SGF.emitManagedCopy(Loc, resultValue, resultTL);
+    case ResultConvention::GuaranteedAddress:
+    case ResultConvention::Guaranteed:
+      llvm_unreachable("borrow accessor not yet implemented");
     }
     llvm_unreachable("bad result convention!");
   };

lib/SILOptimizer/Differentiation/VJPCloner.cpp

@@ -1133,6 +1133,9 @@ SILFunction *VJPCloner::Implementation::createEmptyPullback() {
     case ResultConvention::Pack:
       conv = ParameterConvention::Pack_Guaranteed;
       break;
+    case ResultConvention::GuaranteedAddress:
+    case ResultConvention::Guaranteed:
+      llvm_unreachable("borrow accessor is not yet implemented");
     }
     return {tanType, conv};
   };