[NFC] Apply clang-tidy fixes in Optimizer directories

Author: clementval

flang/include/flang/Optimizer/Analysis/IteratedDominanceFrontier.h

@@ -45,31 +45,31 @@ namespace fir {
 template <class NodeTy, bool IsPostDom>
 class IDFCalculator {
 public:
-  IDFCalculator(mlir::DominanceInfo &DT) : DT(DT), useLiveIn(false) {}
+  IDFCalculator(mlir::DominanceInfo &dt) : dt(dt), useLiveIn(false) {}
 
   /// Give the IDF calculator the set of blocks in which the value is
   /// defined.  This is equivalent to the set of starting blocks it should be
   /// calculating the IDF for (though later gets pruned based on liveness).
   ///
   /// Note: This set *must* live for the entire lifetime of the IDF calculator.
-  void setDefiningBlocks(const llvm::SmallPtrSetImpl<NodeTy *> &Blocks) {
-    DefBlocks = &Blocks;
+  void setDefiningBlocks(const llvm::SmallPtrSetImpl<NodeTy *> &blocks) {
+    defBlocks = &blocks;
   }
 
   /// Give the IDF calculator the set of blocks in which the value is
   /// live on entry to the block.   This is used to prune the IDF calculation to
   /// not include blocks where any phi insertion would be dead.
   ///
   /// Note: This set *must* live for the entire lifetime of the IDF calculator.
-  void setLiveInBlocks(const llvm::SmallPtrSetImpl<NodeTy *> &Blocks) {
-    LiveInBlocks = &Blocks;
+  void setLiveInBlocks(const llvm::SmallPtrSetImpl<NodeTy *> &blocks) {
+    liveInBlocks = &blocks;
     useLiveIn = true;
   }
 
   /// Reset the live-in block set to be empty, and tell the IDF
   /// calculator to not use liveness anymore.
   void resetLiveInBlocks() {
-    LiveInBlocks = nullptr;
+    liveInBlocks = nullptr;
     useLiveIn = false;
   }
 
@@ -79,13 +79,13 @@ class IDFCalculator {
   /// the file-level comment.  It performs DF->IDF pruning using the live-in
   /// set, to avoid computing the IDF for blocks where an inserted PHI node
   /// would be dead.
-  void calculate(llvm::SmallVectorImpl<NodeTy *> &IDFBlocks);
+  void calculate(llvm::SmallVectorImpl<NodeTy *> &idfBlocks);
 
 private:
-  mlir::DominanceInfo &DT;
+  mlir::DominanceInfo &dt;
   bool useLiveIn;
-  const llvm::SmallPtrSetImpl<NodeTy *> *LiveInBlocks;
-  const llvm::SmallPtrSetImpl<NodeTy *> *DefBlocks;
+  const llvm::SmallPtrSetImpl<NodeTy *> *liveInBlocks;
+  const llvm::SmallPtrSetImpl<NodeTy *> *defBlocks;
 };
 
 typedef IDFCalculator<mlir::Block, false> ForwardIDFCalculator;

flang/include/flang/Optimizer/Builder/BoxValue.h

@@ -413,7 +413,7 @@ class ExtendedValue : public details::matcher<ExtendedValue> {
   template <typename A, typename = std::enable_if_t<
                             !std::is_same_v<std::decay_t<A>, ExtendedValue>>>
   constexpr ExtendedValue(A &&a) : box{std::forward<A>(a)} {
-    if (auto b = getUnboxed()) {
+    if (const auto *b = getUnboxed()) {
       if (*b) {
         auto type = b->getType();
         if (type.template isa<fir::BoxCharType>())

flang/include/flang/Optimizer/Builder/Runtime/Assign.h

@@ -16,7 +16,7 @@ class Location;
 
 namespace fir {
 class FirOpBuilder;
-}
+} // namespace fir
 
 namespace fir::runtime {
 

flang/include/flang/Optimizer/Builder/Runtime/Derived.h

@@ -16,7 +16,7 @@ class Location;
 
 namespace fir {
 class FirOpBuilder;
-}
+} // namespace fir
 
 namespace fir::runtime {
 

flang/include/flang/Optimizer/Builder/Runtime/RTBuilder.h

@@ -34,7 +34,7 @@ struct c_double_complex_t;
 
 namespace Fortran::runtime {
 class Descriptor;
-}
+} // namespace Fortran::runtime
 
 namespace fir::runtime {
 

flang/include/flang/Optimizer/CodeGen/CodeGen.h

@@ -44,7 +44,7 @@ using LLVMIRLoweringPrinter =
 std::unique_ptr<mlir::Pass> createLLVMDialectToLLVMPass(
     llvm::raw_ostream &output,
     LLVMIRLoweringPrinter printer =
-        [](llvm::Module &M, llvm::raw_ostream &out) { M.print(out, nullptr); });
+        [](llvm::Module &m, llvm::raw_ostream &out) { m.print(out, nullptr); });
 
 // declarative passes
 #define GEN_PASS_REGISTRATION

flang/include/flang/Optimizer/Support/FIRContext.h

@@ -22,7 +22,7 @@
 
 namespace mlir {
 class ModuleOp;
-}
+}  // namespace mlir
 
 namespace fir {
 class KindMapping;

flang/lib/Optimizer/Analysis/IteratedDominanceFrontier.cpp

@@ -23,7 +23,7 @@ namespace fir {
 
 template <class NodeTy, bool IsPostDom>
 void IDFCalculator<NodeTy, IsPostDom>::calculate(
-    llvm::SmallVectorImpl<NodeTy *> &PHIBlocks) {
+    llvm::SmallVectorImpl<NodeTy *> &phiBlocks) {
   // Use a priority queue keyed on dominator tree level so that inserted nodes
   // are handled from the bottom of the dominator tree upwards. We also augment
   // the level with a DFS number to ensure that the blocks are ordered in a
@@ -35,68 +35,68 @@ void IDFCalculator<NodeTy, IsPostDom>::calculate(
       std::priority_queue<DomTreeNodePair,
                           llvm::SmallVector<DomTreeNodePair, 32>,
                           llvm::less_second>;
-  IDFPriorityQueue PQ;
+  IDFPriorityQueue pq;
 
-  if (DefBlocks->empty())
+  if (defBlocks->empty())
     return;
 
-  DT.updateDFSNumbers();
+  dt.updateDFSNumbers();
 
-  for (NodeTy *BB : *DefBlocks) {
-    if (DomTreeNode *Node = DT.getNode(BB))
-      PQ.push({Node, std::make_pair(Node->getLevel(), Node->getDFSNumIn())});
+  for (NodeTy *bb : *defBlocks) {
+    if (DomTreeNode *node = dt.getNode(bb))
+      pq.push({node, std::make_pair(node->getLevel(), node->getDFSNumIn())});
   }
 
-  llvm::SmallVector<DomTreeNode *, 32> Worklist;
-  llvm::SmallPtrSet<DomTreeNode *, 32> VisitedPQ;
-  llvm::SmallPtrSet<DomTreeNode *, 32> VisitedWorklist;
+  llvm::SmallVector<DomTreeNode *, 32> worklist;
+  llvm::SmallPtrSet<DomTreeNode *, 32> visitedpq;
+  llvm::SmallPtrSet<DomTreeNode *, 32> visitedWorklist;
 
-  while (!PQ.empty()) {
-    DomTreeNodePair RootPair = PQ.top();
-    PQ.pop();
-    DomTreeNode *Root = RootPair.first;
-    unsigned RootLevel = RootPair.second.first;
+  while (!pq.empty()) {
+    DomTreeNodePair rootPair = pq.top();
+    pq.pop();
+    DomTreeNode *root = rootPair.first;
+    unsigned rootLevel = rootPair.second.first;
 
     // Walk all dominator tree children of Root, inspecting their CFG edges with
     // targets elsewhere on the dominator tree. Only targets whose level is at
     // most Root's level are added to the iterated dominance frontier of the
     // definition set.
 
-    Worklist.clear();
-    Worklist.push_back(Root);
-    VisitedWorklist.insert(Root);
+    worklist.clear();
+    worklist.push_back(root);
+    visitedWorklist.insert(root);
 
-    while (!Worklist.empty()) {
-      DomTreeNode *Node = Worklist.pop_back_val();
-      NodeTy *BB = Node->getBlock();
+    while (!worklist.empty()) {
+      DomTreeNode *node = worklist.pop_back_val();
+      NodeTy *bb = node->getBlock();
       // Succ is the successor in the direction we are calculating IDF, so it is
       // successor for IDF, and predecessor for Reverse IDF.
-      auto DoWork = [&](NodeTy *Succ) {
-        DomTreeNode *SuccNode = DT.getNode(Succ);
+      auto doWork = [&](NodeTy *succ) {
+        DomTreeNode *succNode = dt.getNode(succ);
 
-        const unsigned SuccLevel = SuccNode->getLevel();
-        if (SuccLevel > RootLevel)
+        const unsigned succLevel = succNode->getLevel();
+        if (succLevel > rootLevel)
           return;
 
-        if (!VisitedPQ.insert(SuccNode).second)
+        if (!visitedpq.insert(succNode).second)
           return;
 
-        NodeTy *SuccBB = SuccNode->getBlock();
-        if (useLiveIn && !LiveInBlocks->count(SuccBB))
+        NodeTy *succBB = succNode->getBlock();
+        if (useLiveIn && !liveInBlocks->count(succBB))
           return;
 
-        PHIBlocks.emplace_back(SuccBB);
-        if (!DefBlocks->count(SuccBB))
-          PQ.push(std::make_pair(
-              SuccNode, std::make_pair(SuccLevel, SuccNode->getDFSNumIn())));
+        phiBlocks.emplace_back(succBB);
+        if (!defBlocks->count(succBB))
+          pq.push(std::make_pair(
+              succNode, std::make_pair(succLevel, succNode->getDFSNumIn())));
       };
 
-      for (auto *Succ : BB->getSuccessors())
-        DoWork(Succ);
+      for (auto *succ : bb->getSuccessors())
+        doWork(succ);
 
-      for (auto DomChild : *Node) {
-        if (VisitedWorklist.insert(DomChild).second)
-          Worklist.push_back(DomChild);
+      for (auto domChild : *node) {
+        if (visitedWorklist.insert(domChild).second)
+          worklist.push_back(domChild);
       }
     }
   }

flang/lib/Optimizer/Builder/Character.cpp

@@ -70,7 +70,7 @@ LLVM_ATTRIBUTE_UNUSED static bool needToMaterialize(mlir::Value str) {
 
 /// Unwrap integer constant from mlir::Value.
 static llvm::Optional<std::int64_t> getIntIfConstant(mlir::Value value) {
-  if (auto definingOp = value.getDefiningOp())
+  if (auto *definingOp = value.getDefiningOp())
     if (auto cst = mlir::dyn_cast<mlir::ConstantOp>(definingOp))
       if (auto intAttr = cst.getValue().dyn_cast<mlir::IntegerAttr>())
         return intAttr.getInt();
@@ -135,7 +135,7 @@ fir::factory::CharacterExprHelper::toExtendedValue(mlir::Value character,
     // If the embox is accessible, use its operand to avoid filling
     // the generated fir with embox/unbox.
     mlir::Value boxCharLen;
-    if (auto definingOp = character.getDefiningOp()) {
+    if (auto *definingOp = character.getDefiningOp()) {
       if (auto box = dyn_cast<fir::EmboxCharOp>(definingOp)) {
         base = box.memref();
         boxCharLen = box.len();

flang/lib/Optimizer/Builder/FIRBuilder.cpp

@@ -92,23 +92,21 @@ mlir::Value
 fir::FirOpBuilder::createRealConstant(mlir::Location loc, mlir::Type fltTy,
                                       llvm::APFloat::integerPart val) {
   auto apf = [&]() -> llvm::APFloat {
-    if (auto ty = fltTy.dyn_cast<fir::RealType>()) {
+    if (auto ty = fltTy.dyn_cast<fir::RealType>())
       return llvm::APFloat(kindMap.getFloatSemantics(ty.getFKind()), val);
-    } else {
-      if (fltTy.isF16())
-        return llvm::APFloat(llvm::APFloat::IEEEhalf(), val);
-      if (fltTy.isBF16())
-        return llvm::APFloat(llvm::APFloat::BFloat(), val);
-      if (fltTy.isF32())
-        return llvm::APFloat(llvm::APFloat::IEEEsingle(), val);
-      if (fltTy.isF64())
-        return llvm::APFloat(llvm::APFloat::IEEEdouble(), val);
-      if (fltTy.isF80())
-        return llvm::APFloat(llvm::APFloat::x87DoubleExtended(), val);
-      if (fltTy.isF128())
-        return llvm::APFloat(llvm::APFloat::IEEEquad(), val);
-      llvm_unreachable("unhandled MLIR floating-point type");
-    }
+    if (fltTy.isF16())
+      return llvm::APFloat(llvm::APFloat::IEEEhalf(), val);
+    if (fltTy.isBF16())
+      return llvm::APFloat(llvm::APFloat::BFloat(), val);
+    if (fltTy.isF32())
+      return llvm::APFloat(llvm::APFloat::IEEEsingle(), val);
+    if (fltTy.isF64())
+      return llvm::APFloat(llvm::APFloat::IEEEdouble(), val);
+    if (fltTy.isF80())
+      return llvm::APFloat(llvm::APFloat::x87DoubleExtended(), val);
+    if (fltTy.isF128())
+      return llvm::APFloat(llvm::APFloat::IEEEquad(), val);
+    llvm_unreachable("unhandled MLIR floating-point type");
   };
   return createRealConstant(loc, fltTy, apf());
 }