[SIL-opaque] rename initializeComposingUse

Author: atrick

lib/SILOptimizer/Mandatory/AddressLowering.cpp

@@ -1239,7 +1239,7 @@ class AddressMaterialization {
     return storage.storageAddress;
   }
 
-  void initializeOperand(Operand *operand);
+  void initializeComposingUse(Operand *operand);
 
   SILValue recursivelyMaterializeStorage(ValueStorage &storage,
                                          bool intoPhiOperand);
@@ -1269,7 +1269,7 @@ class AddressMaterialization {
 ///
 /// If the operand projects into its use, then the memory was already
 /// initialized when visiting the use.
-void AddressMaterialization::initializeOperand(Operand *operand) {
+void AddressMaterialization::initializeComposingUse(Operand *operand) {
   SILValue def = operand->get();
   if (def->getType().isAddressOnly(*pass.function)) {
     ValueStorage &storage = pass.valueStorageMap.getStorage(def);
@@ -2903,7 +2903,7 @@ class DefRewriter : SILInstructionVisitor<DefRewriter> {
   void visitEnumInst(EnumInst *enumInst) {
     if (enumInst->hasOperand()) {
       // Handle operands here because loadable operands must also be copied.
-      addrMat.initializeOperand(&enumInst->getOperandRef());
+      addrMat.initializeComposingUse(&enumInst->getOperandRef());
     }
     SILValue enumAddr = addrMat.materializeAddress(enumInst);
 
@@ -2916,7 +2916,7 @@ class DefRewriter : SILInstructionVisitor<DefRewriter> {
       InitExistentialValueInst *initExistentialValue) {
 
     // Initialize memory for the operand which may be opaque or loadable.
-    addrMat.initializeOperand(&initExistentialValue->getOperandRef());
+    addrMat.initializeComposingUse(&initExistentialValue->getOperandRef());
   }
 
   // Project an opaque value out of a box-type existential.
@@ -2948,15 +2948,15 @@ class DefRewriter : SILInstructionVisitor<DefRewriter> {
     // For each element, initialize the operand's memory. Some struct elements
     // may be loadable types.
     for (Operand &operand : structInst->getAllOperands())
-      addrMat.initializeOperand(&operand);
+      addrMat.initializeComposingUse(&operand);
   }
 
   // Define an opaque tuple.
   void visitTupleInst(TupleInst *tupleInst) {
     // For each element, initialize the operand's memory. Some tuple elements
     // may be loadable types.
     for (Operand &operand : tupleInst->getAllOperands())
-      addrMat.initializeOperand(&operand);
+      addrMat.initializeComposingUse(&operand);
   }
 };
 } // end anonymous namespace