Use @inout result convention for mutate accessors

Author: meg-gupta

SwiftCompilerSources/Sources/SIL/Argument.swift

@@ -488,8 +488,8 @@ public enum ArgumentConvention : CustomStringConvertible {
       self = .directUnowned
     case .pack:
       self = .packOut
-    case .guaranteed, .guaranteedAddress:
-      fatalError("Result conventions @guaranteed and @guaranteed_addr are always returned directly")
+    case .guaranteed, .guaranteedAddress, .inout:
+      fatalError("Result conventions @guaranteed, @guaranteed_addr and @inout are always returned directly")
     }
   }
 

SwiftCompilerSources/Sources/SIL/FunctionConvention.swift

@@ -112,6 +112,17 @@ public struct FunctionConvention : CustomStringConvertible {
     return results[0].convention == .guaranteedAddress
   }
 
+  public var hasInoutResult: Bool {
+    if results.count != 1 {
+      return false
+    }
+    return results[0].convention == .inout
+  }
+
+  public var hasAddressResult: Bool {
+    return hasGuaranteedAddressResult || hasInoutResult
+  }
+
   public var description: String {
     var str = functionType.description
     for paramIdx in 0..<parameters.count {
@@ -147,7 +158,7 @@ public struct ResultInfo : CustomStringConvertible {
       return hasLoweredAddresses || type.isExistentialArchetypeWithError()
     case .pack:
       return true
-    case .owned, .unowned, .unownedInnerPointer, .autoreleased, .guaranteed, .guaranteedAddress:
+    case .owned, .unowned, .unownedInnerPointer, .autoreleased, .guaranteed, .guaranteedAddress, .inout:
       return false
     }
   }
@@ -373,13 +384,17 @@ public enum ResultConvention : CustomStringConvertible {
   case owned
 
   /// The caller is responsible for using the returned address within a valid
-  /// scope. This is valid only for borrow and mutate accessors.
+  /// scope. This is valid only for borrow accessors.
   case guaranteedAddress
 
   /// The caller is responsible for using the returned value within a valid
   /// scope. This is valid only for borrow accessors.
   case guaranteed
 
+  /// The caller is responsible for mutating the returned address within a valid
+  /// scope. This is valid only for mutate accessors.
+  case `inout`
+
   /// The caller is not responsible for destroying this return value.  Its type may be trivial, or it may simply be offered unsafely.  It is valid at the instant of the return, but further operations may invalidate it.
   case unowned
 
@@ -423,6 +438,8 @@ public enum ResultConvention : CustomStringConvertible {
       return "guaranteed"
     case .guaranteedAddress:
       return "guaranteedAddress"
+    case .inout:
+      return "inout"      
     }
   }
 }
@@ -456,6 +473,7 @@ extension ResultConvention {
       case .Pack:                self = .pack
       case .Guaranteed:          self = .guaranteed
       case .GuaranteedAddress:   self = .guaranteedAddress
+      case .Inout:               self = .inout
       default:
         fatalError("unsupported result convention")
     }

include/swift/AST/Types.h

@@ -4814,12 +4814,16 @@ enum class ResultConvention : uint8_t {
   Pack,
 
   /// The caller is responsible for using the returned address within a valid
-  /// scope. This is valid only for borrow and mutate accessors.
+  /// scope. This is valid only for borrow accessors.
   GuaranteedAddress,
 
   /// The caller is responsible for using the returned value within a valid
   /// scope. This is valid only for borrow accessors.
   Guaranteed,
+
+  /// The caller is responsible for mutating the returned address within a valid
+  /// scope. This is valid only for mutate accessors.
+  Inout,
 };
 
 // Does this result require indirect storage for the purpose of reabstraction?
@@ -4980,6 +4984,14 @@ class SILResultInfo {
     return getConvention() == ResultConvention::GuaranteedAddress;
   }
 
+  bool isInoutResult() const {
+    return getConvention() == ResultConvention::Inout;
+  }
+
+  bool isAddressResult() const {
+    return isGuaranteedAddressResult() || isInoutResult();
+  }
+
   bool isGuaranteedResult() const {
     return getConvention() == ResultConvention::Guaranteed;
   }
@@ -5438,6 +5450,17 @@ class SILFunctionType final
     return getResults()[0].isGuaranteedAddressResult();
   }
 
+  bool hasInoutResult() const {
+    if (getNumResults() != 1) {
+      return false;
+    }
+    return getResults()[0].isInoutResult();
+  }
+
+  bool hasAddressResult() const {
+    return hasGuaranteedAddressResult() || hasInoutResult();
+  }
+
   struct IndirectFormalResultFilter {
     bool operator()(SILResultInfo result) const {
       return result.isFormalIndirect();

include/swift/SIL/SILBridging.h

@@ -110,6 +110,7 @@ enum class BridgedResultConvention {
   Pack,
   GuaranteedAddress,
   Guaranteed,
+  Inout
 };
 
 struct BridgedResultInfo {

include/swift/SIL/SILFunctionConventions.h

@@ -334,6 +334,17 @@ class SILFunctionConventions {
            ResultConvention::GuaranteedAddress;
   }
 
+  bool hasInoutResult() const {
+    if (funcTy->getNumResults() != 1) {
+      return false;
+    }
+    return funcTy->getResults()[0].getConvention() == ResultConvention::Inout;
+  }
+
+  bool hasAddressResult() const {
+    return hasGuaranteedAddressResult() || hasInoutResult();
+  }
+
   struct SILResultTypeFunc;
 
   // Gratuitous template parameter is to delay instantiating `mapped_iterator`
@@ -675,6 +686,7 @@ inline bool SILModuleConventions::isIndirectSILResult(SILResultInfo result,
   case ResultConvention::Autoreleased:
   case ResultConvention::GuaranteedAddress:
   case ResultConvention::Guaranteed:
+  case ResultConvention::Inout:
     return false;
   }
 
@@ -699,7 +711,7 @@ inline SILType
 SILModuleConventions::getSILResultInterfaceType(SILResultInfo result,
                                                 bool loweredAddresses) {
   return SILModuleConventions::isIndirectSILResult(result, loweredAddresses) ||
-                 result.isGuaranteedAddressResult()
+                 result.isAddressResult()
              ? SILType::getPrimitiveAddressType(result.getInterfaceType())
              : SILType::getPrimitiveObjectType(result.getInterfaceType());
 }

include/swift/SIL/SILInstruction.h

@@ -3157,6 +3157,10 @@ class ApplyInst final
   bool hasGuaranteedAddressResult() const {
     return getSubstCalleeConv().hasGuaranteedAddressResult();
   }
+  bool hasInoutResult() const { return getSubstCalleeConv().hasInoutResult(); }
+  bool hasAddressResult() const {
+    return getSubstCalleeConv().hasAddressResult();
+  }
 };
 
 /// PartialApplyInst - Represents the creation of a closure object by partial

lib/AST/ASTPrinter.cpp

@@ -7944,6 +7944,8 @@ static StringRef getStringForResultConvention(ResultConvention conv) {
     return "@guaranteed_addr ";
   case ResultConvention::Guaranteed:
     return "@guaranteed ";
+  case ResultConvention::Inout:
+    return "@inout ";
   }
   llvm_unreachable("bad result convention");
 }

lib/IRGen/CallEmission.h

@@ -103,7 +103,7 @@ class CallEmission {
   virtual void emitCallToUnmappedExplosion(llvm::CallBase *call,
                                            Explosion &out) = 0;
   void emitYieldsToExplosion(Explosion &out);
-  void emitGuaranteedAddressToExplosion(Explosion &out);
+  void emitAddressResultToExplosion(Explosion &out);
   void setKeyPathAccessorArguments(Explosion &in, bool isOutlined,
                                    Explosion &out);
   virtual FunctionPointer getCalleeFunctionPointer() = 0;

lib/IRGen/GenCall.cpp

@@ -592,9 +592,8 @@ namespace {
     /// function type.
     void expandCoroutineContinuationType();
 
-    /// Initializes the result type for functions with @guaranteed_addr return
-    /// convention.
-    void expandGuaranteedAddressResult();
+    /// Initializes the result type for borrow and mutate accessors.
+    void expandAddressResult();
 
     // Expand the components for the async continuation entrypoint of the
     // function type (the function to be called on returning).
@@ -699,8 +698,8 @@ void SignatureExpansion::expandResult(
 
   auto fnConv = getSILFuncConventions();
 
-  if (fnConv.hasGuaranteedAddressResult()) {
-    return expandGuaranteedAddressResult();
+  if (fnConv.hasAddressResult()) {
+    return expandAddressResult();
   }
 
   // Disable the use of sret if we have multiple indirect results.
@@ -920,7 +919,7 @@ void SignatureExpansion::expandCoroutineContinuationParameters() {
   }
 }
 
-void SignatureExpansion::expandGuaranteedAddressResult() {
+void SignatureExpansion::expandAddressResult() {
   CanUseSRet = false;
   ResultIRType = IGM.PtrTy;
 }
@@ -3959,7 +3958,7 @@ void CallEmission::emitYieldsToExplosion(Explosion &out) {
   }
 }
 
-void CallEmission::emitGuaranteedAddressToExplosion(Explosion &out) {
+void CallEmission::emitAddressResultToExplosion(Explosion &out) {
   auto call = emitCallSite();
   out.add(call);
 }
@@ -3980,10 +3979,10 @@ void CallEmission::emitToExplosion(Explosion &out, bool isOutlined) {
   SILFunctionConventions fnConv(getCallee().getSubstFunctionType(),
                                 IGF.getSILModule());
 
-  if (fnConv.hasGuaranteedAddressResult()) {
+  if (fnConv.hasAddressResult()) {
     assert(LastArgWritten == 0 &&
-           "@guaranteed_addr along with indirect result?");
-    emitGuaranteedAddressToExplosion(out);
+           "@guaranteed_addr/@inout along with indirect result?");
+    emitAddressResultToExplosion(out);
     return;
   }
 
@@ -6832,9 +6831,9 @@ void irgen::emitYieldOnceCoroutineResult(IRGenFunction &IGF, Explosion &result,
   }
 }
 
-void irgen::emitGuaranteedAddressResult(IRGenFunction &IGF, Explosion &result,
-                                        SILType funcResultType,
-                                        SILType returnResultType) {
+void irgen::emitAddressResult(IRGenFunction &IGF, Explosion &result,
+                              SILType funcResultType,
+                              SILType returnResultType) {
   assert(funcResultType == returnResultType);
   assert(funcResultType.isAddress());
   auto &Builder = IGF.Builder;

lib/IRGen/GenCall.h

@@ -278,9 +278,8 @@ namespace irgen {
   void emitYieldOnceCoroutineResult(IRGenFunction &IGF, Explosion &result,
                                     SILType funcResultType, SILType returnResultType);
 
-  void emitGuaranteedAddressResult(IRGenFunction &IGF, Explosion &result,
-                                   SILType funcResultType,
-                                   SILType returnResultType);
+  void emitAddressResult(IRGenFunction &IGF, Explosion &result,
+                         SILType funcResultType, SILType returnResultType);
 
   Address emitAutoDiffCreateLinearMapContextWithType(
       IRGenFunction &IGF, llvm::Value *topLevelSubcontextMetatype);