Update the coding style for all code moved in the previous commit.

Requested by gottesmm during review.

Update the variable naming conventions to lower-camel.

Run clang-format.

I'm sure I missed some local variables somewhere--this was a best
effort.

Author: atrick

include/swift/SIL/OptimizationRemark.h

@@ -157,9 +157,9 @@ class Emitter {
     using RemarkT = decltype(RemarkBuilder());
     // Avoid building the remark unless remarks are enabled.
     if (isEnabled<RemarkT>() || Module.getOptRecordStream()) {
-      auto R = RemarkBuilder();
-      R.setPassName(PassName);
-      emit(R);
+      auto rb = RemarkBuilder();
+      rb.setPassName(PassName);
+      emit(rb);
     }
   }
 

include/swift/SILOptimizer/Utils/BasicBlockOptUtils.h

@@ -32,21 +32,21 @@ class BasicBlockCloner;
 class SILLoop;
 class SILLoopInfo;
 
-/// Remove all instructions in the body of \p BB in safe manner by using
+/// Remove all instructions in the body of \p bb in safe manner by using
 /// undef.
-void clearBlockBody(SILBasicBlock *BB);
+void clearBlockBody(SILBasicBlock *bb);
 
 /// Handle the mechanical aspects of removing an unreachable block.
-void removeDeadBlock(SILBasicBlock *BB);
+void removeDeadBlock(SILBasicBlock *bb);
 
 /// Remove all unreachable blocks in a function.
-bool removeUnreachableBlocks(SILFunction &Fn);
+bool removeUnreachableBlocks(SILFunction &f);
 
-/// Return true if there are any users of V outside the specified block.
-inline bool isUsedOutsideOfBlock(SILValue V) {
-  auto *BB = V->getParentBlock();
-  for (auto UI : V->getUses())
-    if (UI->getUser()->getParent() != BB)
+/// Return true if there are any users of v outside the specified block.
+inline bool isUsedOutsideOfBlock(SILValue v) {
+  auto *bb = v->getParentBlock();
+  for (auto *use : v->getUses())
+    if (use->getUser()->getParent() != bb)
       return true;
   return false;
 }
@@ -57,13 +57,13 @@ inline bool isUsedOutsideOfBlock(SILValue V) {
 /// rotated once. ShouldVerify specifies whether to perform verification after
 /// the transformation.
 /// Returns true if the loop could be rotated.
-bool rotateLoop(SILLoop *L, DominanceInfo *DT, SILLoopInfo *LI,
-                bool RotateSingleBlockLoops, SILBasicBlock *UpTo,
-                bool ShouldVerify);
+bool rotateLoop(SILLoop *loop, DominanceInfo *domInfo, SILLoopInfo *loopInfo,
+                bool rotateSingleBlockLoops, SILBasicBlock *upToBB,
+                bool shouldVerify);
 
 /// Helper function to perform SSA updates in case of jump threading.
-void updateSSAAfterCloning(BasicBlockCloner &Cloner, SILBasicBlock *SrcBB,
-                           SILBasicBlock *DestBB);
+void updateSSAAfterCloning(BasicBlockCloner &cloner, SILBasicBlock *srcBB,
+                           SILBasicBlock *destBB);
 
 /// Clone a single basic block and any required successor edges within the same
 /// function.
@@ -95,14 +95,14 @@ class BasicBlockCloner : public SILCloner<BasicBlockCloner> {
 
   /// Clone the given branch instruction's destination block, splitting
   /// its successors, and rewrite the branch instruction.
-  void cloneBranchTarget(BranchInst *BI) {
-    assert(origBB == BI->getDestBB());
+  void cloneBranchTarget(BranchInst *bi) {
+    assert(origBB == bi->getDestBB());
 
-    cloneBlock(/*insertAfter*/BI->getParent());
+    cloneBlock(/*insertAfter*/ bi->getParent());
 
-    SILBuilderWithScope(BI).createBranch(BI->getLoc(), getNewBB(),
-                                         BI->getArgs());
-    BI->eraseFromParent();
+    SILBuilderWithScope(bi).createBranch(bi->getLoc(), getNewBB(),
+                                         bi->getArgs());
+    bi->eraseFromParent();
   }
 
   /// Get the newly cloned block corresponding to `origBB`.
@@ -112,27 +112,27 @@ class BasicBlockCloner : public SILCloner<BasicBlockCloner> {
 
   /// Call this after processing all instructions to fix the control flow
   /// graph. The branch cloner may have left critical edges.
-  bool splitCriticalEdges(DominanceInfo *DT, SILLoopInfo *LI);
+  bool splitCriticalEdges(DominanceInfo *domInfo, SILLoopInfo *loopInfo);
 
 protected:
   // MARK: CRTP overrides.
 
   /// Override getMappedValue to allow values defined outside the block to be
   /// cloned to be reused in the newly cloned block.
-  SILValue getMappedValue(SILValue Value) {
-    if (auto SI = Value->getDefiningInstruction()) {
-      if (!isBlockCloned(SI->getParent()))
-        return Value;
-    } else if (auto BBArg = dyn_cast<SILArgument>(Value)) {
-      if (!isBlockCloned(BBArg->getParent()))
-        return Value;
+  SILValue getMappedValue(SILValue value) {
+    if (auto si = value->getDefiningInstruction()) {
+      if (!isBlockCloned(si->getParent()))
+        return value;
+    } else if (auto bbArg = dyn_cast<SILArgument>(value)) {
+      if (!isBlockCloned(bbArg->getParent()))
+        return value;
     } else {
-      assert(isa<SILUndef>(Value) && "Unexpected Value kind");
-      return Value;
+      assert(isa<SILUndef>(value) && "Unexpected Value kind");
+      return value;
     }
     // `value` is not defined outside the cloned block, so consult the cloner's
     // map of cloned values.
-    return SuperTy::getMappedValue(Value);
+    return SuperTy::getMappedValue(value);
   }
 
   void mapValue(SILValue origValue, SILValue mappedValue) {
@@ -150,26 +150,26 @@ class CloneCollector {
   typedef std::function<bool (SILInstruction *)> FilterType;
 
 private:
-  FilterType Filter;
+  FilterType filter;
 
   // Pairs of collected instructions; (new, old)
-  llvm::SmallVector<value_type, 4> InstructionPairs;
+  llvm::SmallVector<value_type, 4> instructionpairs;
 
-  void collect(SILInstruction *Old, SILInstruction *New) {
-    if (Filter(New))
-      InstructionPairs.push_back(std::make_pair(New, Old));
+  void collect(SILInstruction *oldI, SILInstruction *newI) {
+    if (filter(newI))
+      instructionpairs.push_back(std::make_pair(newI, oldI));
   }
 
 public:
-  CloneCollector(FilterType Filter) : Filter(Filter) {}
+  CloneCollector(FilterType filter) : filter(filter) {}
 
   CallbackType getCallback() {
     return std::bind(&CloneCollector::collect, this, std::placeholders::_1,
                      std::placeholders::_2);
   }
 
   llvm::SmallVectorImpl<value_type> &getInstructionPairs() {
-    return InstructionPairs;
+    return instructionpairs;
   }
 };
 
@@ -220,37 +220,37 @@ class StaticInitCloner : public SILCloner<StaticInitCloner> {
   friend class SILCloner<StaticInitCloner>;
 
   /// The number of not yet cloned operands for each instruction.
-  llvm::DenseMap<SILInstruction *, int> NumOpsToClone;
+  llvm::DenseMap<SILInstruction *, int> numOpsToClone;
 
   /// List of instructions for which all operands are already cloned (or which
   /// don't have any operands).
-  llvm::SmallVector<SILInstruction *, 8> ReadyToClone;
+  llvm::SmallVector<SILInstruction *, 8> readyToClone;
 
 public:
-  StaticInitCloner(SILGlobalVariable *GVar)
-      : SILCloner<StaticInitCloner>(GVar) { }
+  StaticInitCloner(SILGlobalVariable *gVar)
+      : SILCloner<StaticInitCloner>(gVar) {}
 
   /// Add \p InitVal and all its operands (transitively) for cloning.
   ///
   /// Note: all init values must are added, before calling clone().
-  void add(SILInstruction *InitVal);
+  void add(SILInstruction *initVal);
 
   /// Clone \p InitVal and all its operands into the initializer of the
   /// SILGlobalVariable.
   ///
   /// \return Returns the cloned instruction in the SILGlobalVariable.
-  SingleValueInstruction *clone(SingleValueInstruction *InitVal);
+  SingleValueInstruction *clone(SingleValueInstruction *initVal);
 
   /// Convenience function to clone a single \p InitVal.
-  static void appendToInitializer(SILGlobalVariable *GVar,
-                                  SingleValueInstruction *InitVal) {
-    StaticInitCloner Cloner(GVar);
-    Cloner.add(InitVal);
-    Cloner.clone(InitVal);
+  static void appendToInitializer(SILGlobalVariable *gVar,
+                                  SingleValueInstruction *initVal) {
+    StaticInitCloner cloner(gVar);
+    cloner.add(initVal);
+    cloner.clone(initVal);
   }
 
 protected:
-  SILLocation remapLocation(SILLocation Loc) {
+  SILLocation remapLocation(SILLocation loc) {
     return ArtificialUnreachableLocation();
   }
 };

include/swift/SILOptimizer/Utils/CFGOptUtils.h

@@ -39,25 +39,25 @@ class SILLoopInfo;
 /// Adds a new argument to an edge between a branch and a destination
 /// block.
 ///
-/// \param Branch The terminator to add the argument to.
-/// \param Dest The destination block of the edge.
-/// \param Val The value to the arguments of the branch.
+/// \param branch The terminator to add the argument to.
+/// \param dest The destination block of the edge.
+/// \param val The value to the arguments of the branch.
 /// \return The created branch. The old branch is deleted.
 /// The argument is appended at the end of the argument tuple.
-TermInst *addNewEdgeValueToBranch(TermInst *Branch, SILBasicBlock *Dest,
-                                  SILValue Val);
+TermInst *addNewEdgeValueToBranch(TermInst *branch, SILBasicBlock *dest,
+                                  SILValue val);
 
 /// Changes the edge value between a branch and destination basic block
 /// at the specified index. Changes all edges from \p Branch to \p Dest to carry
 /// the value.
 ///
-/// \param Branch The branch to modify.
-/// \param Dest The destination of the edge.
-/// \param Idx The index of the argument to modify.
-/// \param Val The new value to use.
+/// \param branch The branch to modify.
+/// \param dest The destination of the edge.
+/// \param idx The index of the argument to modify.
+/// \param val The new value to use.
 /// \return The new branch. Deletes the old one.
-TermInst *changeEdgeValue(TermInst *Branch, SILBasicBlock *Dest, size_t Idx,
-                          SILValue Val);
+TermInst *changeEdgeValue(TermInst *branch, SILBasicBlock *dest, size_t idx,
+                          SILValue val);
 
 /// Deletes the edge value between a branch and a destination basic block at the
 /// specified index. Asserts internally that the argument along the edge does
@@ -73,76 +73,80 @@ void erasePhiArgument(SILBasicBlock *block, unsigned argIndex);
 
 /// Replace a branch target.
 ///
-/// \param T The terminating instruction to modify.
-/// \param OldDest The successor block that will be replaced.
-/// \param NewDest The new target block.
-/// \param PreserveArgs If set, preserve arguments on the replaced edge.
-void replaceBranchTarget(TermInst *T, SILBasicBlock *OldDest,
-                         SILBasicBlock *NewDest, bool PreserveArgs);
+/// \param t The terminating instruction to modify.
+/// \param oldDest The successor block that will be replaced.
+/// \param newDest The new target block.
+/// \param preserveArgs If set, preserve arguments on the replaced edge.
+void replaceBranchTarget(TermInst *t, SILBasicBlock *oldDest,
+                         SILBasicBlock *newDest, bool preserveArgs);
 
 /// Check if the edge from the terminator is critical.
-bool isCriticalEdge(TermInst *T, unsigned EdgeIdx);
+bool isCriticalEdge(TermInst *t, unsigned edgeIdx);
 
 /// Splits the edge from terminator if it is critical.
 ///
 /// Updates dominance information and loop information if not null.
 /// Returns the newly created basic block on success or nullptr otherwise (if
 /// the edge was not critical).
-SILBasicBlock *splitCriticalEdge(TermInst *T, unsigned EdgeIdx,
-                                 DominanceInfo *DT = nullptr,
-                                 SILLoopInfo *LI = nullptr);
+SILBasicBlock *splitCriticalEdge(TermInst *, unsigned edgeIdx,
+                                 DominanceInfo *domInfo = nullptr,
+                                 SILLoopInfo *loopInfo = nullptr);
 
 /// Splits the critical edges between from and to. This code assumes there is
 /// exactly one edge between the two basic blocks. It will return the wrong
 /// result if there are multiple edges and will assert if there are no edges in
 /// between the two blocks.
 ///
 /// Updates dominance information and loop information if not null.
-SILBasicBlock *splitIfCriticalEdge(SILBasicBlock *From, SILBasicBlock *To,
-                                   DominanceInfo *DT = nullptr,
-                                   SILLoopInfo *LI = nullptr);
+SILBasicBlock *splitIfCriticalEdge(SILBasicBlock *from, SILBasicBlock *to,
+                                   DominanceInfo *domInfo = nullptr,
+                                   SILLoopInfo *loopInfo = nullptr);
 
 /// Splits all critical edges originating from `fromBB`.
-bool splitCriticalEdgesFrom(SILBasicBlock *fromBB, DominanceInfo *DT = nullptr,
-                            SILLoopInfo *LI = nullptr);
+bool splitCriticalEdgesFrom(SILBasicBlock *fromBB,
+                            DominanceInfo *domInfo = nullptr,
+                            SILLoopInfo *loopInfo = nullptr);
 
 /// Splits the edges between two basic blocks.
 ///
 /// Updates dominance information and loop information if not null.
-void splitEdgesFromTo(SILBasicBlock *From, SILBasicBlock *To,
-                      DominanceInfo *DT = nullptr, SILLoopInfo *LI = nullptr);
+void splitEdgesFromTo(SILBasicBlock *from, SILBasicBlock *to,
+                      DominanceInfo *domInfo = nullptr,
+                      SILLoopInfo *loopInfo = nullptr);
 
 /// Splits the basic block before the instruction with an unconditional branch
 /// and updates the dominator tree and loop info. Returns the new, branched to
 /// block that contains the end of \p SplitBeforeInst's block.
-SILBasicBlock *splitBasicBlockAndBranch(SILBuilder &B,
-                                        SILInstruction *SplitBeforeInst,
-                                        DominanceInfo *DT, SILLoopInfo *LI);
+SILBasicBlock *splitBasicBlockAndBranch(SILBuilder &builder,
+                                        SILInstruction *splitBeforeInst,
+                                        DominanceInfo *domInfo,
+                                        SILLoopInfo *loopInfo);
 
 /// Return true if the function has a critical edge, false otherwise.
-bool hasCriticalEdges(SILFunction &F, bool OnlyNonCondBr);
+bool hasCriticalEdges(SILFunction &f, bool onlyNonCondBr);
 
 /// Split all critical edges in the given function, updating the
 /// dominator tree and loop information if they are provided.
 ///
 /// FIXME: This should never be called! Fix passes that create critical edges.
-bool splitAllCriticalEdges(SILFunction &F, DominanceInfo *DT, SILLoopInfo *LI);
+bool splitAllCriticalEdges(SILFunction &F, DominanceInfo *domInfo,
+                           SILLoopInfo *loopInfo);
 
 /// Split all cond_br critical edges with non-trivial arguments in the
 /// function updating the dominator tree and loop information (if they are not
 /// set to null).
 ///
 /// A current invariant of Ownership SIL is that cond_br can only have critical
 /// edges with non-trivial arguments. This simplifies computation.
-bool splitAllCondBrCriticalEdgesWithNonTrivialArgs(SILFunction &Fn,
-                                                   DominanceInfo *DT,
-                                                   SILLoopInfo *LI);
+bool splitAllCondBrCriticalEdgesWithNonTrivialArgs(SILFunction &fn,
+                                                   DominanceInfo *domInfo,
+                                                   SILLoopInfo *loopInfo);
 
 /// Merge a basic block ending in a branch with its successor
 /// if possible. If dominance information or loop info is non null update it.
 /// Return true if block was merged.
-bool mergeBasicBlockWithSuccessor(SILBasicBlock *BB, DominanceInfo *DT,
-                                  SILLoopInfo *LI);
+bool mergeBasicBlockWithSuccessor(SILBasicBlock *bb, DominanceInfo *domInfo,
+                                  SILLoopInfo *loopInfo);
 
 /// Merge basic blocks in the given function by eliminating all unconditional
 /// branches to single-predecessor branch targets.
@@ -152,7 +156,7 @@ bool mergeBasicBlockWithSuccessor(SILBasicBlock *BB, DominanceInfo *DT,
 /// is not done on-the-fly after splitting blocks because merging is linear in
 /// the number of instructions, so interleaved merging and splitting is
 /// quadratic.
-bool mergeBasicBlocks(SILFunction *F);
+bool mergeBasicBlocks(SILFunction *f);
 
 /// Given a list of \p UserBlocks and a list of \p DefBlocks, find a set of
 /// blocks that together with \p UserBlocks joint-postdominate \p
@@ -181,11 +185,11 @@ bool mergeBasicBlocks(SILFunction *F);
 ///
 /// *NOTE* This completion may not be unique.
 void completeJointPostDominanceSet(
-    ArrayRef<SILBasicBlock *> UserBlocks, ArrayRef<SILBasicBlock *> DefBlocks,
-    llvm::SmallVectorImpl<SILBasicBlock *> &Completion);
+    ArrayRef<SILBasicBlock *> userBlocks, ArrayRef<SILBasicBlock *> defBlocks,
+    llvm::SmallVectorImpl<SILBasicBlock *> &completion);
 
-/// Return true if we conservatively find all BB's that are non-failure exit
-/// basic blocks and place them in \p BBs. If we find something we don't
+/// Return true if we conservatively find all bb's that are non-failure exit
+/// basic blocks and place them in \p bbs. If we find something we don't
 /// understand, bail.
 ///
 /// A non-failure exit BB is defined as a BB that:
@@ -202,8 +206,8 @@ void completeJointPostDominanceSet(
 /// implying in most cases this will be one element.
 ///
 /// TODO:
-bool findAllNonFailureExitBBs(SILFunction *F,
-                              llvm::TinyPtrVector<SILBasicBlock *> &BBs);
+bool findAllNonFailureExitBBs(SILFunction *f,
+                              llvm::TinyPtrVector<SILBasicBlock *> &bbs);
 
 } // end namespace swift