Rename SILBuilder::emitDestroyAddr => SILBuilder::emitDestroyAddrAndFold.

Now it matches SILBuilder::emit{StrongRelease,ReleaseValue}AndFold which perform
the same operation but on object types.

Swift SVN r27806

include/swift/SIL/SILBuilder.h

@@ -1140,7 +1140,7 @@ public:
   /// Try to fold a destroy_addr operation into the previous instructions, or
   /// generate an explicit one if that fails.  If this inserts a new
   /// instruction, it returns it, otherwise it returns null.
-  DestroyAddrInst *emitDestroyAddr(SILLocation Loc, SILValue Operand);
+  DestroyAddrInst *emitDestroyAddrAndFold(SILLocation Loc, SILValue Operand);
 
   /// Perform a strong_release instruction at the current location, attempting
   /// to fold it locally into nearby retain instructions or emitting an explicit

lib/SIL/SILBuilder.cpp

@@ -92,7 +92,8 @@ SILBasicBlock *SILBuilder::splitBlockForFallthrough() {
 /// emitDestroyAddr - Try to fold a destroy_addr operation into the previous
 /// instructions, or generate an explicit one if that fails.  If this inserts a
 /// new instruction, it returns it, otherwise it returns null.
-DestroyAddrInst *SILBuilder::emitDestroyAddr(SILLocation Loc, SILValue Operand){
+DestroyAddrInst *SILBuilder::emitDestroyAddrAndFold(SILLocation Loc,
+                                                    SILValue Operand) {
   // Check to see if the instruction immediately before the insertion point is a
   // copy_addr from the specified operand.  If so, we can fold this into the
   // copy_addr as a take.

lib/SIL/TypeLowering.cpp

@@ -887,12 +887,12 @@ namespace {
 
     void emitDestroyAddress(SILBuilder &B, SILLocation loc,
                             SILValue addr) const override {
-      B.emitDestroyAddr(loc, addr);
+      B.emitDestroyAddrAndFold(loc, addr);
     }
 
     void emitDestroyRValue(SILBuilder &B, SILLocation loc,
                            SILValue value) const override {
-      B.emitDestroyAddr(loc, value);
+      B.emitDestroyAddrAndFold(loc, value);
     }
 
     void emitRetainValue(SILBuilder &B, SILLocation loc,

lib/SILGen/SILGenBuiltin.cpp

@@ -220,7 +220,7 @@ static ManagedValue emitBuiltinDestroy(SILGenFunction &gen,
   
   // Destroy the value indirectly. Canonicalization will promote to loads
   // and releases if appropriate.
-  gen.B.emitDestroyAddr(loc, addr);
+  gen.B.emitDestroyAddrAndFold(loc, addr);
   
   return ManagedValue::forUnmanaged(gen.emitEmptyTuple(loc));
 }

lib/SILGen/SILGenDecl.cpp

@@ -218,7 +218,7 @@ public:
 
   void emit(SILGenFunction &gen, CleanupLocation l) override {
     if (v.getType().isAddress())
-      gen.B.emitDestroyAddr(l, v);
+      gen.B.emitDestroyAddrAndFold(l, v);
     else
       gen.B.emitReleaseValueOperation(l, v);
   }
@@ -1193,7 +1193,7 @@ void SILGenFunction::destroyLocalVariable(SILLocation silLoc, VarDecl *vd) {
   if (!Val.getType().isAddress())
     B.emitReleaseValueOperation(silLoc, Val);
   else
-    B.emitDestroyAddr(silLoc, Val);
+    B.emitDestroyAddrAndFold(silLoc, Val);
 }
 
 void SILGenFunction::deallocateUninitializedLocalVariable(SILLocation silLoc,

lib/SILGen/SILGenDestructor.cpp

@@ -134,7 +134,7 @@ void SILGenFunction::emitClassMemberDestruction(SILValue selfValue,
     if (!ti.isTrivial()) {
       SILValue addr = B.createRefElementAddr(cleanupLoc, selfValue, vd,
                                          ti.getLoweredType().getAddressType());
-      B.emitDestroyAddr(cleanupLoc, addr);
+      B.emitDestroyAddrAndFold(cleanupLoc, addr);
     }
   }
 }

lib/SILPasses/AllocBoxToStack.cpp

@@ -433,7 +433,7 @@ static bool rewriteAllocBoxAsAllocStack(AllocBoxInst *ABI,
         continue;
 
       SILBuilderWithScope<1> BuildDestroy(LastRelease);
-      BuildDestroy.emitDestroyAddr(Loc, PointerResult);
+      BuildDestroy.emitDestroyAddrAndFold(Loc, PointerResult);
     }
   }
 

lib/SILPasses/DefiniteInitialization.cpp

@@ -1581,7 +1581,7 @@ SILValue LifetimeChecker::handleConditionalInitAssign() {
       // Emit a destroy_addr in the taken block.
       B.setInsertionPoint(TrueBB->begin());
       SILValue EltPtr = TheMemory.emitElementAddress(Elt, Loc, B);
-      if (auto *DA = B.emitDestroyAddr(Loc, EltPtr))
+      if (auto *DA = B.emitDestroyAddrAndFold(Loc, EltPtr))
         Releases.push_back(DA);
     }
     
@@ -1654,7 +1654,7 @@ handleConditionalDestroys(SILValue ControlVariableAddr) {
         // destroy its value at releases position.
         B.setInsertionPoint(Release);
         SILValue EltPtr = TheMemory.emitElementAddress(Elt, Loc, B);
-        if (auto *DA = B.emitDestroyAddr(Release->getLoc(), EltPtr))
+        if (auto *DA = B.emitDestroyAddrAndFold(Release->getLoc(), EltPtr))
           Releases.push_back(DA);
         continue;
       }
@@ -1701,7 +1701,7 @@ handleConditionalDestroys(SILValue ControlVariableAddr) {
       // Set up the conditional destroy block.
       B.setInsertionPoint(CondDestroyBlock->begin());
       SILValue EltPtr = TheMemory.emitElementAddress(Elt, Loc, B);
-      if (auto *DA = B.emitDestroyAddr(Loc, EltPtr))
+      if (auto *DA = B.emitDestroyAddrAndFold(Loc, EltPtr))
         Releases.push_back(DA);
     }
     

lib/SILPasses/Utils/Local.cpp

@@ -632,7 +632,7 @@ void swift::releasePartialApplyCapturedArg(SILBuilder &Builder, SILLocation Loc,
     return;
   }
 
-  SILInstruction *NewInst = Builder.emitDestroyAddr(Loc, Arg);
+  SILInstruction *NewInst = Builder.emitDestroyAddrAndFold(Loc, Arg);
   Callbacks.CreatedNewInst(NewInst);
 }