ComputeEscapeEffects: don't support exclusive argument -> argument effects.

Exclusive argument -> argument effects cannot appear because such an effect would involve a store which is not permitted for exclusive escapes.

Author: eeckstein

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/ComputeEscapeEffects.swift

@@ -158,9 +158,9 @@ func addArgEffects(_ arg: FunctionArgument, argPath ap: SmallProjectionPath,
     effect = EscapeEffects.ArgumentEffect(.escapingToReturn(toPath, exclusive),
                                           argumentIndex: arg.index, pathPattern: argPath)
   case .toArgument(let toArgIdx, let toPath):
-    let exclusive = isExclusiveEscapeToArgument(fromArgument: arg, fromPath: argPath,
-                                                toArgumentIndex: toArgIdx, toPath: toPath, context)
-    effect = EscapeEffects.ArgumentEffect(.escapingToArgument(toArgIdx, toPath, exclusive),
+    // 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(toArgIdx, toPath, /*exclusive*/ false),
                                           argumentIndex: arg.index, pathPattern: argPath)
   }
   newEffects.append(effect)
@@ -234,29 +234,3 @@ func isExclusiveEscapeToReturn(fromArgument: Argument, fromPath: SmallProjection
   let visitor = IsExclusiveReturnEscapeVisitor(fromArgument: fromArgument, fromPath: fromPath, toPath: toPath)
   return !returnInst.operand.at(toPath).isEscaping(using: visitor, context)
 }
-
-private
-func isExclusiveEscapeToArgument(fromArgument: Argument, fromPath: SmallProjectionPath,
-                                 toArgumentIndex: Int, toPath: SmallProjectionPath, _ context: FunctionPassContext) -> Bool {
-  struct IsExclusiveArgumentEscapeVisitor : EscapeVisitor {
-    let fromArgument: Argument
-    let fromPath: SmallProjectionPath
-    let toArgumentIndex: Int
-    let toPath: SmallProjectionPath
-    
-    mutating func visitDef(def: Value, path: EscapePath) -> DefResult {
-      guard let arg = def as? FunctionArgument else {
-        return .continueWalkUp
-      }
-      if path.followStores { return .abort }
-      if arg == fromArgument && path.projectionPath.matches(pattern: fromPath) { return .walkDown }
-      if arg.index == toArgumentIndex && path.projectionPath.matches(pattern: toPath) { return .walkDown }
-      return .abort
-    }
-  }
-  let visitor = IsExclusiveArgumentEscapeVisitor(fromArgument: fromArgument, fromPath: fromPath,
-                                                 toArgumentIndex: toArgumentIndex, toPath: toPath)
-  let toArg = fromArgument.parentFunction.arguments[toArgumentIndex]
-  return !toArg.at(toPath).isEscapingWhenWalkingDown(using: visitor, context)
-}
-

SwiftCompilerSources/Sources/Optimizer/Utilities/EscapeUtils.swift

@@ -592,7 +592,8 @@ fileprivate struct EscapeWalker<V: EscapeVisitor> : ValueDefUseWalker,
     var matched = false
     for effect in effects.escapeEffects.arguments {
       switch effect.kind {
-      case .escapingToArgument(let toArgIdx, let toPath, let exclusive):
+      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 {
             return isEscaping
@@ -602,20 +603,6 @@ fileprivate struct EscapeWalker<V: EscapeVisitor> : ValueDefUseWalker,
           let arg = apply.arguments[callerToIdx]
 
           let p = Path(projectionPath: toPath, followStores: false, knownType: nil)
-          if walkUp(addressOrValue: arg, path: p) == .abortWalk {
-            return .abortWalk
-          }
-          matched = true
-        } else if toArgIdx == calleeArgIdx && argPath.projectionPath.matches(pattern: toPath) {
-          // Handle the reverse direction of an arg-to-arg escape.
-          guard let callerArgIdx = apply.callerArgIndex(calleeArgIndex: effect.argumentIndex) else {
-            return isEscaping
-          }
-          if !exclusive { return isEscaping }
-
-          let arg = apply.arguments[callerArgIdx]
-          let p = Path(projectionPath: effect.pathPattern, followStores: false, knownType: nil)
-
           if walkUp(addressOrValue: arg, path: p) == .abortWalk {
             return .abortWalk
           }

test/SILOptimizer/escape_effects.sil

@@ -57,7 +57,7 @@ sil [ossa] @unknown_function : $@convention(thin) (@owned X) -> ()
 sil [ossa] @unknown_function_y : $@convention(thin) (@owned Y) -> ()
 
 // CHECK-LABEL: sil [ossa] @test_basic
-// CHECK-NEXT:  [%1: escape v** => %3.v**]
+// CHECK-NEXT:  [%1: escape v** -> %3.v**]
 // CHECK-NEXT:  [%2: noescape, escape c*.v** -> %r.v**]
 // CHECK-NEXT:  [%3: noescape]
 // CHECK-NEXT:  {{^[^[]}}
@@ -201,7 +201,7 @@ sil [ossa] @self_arg_callee : $@convention(thin) (@inout Str) -> () {
 }
 
 // CHECK-LABEL: sil [ossa] @test_self_arg_escape
-// CHECK-NEXT:  [%0: escape v** => %0.v**]
+// CHECK-NEXT:  [%0: escape v** -> %0.v**]
 // CHECK-NEXT:  {{^[^[]}}
 sil [ossa] @test_self_arg_escape : $@convention(thin) (@inout Str) -> () {
 bb0(%0 : $*Str):
@@ -212,7 +212,7 @@ bb0(%0 : $*Str):
 }
 
 // CHECK-LABEL: sil [ossa] @test_self_arg_escape_with_copy
-// CHECK-NEXT:  [%0: escape v** => %0.s1.0.v**]
+// CHECK-NEXT:  [%0: escape v** -> %0.s1.0.v**]
 // CHECK-NEXT:  {{^[^[]}}
 sil [ossa] @test_self_arg_escape_with_copy : $@convention(thin) (@inout Str) -> () {
 bb0(%0 : $*Str):
@@ -225,7 +225,7 @@ bb0(%0 : $*Str):
 }
 
 // CHECK-LABEL: sil [ossa] @test_self_arg_escape_with_bidirectional_copy
-// CHECK-NEXT:  [%0: escape v** => %0.v**]
+// CHECK-NEXT:  [%0: escape v** -> %0.v**]
 // CHECK-NEXT:  {{^[^[]}}
 sil [ossa] @test_self_arg_escape_with_bidirectional_copy : $@convention(thin) (@inout Str) -> () {
 bb0(%0 : $*Str):
@@ -240,7 +240,7 @@ bb0(%0 : $*Str):
 
 // CHECK-LABEL: sil [ossa] @test_content_to_arg_addr
 // CHECK-NEXT:  [%0: noescape **]
-// CHECK-NEXT:  [%1: noescape, escape c*.v** => %0.v**]
+// CHECK-NEXT:  [%1: noescape, escape c*.v** -> %0.v**]
 // CHECK-NEXT:  {{^[^[]}}
 sil [ossa] @test_content_to_arg_addr : $@convention(thin) (@guaranteed Y) -> @out Str {
 bb0(%0 : $*Str, %1 : @guaranteed $Y):

test/SILOptimizer/escape_info.sil

@@ -93,8 +93,8 @@ sil [ossa] @arg_to_return : $@convention(thin) (@owned X) -> @owned Str {
 [%0: escape => %r.s0]
 }
 sil [ossa] @arg_to_arg : $@convention(thin) (@owned X) -> @out Str {
-[%0: noescape]
-[%1: escape => %0.s0]
+[%0: noescape v**]
+[%1: escape -> %0.s0]
 }
 sil [ossa] @content_of_arg_to_return : $@convention(thin) (@owned Z) -> @owned Y {
 [%0: noescape, escape c* => %r]