Handle return_borrow in a few more places in SwiftCompilerSources

Author: meg-gupta

SwiftCompilerSources/Sources/Optimizer/Analysis/AliasAnalysis.swift

@@ -775,7 +775,7 @@ private struct FullApplyEffectsVisitor : EscapeVisitorWithResult {
 
   mutating func visitUse(operand: Operand, path: EscapePath) -> UseResult {
     let user = operand.instruction
-    if user is ReturnInst {
+    if user is ReturnInstruction {
       // Anything which is returned cannot escape to an instruction inside the function.
       return .ignore
     }
@@ -805,7 +805,7 @@ private struct PartialApplyEffectsVisitor : EscapeVisitorWithResult {
 
   mutating func visitUse(operand: Operand, path: EscapePath) -> UseResult {
     let user = operand.instruction
-    if user is ReturnInst {
+    if user is ReturnInstruction {
       // Anything which is returned cannot escape to an instruction inside the function.
       return .ignore
     }
@@ -848,7 +848,7 @@ private struct EscapesToInstructionVisitor : EscapeVisitor {
     if user == target {
       return .abort
     }
-    if user is ReturnInst {
+    if user is ReturnInstruction {
       // Anything which is returned cannot escape to an instruction inside the function.
       return .ignore
     }

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/ComputeEscapeEffects.swift

@@ -81,7 +81,7 @@ let computeEscapeEffects = FunctionPass(name: "compute-escape-effects") {
 private
 func addArgEffects(_ arg: FunctionArgument, argPath ap: SmallProjectionPath,
                    to newEffects: inout [EscapeEffects.ArgumentEffect],
-                   _ returnInst: ReturnInst?, _ context: FunctionPassContext) -> Bool {
+                   _ returnInst: ReturnInstruction?, _ context: FunctionPassContext) -> Bool {
   // Correct the path if the argument is not a class reference itself, but a value type
   // containing one or more references.
   let argPath = arg.type.isClass ? ap : ap.push(.anyValueFields)
@@ -157,7 +157,7 @@ private struct ArgEffectsVisitor : EscapeVisitorWithResult {
   var result = EscapeDestination.notSet
 
   mutating func visitUse(operand: Operand, path: EscapePath) -> UseResult {
-    if operand.instruction is ReturnInst {
+    if operand.instruction is ReturnInstruction {
       // The argument escapes to the function return
       if path.followStores {
         // The escaping path must not introduce a followStores.
@@ -209,13 +209,13 @@ private struct IsExclusiveReturnEscapeVisitor : EscapeVisitorWithResult {
   let returnPath: SmallProjectionPath
   var result = false
 
-  func isExclusiveEscape(returnInst: ReturnInst, _ context: FunctionPassContext) -> Bool {
+  func isExclusiveEscape(returnInst: ReturnInstruction, _ context: FunctionPassContext) -> Bool {
     return returnInst.returnedValue.at(returnPath).visit(using: self, context) ?? false
   }
 
   mutating func visitUse(operand: Operand, path: EscapePath) -> UseResult {
     switch operand.instruction {
-    case is ReturnInst:
+    case is ReturnInstruction:
       if path.followStores { return .abort }
       if path.projectionPath.matches(pattern: returnPath) {
         return .ignore

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/ComputeSideEffects.swift

@@ -254,7 +254,7 @@ 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:
+    case is ReturnInstruction:
       if inst.parentFunction.convention.hasAddressResult {
         addEffects(.read, to: inst.operands[0].value)
       }
@@ -532,7 +532,7 @@ private struct ArgumentEscapingWalker : ValueDefUseWalker, AddressDefUseWalker {
     case is CopyValueInst, is RetainValueInst, is StrongRetainInst,
          is DestroyValueInst, is ReleaseValueInst, is StrongReleaseInst,
          is DebugValueInst, is UnconditionalCheckedCastInst,
-         is ReturnInst:
+         is ReturnInstruction:
       return .continueWalk
 
     case let apply as ApplySite:
@@ -620,7 +620,7 @@ private extension PartialApplyInst {
           // Any escape to apply - regardless if it's an argument or the callee operand - might cause
           // the closure to be called.
           return .abort
-        case is ReturnInst:
+        case is ReturnInstruction:
           return .ignore
         default:
           return .continueWalk

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/LifetimeDependenceScopeFixup.swift

@@ -894,7 +894,7 @@ extension ExtendableScope {
         assert(end.parentBlock.singleSuccessor!.terminator is ReturnInst,
                "a phi only ends a use range if it is a returned value")
         fallthrough
-      case is ReturnInst:
+      case is ReturnInstruction:
         // End this inner scope just before the return. The mark_dependence base operand will be redirected to a
         // function argument.
         let builder = Builder(before: end, location: location, context)

SwiftCompilerSources/Sources/Optimizer/TestPasses/EscapeInfoDumper.swift

@@ -26,7 +26,7 @@ let escapeInfoDumper = FunctionPass(name: "dump-escape-info") {
     var result: Set<String> =  Set()
 
     mutating func visitUse(operand: Operand, path: EscapePath) -> UseResult {
-      if operand.instruction is ReturnInst {
+      if operand.instruction is ReturnInstruction {
         result.insert("return[\(path.projectionPath)]")
         return .ignore
       }
@@ -94,7 +94,7 @@ let addressEscapeInfoDumper = FunctionPass(name: "dump-addr-escape-info") {
       if user == apply {
         return .abort
       }
-      if user is ReturnInst {
+      if user is ReturnInstruction {
         // Anything which is returned cannot escape to an instruction inside the function.
         return .ignore
       }

SwiftCompilerSources/Sources/Optimizer/Utilities/EscapeUtils.swift

@@ -387,7 +387,7 @@ fileprivate struct EscapeWalker<V: EscapeVisitor> : ValueDefUseWalker,
       if handleDestroy(of: operand.value, path: path) == .abortWalk {
         return .abortWalk
       }
-    case is ReturnInst:
+    case is ReturnInstruction:
       return isEscaping
     case is ApplyInst, is TryApplyInst, is BeginApplyInst:
       return walkDownCallee(argOp: operand, apply: instruction as! FullApplySite, path: path)
@@ -534,7 +534,7 @@ fileprivate struct EscapeWalker<V: EscapeVisitor> : ValueDefUseWalker,
       if handleDestroy(of: operand.value, path: path) == .abortWalk {
         return .abortWalk
       }
-    case is ReturnInst:
+    case is ReturnInstruction:
       return isEscaping
     case is ApplyInst, is TryApplyInst, is BeginApplyInst:
       return walkDownCallee(argOp: operand, apply: instruction as! FullApplySite, path: path)

SwiftCompilerSources/Sources/Optimizer/Utilities/LifetimeDependenceUtils.swift

@@ -727,7 +727,7 @@ extension LifetimeDependenceDefUseWalker {
     if let apply = operand.instruction as? FullApplySite {
       return visitAppliedUse(of: operand, by: apply)
     }
-    if operand.instruction is ReturnInst, !operand.value.isEscapable {
+    if operand.instruction is ReturnInstruction, !operand.value.isEscapable {
       return returnedDependence(result: operand)
     }
     if operand.instruction is YieldInst, !operand.value.isEscapable {

SwiftCompilerSources/Sources/Optimizer/Utilities/OptUtils.swift

@@ -880,7 +880,7 @@ private struct EscapesToValueVisitor : EscapeVisitor {
     if operand.value == target.value && path.projectionPath.mayOverlap(with: target.path) {
       return .abort
     }
-    if operand.instruction is ReturnInst {
+    if operand.instruction is ReturnInstruction {
       // Anything which is returned cannot escape to an instruction inside the function.
       return .ignore
     }

SwiftCompilerSources/Sources/SIL/Argument.swift

@@ -212,7 +212,7 @@ public struct Phi {
 extension Phi {
   /// Return true of this phi is directly returned with no side effects between the phi and the return.
   public var isReturnValue: Bool {
-    if let singleUse = value.uses.singleUse, let ret = singleUse.instruction as? ReturnInst,
+    if let singleUse = value.uses.singleUse, let ret = singleUse.instruction as? ReturnInstruction,
        ret.parentBlock == successor {
       for inst in successor.instructions {
         if inst.mayHaveSideEffects {

SwiftCompilerSources/Sources/SIL/Function.swift

@@ -121,9 +121,9 @@ final public class Function : CustomStringConvertible, HasShortDescription, Hash
     blocks.reversed().lazy.flatMap { $0.instructions.reversed() }
   }
 
-  public var returnInstruction: ReturnInst? {
+  public var returnInstruction: ReturnInstruction? {
     for block in blocks.reversed() {
-      if let retInst = block.terminator as? ReturnInst { return retInst }
+      if let retInst = block.terminator as? ReturnInstruction { return retInst }
     }
     return nil
   }