Minor cleanup to PartialInlining logic.

[tulloch]

Summary

Two minor changes:

• Replaces a while loop over basic blocks with that unconditionally increments the counter with the equivalent for loop. This makes the scope of the loop variable slightly clearer (given this is a ~90 line function).
• Replace an instance of std::vector<User *> with std::vector<User*> to be conformant with style guide and consistent with surrounding code.

[chandlerc]

Sorry we never got to this.

If you want to pursue it, please update and add me back as a reviewer. Also, you'll want to use clang-format to fix spacing.

lib/Transforms/IPO/PartialInlining.cpp

Function* PartialInliner::unswitchFunction(Function* F) {
   
   // Special hackery is needed with PHI nodes that have inputs from more than
   // one extracted block.  For simplicity, just split the PHIs into a two-level
   // sequence of PHIs, some of which will go in the extracted region, and some
   // of which will go outside.
   BasicBlock* preReturn = newReturnBlock;
   newReturnBlock = newReturnBlock->splitBasicBlock(
                                               newReturnBlock->getFirstNonPHI());
-  BasicBlock::iterator I = preReturn->begin();
   BasicBlock::iterator Ins = newReturnBlock->begin();
-  while (I != preReturn->end()) {
+  for (BasicBlock::iterator I = preReturn->begin(); I != preReturn->end(); ++I) {
     PHINode* OldPhi = dyn_cast<PHINode>(I);
     if (!OldPhi) break;
     
     PHINode* retPhi = PHINode::Create(OldPhi->getType(), 2, "", Ins);
     OldPhi->replaceAllUsesWith(retPhi);
     Ins = newReturnBlock->getFirstNonPHI();
     
     retPhi->addIncoming(I, preReturn);
     retPhi->addIncoming(OldPhi->getIncomingValueForBlock(newEntryBlock),
                         newEntryBlock);
     OldPhi->removeIncomingValue(newEntryBlock);
-    
-    ++I;
   }
   newEntryBlock->getTerminator()->replaceUsesOfWith(preReturn, newReturnBlock);
   
   // Gather up the blocks that we're going to extract.
   std::vector<BasicBlock*> toExtract;
   toExtract.push_back(newNonReturnBlock);
   for (Function::iterator FI = duplicateFunction->begin(),
        FE = duplicateFunction->end(); FI != FE; ++FI)
     if (&*FI != newEntryBlock && &*FI != newReturnBlock &&
         &*FI != newNonReturnBlock)
       toExtract.push_back(FI);
       
   // The CodeExtractor needs a dominator tree.
   DominatorTree DT;
   DT.recalculate(*duplicateFunction);
 
   // Extract the body of the if.
   Function* extractedFunction
     = CodeExtractor(toExtract, &DT).extractCodeRegion();
   
   InlineFunctionInfo IFI;
   
   // Inline the top-level if test into all callers.
-  std::vector<User *> Users(duplicateFunction->user_begin(),
-                            duplicateFunction->user_end());
+  std::vector<User*> Users(duplicateFunction->user_begin(),
   for (std::vector<User*>::iterator UI = Users.begin(), UE = Users.end();
        UI != UE; ++UI)
     if (CallInst *CI = dyn_cast<CallInst>(*UI))
       InlineFunction(CI, IFI);
     else if (InvokeInst *II = dyn_cast<InvokeInst>(*UI))
       InlineFunction(II, IFI);
   
   // Ditch the duplicate, since we're done with it, and rewrite all remaining