Merge pull request #84180 from meg-gupta/borrowandmutatepr

Add preliminary support for borrow accessors

Author: meg-gupta

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/ComputeSideEffects.swift

@@ -254,6 +254,11 @@ private struct CollectedEffects {
       // effect, it would not give any significant benefit in any of our current optimizations.
       addEffects(.destroy, to: inst.operands[0].value, fromInitialPath: SmallProjectionPath(.anyValueFields))
 
+    case is ReturnInst:
+      if inst.parentFunction.convention.hasGuaranteedAddressResult {
+        addEffects(.read, to: inst.operands[0].value)
+      }
+
     default:
       if inst.mayRelease {
         globalEffects = .worstEffects

SwiftCompilerSources/Sources/Optimizer/Utilities/OwnershipLiveness.swift

@@ -806,6 +806,10 @@ extension InteriorUseWalker {
     if let inst = operand.instruction as? ForwardingInstruction {
       return inst.forwardedResults.walk { walkDownUses(of: $0) }
     }
+    // TODO: Represent apply of borrow accessors as ForwardingOperation and use that over ForwardingInstruction
+    if let apply = operand.instruction as? FullApplySite, apply.hasGuaranteedResult {
+      return walkDownUses(of: apply.singleDirectResult!)
+    }
     // TODO: verify that ForwardInstruction handles all .forward operand ownership and assert that only phis can be
     // reached: assert(Phi(using: operand) != nil)
     return .continueWalk

SwiftCompilerSources/Sources/SIL/ApplySite.swift

@@ -299,6 +299,14 @@ extension ApplySite {
   public func calleeArgumentIndex(of operand: Operand) -> Int? {
     operandConventions.calleeArgumentIndex(of: operand)
   }
+
+  public var hasGuaranteedResult: Bool {
+    functionConvention.hasGuaranteedResult
+  }
+
+  public var hasGuaranteedAddressResult: Bool {
+    functionConvention.hasGuaranteedAddressResult
+  }
 }
 
 extension ApplySite {

SwiftCompilerSources/Sources/SIL/Argument.swift

@@ -488,6 +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")
     }
   }
 

SwiftCompilerSources/Sources/SIL/FunctionConvention.swift

@@ -98,6 +98,20 @@ public struct FunctionConvention : CustomStringConvertible {
     return SILFunctionType_getLifetimeDependencies(functionType.bridged).count() != 0
   }
 
+  public var hasGuaranteedResult: Bool {
+    if results.count != 1 {
+      return false
+    }
+    return results[0].convention == .guaranteed
+  }
+
+  public var hasGuaranteedAddressResult: Bool {
+    if results.count != 1 {
+      return false
+    }
+    return results[0].convention == .guaranteedAddress
+  }
+
   public var description: String {
     var str = functionType.description
     for paramIdx in 0..<parameters.count {
@@ -133,7 +147,7 @@ public struct ResultInfo : CustomStringConvertible {
       return hasLoweredAddresses || type.isExistentialArchetypeWithError()
     case .pack:
       return true
-    case .owned, .unowned, .unownedInnerPointer, .autoreleased:
+    case .owned, .unowned, .unownedInnerPointer, .autoreleased, .guaranteed, .guaranteedAddress:
       return false
     }
   }
@@ -358,6 +372,14 @@ public enum ResultConvention : CustomStringConvertible {
   /// The caller is responsible for destroying this return value.  Its type is non-trivial.
   case owned
 
+  /// The caller is responsible for using the returned address within a valid
+  /// scope. This is valid only for borrow and mutate 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 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
 
@@ -397,6 +419,10 @@ public enum ResultConvention : CustomStringConvertible {
       return "autoreleased"
     case .pack:
       return "pack"
+    case .guaranteed:
+      return "guaranteed"
+    case .guaranteedAddress:
+      return "guaranteedAddress"
     }
   }
 }
@@ -428,6 +454,8 @@ extension ResultConvention {
       case .UnownedInnerPointer: self = .unownedInnerPointer
       case .Autoreleased:        self = .autoreleased
       case .Pack:                self = .pack
+      case .Guaranteed:          self = .guaranteed
+      case .GuaranteedAddress:   self = .guaranteedAddress
       default:
         fatalError("unsupported result convention")
     }

SwiftCompilerSources/Sources/SIL/Utilities/BorrowUtils.swift

@@ -535,6 +535,9 @@ public final class EnclosingValueIterator : IteratorProtocol {
           // Recurse through guaranteed forwarding non-phi instructions.
           let ops = forwardingInst.forwardedOperands
           worklist.pushIfNotVisited(contentsOf: ops.lazy.map { $0.value })
+        } else if value.isGuaranteedApplyResult {
+          let selfArgument = (value as! ApplyInst).arguments.last!
+          worklist.pushIfNotVisited(selfArgument)
         } else {
           fatalError("cannot get borrow introducers for unknown guaranteed value")
         }
@@ -617,6 +620,19 @@ extension Value {
     }
     return self
   }
+
+  public var isGuaranteedApplyResult: Bool {
+    guard let definingInstruction = self.definingInstruction else {
+      return false
+    }
+    guard let apply = definingInstruction as? ApplyInst else {
+      return false
+    }
+    guard apply.singleDirectResult != nil else {
+      return false
+    }
+    return apply.functionConvention.results[0].convention == .guaranteed
+  }
 }
 
 extension Phi {

SwiftCompilerSources/Sources/SIL/Utilities/Verifier.swift

@@ -61,7 +61,7 @@ private extension Instruction {
 
   func checkGuaranteedResults() {
     for result in results where result.ownership == .guaranteed {
-      require(BeginBorrowValue(result) != nil || self is ForwardingInstruction,
+      require(BeginBorrowValue(result) != nil || self is ForwardingInstruction || result.isGuaranteedApplyResult,
               "\(result) must either be a BeginBorrowValue or a ForwardingInstruction")
     }
   }

docs/ABI/Mangling.rst

@@ -401,6 +401,8 @@ Entities
   ACCESSOR ::= 'p'                           // pseudo accessor referring to the storage itself
   ACCESSOR ::= 'x'                           // modify
   ACCESSOR ::= 'y'                           // read
+  ACCESSOR ::= 'b'                           // borrow
+  ACCESSOR ::= 'z'                           // mutate
 
   ADDRESSOR-KIND ::= 'u'                     // unsafe addressor (no owner)
   ADDRESSOR-KIND ::= 'O'                     // owning addressor (non-native owner), not used anymore

docs/SIL/Ownership.md

@@ -814,6 +814,11 @@ SILValue. Instead, it constrains the lifetime of an addressable
 variable. Since the constraint is applied to the in-memory
 representation, no additional lexical SILValue is required.
 
+The `self` function argument in a borrow accessor is not lexical.
+`self` is already borrowed for the duration of the borrow accessor and the
+dependency between borrowed return value and `self` will be represented in SIL,
+making lexical lifetime unnecessary.
+
 ### Deinit Barriers
 
 Deinit barriers (see Instruction.isDeinitBarrier(_:)) are instructions

include/swift/AST/AccessorKinds.def

@@ -116,6 +116,14 @@
 #define INIT_ACCESSOR(ID, KEYWORD) SINGLETON_ACCESSOR(ID, KEYWORD)
 #endif
 
+#ifndef BORROW_ACCESSOR
+#define BORROW_ACCESSOR(ID, KEYWORD) SINGLETON_ACCESSOR(ID, KEYWORD)
+#endif
+
+#ifndef MUTATE_ACCESSOR
+#define MUTATE_ACCESSOR(ID, KEYWORD) SINGLETON_ACCESSOR(ID, KEYWORD)
+#endif
+
 /// This is a getter: a function that is called when a value is loaded
 /// from the storage.  It returns an owned value of the storage type.
 ///
@@ -217,8 +225,12 @@ MUTABLE_ADDRESSOR(MutableAddress, unsafeMutableAddress)
 /// re-writes assignment to initialization.
 INIT_ACCESSOR(Init, init)
 
+BORROW_ACCESSOR(Borrow, borrow)
+
+MUTATE_ACCESSOR(Mutate, mutate)
+
 #ifdef LAST_ACCESSOR
-LAST_ACCESSOR(Init)
+LAST_ACCESSOR(Mutate)
 #undef LAST_ACCESSOR
 #endif