Effects: remove the isExclusive flag from the escapingToArgument effect

An argument-to-argument escape always involves a store, which makes an exclusive escape impossible.

Author: eeckstein

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/ComputeEscapeEffects.swift

@@ -160,7 +160,7 @@ func addArgEffects(_ arg: FunctionArgument, argPath ap: SmallProjectionPath,
   case .toArgument(let toArgIdx, let toPath):
     // Exclusive argument -> argument effects cannot appear because such an effect would
     // involve a store which is not permitted for exclusive escapes.
-    effect = EscapeEffects.ArgumentEffect(.escapingToArgument(toArgumentIndex: toArgIdx, toPath: toPath, isExclusive: false),
+    effect = EscapeEffects.ArgumentEffect(.escapingToArgument(toArgumentIndex: toArgIdx, toPath: toPath),
                                           argumentIndex: arg.index, pathPattern: argPath)
   }
   newEffects.append(effect)
@@ -176,8 +176,10 @@ private func getArgIndicesWithDefinedEscapingEffects(of function: Function) -> S
 
     argsWithDefinedEffects.insert(effect.argumentIndex)
     switch effect.kind {
-      case .notEscaping, .escapingToReturn:         break
-      case .escapingToArgument(let toArgIdx, _, _): argsWithDefinedEffects.insert(toArgIdx)
+    case .notEscaping, .escapingToReturn:
+      break
+    case .escapingToArgument(let toArgIdx, _):
+      argsWithDefinedEffects.insert(toArgIdx)
     }
   }
   return argsWithDefinedEffects

SwiftCompilerSources/Sources/Optimizer/Utilities/EscapeUtils.swift

@@ -594,7 +594,7 @@ fileprivate struct EscapeWalker<V: EscapeVisitor> : ValueDefUseWalker,
     var matched = false
     for effect in effects.escapeEffects.arguments {
       switch effect.kind {
-      case .escapingToArgument(let toArgIdx, let toPath, _):
+      case .escapingToArgument(let toArgIdx, let toPath):
         // Note: exclusive argument -> argument effects cannot appear, so we don't need to handle them here.
         if effect.matches(calleeArgIdx, argPath.projectionPath) {
           guard let callerToIdx = apply.callerArgIndex(calleeArgIndex: toArgIdx) else {

SwiftCompilerSources/Sources/SIL/Effects.swift

@@ -285,7 +285,9 @@ public struct EscapeEffects : CustomStringConvertible, NoReflectionChildren {
       /// Note that theoretically this rule also applies to the `escapingToReturn` effect, but it's impossible
       /// to construct such a situation for an argument which is only escaping to the function return.
       ///
-      case escapingToArgument(toArgumentIndex: Int, toPath: SmallProjectionPath, isExclusive: Bool)
+      /// The `escapingToArgument` doesn't have an `isExclusive` flag, because an argument-to-argument escape
+      /// always involves a store, which makes an exclusive escape impossible.
+      case escapingToArgument(toArgumentIndex: Int, toPath: SmallProjectionPath)
     }
 
     /// To which argument does this effect apply to?
@@ -330,19 +332,19 @@ public struct EscapeEffects : CustomStringConvertible, NoReflectionChildren {
           if resultArgDelta != 1 {
             return nil
           }
-          self.kind = .escapingToArgument(toArgumentIndex: 0, toPath: toPath, isExclusive: exclusive)
+          self.kind = .escapingToArgument(toArgumentIndex: 0, toPath: toPath)
         } else {
           self.kind = .escapingToReturn(toPath: toPath, isExclusive: exclusive)
         }
-      case .escapingToArgument(let toArgIdx, let toPath, let exclusive):
+      case .escapingToArgument(let toArgIdx, let toPath):
         let resultingToArgIdx = toArgIdx + resultArgDelta
         if resultingToArgIdx < 0 {
           if resultingToArgIdx != -1 {
             return nil
           }
-          self.kind = .escapingToReturn(toPath: toPath, isExclusive: exclusive)
+          self.kind = .escapingToReturn(toPath: toPath, isExclusive: false)
         } else {
-          self.kind = .escapingToArgument(toArgumentIndex: resultingToArgIdx, toPath: toPath, isExclusive: exclusive)
+          self.kind = .escapingToArgument(toArgumentIndex: resultingToArgIdx, toPath: toPath)
         }
       }
     }
@@ -362,9 +364,9 @@ public struct EscapeEffects : CustomStringConvertible, NoReflectionChildren {
         case .escapingToReturn(let toPath, let exclusive):
           let toPathStr = (toPath.isEmpty ? "" : ".\(toPath)")
           return "escape\(patternStr) \(exclusive ? "=>" : "->") %r\(toPathStr)"
-        case .escapingToArgument(let toArgIdx, let toPath, let exclusive):
+        case .escapingToArgument(let toArgIdx, let toPath):
           let toPathStr = (toPath.isEmpty ? "" : ".\(toPath)")
-          return "escape\(patternStr) \(exclusive ? "=>" : "->") %\(toArgIdx)\(toPathStr)"
+          return "escape\(patternStr) -> %\(toArgIdx)\(toPathStr)"
       }
     }
 
@@ -663,16 +665,21 @@ extension StringParser {
             try throwError("multi-value returns not supported yet")
           }
           let toPath = try parsePathPatternFromSource(for: function, type: function.argumentTypes[0])
-          return EscapeEffects.ArgumentEffect(.escapingToArgument(toArgumentIndex: 0, toPath: toPath, isExclusive: exclusive),
+
+          // Exclusive escapes are ignored for indirect return values.
+          return EscapeEffects.ArgumentEffect(.escapingToArgument(toArgumentIndex: 0, toPath: toPath),
                                       argumentIndex: fromArgIdx, pathPattern: fromPath, isDerived: false)
         }
         let toPath = try parsePathPatternFromSource(for: function, type: function.resultType)
         return EscapeEffects.ArgumentEffect(.escapingToReturn(toPath: toPath, isExclusive: exclusive),
                                     argumentIndex: fromArgIdx, pathPattern: fromPath, isDerived: false)
       }
+      if exclusive {
+        try throwError("exclusive escapes to arguments are not supported")
+      }
       let toArgIdx = try parseArgumentIndexFromSource(for: function, params: params)
       let toPath = try parsePathPatternFromSource(for: function, type: function.argumentTypes[toArgIdx])
-      return EscapeEffects.ArgumentEffect(.escapingToArgument(toArgumentIndex: toArgIdx, toPath: toPath, isExclusive: exclusive),
+      return EscapeEffects.ArgumentEffect(.escapingToArgument(toArgumentIndex: toArgIdx, toPath: toPath),
                                   argumentIndex: fromArgIdx, pathPattern: fromPath, isDerived: false)
     }
     try throwError("unknown effect")
@@ -739,9 +746,12 @@ extension StringParser {
           effect = EscapeEffects.ArgumentEffect(.escapingToReturn(toPath: toPath, isExclusive: exclusive),
                                                 argumentIndex: argumentIndex, pathPattern: fromPath, isDerived: isDerived)
         } else {
+          if exclusive {
+            try throwError("exclusive escapes to arguments are not supported")
+          }
           let toArgIdx = try parseArgumentIndexFromSIL()
           let toPath = consume(".") ? try parseProjectionPathFromSIL() : SmallProjectionPath()
-          effect = EscapeEffects.ArgumentEffect(.escapingToArgument(toArgumentIndex: toArgIdx, toPath: toPath, isExclusive: exclusive),
+          effect = EscapeEffects.ArgumentEffect(.escapingToArgument(toArgumentIndex: toArgIdx, toPath: toPath),
                                                 argumentIndex: argumentIndex, pathPattern: fromPath, isDerived: isDerived)
         }
         effects.escapeEffects.arguments.append(effect)

test/SILGen/effectsattr.swift

@@ -20,7 +20,7 @@
 @_effects(notEscaping t.**) @_silgen_name("func5") func func5<T>(_ t: T) { }
 
 //CHECK-LABEL: sil hidden [ossa] @func6
-//CHECK-NEXT:  [%1: escape! v**.c* => %0.v**]
+//CHECK-NEXT:  [%1: escape! v**.c* -> %0.v**]
 //CHECK-NEXT:  {{^[^[]}}
 @_effects(escaping t.value**.class* => return.value**) @_silgen_name("func6") func func6<T>(_ t: T) -> T { }
 

test/SILOptimizer/escape_effects.sil

@@ -197,7 +197,7 @@ bb0(%0 : @guaranteed $Z, %1 : @owned $Y):
 }
 
 sil [ossa] @self_arg_callee : $@convention(thin) (@inout Str) -> () {
-[%0: escape v** => %0.v**] 
+[%0: escape v** -> %0.v**] 
 }
 
 // CHECK-LABEL: sil [ossa] @test_self_arg_escape

test/SILOptimizer/escape_info.sil

@@ -1011,11 +1011,11 @@ sil @closure3 : $@convention(thin) (@guaranteed Z) -> () {
 [%0: noescape **]
 }
 sil [ossa] @closure4 : $@convention(thin) (@guaranteed X, @guaranteed Y) -> () {
-[%0: escape => %1]
+[%0: escape -> %1]
 [%1: noescape]
 }
 sil [ossa] @closure5 : $@convention(thin) (@guaranteed Y, @guaranteed X) -> () {
-[%1: escape => %0, noescape]
+[%1: escape -> %0, noescape]
 }
 
 sil [ossa] @closure6 : $@convention(thin) (@guaranteed Y, @guaranteed Y) -> @owned Y {

test/SILOptimizer/specialize_reabstraction.sil

@@ -136,21 +136,21 @@ bb0(%0 : $Bool):
 }
 
 // CHECK-LABEL: sil shared @$s21arg_escapes_to_return4main1XC_Tg5
-// CHECK-NEXT:  [%0: escape => %r]
+// CHECK-NEXT:  [%0: escape -> %r]
 // CHECK-NEXT:  {{^[^[]}}
 sil @arg_escapes_to_return : $@convention(thin) <T> (@in_guaranteed T) -> @out T {
-[%1: escape => %0] 
+[%1: escape -> %0] 
 bb0(%0 : $*T, %1 : $*T):
   copy_addr %1 to [init] %0 : $*T
   %4 = tuple ()
   return %4 : $()
 }
 
 // CHECK-LABEL: sil shared @$s015arg_escapes_to_A04main1XC_Tg5
-// CHECK-NEXT:  [%1: escape => %0]
+// CHECK-NEXT:  [%1: escape -> %0]
 // CHECK-NEXT:  {{^[^[]}}
 sil @arg_escapes_to_arg : $@convention(thin) <T> (@inout T, @in_guaranteed T) -> () {
-[%1: escape => %0] 
+[%1: escape -> %0] 
 bb0(%0 : $*T, %1 : $*T):
   copy_addr %1 to %0 : $*T
   %4 = tuple ()