Fix clang-tidy issues in mlir/ (NFC)

[mehdi_amini]

Fix build

[mehdi_amini]

More build fix

[mehdi_amini]

More clang-tidy fix (to be reviewed, WIP)

[mehdi_amini]

Some minor tuning on the format post-tidy.

mlir/examples/toy/Ch1/parser/AST.cpp

 }
 
 /// Helper to print recursively a literal. This handles nested array like:
 ///    [ [ 1, 2 ], [ 3, 4 ] ]
 /// We print out such array with the dimensions spelled out at every level:
 ///    <2,2>[<2>[ 1, 2 ], <2>[ 3, 4 ] ]
 void printLitHelper(ExprAST *litOrNum) {
   // Inside a literal expression we can have either a number or another literal
-  if (auto num = llvm::dyn_cast<NumberExprAST>(litOrNum)) {
+  if (auto *num = llvm::dyn_cast<NumberExprAST>(litOrNum)) {
     llvm::errs() << num->getValue();
     return;
   }
   auto *literal = llvm::cast<LiteralExprAST>(litOrNum);
 
   // Print the dimension for this literal first
   llvm::errs() << "<";
   llvm::interleaveComma(literal->getDims(), llvm::errs());

mlir/examples/toy/Ch1/toyc.cpp

 namespace cl = llvm::cl;
 
 static cl::opt<std::string> inputFilename(cl::Positional,
                                           cl::desc("<input toy file>"),
                                           cl::init("-"),
                                           cl::value_desc("filename"));
 namespace {
 enum Action { None, DumpAST };
-}
+} // namespace
 
 static cl::opt<enum Action>
     emitAction("emit", cl::desc("Select the kind of output desired"),
                cl::values(clEnumValN(DumpAST, "ast", "output the AST dump")));
 
 /// Returns a Toy AST resulting from parsing the file or a nullptr on error.
 std::unique_ptr<toy::ModuleAST> parseInputFile(llvm::StringRef filename) {
   llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> fileOrErr =

mlir/examples/toy/Ch2/mlir/MLIRGen.cpp

public:
 
   /// Public API: convert the AST for a Toy module (source file) to an MLIR
   /// Module operation.
   mlir::ModuleOp mlirGen(ModuleAST &moduleAST) {
     // We create an empty MLIR module and codegen functions one at a time and
     // add them to the module.
     theModule = mlir::ModuleOp::create(builder.getUnknownLoc());
 
-    for (FunctionAST &F : moduleAST) {
-      auto func = mlirGen(F);
+    for (FunctionAST &f : moduleAST) {
+      auto func = mlirGen(f);
       if (!func)
         return nullptr;
       theModule.push_back(func);
     }
 
     // Verify the module after we have finished constructing it, this will check
     // the structural properties of the IR and invoke any specific verifiers we
     // have on the Toy operations.
private:
 
   /// Create the prototype for an MLIR function with as many arguments as the
   /// provided Toy AST prototype.
   mlir::FuncOp mlirGen(PrototypeAST &proto) {
     auto location = loc(proto.loc());
 
     // This is a generic function, the return type will be inferred later.
     // Arguments type are uniformly unranked tensors.
-    llvm::SmallVector<mlir::Type, 4> arg_types(proto.getArgs().size(),
-                                               getType(VarType{}));
-    auto func_type = builder.getFunctionType(arg_types, llvm::None);
-    return mlir::FuncOp::create(location, proto.getName(), func_type);
+    llvm::SmallVector<mlir::Type, 4> argTypes(proto.getArgs().size(),
+    auto funcType = builder.getFunctionType(argTypes, llvm::None);
+    return mlir::FuncOp::create(location, proto.getName(), funcType);
   }
 
   /// Emit a new function and add it to the MLIR module.
   mlir::FuncOp mlirGen(FunctionAST &funcAST) {
     // Create a scope in the symbol table to hold variable declarations.
-    ScopedHashTableScope<llvm::StringRef, mlir::Value> var_scope(symbolTable);
+    ScopedHashTableScope<llvm::StringRef, mlir::Value> varScope(symbolTable);
 
     // Create an MLIR function for the given prototype.
     mlir::FuncOp function(mlirGen(*funcAST.getProto()));
     if (!function)
       return nullptr;
 
     // Let's start the body of the function now!
     // In MLIR the entry block of the function is special: it must have the same
mlir::Value mlirGen(ExprAST &expr) {
     }
   }
 
   /// Handle a variable declaration, we'll codegen the expression that forms the
   /// initializer and record the value in the symbol table before returning it.
   /// Future expressions will be able to reference this variable through symbol
   /// table lookup.
   mlir::Value mlirGen(VarDeclExprAST &vardecl) {
-    auto init = vardecl.getInitVal();
+    auto *init = vardecl.getInitVal();
     if (!init) {
       emitError(loc(vardecl.loc()),
                 "missing initializer in variable declaration");
       return nullptr;
     }
 
     mlir::Value value = mlirGen(*init);
     if (!value)
mlir::Value mlirGen(VarDeclExprAST &vardecl) {
     // Register the value in the symbol table.
     if (failed(declare(vardecl.getName(), value)))
       return nullptr;
     return value;
   }
 
   /// Codegen a list of expression, return failure if one of them hit an error.
   mlir::LogicalResult mlirGen(ExprASTList &blockAST) {
-    ScopedHashTableScope<StringRef, mlir::Value> var_scope(symbolTable);
+    ScopedHashTableScope<StringRef, mlir::Value> varScope(symbolTable);
     for (auto &expr : blockAST) {
       // Specific handling for variable declarations, return statement, and
       // print. These can only appear in block list and not in nested
       // expressions.
       if (auto *vardecl = dyn_cast<VarDeclExprAST>(expr.get())) {
         if (!mlirGen(*vardecl))
           return mlir::failure();
         continue;

mlir/examples/toy/Ch2/parser/AST.cpp

 }
 
 /// Helper to print recursively a literal. This handles nested array like:
 ///    [ [ 1, 2 ], [ 3, 4 ] ]
 /// We print out such array with the dimensions spelled out at every level:
 ///    <2,2>[<2>[ 1, 2 ], <2>[ 3, 4 ] ]
 void printLitHelper(ExprAST *litOrNum) {
   // Inside a literal expression we can have either a number or another literal
-  if (auto num = llvm::dyn_cast<NumberExprAST>(litOrNum)) {
+  if (auto *num = llvm::dyn_cast<NumberExprAST>(litOrNum)) {
     llvm::errs() << num->getValue();
     return;
   }
   auto *literal = llvm::cast<LiteralExprAST>(litOrNum);
 
   // Print the dimension for this literal first
   llvm::errs() << "<";
   llvm::interleaveComma(literal->getDims(), llvm::errs());

mlir/examples/toy/Ch2/toyc.cpp

 
 static cl::opt<std::string> inputFilename(cl::Positional,
                                           cl::desc("<input toy file>"),
                                           cl::init("-"),
                                           cl::value_desc("filename"));
 
 namespace {
 enum InputType { Toy, MLIR };
-}
+} // namespace
 static cl::opt<enum InputType> inputType(
     "x", cl::init(Toy), cl::desc("Decided the kind of output desired"),
     cl::values(clEnumValN(Toy, "toy", "load the input file as a Toy source.")),
     cl::values(clEnumValN(MLIR, "mlir",
                           "load the input file as an MLIR file")));
 
 namespace {
 enum Action { None, DumpAST, DumpMLIR };
-}
+} // namespace
 static cl::opt<enum Action> emitAction(
     "emit", cl::desc("Select the kind of output desired"),
     cl::values(clEnumValN(DumpAST, "ast", "output the AST dump")),
     cl::values(clEnumValN(DumpMLIR, "mlir", "output the MLIR dump")));
 
 /// Returns a Toy AST resulting from parsing the file or a nullptr on error.
 std::unique_ptr<toy::ModuleAST> parseInputFile(llvm::StringRef filename) {
   llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> fileOrErr =
if (inputType != InputType::MLIR &&
 
     module->dump();
     return 0;
   }
 
   // Otherwise, the input is '.mlir'.
   llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> fileOrErr =
       llvm::MemoryBuffer::getFileOrSTDIN(inputFilename);
-  if (std::error_code EC = fileOrErr.getError()) {
-    llvm::errs() << "Could not open input file: " << EC.message() << "\n";
+  if (std::error_code ec = fileOrErr.getError()) {
+    llvm::errs() << "Could not open input file: " << ec.message() << "\n";
     return -1;
   }
 
   // Parse the input mlir.
   llvm::SourceMgr sourceMgr;
   sourceMgr.AddNewSourceBuffer(std::move(*fileOrErr), llvm::SMLoc());
   mlir::OwningModuleRef module = mlir::parseSourceFile(sourceMgr, &context);
   if (!module) {

mlir/examples/toy/Ch3/mlir/MLIRGen.cpp

public:
 
   /// Public API: convert the AST for a Toy module (source file) to an MLIR
   /// Module operation.
   mlir::ModuleOp mlirGen(ModuleAST &moduleAST) {
     // We create an empty MLIR module and codegen functions one at a time and
     // add them to the module.
     theModule = mlir::ModuleOp::create(builder.getUnknownLoc());
 
-    for (FunctionAST &F : moduleAST) {
-      auto func = mlirGen(F);
+    for (FunctionAST &f : moduleAST) {
+      auto func = mlirGen(f);
       if (!func)
         return nullptr;
       theModule.push_back(func);
     }
 
     // Verify the module after we have finished constructing it, this will check
     // the structural properties of the IR and invoke any specific verifiers we
     // have on the Toy operations.
private:
 
   /// Create the prototype for an MLIR function with as many arguments as the
   /// provided Toy AST prototype.
   mlir::FuncOp mlirGen(PrototypeAST &proto) {
     auto location = loc(proto.loc());
 
     // This is a generic function, the return type will be inferred later.
     // Arguments type are uniformly unranked tensors.
-    llvm::SmallVector<mlir::Type, 4> arg_types(proto.getArgs().size(),
-                                               getType(VarType{}));
-    auto func_type = builder.getFunctionType(arg_types, llvm::None);
-    return mlir::FuncOp::create(location, proto.getName(), func_type);
+    llvm::SmallVector<mlir::Type, 4> argTypes(proto.getArgs().size(),
+    auto funcType = builder.getFunctionType(argTypes, llvm::None);
+    return mlir::FuncOp::create(location, proto.getName(), funcType);
   }
 
   /// Emit a new function and add it to the MLIR module.
   mlir::FuncOp mlirGen(FunctionAST &funcAST) {
     // Create a scope in the symbol table to hold variable declarations.
-    ScopedHashTableScope<llvm::StringRef, mlir::Value> var_scope(symbolTable);
+    ScopedHashTableScope<llvm::StringRef, mlir::Value> varScope(symbolTable);
 
     // Create an MLIR function for the given prototype.
     mlir::FuncOp function(mlirGen(*funcAST.getProto()));
     if (!function)
       return nullptr;
 
     // Let's start the body of the function now!
     // In MLIR the entry block of the function is special: it must have the same
mlir::Value mlirGen(ExprAST &expr) {
     }
   }
 
   /// Handle a variable declaration, we'll codegen the expression that forms the
   /// initializer and record the value in the symbol table before returning it.
   /// Future expressions will be able to reference this variable through symbol
   /// table lookup.
   mlir::Value mlirGen(VarDeclExprAST &vardecl) {
-    auto init = vardecl.getInitVal();
+    auto *init = vardecl.getInitVal();
     if (!init) {
       emitError(loc(vardecl.loc()),
                 "missing initializer in variable declaration");
       return nullptr;
     }
 
     mlir::Value value = mlirGen(*init);
     if (!value)
mlir::Value mlirGen(VarDeclExprAST &vardecl) {
     // Register the value in the symbol table.
     if (failed(declare(vardecl.getName(), value)))
       return nullptr;
     return value;
   }
 
   /// Codegen a list of expression, return failure if one of them hit an error.
   mlir::LogicalResult mlirGen(ExprASTList &blockAST) {
-    ScopedHashTableScope<StringRef, mlir::Value> var_scope(symbolTable);
+    ScopedHashTableScope<StringRef, mlir::Value> varScope(symbolTable);
     for (auto &expr : blockAST) {
       // Specific handling for variable declarations, return statement, and
       // print. These can only appear in block list and not in nested
       // expressions.
       if (auto *vardecl = dyn_cast<VarDeclExprAST>(expr.get())) {
         if (!mlirGen(*vardecl))
           return mlir::failure();
         continue;

mlir/examples/toy/Ch3/parser/AST.cpp

 }
 
 /// Helper to print recursively a literal. This handles nested array like:
 ///    [ [ 1, 2 ], [ 3, 4 ] ]
 /// We print out such array with the dimensions spelled out at every level:
 ///    <2,2>[<2>[ 1, 2 ], <2>[ 3, 4 ] ]
 void printLitHelper(ExprAST *litOrNum) {
   // Inside a literal expression we can have either a number or another literal
-  if (auto num = llvm::dyn_cast<NumberExprAST>(litOrNum)) {
+  if (auto *num = llvm::dyn_cast<NumberExprAST>(litOrNum)) {
     llvm::errs() << num->getValue();
     return;
   }
   auto *literal = llvm::cast<LiteralExprAST>(litOrNum);
 
   // Print the dimension for this literal first
   llvm::errs() << "<";
   llvm::interleaveComma(literal->getDims(), llvm::errs());

mlir/examples/toy/Ch3/toyc.cpp

 
 static cl::opt<std::string> inputFilename(cl::Positional,
                                           cl::desc("<input toy file>"),
                                           cl::init("-"),
                                           cl::value_desc("filename"));
 
 namespace {
 enum InputType { Toy, MLIR };
-}
+} // namespace
 static cl::opt<enum InputType> inputType(
     "x", cl::init(Toy), cl::desc("Decided the kind of output desired"),
     cl::values(clEnumValN(Toy, "toy", "load the input file as a Toy source.")),
     cl::values(clEnumValN(MLIR, "mlir",
                           "load the input file as an MLIR file")));
 
 namespace {
 enum Action { None, DumpAST, DumpMLIR };
-}
+} // namespace
 static cl::opt<enum Action> emitAction(
     "emit", cl::desc("Select the kind of output desired"),
     cl::values(clEnumValN(DumpAST, "ast", "output the AST dump")),
     cl::values(clEnumValN(DumpMLIR, "mlir", "output the MLIR dump")));
 
 static cl::opt<bool> enableOpt("opt", cl::desc("Enable optimizations"));
 
 /// Returns a Toy AST resulting from parsing the file or a nullptr on error.
if (!moduleAST)
       return 6;
     module = mlirGen(context, *moduleAST);
     return !module ? 1 : 0;
   }
 
   // Otherwise, the input is '.mlir'.
   llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> fileOrErr =
       llvm::MemoryBuffer::getFileOrSTDIN(inputFilename);
-  if (std::error_code EC = fileOrErr.getError()) {
-    llvm::errs() << "Could not open input file: " << EC.message() << "\n";
+  if (std::error_code ec = fileOrErr.getError()) {
+    llvm::errs() << "Could not open input file: " << ec.message() << "\n";
     return -1;
   }
 
   // Parse the input mlir.
   sourceMgr.AddNewSourceBuffer(std::move(*fileOrErr), llvm::SMLoc());
   module = mlir::parseSourceFile(sourceMgr, &context);
   if (!module) {
     llvm::errs() << "Error can't load file " << inputFilename << "\n";

mlir/examples/toy/Ch4/mlir/MLIRGen.cpp

public:
 
   /// Public API: convert the AST for a Toy module (source file) to an MLIR
   /// Module operation.
   mlir::ModuleOp mlirGen(ModuleAST &moduleAST) {
     // We create an empty MLIR module and codegen functions one at a time and
     // add them to the module.
     theModule = mlir::ModuleOp::create(builder.getUnknownLoc());
 
-    for (FunctionAST &F : moduleAST) {
-      auto func = mlirGen(F);
+    for (FunctionAST &f : moduleAST) {
+      auto func = mlirGen(f);
       if (!func)
         return nullptr;
       theModule.push_back(func);
     }
 
     // Verify the module after we have finished constructing it, this will check
     // the structural properties of the IR and invoke any specific verifiers we
     // have on the Toy operations.
private:
 
   /// Create the prototype for an MLIR function with as many arguments as the
   /// provided Toy AST prototype.
   mlir::FuncOp mlirGen(PrototypeAST &proto) {
     auto location = loc(proto.loc());
 
     // This is a generic function, the return type will be inferred later.
     // Arguments type are uniformly unranked tensors.
-    llvm::SmallVector<mlir::Type, 4> arg_types(proto.getArgs().size(),
-                                               getType(VarType{}));
-    auto func_type = builder.getFunctionType(arg_types, llvm::None);
-    return mlir::FuncOp::create(location, proto.getName(), func_type);
+    llvm::SmallVector<mlir::Type, 4> argTypes(proto.getArgs().size(),
+    auto funcType = builder.getFunctionType(argTypes, llvm::None);
+    return mlir::FuncOp::create(location, proto.getName(), funcType);
   }
 
   /// Emit a new function and add it to the MLIR module.
   mlir::FuncOp mlirGen(FunctionAST &funcAST) {
     // Create a scope in the symbol table to hold variable declarations.
-    ScopedHashTableScope<llvm::StringRef, mlir::Value> var_scope(symbolTable);
+    ScopedHashTableScope<llvm::StringRef, mlir::Value> varScope(symbolTable);
 
     // Create an MLIR function for the given prototype.
     mlir::FuncOp function(mlirGen(*funcAST.getProto()));
     if (!function)
       return nullptr;
 
     // Let's start the body of the function now!
     // In MLIR the entry block of the function is special: it must have the same
mlir::Value mlirGen(ExprAST &expr) {
     }
   }
 
   /// Handle a variable declaration, we'll codegen the expression that forms the
   /// initializer and record the value in the symbol table before returning it.
   /// Future expressions will be able to reference this variable through symbol
   /// table lookup.
   mlir::Value mlirGen(VarDeclExprAST &vardecl) {
-    auto init = vardecl.getInitVal();
+    auto *init = vardecl.getInitVal();
     if (!init) {
       emitError(loc(vardecl.loc()),
                 "missing initializer in variable declaration");
       return nullptr;
     }
 
     mlir::Value value = mlirGen(*init);
     if (!value)
mlir::Value mlirGen(VarDeclExprAST &vardecl) {
     // Register the value in the symbol table.
     if (failed(declare(vardecl.getName(), value)))
       return nullptr;
     return value;
   }
 
   /// Codegen a list of expression, return failure if one of them hit an error.
   mlir::LogicalResult mlirGen(ExprASTList &blockAST) {
-    ScopedHashTableScope<StringRef, mlir::Value> var_scope(symbolTable);
+    ScopedHashTableScope<StringRef, mlir::Value> varScope(symbolTable);
     for (auto &expr : blockAST) {
       // Specific handling for variable declarations, return statement, and
       // print. These can only appear in block list and not in nested
       // expressions.
       if (auto *vardecl = dyn_cast<VarDeclExprAST>(expr.get())) {
         if (!mlirGen(*vardecl))
           return mlir::failure();
         continue;

mlir/examples/toy/Ch4/parser/AST.cpp

 }
 
 /// Helper to print recursively a literal. This handles nested array like:
 ///    [ [ 1, 2 ], [ 3, 4 ] ]
 /// We print out such array with the dimensions spelled out at every level:
 ///    <2,2>[<2>[ 1, 2 ], <2>[ 3, 4 ] ]
 void printLitHelper(ExprAST *litOrNum) {
   // Inside a literal expression we can have either a number or another literal
-  if (auto num = llvm::dyn_cast<NumberExprAST>(litOrNum)) {
+  if (auto *num = llvm::dyn_cast<NumberExprAST>(litOrNum)) {
     llvm::errs() << num->getValue();
     return;
   }
   auto *literal = llvm::cast<LiteralExprAST>(litOrNum);
 
   // Print the dimension for this literal first
   llvm::errs() << "<";
   llvm::interleaveComma(literal->getDims(), llvm::errs());

mlir/examples/toy/Ch4/toyc.cpp

 
 static cl::opt<std::string> inputFilename(cl::Positional,
                                           cl::desc("<input toy file>"),
                                           cl::init("-"),
                                           cl::value_desc("filename"));
 
 namespace {
 enum InputType { Toy, MLIR };
-}
+} // namespace
 static cl::opt<enum InputType> inputType(
     "x", cl::init(Toy), cl::desc("Decided the kind of output desired"),
     cl::values(clEnumValN(Toy, "toy", "load the input file as a Toy source.")),
     cl::values(clEnumValN(MLIR, "mlir",
                           "load the input file as an MLIR file")));
 
 namespace {
 enum Action { None, DumpAST, DumpMLIR };
-}
+} // namespace
 static cl::opt<enum Action> emitAction(
     "emit", cl::desc("Select the kind of output desired"),
     cl::values(clEnumValN(DumpAST, "ast", "output the AST dump")),
     cl::values(clEnumValN(DumpMLIR, "mlir", "output the MLIR dump")));
 
 static cl::opt<bool> enableOpt("opt", cl::desc("Enable optimizations"));
 
 /// Returns a Toy AST resulting from parsing the file or a nullptr on error.
if (!moduleAST)
       return 6;
     module = mlirGen(context, *moduleAST);
     return !module ? 1 : 0;
   }
 
   // Otherwise, the input is '.mlir'.
   llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> fileOrErr =
       llvm::MemoryBuffer::getFileOrSTDIN(inputFilename);
-  if (std::error_code EC = fileOrErr.getError()) {
-    llvm::errs() << "Could not open input file: " << EC.message() << "\n";
+  if (std::error_code ec = fileOrErr.getError()) {
+    llvm::errs() << "Could not open input file: " << ec.message() << "\n";
     return -1;
   }
 
   // Parse the input mlir.
   sourceMgr.AddNewSourceBuffer(std::move(*fileOrErr), llvm::SMLoc());
   module = mlir::parseSourceFile(sourceMgr, &context);
   if (!module) {
     llvm::errs() << "Error can't load file " << inputFilename << "\n";

mlir/examples/toy/Ch5/mlir/MLIRGen.cpp

public:
 
   /// Public API: convert the AST for a Toy module (source file) to an MLIR
   /// Module operation.
   mlir::ModuleOp mlirGen(ModuleAST &moduleAST) {
     // We create an empty MLIR module and codegen functions one at a time and
     // add them to the module.
     theModule = mlir::ModuleOp::create(builder.getUnknownLoc());
 
-    for (FunctionAST &F : moduleAST) {
-      auto func = mlirGen(F);
+    for (FunctionAST &f : moduleAST) {
+      auto func = mlirGen(f);
       if (!func)
         return nullptr;
       theModule.push_back(func);
     }
 
     // Verify the module after we have finished constructing it, this will check
     // the structural properties of the IR and invoke any specific verifiers we
     // have on the Toy operations.
private:
 
   /// Create the prototype for an MLIR function with as many arguments as the
   /// provided Toy AST prototype.
   mlir::FuncOp mlirGen(PrototypeAST &proto) {
     auto location = loc(proto.loc());
 
     // This is a generic function, the return type will be inferred later.
     // Arguments type are uniformly unranked tensors.
-    llvm::SmallVector<mlir::Type, 4> arg_types(proto.getArgs().size(),
-                                               getType(VarType{}));
-    auto func_type = builder.getFunctionType(arg_types, llvm::None);
-    return mlir::FuncOp::create(location, proto.getName(), func_type);
+    llvm::SmallVector<mlir::Type, 4> argTypes(proto.getArgs().size(),
+    auto funcType = builder.getFunctionType(argTypes, llvm::None);
+    return mlir::FuncOp::create(location, proto.getName(), funcType);
   }
 
   /// Emit a new function and add it to the MLIR module.
   mlir::FuncOp mlirGen(FunctionAST &funcAST) {
     // Create a scope in the symbol table to hold variable declarations.
-    ScopedHashTableScope<llvm::StringRef, mlir::Value> var_scope(symbolTable);
+    ScopedHashTableScope<llvm::StringRef, mlir::Value> varScope(symbolTable);
 
     // Create an MLIR function for the given prototype.
     mlir::FuncOp function(mlirGen(*funcAST.getProto()));
     if (!function)
       return nullptr;
 
     // Let's start the body of the function now!
     // In MLIR the entry block of the function is special: it must have the same
mlir::Value mlirGen(ExprAST &expr) {
     }
   }
 
   /// Handle a variable declaration, we'll codegen the expression that forms the
   /// initializer and record the value in the symbol table before returning it.
   /// Future expressions will be able to reference this variable through symbol
   /// table lookup.
   mlir::Value mlirGen(VarDeclExprAST &vardecl) {
-    auto init = vardecl.getInitVal();
+    auto *init = vardecl.getInitVal();
     if (!init) {
       emitError(loc(vardecl.loc()),
                 "missing initializer in variable declaration");
       return nullptr;
     }
 
     mlir::Value value = mlirGen(*init);
     if (!value)
mlir::Value mlirGen(VarDeclExprAST &vardecl) {
     // Register the value in the symbol table.
     if (failed(declare(vardecl.getName(), value)))
       return nullptr;
     return value;
   }
 
   /// Codegen a list of expression, return failure if one of them hit an error.
   mlir::LogicalResult mlirGen(ExprASTList &blockAST) {
-    ScopedHashTableScope<StringRef, mlir::Value> var_scope(symbolTable);
+    ScopedHashTableScope<StringRef, mlir::Value> varScope(symbolTable);
     for (auto &expr : blockAST) {
       // Specific handling for variable declarations, return statement, and
       // print. These can only appear in block list and not in nested
       // expressions.
       if (auto *vardecl = dyn_cast<VarDeclExprAST>(expr.get())) {
         if (!mlirGen(*vardecl))
           return mlir::failure();
         continue;

mlir/examples/toy/Ch5/parser/AST.cpp

 }
 
 /// Helper to print recursively a literal. This handles nested array like:
 ///    [ [ 1, 2 ], [ 3, 4 ] ]
 /// We print out such array with the dimensions spelled out at every level:
 ///    <2,2>[<2>[ 1, 2 ], <2>[ 3, 4 ] ]
 void printLitHelper(ExprAST *litOrNum) {
   // Inside a literal expression we can have either a number or another literal
-  if (auto num = llvm::dyn_cast<NumberExprAST>(litOrNum)) {
+  if (auto *num = llvm::dyn_cast<NumberExprAST>(litOrNum)) {
     llvm::errs() << num->getValue();
     return;
   }
   auto *literal = llvm::cast<LiteralExprAST>(litOrNum);
 
   // Print the dimension for this literal first
   llvm::errs() << "<";
   llvm::interleaveComma(literal->getDims(), llvm::errs());

mlir/examples/toy/Ch5/toyc.cpp

 
 static cl::opt<std::string> inputFilename(cl::Positional,
                                           cl::desc("<input toy file>"),
                                           cl::init("-"),
                                           cl::value_desc("filename"));
 
 namespace {
 enum InputType { Toy, MLIR };
-}
+} // namespace
 static cl::opt<enum InputType> inputType(
     "x", cl::init(Toy), cl::desc("Decided the kind of output desired"),
     cl::values(clEnumValN(Toy, "toy", "load the input file as a Toy source.")),
     cl::values(clEnumValN(MLIR, "mlir",
                           "load the input file as an MLIR file")));
 
 namespace {
 enum Action { None, DumpAST, DumpMLIR, DumpMLIRAffine };
-}
+} // namespace
 static cl::opt<enum Action> emitAction(
     "emit", cl::desc("Select the kind of output desired"),
     cl::values(clEnumValN(DumpAST, "ast", "output the AST dump")),
     cl::values(clEnumValN(DumpMLIR, "mlir", "output the MLIR dump")),
     cl::values(clEnumValN(DumpMLIRAffine, "mlir-affine",
                           "output the MLIR dump after affine lowering")));
 
 static cl::opt<bool> enableOpt("opt", cl::desc("Enable optimizations"));
if (!moduleAST)
       return 6;
     module = mlirGen(context, *moduleAST);
     return !module ? 1 : 0;
   }
 
   // Otherwise, the input is '.mlir'.
   llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> fileOrErr =
       llvm::MemoryBuffer::getFileOrSTDIN(inputFilename);
-  if (std::error_code EC = fileOrErr.getError()) {
-    llvm::errs() << "Could not open input file: " << EC.message() << "\n";
+  if (std::error_code ec = fileOrErr.getError()) {
+    llvm::errs() << "Could not open input file: " << ec.message() << "\n";
     return -1;
   }
 
   // Parse the input mlir.
   sourceMgr.AddNewSourceBuffer(std::move(*fileOrErr), llvm::SMLoc());
   module = mlir::parseSourceFile(sourceMgr, &context);
   if (!module) {
     llvm::errs() << "Error can't load file " << inputFilename << "\n";

mlir/examples/toy/Ch6/mlir/MLIRGen.cpp

public:
 
   /// Public API: convert the AST for a Toy module (source file) to an MLIR
   /// Module operation.
   mlir::ModuleOp mlirGen(ModuleAST &moduleAST) {
     // We create an empty MLIR module and codegen functions one at a time and
     // add them to the module.
     theModule = mlir::ModuleOp::create(builder.getUnknownLoc());
 
-    for (FunctionAST &F : moduleAST) {
-      auto func = mlirGen(F);
+    for (FunctionAST &f : moduleAST) {
+      auto func = mlirGen(f);
       if (!func)
         return nullptr;
       theModule.push_back(func);
     }
 
     // Verify the module after we have finished constructing it, this will check
     // the structural properties of the IR and invoke any specific verifiers we
     // have on the Toy operations.
private:
 
   /// Create the prototype for an MLIR function with as many arguments as the
   /// provided Toy AST prototype.
   mlir::FuncOp mlirGen(PrototypeAST &proto) {
     auto location = loc(proto.loc());
 
     // This is a generic function, the return type will be inferred later.
     // Arguments type are uniformly unranked tensors.
-    llvm::SmallVector<mlir::Type, 4> arg_types(proto.getArgs().size(),
-                                               getType(VarType{}));
-    auto func_type = builder.getFunctionType(arg_types, llvm::None);
-    return mlir::FuncOp::create(location, proto.getName(), func_type);
+    llvm::SmallVector<mlir::Type, 4> argTypes(proto.getArgs().size(),
+    auto funcType = builder.getFunctionType(argTypes, llvm::None);
+    return mlir::FuncOp::create(location, proto.getName(), funcType);
   }
 
   /// Emit a new function and add it to the MLIR module.
   mlir::FuncOp mlirGen(FunctionAST &funcAST) {
     // Create a scope in the symbol table to hold variable declarations.
-    ScopedHashTableScope<llvm::StringRef, mlir::Value> var_scope(symbolTable);
+    ScopedHashTableScope<llvm::StringRef, mlir::Value> varScope(symbolTable);
 
     // Create an MLIR function for the given prototype.
     mlir::FuncOp function(mlirGen(*funcAST.getProto()));
     if (!function)
       return nullptr;
 
     // Let's start the body of the function now!
     // In MLIR the entry block of the function is special: it must have the same
mlir::Value mlirGen(ExprAST &expr) {
     }
   }
 
   /// Handle a variable declaration, we'll codegen the expression that forms the
   /// initializer and record the value in the symbol table before returning it.
   /// Future expressions will be able to reference this variable through symbol
   /// table lookup.
   mlir::Value mlirGen(VarDeclExprAST &vardecl) {
-    auto init = vardecl.getInitVal();
+    auto *init = vardecl.getInitVal();
     if (!init) {
       emitError(loc(vardecl.loc()),
                 "missing initializer in variable declaration");
       return nullptr;
     }
 
     mlir::Value value = mlirGen(*init);
     if (!value)
mlir::Value mlirGen(VarDeclExprAST &vardecl) {
     // Register the value in the symbol table.
     if (failed(declare(vardecl.getName(), value)))
       return nullptr;
     return value;
   }
 
   /// Codegen a list of expression, return failure if one of them hit an error.
   mlir::LogicalResult mlirGen(ExprASTList &blockAST) {
-    ScopedHashTableScope<StringRef, mlir::Value> var_scope(symbolTable);
+    ScopedHashTableScope<StringRef, mlir::Value> varScope(symbolTable);
     for (auto &expr : blockAST) {
       // Specific handling for variable declarations, return statement, and
       // print. These can only appear in block list and not in nested
       // expressions.
       if (auto *vardecl = dyn_cast<VarDeclExprAST>(expr.get())) {
         if (!mlirGen(*vardecl))
           return mlir::failure();
         continue;

mlir/examples/toy/Ch6/parser/AST.cpp

 }
 
 /// Helper to print recursively a literal. This handles nested array like:
 ///    [ [ 1, 2 ], [ 3, 4 ] ]
 /// We print out such array with the dimensions spelled out at every level:
 ///    <2,2>[<2>[ 1, 2 ], <2>[ 3, 4 ] ]
 void printLitHelper(ExprAST *litOrNum) {
   // Inside a literal expression we can have either a number or another literal
-  if (auto num = llvm::dyn_cast<NumberExprAST>(litOrNum)) {
+  if (auto *num = llvm::dyn_cast<NumberExprAST>(litOrNum)) {
     llvm::errs() << num->getValue();
     return;
   }
   auto *literal = llvm::cast<LiteralExprAST>(litOrNum);
 
   // Print the dimension for this literal first
   llvm::errs() << "<";
   llvm::interleaveComma(literal->getDims(), llvm::errs());

mlir/examples/toy/Ch6/toyc.cpp

 
 static cl::opt<std::string> inputFilename(cl::Positional,
                                           cl::desc("<input toy file>"),
                                           cl::init("-"),
                                           cl::value_desc("filename"));
 
 namespace {
 enum InputType { Toy, MLIR };
-}
+} // namespace
 static cl::opt<enum InputType> inputType(
     "x", cl::init(Toy), cl::desc("Decided the kind of output desired"),
     cl::values(clEnumValN(Toy, "toy", "load the input file as a Toy source.")),
     cl::values(clEnumValN(MLIR, "mlir",
                           "load the input file as an MLIR file")));
 
 namespace {
 enum Action {
   None,
   DumpAST,
   DumpMLIR,
   DumpMLIRAffine,
   DumpMLIRLLVM,
   DumpLLVMIR,
   RunJIT
 };
-}
+} // namespace
 static cl::opt<enum Action> emitAction(
     "emit", cl::desc("Select the kind of output desired"),
     cl::values(clEnumValN(DumpAST, "ast", "output the AST dump")),
     cl::values(clEnumValN(DumpMLIR, "mlir", "output the MLIR dump")),
     cl::values(clEnumValN(DumpMLIRAffine, "mlir-affine",
                           "output the MLIR dump after affine lowering")),
     cl::values(clEnumValN(DumpMLIRLLVM, "mlir-llvm",
                           "output the MLIR dump after llvm lowering")),
if (!moduleAST)
       return 6;
     module = mlirGen(context, *moduleAST);
     return !module ? 1 : 0;
   }
 
   // Otherwise, the input is '.mlir'.
   llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> fileOrErr =
       llvm::MemoryBuffer::getFileOrSTDIN(inputFilename);
-  if (std::error_code EC = fileOrErr.getError()) {
-    llvm::errs() << "Could not open input file: " << EC.message() << "\n";
+  if (std::error_code ec = fileOrErr.getError()) {
+    llvm::errs() << "Could not open input file: " << ec.message() << "\n";
     return -1;
   }
 
   // Parse the input mlir.
   llvm::SourceMgr sourceMgr;
   sourceMgr.AddNewSourceBuffer(std::move(*fileOrErr), llvm::SMLoc());
   module = mlir::parseSourceFile(sourceMgr, &context);
   if (!module) {

mlir/examples/toy/Ch7/mlir/MLIRGen.cpp

mlir::FuncOp mlirGen(PrototypeAST &proto) {
     llvm::SmallVector<mlir::Type, 4> argTypes;
     argTypes.reserve(proto.getArgs().size());
     for (auto &arg : proto.getArgs()) {
       mlir::Type type = getType(arg->getType(), arg->loc());
       if (!type)
         return nullptr;
       argTypes.push_back(type);
     }
-    auto func_type = builder.getFunctionType(argTypes, llvm::None);
-    return mlir::FuncOp::create(location, proto.getName(), func_type);
+    auto funcType = builder.getFunctionType(argTypes, llvm::None);
+    return mlir::FuncOp::create(location, proto.getName(), funcType);
   }
 
   /// Emit a new function and add it to the MLIR module.
   mlir::FuncOp mlirGen(FunctionAST &funcAST) {
     // Create a scope in the symbol table to hold variable declarations.
-    SymbolTableScopeT var_scope(symbolTable);
+    SymbolTableScopeT varScope(symbolTable);
 
     // Create an MLIR function for the given prototype.
     mlir::FuncOp function(mlirGen(*funcAST.getProto()));
     if (!function)
       return nullptr;
 
     // Let's start the body of the function now!
     // In MLIR the entry block of the function is special: it must have the same
if (!structAST)
       return llvm::None;
 
     // Get the name from the RHS.
     VariableExprAST *name = llvm::dyn_cast<VariableExprAST>(accessOp.getRHS());
     if (!name)
       return llvm::None;
 
     auto structVars = structAST->getVariables();
-    auto it = llvm::find_if(structVars, [&](auto &var) {
+    const auto *it = llvm::find_if(structVars, [&](auto &var) {
       return var->getName() == name->getName();
     });
     if (it == structVars.end())
       return llvm::None;
     return it - structVars.begin();
   }
 
   /// Emit a binary operation
mlir::Value mlirGen(ExprAST &expr) {
     }
   }
 
   /// Handle a variable declaration, we'll codegen the expression that forms the
   /// initializer and record the value in the symbol table before returning it.
   /// Future expressions will be able to reference this variable through symbol
   /// table lookup.
   mlir::Value mlirGen(VarDeclExprAST &vardecl) {
-    auto init = vardecl.getInitVal();
+    auto *init = vardecl.getInitVal();
     if (!init) {
       emitError(loc(vardecl.loc()),
                 "missing initializer in variable declaration");
       return nullptr;
     }
 
     mlir::Value value = mlirGen(*init);
     if (!value)
mlir::Value mlirGen(VarDeclExprAST &vardecl) {
     // Register the value in the symbol table.
     if (failed(declare(vardecl, value)))
       return nullptr;
     return value;
   }
 
   /// Codegen a list of expression, return failure if one of them hit an error.
   mlir::LogicalResult mlirGen(ExprASTList &blockAST) {
-    SymbolTableScopeT var_scope(symbolTable);
+    SymbolTableScopeT varScope(symbolTable);
     for (auto &expr : blockAST) {
       // Specific handling for variable declarations, return statement, and
       // print. These can only appear in block list and not in nested
       // expressions.
       if (auto *vardecl = dyn_cast<VarDeclExprAST>(expr.get())) {
         if (!mlirGen(*vardecl))
           return mlir::failure();
         continue;

mlir/examples/toy/Ch7/parser/AST.cpp

 }
 
 /// Helper to print recursively a literal. This handles nested array like:
 ///    [ [ 1, 2 ], [ 3, 4 ] ]
 /// We print out such array with the dimensions spelled out at every level:
 ///    <2,2>[<2>[ 1, 2 ], <2>[ 3, 4 ] ]
 void printLitHelper(ExprAST *litOrNum) {
   // Inside a literal expression we can have either a number or another literal
-  if (auto num = llvm::dyn_cast<NumberExprAST>(litOrNum)) {
+  if (auto *num = llvm::dyn_cast<NumberExprAST>(litOrNum)) {
     llvm::errs() << num->getValue();
     return;
   }
   auto *literal = llvm::cast<LiteralExprAST>(litOrNum);
 
   // Print the dimension for this literal first
   llvm::errs() << "<";
   llvm::interleaveComma(literal->getDims(), llvm::errs());

mlir/examples/toy/Ch7/toyc.cpp

 
 static cl::opt<std::string> inputFilename(cl::Positional,
                                           cl::desc("<input toy file>"),
                                           cl::init("-"),
                                           cl::value_desc("filename"));
 
 namespace {
 enum InputType { Toy, MLIR };
-}
+} // namespace
 static cl::opt<enum InputType> inputType(
     "x", cl::init(Toy), cl::desc("Decided the kind of output desired"),
     cl::values(clEnumValN(Toy, "toy", "load the input file as a Toy source.")),
     cl::values(clEnumValN(MLIR, "mlir",
                           "load the input file as an MLIR file")));
 
 namespace {
 enum Action {
   None,
   DumpAST,
   DumpMLIR,
   DumpMLIRAffine,
   DumpMLIRLLVM,
   DumpLLVMIR,
   RunJIT
 };
-}
+} // namespace
 static cl::opt<enum Action> emitAction(
     "emit", cl::desc("Select the kind of output desired"),
     cl::values(clEnumValN(DumpAST, "ast", "output the AST dump")),
     cl::values(clEnumValN(DumpMLIR, "mlir", "output the MLIR dump")),
     cl::values(clEnumValN(DumpMLIRAffine, "mlir-affine",
                           "output the MLIR dump after affine lowering")),
     cl::values(clEnumValN(DumpMLIRLLVM, "mlir-llvm",
                           "output the MLIR dump after llvm lowering")),
if (!moduleAST)
       return 6;
     module = mlirGen(context, *moduleAST);
     return !module ? 1 : 0;
   }
 
   // Otherwise, the input is '.mlir'.
   llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> fileOrErr =
       llvm::MemoryBuffer::getFileOrSTDIN(inputFilename);
-  if (std::error_code EC = fileOrErr.getError()) {
-    llvm::errs() << "Could not open input file: " << EC.message() << "\n";
+  if (std::error_code ec = fileOrErr.getError()) {
+    llvm::errs() << "Could not open input file: " << ec.message() << "\n";
     return -1;
   }
 
   // Parse the input mlir.
   llvm::SourceMgr sourceMgr;
   sourceMgr.AddNewSourceBuffer(std::move(*fileOrErr), llvm::SMLoc());
   module = mlir::parseSourceFile(sourceMgr, &context);
   if (!module) {

mlir/lib/Analysis/SliceAnalysis.cpp

struct DFSState {
   DFSState(const SetVector<Operation *> &set)
       : toSort(set), topologicalCounts(), seen() {}
   const SetVector<Operation *> &toSort;
   SmallVector<Operation *, 16> topologicalCounts;
   DenseSet<Operation *> seen;
 };
 } // namespace
 
-static void DFSPostorder(Operation *root, DFSState *state) {
+static void dfsPostorder(Operation *root, DFSState *state) {
   SmallVector<Operation *> queue(1, root);
   std::vector<Operation *> ops;
   while (!queue.empty()) {
     Operation *current = queue.pop_back_val();
     ops.push_back(current);
     for (Value result : current->getResults()) {
       for (Operation *op : result.getUsers())
         queue.push_back(op);
mlir::topologicalSort(const SetVector<Operation *> &toSort) {
   if (toSort.empty()) {
     return toSort;
   }
 
   // Run from each root with global count and `seen` set.
   DFSState state(toSort);
   for (auto *s : toSort) {
     assert(toSort.count(s) == 1 && "NYI: multi-sets not supported");
-    DFSPostorder(s, &state);
+    dfsPostorder(s, &state);
   }
 
   // Reorder and return.
   SetVector<Operation *> res;
   for (auto it = state.topologicalCounts.rbegin(),
             eit = state.topologicalCounts.rend();
        it != eit; ++it) {
     res.insert(*it);
   }
   return res;
 }

mlir/lib/Analysis/Utils.cpp

bool MemRefAccess::operator==(const MemRefAccess &rhs) const {
   rhs.getAccessMap(&rhsMap);
   AffineValueMap::difference(thisMap, rhsMap, &diff);
   return llvm::all_of(diff.getAffineMap().getResults(),
                       [](AffineExpr e) { return e == 0; });
 }
 
 /// Returns the number of surrounding loops common to 'loopsA' and 'loopsB',
 /// where each lists loops from outer-most to inner-most in loop nest.
-unsigned mlir::getNumCommonSurroundingLoops(Operation &A, Operation &B) {
+unsigned mlir::getNumCommonSurroundingLoops(Operation &a, Operation &b) {
   SmallVector<AffineForOp, 4> loopsA, loopsB;
-  getLoopIVs(A, &loopsA);
-  getLoopIVs(B, &loopsB);
+  getLoopIVs(a, &loopsA);
+  getLoopIVs(b, &loopsB);
 
   unsigned minNumLoops = std::min(loopsA.size(), loopsB.size());
   unsigned numCommonLoops = 0;
   for (unsigned i = 0; i < minNumLoops; ++i) {
     if (loopsA[i].getOperation() != loopsB[i].getOperation())
       break;
     ++numCommonLoops;
   }

mlir/lib/Bindings/Python/IRAttributes.cpp

 
 #include "mlir-c/BuiltinAttributes.h"
 #include "mlir-c/BuiltinTypes.h"
 
 namespace py = pybind11;
 using namespace mlir;
 using namespace mlir::python;
 
-using llvm::None;
 using llvm::Optional;
 using llvm::SmallVector;
 using llvm::Twine;
 
 //------------------------------------------------------------------------------
 // Docstrings (trivial, non-duplicated docstrings are included inline).
 //------------------------------------------------------------------------------
 
py::buffer_info accessBuffer() {
 
     MlirType shapedType = mlirAttributeGetType(*this);
     MlirType elementType = mlirShapedTypeGetElementType(shapedType);
     std::string format;
 
     if (mlirTypeIsAF32(elementType)) {
       // f32
       return bufferInfo<float>(shapedType);
-    } else if (mlirTypeIsAF64(elementType)) {
+    }
+    if (mlirTypeIsAF64(elementType)) {
       // f64
       return bufferInfo<double>(shapedType);
     } else if (mlirTypeIsAF16(elementType)) {
       // f16
       return bufferInfo<uint16_t>(shapedType, "e");
     } else if (mlirTypeIsAInteger(elementType) &&
                mlirIntegerTypeGetWidth(elementType) == 32) {
       if (mlirIntegerTypeIsSignless(elementType) ||
static void bindDerived(ClassTy &c) {
     c.def("__contains__", &PyDictAttribute::dunderContains);
     c.def("__len__", &PyDictAttribute::dunderLen);
     c.def_static(
         "get",
         [](py::dict attributes, DefaultingPyMlirContext context) {
           SmallVector<MlirNamedAttribute> mlirNamedAttributes;
           mlirNamedAttributes.reserve(attributes.size());
           for (auto &it : attributes) {
-            auto &mlir_attr = it.second.cast<PyAttribute &>();
+            auto &mlirAttr = it.second.cast<PyAttribute &>();
             auto name = it.first.cast<std::string>();
             mlirNamedAttributes.push_back(mlirNamedAttributeGet(
-                mlirIdentifierGet(mlirAttributeGetContext(mlir_attr),
+                mlirIdentifierGet(mlirAttributeGetContext(mlirAttr),
                                   toMlirStringRef(name)),
-                mlir_attr));
+                mlirAttr));
           }
           MlirAttribute attr =
               mlirDictionaryAttrGet(context->get(), mlirNamedAttributes.size(),
                                     mlirNamedAttributes.data());
           return PyDictAttribute(context->getRef(), attr);
         },
         py::arg("value") = py::dict(), py::arg("context") = py::none(),
         "Gets an uniqued dict attribute");

mlir/lib/Bindings/Python/IRCore.cpp

if (operandSegmentSpecObj.is_none()) {
     }
     operandSegmentLengths.reserve(operandList.size());
     for (auto it :
          llvm::enumerate(llvm::zip(operandList, operandSegmentSpec))) {
       int segmentSpec = std::get<1>(it.value());
       if (segmentSpec == 1 || segmentSpec == 0) {
         // Unpack unary element.
         try {
-          auto operandValue = py::cast<PyValue *>(std::get<0>(it.value()));
+          auto *operandValue = py::cast<PyValue *>(std::get<0>(it.value()));
           if (operandValue) {
             operands.push_back(operandValue);
             operandSegmentLengths.push_back(1);
           } else if (segmentSpec == 0) {
             // Allowed to be optional.
             operandSegmentLengths.push_back(0);
           } else {
             throw py::cast_error("was None and operand is not optional");
py::class_<PyModule>(m, "Module", py::module_local())
                                              mlirModuleGetOperation(self.get()),
                                              self.getRef().releaseObject())
                 .releaseObject();
           },
           "Accesses the module as an operation")
       .def_property_readonly(
           "body",
           [](PyModule &self) {
-            PyOperationRef module_op = PyOperation::forOperation(
+            PyOperationRef moduleOp = PyOperation::forOperation(
                 self.getContext(), mlirModuleGetOperation(self.get()),
                 self.getRef().releaseObject());
-            PyBlock returnBlock(module_op, mlirModuleGetBody(self.get()));
+            PyBlock returnBlock(moduleOp, mlirModuleGetBody(self.get()));
             return returnBlock;
           },
           "Return the block for this module")
       .def(
           "dump",
           [](PyModule &self) {
             mlirOperationDump(mlirModuleGetOperation(self.get()));
           },

mlir/lib/Bindings/Python/IRModule.cpp

for (std::string moduleName : localSearchPrefixes) {
     moduleName.append(dialectNamespace.data(), dialectNamespace.size());
 
     try {
       py::gil_scoped_release();
       loaded = py::module::import(moduleName.c_str());
     } catch (py::error_already_set &e) {
       if (e.matches(PyExc_ModuleNotFoundError)) {
         continue;
-      } else {
-        throw;
       }
+      throw;
     }
     break;
   }
 
   // Note: Iterator cannot be shared from prior to loading, since re-entrancy
   // may have occurred, which may do anything.
   loadedDialectModulesCache.insert(dialectNamespace);
 }
// Attempt to find from the canonical map and cache.
     auto foundIt = rawOpViewClassMap.find(operationName);
     if (foundIt != rawOpViewClassMap.end()) {
       if (foundIt->second.is_none())
         return llvm::None;
       assert(foundIt->second && "py::object is defined");
       // Positive cache.
       rawOpViewClassMapCache[operationName] = foundIt->second;
       return foundIt->second;
-    } else {
-      // Negative cache.
-      rawOpViewClassMap[operationName] = py::none();
-      return llvm::None;
-    }
-  }
-}
+    }
 
 void PyGlobals::clearImportCache() {
   py::gil_scoped_acquire();
   loadedDialectModulesCache.clear();
   rawOpViewClassMapCache.clear();
 }

mlir/lib/Bindings/Python/PybindUtils.cpp

 //===- PybindUtils.cpp - Utilities for interop with pybind11 --------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "PybindUtils.h"
 
-namespace py = pybind11;
-
 pybind11::error_already_set
 mlir::python::SetPyError(PyObject *excClass, const llvm::Twine &message) {
   auto messageStr = message.str();
   PyErr_SetString(excClass, messageStr.c_str());
   return pybind11::error_already_set();
 }

mlir/lib/Bindings/Python/Transforms/Transforms.cpp

 //===- Transforms.cpp - Pybind module for the Transforms library ----------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir-c/Transforms.h"
 
 #include <pybind11/pybind11.h>
 
-namespace py = pybind11;
-
 // -----------------------------------------------------------------------------
 // Module initialization.
 // -----------------------------------------------------------------------------
 
 PYBIND11_MODULE(_mlirTransforms, m) {
   m.doc() = "MLIR Transforms library";
 
   // Register all the passes in the Transforms library on load.
   mlirRegisterTransformsPasses();
 }

mlir/lib/CAPI/IR/IR.cpp

 void mlirSymbolTableErase(MlirSymbolTable symbolTable,
                           MlirOperation operation) {
   unwrap(symbolTable)->erase(unwrap(operation));
 }
 
 MlirLogicalResult mlirSymbolTableReplaceAllSymbolUses(MlirStringRef oldSymbol,
                                                       MlirStringRef newSymbol,
                                                       MlirOperation from) {
-  auto cppFrom = unwrap(from);
+  auto *cppFrom = unwrap(from);
   auto *context = cppFrom->getContext();
   auto oldSymbolAttr = StringAttr::get(unwrap(oldSymbol), context);
   auto newSymbolAttr = StringAttr::get(unwrap(newSymbol), context);
   return wrap(SymbolTable::replaceAllSymbolUses(oldSymbolAttr, newSymbolAttr,
                                                 unwrap(from)));
 }
 
 void mlirSymbolTableWalkSymbolTables(MlirOperation from, bool allSymUsesVisible,

mlir/lib/Conversion/LLVMCommon/MemRefBuilder.cpp

Value UnrankedMemRefDescriptor::sizeBasePtr(
   Type elemPtrTy = elemPtrPtrType.getElementType();
   Type indexTy = typeConverter.getIndexType();
   Type structPtrTy =
       LLVM::LLVMPointerType::get(LLVM::LLVMStructType::getLiteral(
           indexTy.getContext(), {elemPtrTy, elemPtrTy, indexTy, indexTy}));
   Value structPtr =
       builder.create<LLVM::BitcastOp>(loc, structPtrTy, memRefDescPtr);
 
-  Type int32_type = typeConverter.convertType(builder.getI32Type());
+  Type int32Type = typeConverter.convertType(builder.getI32Type());
   Value zero =
       createIndexAttrConstant(builder, loc, typeConverter.getIndexType(), 0);
-  Value three = builder.create<LLVM::ConstantOp>(loc, int32_type,
+  Value three = builder.create<LLVM::ConstantOp>(loc, int32Type,
                                                  builder.getI32IntegerAttr(3));
   return builder.create<LLVM::GEPOp>(loc, LLVM::LLVMPointerType::get(indexTy),
                                      structPtr, ValueRange({zero, three}));
 }
 
 Value UnrankedMemRefDescriptor::size(OpBuilder &builder, Location loc,
                                      LLVMTypeConverter typeConverter,
                                      Value sizeBasePtr, Value index) {

mlir/lib/Conversion/PDLToPDLInterp/RootOrdering.cpp

if (cycleSet.contains(target)) {
       }
       // Erase the node in the cycle.
       graph.erase(outer);
     } else {
       // Target not in cycle => edges going away from or unrelated to the cycle.
       DenseMap<Value, RootOrderingCost> &costs = outer->second;
       Value bestSource;
       std::pair<unsigned, unsigned> bestCost;
-      auto inner = costs.begin(), inner_e = costs.end();
-      while (inner != inner_e) {
+      auto inner = costs.begin(), innerE = costs.end();
+      while (inner != innerE) {
         Value source = inner->first;
         if (cycleSet.contains(source)) {
           // Going-away edge => get its cost and erase it.
           if (!bestSource || bestCost > inner->second.cost) {
             bestSource = source;
             bestCost = inner->second.cost;
           }
           costs.erase(inner++);

mlir/lib/Conversion/SCFToGPU/SCFToGPU.cpp

launchOp.body().front().getOperations().splice(
       launchOp.body().front().begin(),
       innermostForOp.getBody()->getOperations());
 
   // Remap the loop iterators to use block/thread identifiers instead.  Loops
   // may iterate from LB with step S whereas GPU thread/block ids always iterate
   // from 0 to N with step 1.  Therefore, loop induction variables are replaced
   // with (gpu-thread/block-id * S) + LB.
   builder.setInsertionPointToStart(&launchOp.body().front());
-  auto lbArgumentIt = lbs.begin();
-  auto stepArgumentIt = steps.begin();
+  auto *lbArgumentIt = lbs.begin();
+  auto *stepArgumentIt = steps.begin();
   for (auto en : llvm::enumerate(ivs)) {
     Value id =
         en.index() < numBlockDims
             ? getDim3Value(launchOp.getBlockIds(), en.index())
             : getDim3Value(launchOp.getThreadIds(), en.index() - numBlockDims);
     Value step = steps[en.index()];
     if (!isConstantOne(step))
       id = builder.create<arith::MulIOp>(rootForOp.getLoc(), step, id);
if (auto nestedParallel = dyn_cast<ParallelOp>(op)) {
       // Insert that now. This will also update the worklist with the loops
       // body.
       if (failed(processParallelLoop(nestedParallel, launchOp, cloningMap,
                                      worklist, launchBounds, rewriter)))
         return failure();
     } else if (op == launchOp.getOperation()) {
       // Found our sentinel value. We have finished the operations from one
       // nesting level, pop one level back up.
-      auto parent = rewriter.getInsertionPoint()->getParentOp();
+      auto *parent = rewriter.getInsertionPoint()->getParentOp();
       rewriter.setInsertionPointAfter(parent);
       leftNestingScope = true;
       seenSideeffects = false;
     } else {
       // Otherwise we copy it over.
       Operation *clone = rewriter.clone(*op, cloningMap);
       cloningMap.map(op->getResults(), clone->getResults());
       // Check for side effects.

mlir/lib/Conversion/SCFToStandard/SCFToStandard.cpp

ParallelLowering::matchAndRewrite(ParallelOp parallelOp,
   // a further rewrite. If a parallel loop contains reductions (and thus returns
   // values), forward the initial values for the reductions down the loop
   // hierarchy and bubble up the results by modifying the "yield" terminator.
   SmallVector<Value, 4> iterArgs = llvm::to_vector<4>(parallelOp.getInitVals());
   SmallVector<Value, 4> ivs;
   ivs.reserve(parallelOp.getNumLoops());
   bool first = true;
   SmallVector<Value, 4> loopResults(iterArgs);
-  for (auto loop_operands :
+  for (auto loopOperands :
        llvm::zip(parallelOp.getInductionVars(), parallelOp.getLowerBound(),
                  parallelOp.getUpperBound(), parallelOp.getStep())) {
     Value iv, lower, upper, step;
-    std::tie(iv, lower, upper, step) = loop_operands;
+    std::tie(iv, lower, upper, step) = loopOperands;
     ForOp forOp = rewriter.create<ForOp>(loc, lower, upper, step, iterArgs);
     ivs.push_back(forOp.getInductionVar());
     auto iterRange = forOp.getRegionIterArgs();
     iterArgs.assign(iterRange.begin(), iterRange.end());
 
     if (first) {
       // Store the results of the outermost loop that will be used to replace
       // the results of the parallel loop when it is fully rewritten.

mlir/lib/Conversion/SPIRVToLLVM/SPIRVToLLVM.cpp

if (vector1Size == vector2Size) {
       rewriter.replaceOpWithNewOp<LLVM::ShuffleVectorOp>(op, vector1, vector2,
                                                          components);
       return success();
     }
 
     auto dstType = typeConverter.convertType(op.getType());
     auto scalarType = dstType.cast<VectorType>().getElementType();
     auto componentsArray = components.getValue();
-    auto context = rewriter.getContext();
+    auto *context = rewriter.getContext();
     auto llvmI32Type = IntegerType::get(context, 32);
     Value targetOp = rewriter.create<LLVM::UndefOp>(loc, dstType);
     for (unsigned i = 0; i < componentsArray.size(); i++) {
       if (componentsArray[i].isa<IntegerAttr>())
         op.emitError("unable to support non-constant component");
 
       int indexVal = componentsArray[i].cast<IntegerAttr>().getInt();
       if (indexVal == -1)

mlir/lib/Conversion/TosaToLinalg/TosaToLinalg.cpp

rewriter.replaceOp(op, genericOp.getResult(0));
           Value topPart = rewriter.create<arith::SubFOp>(loc, oneVal, dy);
           topAcc = rewriter.create<arith::MulFOp>(loc, topAcc, topPart);
           bottomAcc =
               rewriter.create<arith::MulFOp>(loc, bottomAcc, bottomPart);
           Value result = rewriter.create<arith::AddFOp>(loc, topAcc, bottomAcc);
 
           rewriter.create<linalg::YieldOp>(loc, result);
           return success();
-        } else {
-          y0x0 = rewriter.create<arith::ExtSIOp>(loc, resultElementTy, y0x0);
-          y0x1 = rewriter.create<arith::ExtSIOp>(loc, resultElementTy, y0x1);
-          y1x0 = rewriter.create<arith::ExtSIOp>(loc, resultElementTy, y1x0);
-          y1x1 = rewriter.create<arith::ExtSIOp>(loc, resultElementTy, y1x1);
+        }
 
-          if (resultElementTy.getIntOrFloatBitWidth() > 32) {
-            dx = rewriter.create<arith::ExtSIOp>(loc, resultElementTy, dx);
-            dy = rewriter.create<arith::ExtSIOp>(loc, resultElementTy, dy);
-          }
 
           auto unitVal = rewriter.create<arith::ConstantOp>(
               loc, rewriter.getIntegerAttr(resultElementTy, 1 << shift));
           Value rightPart = dx;
           Value leftPart = rewriter.create<arith::SubIOp>(loc, unitVal, dx);
 
           y0x0 = rewriter.create<arith::MulIOp>(loc, y0x0, leftPart);
           y0x1 = rewriter.create<arith::MulIOp>(loc, y0x1, rightPart);
           Value topAcc = rewriter.create<arith::AddIOp>(loc, y0x0, y0x1);
 
           y1x0 = rewriter.create<arith::MulIOp>(loc, y1x0, leftPart);
           y1x1 = rewriter.create<arith::MulIOp>(loc, y1x1, rightPart);
           Value bottomAcc = rewriter.create<arith::AddIOp>(loc, y1x0, y1x1);
 
           Value bottomPart = dy;
           Value topPart = rewriter.create<arith::SubIOp>(loc, unitVal, dy);
           topAcc = rewriter.create<arith::MulIOp>(loc, topAcc, topPart);
           bottomAcc =
               rewriter.create<arith::MulIOp>(loc, bottomAcc, bottomPart);
           Value result = rewriter.create<arith::AddIOp>(loc, topAcc, bottomAcc);
 
           rewriter.create<linalg::YieldOp>(loc, result);
           return success();
-        }
-      }
 
       return failure();
     }
 
     return success();
   }
 };
 

mlir/lib/Dialect/GPU/Transforms/AllReduceLowering.cpp

 
 using namespace mlir;
 
 namespace {
 
 struct GpuAllReduceRewriter {
   using AccumulatorFactory = std::function<Value(Value, Value)>;
 
-  GpuAllReduceRewriter(gpu::GPUFuncOp funcOp_, gpu::AllReduceOp reduceOp_,
-                       PatternRewriter &rewriter_)
-      : funcOp(funcOp_), reduceOp(reduceOp_), rewriter(rewriter_),
+  GpuAllReduceRewriter(gpu::GPUFuncOp funcOp, gpu::AllReduceOp reduceOp,
+                       PatternRewriter &rewriter)
+      : funcOp(funcOp), reduceOp(reduceOp), rewriter(rewriter),
         loc(reduceOp.getLoc()), valueType(reduceOp.value().getType()),
         indexType(IndexType::get(reduceOp.getContext())),
         int32Type(IntegerType::get(reduceOp.getContext(), /*width=*/32)) {}
 
   /// Creates an all_reduce across the workgroup.
   ///
   /// First reduce the elements within a subgroup. The first invocation of each
   /// subgroup writes the intermediate result to workgroup memory. After

mlir/lib/Dialect/GPU/Transforms/KernelOutlining.cpp

 private:
   /// Returns a gpu.module containing kernelFunc and all callees (recursive).
   gpu::GPUModuleOp createKernelModule(gpu::GPUFuncOp kernelFunc,
                                       const SymbolTable &parentSymbolTable) {
     // TODO: This code cannot use an OpBuilder because it must be inserted into
     // a SymbolTable by the caller. SymbolTable needs to be refactored to
     // prevent manual building of Ops with symbols in code using SymbolTables
     // and then this needs to use the OpBuilder.
-    auto context = getOperation().getContext();
+    auto *context = getOperation().getContext();
     OpBuilder builder(context);
     auto kernelModule = builder.create<gpu::GPUModuleOp>(kernelFunc.getLoc(),
                                                          kernelFunc.getName());
 
     // If a valid data layout spec was provided, attach it to the kernel module.
     // Otherwise, the default data layout will be used.
     if (dataLayoutSpec)
       kernelModule->setAttr("dlspec", dataLayoutSpec);

mlir/lib/Dialect/LLVMIR/IR/LLVMTypes.cpp

 bool LLVMPointerType::areCompatible(DataLayoutEntryListRef oldLayout,
                                     DataLayoutEntryListRef newLayout) const {
   for (DataLayoutEntryInterface newEntry : newLayout) {
     if (!newEntry.isTypeEntry())
       continue;
     unsigned size = kDefaultPointerSizeBits;
     unsigned abi = kDefaultPointerAlignment;
     auto newType = newEntry.getKey().get<Type>().cast<LLVMPointerType>();
-    auto it = llvm::find_if(oldLayout, [&](DataLayoutEntryInterface entry) {
+    const auto *it =
+        llvm::find_if(oldLayout, [&](DataLayoutEntryInterface entry) {
           if (auto type = entry.getKey().dyn_cast<Type>()) {
             return type.cast<LLVMPointerType>().getAddressSpace() ==
                    newType.getAddressSpace();
           }
           return false;
         });
     if (it == oldLayout.end()) {
       llvm::find_if(oldLayout, [&](DataLayoutEntryInterface entry) {
         if (auto type = entry.getKey().dyn_cast<Type>()) {
           return type.cast<LLVMPointerType>().getAddressSpace() == 0;
         }
         return false;
       });
     }
LLVMStructType::getTypeSizeInBits(const DataLayout &dataLayout,
   // At the end, add padding to the struct to satisfy its own alignment
   // requirement. Otherwise structs inside of arrays would be misaligned.
   structSize = llvm::alignTo(structSize, structAlignment);
   return structSize * kBitsInByte;
 }
 
 namespace {
 enum class StructDLEntryPos { Abi = 0, Preferred = 1 };
-}
+} // namespace
 
 static Optional<unsigned>
 getStructDataLayoutEntry(DataLayoutEntryListRef params, LLVMStructType type,
                          StructDLEntryPos pos) {
-  auto currentEntry = llvm::find_if(params, [](DataLayoutEntryInterface entry) {
+  const auto *currentEntry =
+      llvm::find_if(params, [](DataLayoutEntryInterface entry) {
         return entry.isTypeEntry();
       });
   if (currentEntry == params.end())
     return llvm::None;
 
   auto attr = currentEntry->getValue().cast<DenseIntElementsAttr>();
   if (pos == StructDLEntryPos::Preferred &&
       attr.size() <= static_cast<unsigned>(StructDLEntryPos::Preferred))
     // If no preferred was specified, fall back to abi alignment
     pos = StructDLEntryPos::Abi;

 }
 
 bool LLVMStructType::areCompatible(DataLayoutEntryListRef oldLayout,
                                    DataLayoutEntryListRef newLayout) const {
   for (DataLayoutEntryInterface newEntry : newLayout) {
     if (!newEntry.isTypeEntry())
       continue;
 
-    auto previousEntry =
+    const auto *previousEntry =
         llvm::find_if(oldLayout, [](DataLayoutEntryInterface entry) {
           return entry.isTypeEntry();
         });
     if (previousEntry == oldLayout.end())
       continue;
 
     unsigned abi = extractStructSpecValue(previousEntry->getValue(),
                                           StructDLEntryPos::Abi);

mlir/lib/Dialect/Linalg/IR/LinalgOps.cpp

if (auto toIntType = toType.dyn_cast<IntegerType>()) {
       }
     }
 
     emitWarning(operand.getLoc()) << "could not cast operand of type "
                                   << operand.getType() << " to " << toType;
     return operand;
   }
 
+  // NOLINTNEXTLINE(*-identifier-naming): externally called.
   Value applyfn__add(Value lhs, Value rhs) {
     OpBuilder builder = getBuilder();
     if (isFloatingPoint(lhs))
       return builder.create<arith::AddFOp>(lhs.getLoc(), lhs, rhs);
     if (isInteger(lhs))
       return builder.create<arith::AddIOp>(lhs.getLoc(), lhs, rhs);
     llvm_unreachable("unsupported non numeric type");
   }
 
+  // NOLINTNEXTLINE(*-identifier-naming): externally called.
   Value applyfn__exp(Value x) {
     OpBuilder builder = getBuilder();
     if (isFloatingPoint(x))
       return builder.create<math::ExpOp>(x.getLoc(), x);
     llvm_unreachable("unsupported non numeric type");
   }
 
+  // NOLINTNEXTLINE(*-identifier-naming): externally called.
   Value applyfn__log(Value x) {
     OpBuilder builder = getBuilder();
     if (isFloatingPoint(x))
       return builder.create<math::LogOp>(x.getLoc(), x);
     llvm_unreachable("unsupported non numeric type");
   }
 
+  // NOLINTNEXTLINE(*-identifier-naming): externally called.
   Value applyfn__sub(Value lhs, Value rhs) {
     OpBuilder builder = getBuilder();
     if (isFloatingPoint(lhs))
       return builder.create<arith::SubFOp>(lhs.getLoc(), lhs, rhs);
     if (isInteger(lhs))
       return builder.create<arith::SubIOp>(lhs.getLoc(), lhs, rhs);
     llvm_unreachable("unsupported non numeric type");
   }
 
+  // NOLINTNEXTLINE(*-identifier-naming): externally called.
   Value applyfn__mul(Value lhs, Value rhs) {
     OpBuilder builder = getBuilder();
     if (isFloatingPoint(lhs))
       return builder.create<arith::MulFOp>(lhs.getLoc(), lhs, rhs);
     if (isInteger(lhs))
       return builder.create<arith::MulIOp>(lhs.getLoc(), lhs, rhs);
     llvm_unreachable("unsupported non numeric type");
   }
 
+  // NOLINTNEXTLINE(*-identifier-naming): externally called.
   Value applyfn__max(Value lhs, Value rhs) {
     OpBuilder builder = getBuilder();
     if (isFloatingPoint(lhs))
       return builder.create<arith::MaxFOp>(lhs.getLoc(), lhs, rhs);
     if (isInteger(lhs))
       return builder.create<arith::MaxSIOp>(lhs.getLoc(), lhs, rhs);
     llvm_unreachable("unsupported non numeric type");
   }
 
+  // NOLINTNEXTLINE(*-identifier-naming): externally called.
   Value applyfn__max_unsigned(Value lhs, Value rhs) {
     OpBuilder builder = getBuilder();
     if (isFloatingPoint(lhs))
       return builder.create<arith::MaxFOp>(lhs.getLoc(), lhs, rhs);
     if (isInteger(lhs))
       return builder.create<arith::MaxUIOp>(lhs.getLoc(), lhs, rhs);
     llvm_unreachable("unsupported non numeric type");
   }
 
+  // NOLINTNEXTLINE(*-identifier-naming): externally called.
   Value applyfn__min(Value lhs, Value rhs) {
     OpBuilder builder = getBuilder();
     if (isFloatingPoint(lhs))
       return builder.create<arith::MinFOp>(lhs.getLoc(), lhs, rhs);
     if (isInteger(lhs))
       return builder.create<arith::MinSIOp>(lhs.getLoc(), lhs, rhs);
     llvm_unreachable("unsupported non numeric type");
   }
 
+  // NOLINTNEXTLINE(*-identifier-naming): externally called.
   Value applyfn__min_unsigned(Value lhs, Value rhs) {
     OpBuilder builder = getBuilder();
     if (isFloatingPoint(lhs))
       return builder.create<arith::MinFOp>(lhs.getLoc(), lhs, rhs);
     if (isInteger(lhs))
       return builder.create<arith::MinUIOp>(lhs.getLoc(), lhs, rhs);
     llvm_unreachable("unsupported non numeric type");
   }
static ParseResult parseTiledLoopOp(OpAsmParser &parser,
   SmallVector<OpAsmParser::OperandType, 4> steps;
   if (parser.parseKeyword("step") ||
       parser.parseOperandList(steps, ivs.size(),
                               OpAsmParser::Delimiter::Paren) ||
       parser.resolveOperands(steps, builder.getIndexType(), result.operands))
     return failure();
 
   // Parse input tensors.
-  SmallVector<OpAsmParser::OperandType, 4> inputs, input_region_args;
+  SmallVector<OpAsmParser::OperandType, 4> inputs, inputRegionArgs;
   SmallVector<Type, 4> inputTypes;
   if (succeeded(parser.parseOptionalKeyword("ins"))) {
     llvm::SMLoc inputsOperandsLoc = parser.getCurrentLocation();
 
-    if (parser.parseAssignmentListWithTypes(input_region_args, inputs,
+    if (parser.parseAssignmentListWithTypes(inputRegionArgs, inputs,
                                             inputTypes))
       return failure();
 
     if (parser.resolveOperands(inputs, inputTypes, inputsOperandsLoc,
                                result.operands))
       return failure();
   }
 
   // Parse output tensors.
-  SmallVector<OpAsmParser::OperandType, 4> outputs, output_region_args;
+  SmallVector<OpAsmParser::OperandType, 4> outputs, outputRegionArgs;
   SmallVector<Type, 4> outputTypes;
   if (succeeded(parser.parseOptionalKeyword("outs"))) {
     llvm::SMLoc outputsOperandsLoc = parser.getCurrentLocation();
 
-    if (parser.parseAssignmentListWithTypes(output_region_args, outputs,
+    if (parser.parseAssignmentListWithTypes(outputRegionArgs, outputs,
                                             outputTypes))
       return failure();
 
     if (parser.resolveOperands(outputs, outputTypes, outputsOperandsLoc,
                                result.operands))
       return failure();
     for (Type outputType : outputTypes)
       if (outputType.isa<RankedTensorType>())
result.addAttribute(
                                 static_cast<int32_t>(upper.size()),
                                 static_cast<int32_t>(steps.size()),
                                 static_cast<int32_t>(inputs.size()),
                                 static_cast<int32_t>(outputs.size())}));
 
   // Parse the body.
   Region *body = result.addRegion();
 
-  SmallVector<Type, 4> region_types(ivs.size(), builder.getIndexType());
-  region_types.append(inputTypes);
-  region_types.append(outputTypes);
-
-  SmallVector<OpAsmParser::OperandType, 4> region_args(ivs);
-  region_args.append(input_region_args);
-  region_args.append(output_region_args);
+  SmallVector<Type, 4> regionTypes(ivs.size(), builder.getIndexType());
+  regionTypes.append(inputTypes);
+  regionTypes.append(outputTypes);
+
+  SmallVector<OpAsmParser::OperandType, 4> regionArgs(ivs);
+  regionArgs.append(inputRegionArgs);
+  regionArgs.append(outputRegionArgs);
 
-  if (parser.parseRegion(*body, region_args, region_types))
+  if (parser.parseRegion(*body, regionArgs, regionTypes))
     return failure();
 
   // Parse optional attributes.
   parser.parseOptionalAttrDict(result.attributes);
 
   return success();
 }
 

mlir/lib/Dialect/Linalg/Transforms/ElementwiseToLinalg.cpp

patterns.add<ConvertAnyElementwiseMappableOpOnRankedTensors>(
       patterns.getContext());
 }
 
 namespace {
 class ConvertElementwiseToLinalgPass
     : public ConvertElementwiseToLinalgBase<ConvertElementwiseToLinalgPass> {
 
   void runOnOperation() final {
-    auto func = getOperation();
+    auto *func = getOperation();
     auto *context = &getContext();
     ConversionTarget target(*context);
     RewritePatternSet patterns(context);
 
     mlir::linalg::populateElementwiseToLinalgConversionPatterns(patterns);
     target.markUnknownOpDynamicallyLegal([](Operation *op) {
       return !isElementwiseMappableOpOnRankedTensors(op);
     });

mlir/lib/Dialect/Linalg/Transforms/Vectorization.cpp

 /// or
 ///
 /// ```
 ///   Op def: (     n,     w,     c,    kw )
 ///    Iters: ({Par(), Par(), Par(), Red()})
 ///   Layout: {{n, strideW * w + dilationW * kw, c}, {kw, c}, {n, w, c}}
 /// ```
 /// kw is unrolled, w is unrolled iff dilationW > 1.
-struct Conv1D_NWC_Generator : public StructuredGenerator<LinalgOp> {
-  Conv1D_NWC_Generator(OpBuilder &builder, LinalgOp linalgOp, int strideW,
-                       int dilationW)
+struct Conv1DNwcGenerator : public StructuredGenerator<LinalgOp> {
+  Conv1DNwcGenerator(OpBuilder &builder, LinalgOp linalgOp, int strideW,
       : StructuredGenerator<LinalgOp>(builder, linalgOp), valid(false),
         strideW(strideW), dilationW(dilationW) {
     // Determine whether `linalgOp` can be generated with this generator
     if (linalgOp.getNumInputs() != 2 || linalgOp.getNumOutputs() != 1)
       return;
     lhsShaped = linalgOp.inputs()[0];
     rhsShaped = linalgOp.inputs()[1];
     resShaped = linalgOp.outputs()[0];
struct Conv1DNwcGenerator : public StructuredGenerator<LinalgOp> {
   /// Generate a vector implementation for:
   /// ```
   ///   Op def: (     n,     w,     c,    kw)
   ///    Iters: ({Par(), Par(), Par(), Red()})
   ///   Layout: {{n, strideW * w + dilationW * kw, c}, {kw, c}, {n, w, c}}
   /// ```
   /// kw is always unrolled.
   /// TODO: w (resp. kw) is unrolled when the strideW ( resp. dilationW) is > 1.
-  FailureOr<Operation *> dilated_conv() {
+  FailureOr<Operation *> dilatedConv() {
     if (!valid)
       return failure();
 
     int nSize = lhsShapedType.getShape()[0];
     int wSize = resShapedType.getShape()[1];
     int cSize = lhsShapedType.getShape()[2];
     int kwSize = rhsShapedType.getShape()[0];
 
FailureOr<Operation *> generateDilatedConv() {
     bindDims(ctx, n, w, c, kw);
     if (!iters({Par(), Par(), Par(), Red()}))
       return failure();
 
     // No transposition needed.
     if (layout({/*lhsIndex*/ {n, strideW * w + dilationW * kw, c},
                 /*rhsIndex*/ {kw, c},
                 /*resIndex*/ {n, w, c}}))
-      return dilated_conv();
+      return dilatedConv();
     return failure();
   }
 
 private:
   bool valid;
   int strideW, dilationW;
   Value lhsShaped, rhsShaped, resShaped;
   ShapedType lhsShapedType, rhsShapedType, resShapedType;
 };
 } // namespace
 
 /// Helper function to vectorize a `linalgOp` with convolution semantics.
 // TODO: extend the generic vectorization to support windows and drop this.
 static FailureOr<Operation *>
 vectorizeConvolution(OpBuilder &b, ConvolutionOpInterface convOp) {
   // TODO: these are legitimately part of ConvolutionOpInterface.
   auto strides = convOp->getAttrOfType<DenseIntElementsAttr>("strides");
   auto dilations = convOp->getAttrOfType<DenseIntElementsAttr>("dilations");
   auto stride = strides ? *strides.getValues<uint64_t>().begin() : 1;
   auto dilation = dilations ? *dilations.getValues<uint64_t>().begin() : 1;
   LinalgOp linalgOp = cast<LinalgOp>(convOp.getOperation());
-  Conv1D_NWC_Generator e(b, linalgOp, stride, dilation);
+  Conv1DNwcGenerator e(b, linalgOp, stride, dilation);
   auto res = e.generateConv();
   if (succeeded(res))
     return res;
   return e.generateDilatedConv();
 }
 
 struct VectorizeConvolution
     : public OpInterfaceRewritePattern<ConvolutionOpInterface> {

mlir/lib/Dialect/Math/Transforms/PolynomialApproximation.cpp

 static Value clamp(ImplicitLocOpBuilder &builder, Value value, Value lowerBound,
                    Value upperBound) {
   return max(builder, min(builder, value, upperBound), lowerBound);
 }
 
 // Decomposes given floating point value `arg` into a normalized fraction and
 // an integral power of two (see std::frexp). Returned values have float type.
 static std::pair<Value, Value> frexp(ImplicitLocOpBuilder &builder, Value arg,
-                                     bool is_positive = false) {
+                                     bool isPositive = false) {
   assert(getElementTypeOrSelf(arg).isF32() && "arg must be f32 type");
   ArrayRef<int64_t> shape = vectorShape(arg);
 
   auto bcast = [&](Value value) -> Value {
     return broadcast(builder, value, shape);
   };
 
   auto i32 = builder.getIntegerType(32);
static std::pair<Value, Value> frexp(ImplicitLocOpBuilder &builder, Value arg,
   Value i32Arg = builder.create<arith::BitcastOp>(i32Vec, arg);
 
   // Compute normalized fraction.
   Value tmp0 = builder.create<arith::AndIOp>(i32Arg, bcast(i32InvMantMask));
   Value tmp1 = builder.create<arith::OrIOp>(tmp0, bcast(i32Half));
   Value normalizedFraction = builder.create<arith::BitcastOp>(f32Vec, tmp1);
 
   // Compute exponent.
-  Value arg0 = is_positive ? arg : builder.create<math::AbsOp>(arg);
+  Value arg0 = isPositive ? arg : builder.create<math::AbsOp>(arg);
   Value biasedExponentBits = builder.create<arith::ShRUIOp>(
       builder.create<arith::BitcastOp>(i32Vec, arg0),
       bcast(i32Cst(builder, 23)));
   Value biasedExponent =
       builder.create<arith::SIToFPOp>(f32Vec, biasedExponentBits);
   Value exponent =
       builder.create<arith::SubFOp>(biasedExponent, bcast(cst126f));
 

mlir/lib/Dialect/OpenMP/IR/OpenMPDialect.cpp

if (parser.parseAttribute(symbols.emplace_back()) || parser.parseArrow() ||
       return failure();
   } while (succeeded(parser.parseOptionalComma()));
   return parser.parseRParen();
 }
 
 /// Print Reduction clause
 static void printReductionVarList(OpAsmPrinter &p,
                                   Optional<ArrayAttr> reductions,
-                                  OperandRange reduction_vars) {
+                                  OperandRange reductionVars) {
   p << "reduction(";
   for (unsigned i = 0, e = reductions->size(); i < e; ++i) {
     if (i != 0)
       p << ", ";
-    p << (*reductions)[i] << " -> " << reduction_vars[i] << " : "
-      << reduction_vars[i].getType();
+    p << (*reductions)[i] << " -> " << reductionVars[i] << " : "
+      << reductionVars[i].getType();
   }
   p << ") ";
 }
 
 /// Verifies Reduction Clause
 static LogicalResult verifyReductionVarList(Operation *op,
                                             Optional<ArrayAttr> reductions,
-                                            OperandRange reduction_vars) {
-  if (reduction_vars.size() != 0) {
-    if (!reductions || reductions->size() != reduction_vars.size())
+                                            OperandRange reductionVars) {
+  if (reductionVars.size() != 0) {
+    if (!reductions || reductions->size() != reductionVars.size())
       return op->emitOpError()
              << "expected as many reduction symbol references "
                 "as reduction variables";
   } else {
     if (reductions)
       return op->emitOpError() << "unexpected reduction symbol references";
     return success();
   }
 
   DenseSet<Value> accumulators;
-  for (auto args : llvm::zip(reduction_vars, *reductions)) {
+  for (auto args : llvm::zip(reductionVars, *reductions)) {
     Value accum = std::get<0>(args);
 
     if (!accumulators.insert(accum).second)
       return op->emitOpError() << "accumulator variable used more than once";
 
     Type varType = accum.getType().cast<PointerLikeType>();
     auto symbolRef = std::get<1>(args).cast<SymbolRefAttr>();
     auto decl =

mlir/lib/Dialect/PDL/IR/PDL.cpp

 
 //===----------------------------------------------------------------------===//
 // pdl::PatternOp
 //===----------------------------------------------------------------------===//
 
 static LogicalResult verify(PatternOp pattern) {
   Region &body = pattern.body();
   Operation *term = body.front().getTerminator();
-  auto rewrite_op = dyn_cast<RewriteOp>(term);
-  if (!rewrite_op) {
+  auto rewriteOp = dyn_cast<RewriteOp>(term);
+  if (!rewriteOp) {
     return pattern.emitOpError("expected body to terminate with `pdl.rewrite`")
         .attachNote(term->getLoc())
         .append("see terminator defined here");
   }
 
   // Check that all values defined in the top-level pattern belong to the PDL
   // dialect.
   WalkResult result = body.walk([&](Operation *op) -> WalkResult {

mlir/lib/Dialect/PDLInterp/IR/PDLInterp.cpp

 // pdl_interp::ForEachOp
 //===----------------------------------------------------------------------===//
 
 void ForEachOp::build(::mlir::OpBuilder &builder, ::mlir::OperationState &state,
                       Value range, Block *successor, bool initLoop) {
   build(builder, state, range, successor);
   if (initLoop) {
     // Create the block and the loop variable.
-    auto range_type = range.getType().cast<pdl::RangeType>();
+    auto rangeType = range.getType().cast<pdl::RangeType>();
     state.regions.front()->emplaceBlock();
-    state.regions.front()->addArgument(range_type.getElementType());
+    state.regions.front()->addArgument(rangeType.getElementType());
   }
 }
 
 static ParseResult parseForEachOp(OpAsmParser &parser, OperationState &result) {
   // Parse the loop variable followed by type.
   OpAsmParser::OperandType loopVariable;
   Type loopVariableType;
   if (parser.parseRegionArgument(loopVariable) ||

mlir/lib/Dialect/Quant/IR/QuantTypes.cpp

QuantizedType::getQuantizedElementType(Type primitiveOrContainerType) {
   }
   return primitiveOrContainerType.dyn_cast<QuantizedType>();
 }
 
 Type QuantizedType::castFromStorageType(Type candidateType) {
   if (candidateType == getStorageType()) {
     // i.e. i32 -> quant<"uniform[i8:f32]{1.0}">
     return *this;
-  } else if (candidateType.isa<RankedTensorType>()) {
+  }
+  if (candidateType.isa<RankedTensorType>()) {
     // i.e. tensor<4xi8> -> tensor<4x!quant<"uniform[i8:f32]{1.0}">>
     return RankedTensorType::get(
         candidateType.cast<RankedTensorType>().getShape(), getStorageType());
-  } else if (candidateType.isa<UnrankedTensorType>()) {
+  }
+  if (candidateType.isa<UnrankedTensorType>()) {
     // i.e. tensor<i8> -> tensor<!quant<"uniform[i8:f32]{1.0}">>
     return UnrankedTensorType::get(getStorageType());
   } else if (candidateType.isa<VectorType>()) {
     // i.e. tensor<4xi8> -> tensor<4x!quant<"uniform[i8:f32]{1.0}">>
     return VectorType::get(candidateType.cast<VectorType>().getShape(),
                            getStorageType());
   }
 
   return nullptr;
 }
 
 Type QuantizedType::castToStorageType(Type quantizedType) {
   if (quantizedType.isa<QuantizedType>()) {
     // i.e. quant<"uniform[i8:f32]{1.0}"> -> i8
     return quantizedType.cast<QuantizedType>().getStorageType();
-  } else if (quantizedType.isa<ShapedType>()) {
+  }
+  if (quantizedType.isa<ShapedType>()) {
     // i.e. tensor<4xi8> -> tensor<4x!quant<"uniform[i8:f32]{1.0}">>
     ShapedType sType = quantizedType.cast<ShapedType>();
     if (!sType.getElementType().isa<QuantizedType>()) {
       return nullptr;
     }
     Type storageType =
         sType.getElementType().cast<QuantizedType>().getStorageType();
     if (quantizedType.isa<RankedTensorType>()) {
       return RankedTensorType::get(sType.getShape(), storageType);
-    } else if (quantizedType.isa<UnrankedTensorType>()) {
+    }
+    if (quantizedType.isa<UnrankedTensorType>()) {
       return UnrankedTensorType::get(storageType);
     } else if (quantizedType.isa<VectorType>()) {
       return VectorType::get(sType.getShape(), storageType);
     }
   }
 
   return nullptr;
 }
 
 Type QuantizedType::castFromExpressedType(Type candidateType) {
   if (candidateType == getExpressedType()) {
     // i.e. f32 -> quant<"uniform[i8:f32]{1.0}">
     return *this;
-  } else if (candidateType.isa<ShapedType>()) {
+  }
+  if (candidateType.isa<ShapedType>()) {
     ShapedType candidateShapedType = candidateType.cast<ShapedType>();
     if (candidateShapedType.getElementType() != getExpressedType()) {
       return nullptr;
     }
 
     if (candidateType.isa<RankedTensorType>()) {
       // i.e. tensor<4xf32> -> tensor<4x!quant<"uniform[i8:f32]{1.0}">>
       return RankedTensorType::get(candidateShapedType.getShape(), *this);
-    } else if (candidateType.isa<UnrankedTensorType>()) {
+    }
+    if (candidateType.isa<UnrankedTensorType>()) {
       // i.e. tensor<xf32> -> tensor<x!quant<"uniform[i8:f32]{1.0}">>
       return UnrankedTensorType::get(*this);
     } else if (candidateType.isa<VectorType>()) {
       // i.e. tensor<4xf32> -> tensor<4x!quant<"uniform[i8:f32]{1.0}">>
       return VectorType::get(candidateShapedType.getShape(), *this);
     }
   }
 
   return nullptr;
 }
 
 Type QuantizedType::castToExpressedType(Type quantizedType) {
   if (quantizedType.isa<QuantizedType>()) {
     // i.e. quant<"uniform[i8:f32]{1.0}"> -> f32
     return quantizedType.cast<QuantizedType>().getExpressedType();
-  } else if (quantizedType.isa<ShapedType>()) {
+  }
+  if (quantizedType.isa<ShapedType>()) {
     // i.e. tensor<4xi8> -> tensor<4x!quant<"uniform[i8:f32]{1.0}">>
     ShapedType sType = quantizedType.cast<ShapedType>();
     if (!sType.getElementType().isa<QuantizedType>()) {
       return nullptr;
     }
     Type expressedType =
         sType.getElementType().cast<QuantizedType>().getExpressedType();
     if (quantizedType.isa<RankedTensorType>()) {
       return RankedTensorType::get(sType.getShape(), expressedType);
-    } else if (quantizedType.isa<UnrankedTensorType>()) {
+    }
+    if (quantizedType.isa<UnrankedTensorType>()) {
       return UnrankedTensorType::get(expressedType);
     } else if (quantizedType.isa<VectorType>()) {
       return VectorType::get(sType.getShape(), expressedType);
     }
   }
 
   return nullptr;
 }

mlir/lib/Dialect/Quant/Transforms/ConvertSimQuant.cpp

 };
 
 } // namespace
 
 void ConvertSimulatedQuantPass::runOnFunction() {
   bool hadFailure = false;
   auto func = getFunction();
   RewritePatternSet patterns(func.getContext());
-  auto ctx = func.getContext();
+  auto *ctx = func.getContext();
   patterns.add<ConstFakeQuantRewrite, ConstFakeQuantPerAxisRewrite>(
       ctx, &hadFailure);
   (void)applyPatternsAndFoldGreedily(func, std::move(patterns));
   if (hadFailure)
     signalPassFailure();
 }
 
 std::unique_ptr<OperationPass<FuncOp>>
 mlir::quant::createConvertSimulatedQuantPass() {
   return std::make_unique<ConvertSimulatedQuantPass>();
 }

mlir/lib/Dialect/Quant/Utils/FakeQuantSupport.cpp

return UniformQuantizedType::getChecked(loc, flags, storageType,
                                           expressedType, scale, nudgedZeroPoint,
                                           qmin, qmax);
 }
 
 UniformQuantizedPerAxisType mlir::quant::fakeQuantAttrsToType(
     Location loc, unsigned numBits, int32_t quantizedDimension,
     ArrayRef<double> rmins, ArrayRef<double> rmaxs, bool narrowRange,
     Type expressedType, bool isSigned) {
-  size_t axis_size = rmins.size();
-  if (axis_size != rmaxs.size()) {
+  size_t axisSize = rmins.size();
+  if (axisSize != rmaxs.size()) {
     return (emitError(loc, "mismatched per-axis min and max size: ")
-                << axis_size << " vs. " << rmaxs.size(),
+                << axisSize << " vs. " << rmaxs.size(),
             nullptr);
   }
 
   MLIRContext *ctx = expressedType.getContext();
   Type storageType;
   int64_t qmin;
   int64_t qmax;
   if (getDefaultStorageParams(numBits, narrowRange, isSigned, ctx, storageType,
                               qmin, qmax)) {
     return (emitError(loc, "unsupported FakeQuant number of bits: ") << numBits,
             nullptr);
   }
 
   SmallVector<double, 4> scales;
   SmallVector<int64_t, 4> zeroPoints;
-  scales.reserve(axis_size);
-  zeroPoints.reserve(axis_size);
-  for (size_t axis = 0; axis != axis_size; ++axis) {
+  scales.reserve(axisSize);
+  zeroPoints.reserve(axisSize);
+  for (size_t axis = 0; axis != axisSize; ++axis) {
     double rmin = rmins[axis];
     double rmax = rmaxs[axis];
     if (std::fabs(rmax - rmin) < std::numeric_limits<double>::epsilon()) {
       scales.push_back(1.0);
       zeroPoints.push_back(qmin);
       continue;
     }
 

mlir/lib/Dialect/Quant/Utils/QuantizeUtils.cpp

Attribute mlir::quant::quantizeAttrUniform(
     const UniformQuantizedValueConverter &converter, Type &outConvertedType) {
   // Fork to handle different variants of constants supported.
   if (realValue.isa<DenseFPElementsAttr>()) {
     // Dense tensor or vector constant.
     auto converted = convertDenseFPElementsAttr(
         realValue.cast<DenseFPElementsAttr>(), quantizedElementType, converter);
     outConvertedType = converted.getType();
     return converted;
-  } else if (realValue.isa<SparseElementsAttr>()) {
+  }
+  if (realValue.isa<SparseElementsAttr>()) {
     // Sparse tensor or vector constant.
     auto converted = convertSparseElementsAttr(
         realValue.cast<SparseElementsAttr>(), quantizedElementType, converter);
     outConvertedType = converted.getType();
     return converted;
-  } else {
-    // Nothing else matched: try to convert a primitive.
-    return convertPrimitiveValueAttr(realValue, quantizedElementType, converter,
-                                     outConvertedType);
-  }
-}
+  }
 
 /// Convert an attribute from a type based on
 /// quantizedElementType.getExpressedType() to one based on
 /// quantizedElementType.getStorageType().
 /// Returns nullptr if the conversion is not supported.
 /// On success, stores the converted type in outConvertedType.
 Attribute mlir::quant::quantizeAttr(Attribute realValue,
                                     QuantizedType quantizedElementType,
                                     Type &outConvertedType) {
   if (auto uniformQuantized =
           quantizedElementType.dyn_cast<UniformQuantizedType>()) {
     UniformQuantizedValueConverter converter(uniformQuantized);
     return quantizeAttrUniform(realValue, uniformQuantized, converter,
                                outConvertedType);
-
-  } else if (auto uniformQuantizedPerAxis =
-                 quantizedElementType.dyn_cast<UniformQuantizedPerAxisType>()) {
+  }
+  if (auto uniformQuantizedPerAxis =
     UniformQuantizedPerAxisValueConverter converter(uniformQuantizedPerAxis);
     auto converted = converter.convert(realValue);
     // TODO: why we need this outConvertedType? remove it?
     if (converted) {
       outConvertedType = converted.getType();
     }
     return converted;
-  } else {
-    return nullptr;
   }
+  return nullptr;
 }

mlir/lib/Dialect/SPIRV/IR/SPIRVCanonicalization.cpp

 }
 
 //===----------------------------------------------------------------------===//
 // TableGen'erated canonicalizers
 //===----------------------------------------------------------------------===//
 
 namespace {
 #include "SPIRVCanonicalization.inc"
-}
+} // namespace
 
 //===----------------------------------------------------------------------===//
 // spv.AccessChainOp
 //===----------------------------------------------------------------------===//
 
 namespace {
 
 /// Combines chained `spirv::AccessChainOp` operations into one

mlir/lib/Dialect/SPIRV/IR/SPIRVOps.cpp

if (parser.resolveOperands(operandInfo,
                              parser.getNameLoc(), state.operands)) {
     return failure();
   }
 
   state.addTypes(elementType);
   return success();
 }
 
-static void print(spirv::CooperativeMatrixLoadNVOp M, OpAsmPrinter &printer) {
-  printer << " " << M.pointer() << ", " << M.stride() << ", "
-          << M.columnmajor();
+static void print(spirv::CooperativeMatrixLoadNVOp m, OpAsmPrinter &printer) {
+  printer << " " << m.pointer() << ", " << m.stride() << ", "
+          << m.columnmajor();
   // Print optional memory access attribute.
-  if (auto memAccess = M.memory_access())
+  if (auto memAccess = m.memory_access())
     printer << " [\"" << stringifyMemoryAccess(*memAccess) << "\"]";
-  printer << " : " << M.pointer().getType() << " as " << M.getType();
+  printer << " : " << m.pointer().getType() << " as " << m.getType();
 }
 
 static LogicalResult verifyPointerAndCoopMatrixType(Operation *op, Type pointer,
                                                     Type coopMatrix) {
   Type pointeeType = pointer.cast<spirv::PointerType>().getPointeeType();
   if (!pointeeType.isa<spirv::ScalarType>() && !pointeeType.isa<VectorType>())
     return op->emitError(
                "Pointer must point to a scalar or vector type but provided ")

mlir/lib/Dialect/Shape/IR/Shape.cpp

 
 using namespace mlir;
 using namespace mlir::shape;
 
 #include "mlir/Dialect/Shape/IR/ShapeOpsDialect.cpp.inc"
 
 namespace {
 #include "ShapeCanonicalization.inc"
-}
+} // namespace
 
 RankedTensorType shape::getExtentTensorType(MLIRContext *ctx, int64_t rank) {
   return RankedTensorType::get({rank}, IndexType::get(ctx));
 }
 
 bool shape::isExtentTensorType(Type type) {
   auto ranked = type.dyn_cast<RankedTensorType>();
   return ranked && ranked.getRank() == 1 && ranked.getElementType().isIndex();
 }
 
 LogicalResult shape::getShapeVec(Value input,
                                  SmallVectorImpl<int64_t> &shapeValues) {
   if (auto inputOp = input.getDefiningOp<ShapeOfOp>()) {
     auto type = inputOp.getArg().getType().dyn_cast<ShapedType>();
     if (!type.hasRank())
       return failure();
     shapeValues = llvm::to_vector<6>(type.getShape());
     return success();
-  } else if (auto inputOp = input.getDefiningOp<ConstShapeOp>()) {
+  }
+  if (auto inputOp = input.getDefiningOp<ConstShapeOp>()) {
     shapeValues = llvm::to_vector<6>(inputOp.getShape().getValues<int64_t>());
     return success();
   } else if (auto inputOp = input.getDefiningOp<arith::ConstantOp>()) {
     shapeValues = llvm::to_vector<6>(
         inputOp.getValue().cast<DenseIntElementsAttr>().getValues<int64_t>());
     return success();
   } else {
     return failure();

mlir/lib/Dialect/StandardOps/IR/Ops.cpp

struct SimplifyConstCondBranchPred : public OpRewritePattern<CondBranchOp> {
 
   LogicalResult matchAndRewrite(CondBranchOp condbr,
                                 PatternRewriter &rewriter) const override {
     if (matchPattern(condbr.getCondition(), m_NonZero())) {
       // True branch taken.
       rewriter.replaceOpWithNewOp<BranchOp>(condbr, condbr.getTrueDest(),
                                             condbr.getTrueOperands());
       return success();
-    } else if (matchPattern(condbr.getCondition(), m_Zero())) {
+    }
+    if (matchPattern(condbr.getCondition(), m_Zero())) {
       // False branch taken.
       rewriter.replaceOpWithNewOp<BranchOp>(condbr, condbr.getFalseDest(),
                                             condbr.getFalseOperands());
       return success();
     }
     return failure();
   }
 };

mlir/lib/Dialect/Tensor/IR/TensorInferTypeOpInterfaceImpl.cpp

 template <typename OpTy>
 struct ReifyExpandOrCollapseShapeOp
     : public ReifyRankedShapedTypeOpInterface::ExternalModel<
           ReifyExpandOrCollapseShapeOp<OpTy>, OpTy> {
   LogicalResult
   reifyResultShapes(Operation *op, OpBuilder &b,
                     ReifiedRankedShapedTypeDims &reifiedReturnShapes) const {
     auto loc = op->getLoc();
-    auto reshape_op = cast<OpTy>(op);
-    auto result_shape = getReshapeOutputShapeFromInputShape(
-        b, loc, reshape_op.src(), reshape_op.getResultType().getShape(),
-        reshape_op.getReassociationMaps());
-    reifiedReturnShapes.push_back(getAsValues(b, loc, result_shape));
+    auto reshapeOp = cast<OpTy>(op);
+    auto resultShape = getReshapeOutputShapeFromInputShape(
+        b, loc, reshapeOp.src(), reshapeOp.getResultType().getShape(),
+        reshapeOp.getReassociationMaps());
+    reifiedReturnShapes.push_back(getAsValues(b, loc, resultShape));
     return success();
   }
 };
 
 void mlir::tensor::registerInferTypeOpInterfaceExternalModels(
     DialectRegistry &registry) {
   registry
       .addOpInterface<tensor::ExpandShapeOp,
                       ReifyExpandOrCollapseShapeOp<tensor::ExpandShapeOp>>();
   registry
       .addOpInterface<tensor::CollapseShapeOp,
                       ReifyExpandOrCollapseShapeOp<tensor::CollapseShapeOp>>();
 }

mlir/lib/Dialect/Tensor/IR/TensorOps.cpp

if (shapedType && shapedType.hasRank())
     return IntegerAttr::get(IndexType::get(getContext()), shapedType.getRank());
   return IntegerAttr();
 }
 
 //===----------------------------------------------------------------------===//
 // ReshapeOp
 //===----------------------------------------------------------------------===//
 
-static int64_t GetNumElements(ShapedType type) {
+static int64_t getNumElements(ShapedType type) {
   int64_t numElements = 1;
   for (auto dim : type.getShape())
     numElements *= dim;
   return numElements;
 }
 
 static LogicalResult verify(ReshapeOp op) {
   TensorType operandType = op.source().getType().cast<TensorType>();
   TensorType resultType = op.result().getType().cast<TensorType>();
 
   if (operandType.getElementType() != resultType.getElementType())
     return op.emitOpError("element types of source and destination tensor "
                           "types should be the same");
 
   int64_t shapeSize =
       op.shape().getType().cast<RankedTensorType>().getDimSize(0);
   auto resultRankedType = resultType.dyn_cast<RankedTensorType>();
   auto operandRankedType = operandType.dyn_cast<RankedTensorType>();
 
   if (resultRankedType) {
     if (operandRankedType && resultRankedType.hasStaticShape() &&
         operandRankedType.hasStaticShape()) {
-      if (GetNumElements(operandRankedType) != GetNumElements(resultRankedType))
+      if (getNumElements(operandRankedType) != getNumElements(resultRankedType))
         return op.emitOpError("source and destination tensor should have the "
                               "same number of elements");
     }
     if (shapeSize == TensorType::kDynamicSize)
       return op.emitOpError("cannot use shape operand with dynamic length to "
                             "reshape to statically-ranked tensor type");
     if (shapeSize != resultRankedType.getRank())
       return op.emitOpError(

mlir/lib/Dialect/Tensor/Transforms/Bufferize.cpp

matchAndRewrite(tensor::FromElementsOp op, OpAdaptor adaptor,
     auto maxDim = *std::max_element(shape.begin(), shape.end());
     SmallVector<Value, 2> constants;
     constants.reserve(maxDim);
     for (int i = 0; i < maxDim; ++i)
       constants.push_back(rewriter.create<arith::ConstantIndexOp>(loc, i));
 
     // Traverse all `elements` and create `memref.store` ops.
     ImplicitLocOpBuilder b(loc, rewriter);
-    auto element_it = adaptor.elements().begin();
+    auto elementIt = adaptor.elements().begin();
     SmallVector<Value, 2> indices(tensorType.getRank(), constants[0]);
-    CreateStores(/*dim=*/0, buffer, shape, constants, element_it, indices, b);
+    createStores(/*dim=*/0, buffer, shape, constants, elementIt, indices, b);
 
     rewriter.replaceOp(op, {buffer});
     return success();
   }
 
 private:
   // Implements backtracking to traverse indices of the output buffer while
   // iterating over op.elements().
-  void CreateStores(int dim, Value buffer, ArrayRef<int64_t> shape,
-                    ArrayRef<Value> constants, ValueRange::iterator &element_it,
+  void createStores(int dim, Value buffer, ArrayRef<int64_t> shape,
+                    ArrayRef<Value> constants, ValueRange::iterator &elementIt,
                     SmallVectorImpl<Value> &indices,
                     ImplicitLocOpBuilder b) const {
     if (dim == static_cast<int>(shape.size()) - 1) {
       for (int i = 0; i < shape.back(); ++i) {
         indices.back() = constants[i];
-        b.create<memref::StoreOp>(*element_it, buffer, indices);
-        ++element_it;
+        b.create<memref::StoreOp>(*elementIt, buffer, indices);
+        ++elementIt;
       }
       return;
     }
     for (int i = 0; i < shape[dim]; ++i) {
       indices[dim] = constants[i];
-      CreateStores(dim + 1, buffer, shape, constants, element_it, indices, b);
+      createStores(dim + 1, buffer, shape, constants, elementIt, indices, b);
     }
   }
 };
 
 struct BufferizeGenerateOp : public OpConversionPattern<tensor::GenerateOp> {
   using OpConversionPattern::OpConversionPattern;
 
   LogicalResult

mlir/lib/Dialect/Tosa/IR/TosaOps.cpp

 }
 
 /// This builder is called on TOSA pad operator when an explicit pad_const
 /// value is passed in. It also optionally constructs quantization_attr.
 static void buildExplicitValuePadOpWithQuantInfo(OpBuilder &builder,
                                                  OperationState &result,
                                                  Type outputType, Value input,
                                                  Value paddings,
-                                                 Value pad_const) {
-  result.addOperands({input, paddings, pad_const});
+                                                 Value padConst) {
+  result.addOperands({input, paddings, padConst});
   auto quantAttr = buildPadOpQuantizationAttr(builder, input);
   if (quantAttr)
     result.addAttribute("quantization_info", quantAttr);
   result.types.push_back(outputType);
 }
 
 //===----------------------------------------------------------------------===//
 // TOSA Operator Return Type Inference.

mlir/lib/Dialect/Tosa/Transforms/TosaDecomposeTransposeConv.cpp

 static void getValuesFromIntArrayAttribute(ArrayAttr attr,
                                            SmallVector<T> &arrayValues) {
   for (Attribute val : attr.getValue()) {
     arrayValues.push_back(val.cast<IntegerAttr>().getValue().getSExtValue());
   }
 }
 
 template <typename TosaOp, typename... Args>
-TosaOp CreateOpAndInfer(PatternRewriter &rewriter, Location loc, Type result_ty,
+TosaOp createOpAndInfer(PatternRewriter &rewriter, Location loc, Type resultTy,
                         Args &&...args) {
-  auto op = rewriter.create<TosaOp>(loc, result_ty, args...);
+  auto op = rewriter.create<TosaOp>(loc, resultTy, args...);
 
   InferShapedTypeOpInterface shapeInterface =
       dyn_cast<InferShapedTypeOpInterface>(op.getOperation());
   if (!shapeInterface)
     return op;
 
   SmallVector<ShapedTypeComponents> returnedShapes;
   if (shapeInterface
           .inferReturnTypeComponents(op.getContext(), op.getLoc(),
                                      op->getOperands(), op->getAttrDictionary(),
                                      op->getRegions(), returnedShapes)
           .failed())
     return op;
 
   // We need to use the element type of the existing result type to generate
   // the new result shaped type. This is because rescale can include a cast to
   // different bit-width types and does not have a TypeAttr to define the
   // target type.
   auto result = op->getResult(0);
   auto predictedShape = returnedShapes[0];
   auto currentKnowledge =
-      mlir::tosa::ValueKnowledge::getKnowledgeFromType(result_ty);
+      mlir::tosa::ValueKnowledge::getKnowledgeFromType(resultTy);
 
   // Compute the knowledge based on the inferred type.
   auto inferredKnowledge =
       mlir::tosa::ValueKnowledge::getPessimisticValueState();
-  inferredKnowledge.dtype = result_ty.cast<ShapedType>().getElementType();
+  inferredKnowledge.dtype = resultTy.cast<ShapedType>().getElementType();
   inferredKnowledge.hasRank = predictedShape.hasRank();
   if (predictedShape.hasRank()) {
     for (auto dim : predictedShape.getDims()) {
       inferredKnowledge.sizes.push_back(dim);
     }
   }
 
   // Compute the new type based on the joined version.
   auto newKnowledge =
       mlir::tosa::ValueKnowledge::join(currentKnowledge, inferredKnowledge);
-  auto new_ty = newKnowledge.getType();
-  result.setType(new_ty);
+  auto newTy = newKnowledge.getType();
+  result.setType(newTy);
   return op;
 }
 
 class TransposeConvDilatedConverter
     : public OpRewritePattern<tosa::TransposeConv2DOp> {
 public:
   using OpRewritePattern<tosa::TransposeConv2DOp>::OpRewritePattern;
   LogicalResult matchAndRewrite(tosa::TransposeConv2DOp op,
LogicalResult matchAndRewrite(tosa::TransposeConv2DOp op,
     // Pad the weight so that it is modulo of the striding.
     llvm::SmallVector<int32_t, 8> weightPadding = {0, 0, 0, 0, 0, 0, 0, 0};
     weightPadding[3] =
         weightHeight % stride[0] ? stride[0] - weightHeight % stride[0] : 0;
     weightPadding[5] =
         weightWidth % stride[1] ? stride[1] - weightWidth % stride[1] : 0;
     DenseElementsAttr weightPaddingAttr = DenseIntElementsAttr::get(
         RankedTensorType::get({4, 2}, rewriter.getI32Type()), weightPadding);
-    Value weightPaddingVal = CreateOpAndInfer<tosa::ConstOp>(
+    Value weightPaddingVal = createOpAndInfer<tosa::ConstOp>(
         rewriter, loc, weightPaddingAttr.getType(), weightPaddingAttr);
 
     if (op.quantization_info().hasValue()) {
       auto quantInfo = op.quantization_info().getValue();
-      weight = CreateOpAndInfer<tosa::PadOp>(
+      weight = createOpAndInfer<tosa::PadOp>(
           rewriter, loc, UnrankedTensorType::get(weightETy), weight,
           weightPaddingVal, nullptr,
           PadOpQuantizationAttr::get(quantInfo.weight_zp(),
                                      rewriter.getContext()));
 
     } else {
-      weight = CreateOpAndInfer<tosa::PadOp>(rewriter, loc,
+      weight = createOpAndInfer<tosa::PadOp>(rewriter, loc,
                                              UnrankedTensorType::get(weightETy),
                                              weight, weightPaddingVal);
     }
 
     weightTy = weight.getType().cast<ShapedType>();
     weightHeight = weightTy.getDimSize(1);
     weightWidth = weightTy.getDimSize(2);
 
     // Split out the width / height by the stride dimensions.
     llvm::SmallVector<int64_t, 6> weightReshapeDims0 = {
         outputChannels, weightHeight / stride[0],
         stride[0],      weightWidth / stride[1],
         stride[1],      inputChannels};
-    weight = CreateOpAndInfer<tosa::ReshapeOp>(
+    weight = createOpAndInfer<tosa::ReshapeOp>(
         rewriter, loc, UnrankedTensorType::get(weightETy), weight,
         rewriter.getI64ArrayAttr(weightReshapeDims0));
 
     // Transpose the factored-out stride to the output channels.
     Value transposeWeightVal = rewriter.create<tosa::ConstOp>(
         loc, RankedTensorType::get({6}, rewriter.getI32Type()),
         rewriter.getI32TensorAttr({2, 4, 0, 1, 3, 5}));
 
-    weight = CreateOpAndInfer<tosa::TransposeOp>(
+    weight = createOpAndInfer<tosa::TransposeOp>(
         rewriter, loc, UnrankedTensorType::get(weightETy), weight,
         transposeWeightVal);
 
     // Collapse the strides and output channels into a single dimension.
     llvm::SmallVector<int64_t, 6> weightReshapeDims1 = {
         outputChannels * stride[0] * stride[1], weightHeight / stride[0],
         weightWidth / stride[1], inputChannels};
-    weight = CreateOpAndInfer<tosa::ReshapeOp>(
+    weight = createOpAndInfer<tosa::ReshapeOp>(
         rewriter, loc, UnrankedTensorType::get(weightETy), weight,
         rewriter.getI64ArrayAttr(weightReshapeDims1));
     ShapedType restridedWeightTy = weight.getType().cast<ShapedType>();
 
-    weight = CreateOpAndInfer<tosa::ReverseOp>(
+    weight = createOpAndInfer<tosa::ReverseOp>(
         rewriter, loc, UnrankedTensorType::get(weightETy), weight,
         rewriter.getI64IntegerAttr(1));
-    weight = CreateOpAndInfer<tosa::ReverseOp>(
+    weight = createOpAndInfer<tosa::ReverseOp>(
         rewriter, loc, UnrankedTensorType::get(weightETy), weight,
         rewriter.getI64IntegerAttr(2));
 
     // We need to pad the input far enough that we can pull all values.
     llvm::SmallVector<int32_t, 8> inputPadding = {0, 0, 0, 0, 0, 0, 0, 0};
     inputPadding[2] += restridedWeightTy.getDimSize(1) - 1;
     inputPadding[3] += restridedWeightTy.getDimSize(1) - 1;
     inputPadding[4] += restridedWeightTy.getDimSize(2) - 1;
     inputPadding[5] += restridedWeightTy.getDimSize(2) - 1;
 
     DenseElementsAttr inputPaddingAttr = DenseIntElementsAttr::get(
         RankedTensorType::get({4, 2}, rewriter.getI32Type()), inputPadding);
 
-    Value inputPaddingVal = CreateOpAndInfer<tosa::ConstOp>(
+    Value inputPaddingVal = createOpAndInfer<tosa::ConstOp>(
         rewriter, loc, inputPaddingAttr.getType(), inputPaddingAttr);
 
     if (op.quantization_info().hasValue()) {
       auto quantInfo = op.quantization_info().getValue();
-      input = CreateOpAndInfer<tosa::PadOp>(
+      input = createOpAndInfer<tosa::PadOp>(
           rewriter, loc, UnrankedTensorType::get(inputETy), input,
           inputPaddingVal, nullptr,
           PadOpQuantizationAttr::get(quantInfo.input_zp(),
                                      rewriter.getContext()));
     } else {
-      input = CreateOpAndInfer<tosa::PadOp>(rewriter, loc,
+      input = createOpAndInfer<tosa::PadOp>(rewriter, loc,
                                             UnrankedTensorType::get(inputETy),
                                             input, inputPaddingVal);
     }
 
     // We use a zero bias as we need to broadcast the bias.
     auto zeroBias = rewriter.create<tosa::ConstOp>(
         loc,
         RankedTensorType::get({outputChannels * stride[0] * stride[1]},
                               biasETy),
         DenseElementsAttr::get(
             RankedTensorType::get({outputChannels * stride[0] * stride[1]},
                                   biasETy),
             rewriter.getZeroAttr(biasETy)));
 
     // Perform the convolution using the zero bias.
     Value conv2d;
     if (op.quantization_info().hasValue()) {
-      conv2d = CreateOpAndInfer<tosa::Conv2DOp>(
+      conv2d = createOpAndInfer<tosa::Conv2DOp>(
                    rewriter, loc, UnrankedTensorType::get(resultETy), input,
                    weight, zeroBias,
                    /*pad=*/rewriter.getI64ArrayAttr({0, 0, 0, 0}),
                    /*stride=*/rewriter.getI64ArrayAttr({1, 1}),
                    /*dilation=*/rewriter.getI64ArrayAttr({1, 1}),
                    op.quantization_info().getValue())
                    .getResult();
     } else {
-      conv2d = CreateOpAndInfer<tosa::Conv2DOp>(
+      conv2d = createOpAndInfer<tosa::Conv2DOp>(
                    rewriter, loc, UnrankedTensorType::get(resultETy), input,
                    weight, zeroBias,
                    /*pad=*/rewriter.getI64ArrayAttr({0, 0, 0, 0}),
                    /*stride=*/rewriter.getI64ArrayAttr({1, 1}),
                    /*dilation=*/rewriter.getI64ArrayAttr({1, 1}))
                    .getResult();
     }
 
     // Factor the resulting width / height.
     ShapedType convTy = conv2d.getType().cast<ShapedType>();
     Type convETy = convTy.getElementType();
 
     int64_t convHeight = convTy.getDimSize(1);
     int64_t convWidth = convTy.getDimSize(2);
 
     // Factor striding out of the convolution result.
     llvm::SmallVector<int64_t, 6> convReshapeDims0 = {
         batch, convHeight, convWidth, stride[0], stride[1], outputChannels};
-    conv2d = CreateOpAndInfer<tosa::ReshapeOp>(
+    conv2d = createOpAndInfer<tosa::ReshapeOp>(
         rewriter, loc, UnrankedTensorType::get(resultETy), conv2d,
         rewriter.getI64ArrayAttr(convReshapeDims0));
 
     // Transpose the factored-out stride to the output channels.
     Value transposeConvVal = rewriter.create<tosa::ConstOp>(
         loc, RankedTensorType::get({6}, rewriter.getI32Type()),
         rewriter.getI32TensorAttr({0, 1, 3, 2, 4, 5}));
 
-    conv2d = CreateOpAndInfer<tosa::TransposeOp>(
+    conv2d = createOpAndInfer<tosa::TransposeOp>(
         rewriter, loc, UnrankedTensorType::get(convETy), conv2d,
         transposeConvVal);
 
     // Fuse striding behavior back into width / height.
     llvm::SmallVector<int64_t, 6> convReshapeDims1 = {
         batch, convHeight * stride[0], convWidth * stride[1], outputChannels};
-    conv2d = CreateOpAndInfer<tosa::ReshapeOp>(
+    conv2d = createOpAndInfer<tosa::ReshapeOp>(
         rewriter, loc, UnrankedTensorType::get(resultETy), conv2d,
         rewriter.getI64ArrayAttr(convReshapeDims1));
 
     // Slice out the final result.
     llvm::SmallVector<int64_t, 4> sliceBegin = {0, 0, 0, 0};
     llvm::SmallVector<int64_t, 4> sliceSize(resultTy.getShape().begin(),
                                             resultTy.getShape().begin());
     sliceBegin[1] = pad[0];
     sliceBegin[2] = pad[1];
 
-    auto slice = CreateOpAndInfer<tosa::SliceOp>(
+    auto slice = createOpAndInfer<tosa::SliceOp>(
                      rewriter, loc, UnrankedTensorType::get(resultETy), conv2d,
                      rewriter.getI64ArrayAttr(sliceBegin),
                      rewriter.getI64ArrayAttr(resultTy.getShape()))
                      .getResult();
 
     auto addBias =
-        CreateOpAndInfer<tosa::AddOp>(rewriter, loc, op.getType(), slice, bias);
+        createOpAndInfer<tosa::AddOp>(rewriter, loc, op.getType(), slice, bias);
 
     rewriter.replaceOp(op, addBias.getResult());
 
     return success();
   }
 };
 
 /// Pass that enables broadcast by making all input arrays have the same

mlir/lib/Dialect/Tosa/Transforms/TosaInferShapes.cpp

for (Operation &op : block) {
               .succeeded()) {
         for (auto it : llvm::zip(op.getResults(), returnedShapes)) {
           Value result = std::get<0>(it);
           ShapedTypeComponents predictedShape = std::get<1>(it);
 
           // Check whether this use case is replaceable. We define an op as
           // being replaceable if it is used by a ReturnOp or a TosaOp.
           bool replaceable = true;
-          for (auto user : result.getUsers()) {
+          for (auto *user : result.getUsers()) {
             if (isa<ReturnOp>(user))
               continue;
             if (user->getDialect()->getNamespace() ==
                 TosaDialect::getDialectNamespace())
               continue;
 
             replaceable = false;
           }

mlir/lib/Dialect/Vector/VectorTransforms.cpp

UnrolledOuterProductGenerator(OpBuilder &builder, vector::ContractionOp op)
         kind(op.kind()), lhs(op.lhs()), rhs(op.rhs()), res(op.acc()),
         lhsType(op.getLhsType()) {}
 
   Value t(Value v) {
     static constexpr std::array<int64_t, 2> perm = {1, 0};
     return builder.create<vector::TransposeOp>(loc, v, perm);
   }
 
-  Value outer_prod(Value lhs, Value rhs, Value res, int reductionSize) {
+  Value outerProd(Value lhs, Value rhs, Value res, int reductionSize) {
     assert(reductionSize > 0);
     for (int64_t k = 0; k < reductionSize; ++k) {
       Value a = builder.create<vector::ExtractOp>(loc, lhs, k);
       Value b = builder.create<vector::ExtractOp>(loc, rhs, k);
       res = builder.create<vector::OuterProductOp>(loc, res.getType(), a, b,
                                                    res, kind);
     }
     return res;
   }
 
   /// Two outer parallel, one inner reduction (matmat flavor).
   FailureOr<Value> matmat() {
     if (!iters({Par(), Par(), Red()}))
       return failure();
     // Set up the parallel/reduction structure in the right form.
     AffineExpr m, n, k;
     bindDims(builder.getContext(), m, n, k);
     // Classical row-major matmul:  Just permute the lhs.
     if (layout({{m, k}, {k, n}, {m, n}}))
-      return outer_prod(t(lhs), rhs, res, lhsType.getDimSize(1));
+      return outerProd(t(lhs), rhs, res, lhsType.getDimSize(1));
     // TODO: may be better to fail and use some vector<k> -> scalar reduction.
     if (layout({{m, k}, {n, k}, {m, n}})) {
       Value tlhs = t(lhs);
-      return outer_prod(tlhs, t(rhs), res, lhsType.getDimSize(1));
+      return outerProd(tlhs, t(rhs), res, lhsType.getDimSize(1));
     }
     // No need to permute anything.
     if (layout({{k, m}, {k, n}, {m, n}}))
-      return outer_prod(lhs, rhs, res, lhsType.getDimSize(0));
+      return outerProd(lhs, rhs, res, lhsType.getDimSize(0));
     // Just permute the rhs.
     if (layout({{k, m}, {n, k}, {m, n}}))
-      return outer_prod(lhs, t(rhs), res, lhsType.getDimSize(0));
+      return outerProd(lhs, t(rhs), res, lhsType.getDimSize(0));
     // Transposed output: swap RHS and LHS.
     // Classical row-major matmul: permute the lhs.
     if (layout({{m, k}, {k, n}, {n, m}}))
-      return outer_prod(rhs, t(lhs), res, lhsType.getDimSize(1));
+      return outerProd(rhs, t(lhs), res, lhsType.getDimSize(1));
     // TODO: may be better to fail and use some vector<k> -> scalar reduction.
     if (layout({{m, k}, {n, k}, {n, m}})) {
       Value trhs = t(rhs);
-      return outer_prod(trhs, t(lhs), res, lhsType.getDimSize(1));
+      return outerProd(trhs, t(lhs), res, lhsType.getDimSize(1));
     }
     if (layout({{k, m}, {k, n}, {n, m}}))
-      return outer_prod(rhs, lhs, res, lhsType.getDimSize(0));
+      return outerProd(rhs, lhs, res, lhsType.getDimSize(0));
     if (layout({{k, m}, {n, k}, {n, m}}))
-      return outer_prod(t(rhs), lhs, res, lhsType.getDimSize(0));
+      return outerProd(t(rhs), lhs, res, lhsType.getDimSize(0));
     return failure();
   }
 
   /// One outer parallel, one inner reduction (matvec flavor)
   FailureOr<Value> matvec() {
     if (!iters({Par(), Red()}))
       return failure();
     AffineExpr m, k;
     bindDims(builder.getContext(), m, k);
 
     // Case mat-vec: transpose.
     if (layout({{m, k}, {k}, {m}}))
-      return outer_prod(t(lhs), rhs, res, lhsType.getDimSize(1));
+      return outerProd(t(lhs), rhs, res, lhsType.getDimSize(1));
     // Case mat-trans-vec: ready to go.
     if (layout({{k, m}, {k}, {m}}))
-      return outer_prod(lhs, rhs, res, lhsType.getDimSize(0));
+      return outerProd(lhs, rhs, res, lhsType.getDimSize(0));
     // Case vec-mat: swap and transpose.
     if (layout({{k}, {m, k}, {m}}))
-      return outer_prod(t(rhs), lhs, res, lhsType.getDimSize(0));
+      return outerProd(t(rhs), lhs, res, lhsType.getDimSize(0));
     // Case vec-mat-trans: swap and ready to go.
     if (layout({{k}, {k, m}, {m}}))
-      return outer_prod(rhs, lhs, res, lhsType.getDimSize(0));
+      return outerProd(rhs, lhs, res, lhsType.getDimSize(0));
     return failure();
   }
 
   //
   // One outer reduction, one inner parallel (tmatvec flavor)
   //
   FailureOr<Value> tmatvec() {
     if (!iters({Red(), Par()}))
       return failure();
     AffineExpr k, m;
     bindDims(builder.getContext(), k, m);
 
     // Case mat-vec: transpose.
     if (layout({{m, k}, {k}, {m}}))
-      return outer_prod(t(lhs), rhs, res, lhsType.getDimSize(1));
+      return outerProd(t(lhs), rhs, res, lhsType.getDimSize(1));
     // Case mat-trans-vec: ready to go.
     if (layout({{k, m}, {k}, {m}}))
-      return outer_prod(lhs, rhs, res, lhsType.getDimSize(0));
+      return outerProd(lhs, rhs, res, lhsType.getDimSize(0));
     // Case vec-mat: swap and transpose.
     if (layout({{k}, {m, k}, {m}}))
-      return outer_prod(t(rhs), lhs, res, lhsType.getDimSize(0));
+      return outerProd(t(rhs), lhs, res, lhsType.getDimSize(0));
     // Case vec-mat-trans: swap and ready to go.
     if (layout({{k}, {k, m}, {m}}))
-      return outer_prod(rhs, lhs, res, lhsType.getDimSize(0));
+      return outerProd(rhs, lhs, res, lhsType.getDimSize(0));
     return failure();
   }
 
 private:
   vector::CombiningKind kind;
   Value lhs, rhs, res;
   VectorType lhsType;
 };

mlir/lib/Dialect/X86Vector/Transforms/AVXTranspose.cpp

 using namespace mlir::x86vector::avx2;
 using namespace mlir::x86vector::avx2::inline_asm;
 using namespace mlir::x86vector::avx2::intrin;
 
 Value mlir::x86vector::avx2::inline_asm::mm256BlendPsAsm(
     ImplicitLocOpBuilder &b, Value v1, Value v2, uint8_t mask) {
   auto asmDialectAttr =
       LLVM::AsmDialectAttr::get(b.getContext(), LLVM::AsmDialect::AD_Intel);
-  auto asmTp = "vblendps $0, $1, $2, {0}";
-  auto asmCstr = "=x,x,x"; // Careful: constraint parser is very brittle: no ws!
+  const auto *asmTp = "vblendps $0, $1, $2, {0}";
+  const auto *asmCstr =
+      "=x,x,x"; // Careful: constraint parser is very brittle: no ws!
   SmallVector<Value> asmVals{v1, v2};
   auto asmStr = llvm::formatv(asmTp, llvm::format_hex(mask, /*width=*/2)).str();
   auto asmOp = b.create<LLVM::InlineAsmOp>(
       v1.getType(), asmVals, asmStr, asmCstr, false, false, asmDialectAttr);
   return asmOp.getResult(0);
 }
 
 Value mlir::x86vector::avx2::intrin::mm256UnpackLoPs(ImplicitLocOpBuilder &b,

 #ifndef NDEBUG
   auto vt = VectorType::get({8}, Float32Type::get(ib.getContext()));
   assert(vs.size() == 4 && "expects 4 vectors");
   assert(llvm::all_of(ValueRange{vs}.getTypes(),
                       [&](Type t) { return t == vt; }) &&
          "expects all types to be vector<8xf32>");
 #endif
 
-  Value T0 = mm256UnpackLoPs(ib, vs[0], vs[1]);
-  Value T1 = mm256UnpackHiPs(ib, vs[0], vs[1]);
-  Value T2 = mm256UnpackLoPs(ib, vs[2], vs[3]);
-  Value T3 = mm256UnpackHiPs(ib, vs[2], vs[3]);
-  Value S0 = mm256ShufflePs(ib, T0, T2, MaskHelper::shuffle<1, 0, 1, 0>());
-  Value S1 = mm256ShufflePs(ib, T0, T2, MaskHelper::shuffle<3, 2, 3, 2>());
-  Value S2 = mm256ShufflePs(ib, T1, T3, MaskHelper::shuffle<1, 0, 1, 0>());
-  Value S3 = mm256ShufflePs(ib, T1, T3, MaskHelper::shuffle<3, 2, 3, 2>());
-  vs[0] = mm256Permute2f128Ps(ib, S0, S1, MaskHelper::permute<2, 0>());
-  vs[1] = mm256Permute2f128Ps(ib, S2, S3, MaskHelper::permute<2, 0>());
-  vs[2] = mm256Permute2f128Ps(ib, S0, S1, MaskHelper::permute<3, 1>());
-  vs[3] = mm256Permute2f128Ps(ib, S2, S3, MaskHelper::permute<3, 1>());
+  Value t0 = mm256UnpackLoPs(ib, vs[0], vs[1]);
+  Value t1 = mm256UnpackHiPs(ib, vs[0], vs[1]);
+  Value t2 = mm256UnpackLoPs(ib, vs[2], vs[3]);
+  Value t3 = mm256UnpackHiPs(ib, vs[2], vs[3]);
+  Value s0 = mm256ShufflePs(ib, t0, t2, MaskHelper::shuffle<1, 0, 1, 0>());
+  Value s1 = mm256ShufflePs(ib, t0, t2, MaskHelper::shuffle<3, 2, 3, 2>());
+  Value s2 = mm256ShufflePs(ib, t1, t3, MaskHelper::shuffle<1, 0, 1, 0>());
+  Value s3 = mm256ShufflePs(ib, t1, t3, MaskHelper::shuffle<3, 2, 3, 2>());
+  vs[0] = mm256Permute2f128Ps(ib, s0, s1, MaskHelper::permute<2, 0>());
+  vs[1] = mm256Permute2f128Ps(ib, s2, s3, MaskHelper::permute<2, 0>());
+  vs[2] = mm256Permute2f128Ps(ib, s0, s1, MaskHelper::permute<3, 1>());
+  vs[3] = mm256Permute2f128Ps(ib, s2, s3, MaskHelper::permute<3, 1>());
 }
 
 /// AVX2 8x8xf32-specific transpose lowering using a "C intrinsics" model.
 void mlir::x86vector::avx2::transpose8x8xf32(ImplicitLocOpBuilder &ib,
                                              MutableArrayRef<Value> vs) {
   auto vt = VectorType::get({8}, Float32Type::get(ib.getContext()));
   (void)vt;
   assert(vs.size() == 8 && "expects 8 vectors");
   assert(llvm::all_of(ValueRange{vs}.getTypes(),
                       [&](Type t) { return t == vt; }) &&
          "expects all types to be vector<8xf32>");
 
-  Value T0 = mm256UnpackLoPs(ib, vs[0], vs[1]);
-  Value T1 = mm256UnpackHiPs(ib, vs[0], vs[1]);
-  Value T2 = mm256UnpackLoPs(ib, vs[2], vs[3]);
-  Value T3 = mm256UnpackHiPs(ib, vs[2], vs[3]);
-  Value T4 = mm256UnpackLoPs(ib, vs[4], vs[5]);
-  Value T5 = mm256UnpackHiPs(ib, vs[4], vs[5]);
-  Value T6 = mm256UnpackLoPs(ib, vs[6], vs[7]);
-  Value T7 = mm256UnpackHiPs(ib, vs[6], vs[7]);
+  Value t0 = mm256UnpackLoPs(ib, vs[0], vs[1]);
+  Value t1 = mm256UnpackHiPs(ib, vs[0], vs[1]);
+  Value t2 = mm256UnpackLoPs(ib, vs[2], vs[3]);
+  Value t3 = mm256UnpackHiPs(ib, vs[2], vs[3]);
+  Value t4 = mm256UnpackLoPs(ib, vs[4], vs[5]);
+  Value t5 = mm256UnpackHiPs(ib, vs[4], vs[5]);
+  Value t6 = mm256UnpackLoPs(ib, vs[6], vs[7]);
+  Value t7 = mm256UnpackHiPs(ib, vs[6], vs[7]);
 
   using inline_asm::mm256BlendPsAsm;
-  Value sh0 = mm256ShufflePs(ib, T0, T2, MaskHelper::shuffle<1, 0, 3, 2>());
-  Value sh2 = mm256ShufflePs(ib, T1, T3, MaskHelper::shuffle<1, 0, 3, 2>());
-  Value sh4 = mm256ShufflePs(ib, T4, T6, MaskHelper::shuffle<1, 0, 3, 2>());
-  Value sh6 = mm256ShufflePs(ib, T5, T7, MaskHelper::shuffle<1, 0, 3, 2>());
-
-  Value S0 =
-      mm256BlendPsAsm(ib, T0, sh0, MaskHelper::blend<0, 0, 1, 1, 0, 0, 1, 1>());
-  Value S1 =
-      mm256BlendPsAsm(ib, T2, sh0, MaskHelper::blend<1, 1, 0, 0, 1, 1, 0, 0>());
-  Value S2 =
-      mm256BlendPsAsm(ib, T1, sh2, MaskHelper::blend<0, 0, 1, 1, 0, 0, 1, 1>());
-  Value S3 =
-      mm256BlendPsAsm(ib, T3, sh2, MaskHelper::blend<1, 1, 0, 0, 1, 1, 0, 0>());
-  Value S4 =
-      mm256BlendPsAsm(ib, T4, sh4, MaskHelper::blend<0, 0, 1, 1, 0, 0, 1, 1>());
-  Value S5 =
-      mm256BlendPsAsm(ib, T6, sh4, MaskHelper::blend<1, 1, 0, 0, 1, 1, 0, 0>());
-  Value S6 =
-      mm256BlendPsAsm(ib, T5, sh6, MaskHelper::blend<0, 0, 1, 1, 0, 0, 1, 1>());
-  Value S7 =
-      mm256BlendPsAsm(ib, T7, sh6, MaskHelper::blend<1, 1, 0, 0, 1, 1, 0, 0>());
-
-  vs[0] = mm256Permute2f128Ps(ib, S0, S4, MaskHelper::permute<2, 0>());
-  vs[1] = mm256Permute2f128Ps(ib, S1, S5, MaskHelper::permute<2, 0>());
-  vs[2] = mm256Permute2f128Ps(ib, S2, S6, MaskHelper::permute<2, 0>());
-  vs[3] = mm256Permute2f128Ps(ib, S3, S7, MaskHelper::permute<2, 0>());
-  vs[4] = mm256Permute2f128Ps(ib, S0, S4, MaskHelper::permute<3, 1>());
-  vs[5] = mm256Permute2f128Ps(ib, S1, S5, MaskHelper::permute<3, 1>());
-  vs[6] = mm256Permute2f128Ps(ib, S2, S6, MaskHelper::permute<3, 1>());
-  vs[7] = mm256Permute2f128Ps(ib, S3, S7, MaskHelper::permute<3, 1>());
+  Value sh0 = mm256ShufflePs(ib, t0, t2, MaskHelper::shuffle<1, 0, 3, 2>());
+  Value sh2 = mm256ShufflePs(ib, t1, t3, MaskHelper::shuffle<1, 0, 3, 2>());
+  Value sh4 = mm256ShufflePs(ib, t4, t6, MaskHelper::shuffle<1, 0, 3, 2>());
+  Value sh6 = mm256ShufflePs(ib, t5, t7, MaskHelper::shuffle<1, 0, 3, 2>());
+
+  Value s0 =
+      mm256BlendPsAsm(ib, t0, sh0, MaskHelper::blend<0, 0, 1, 1, 0, 0, 1, 1>());
+  Value s1 =
+      mm256BlendPsAsm(ib, t2, sh0, MaskHelper::blend<1, 1, 0, 0, 1, 1, 0, 0>());
+  Value s2 =
+      mm256BlendPsAsm(ib, t1, sh2, MaskHelper::blend<0, 0, 1, 1, 0, 0, 1, 1>());
+  Value s3 =
+      mm256BlendPsAsm(ib, t3, sh2, MaskHelper::blend<1, 1, 0, 0, 1, 1, 0, 0>());
+  Value s4 =
+      mm256BlendPsAsm(ib, t4, sh4, MaskHelper::blend<0, 0, 1, 1, 0, 0, 1, 1>());
+  Value s5 =
+      mm256BlendPsAsm(ib, t6, sh4, MaskHelper::blend<1, 1, 0, 0, 1, 1, 0, 0>());
+  Value s6 =
+      mm256BlendPsAsm(ib, t5, sh6, MaskHelper::blend<0, 0, 1, 1, 0, 0, 1, 1>());
+  Value s7 =
+      mm256BlendPsAsm(ib, t7, sh6, MaskHelper::blend<1, 1, 0, 0, 1, 1, 0, 0>());
+
+  vs[0] = mm256Permute2f128Ps(ib, s0, s4, MaskHelper::permute<2, 0>());
+  vs[1] = mm256Permute2f128Ps(ib, s1, s5, MaskHelper::permute<2, 0>());
+  vs[2] = mm256Permute2f128Ps(ib, s2, s6, MaskHelper::permute<2, 0>());
+  vs[3] = mm256Permute2f128Ps(ib, s3, s7, MaskHelper::permute<2, 0>());
+  vs[4] = mm256Permute2f128Ps(ib, s0, s4, MaskHelper::permute<3, 1>());
+  vs[5] = mm256Permute2f128Ps(ib, s1, s5, MaskHelper::permute<3, 1>());
+  vs[6] = mm256Permute2f128Ps(ib, s2, s6, MaskHelper::permute<3, 1>());
+  vs[7] = mm256Permute2f128Ps(ib, s3, s7, MaskHelper::permute<3, 1>());
 }
 
 /// Rewrite avx2-specific 2-D vector.transpose, for the supported cases and
 /// depending on the `TransposeLoweringOptions`.
 class TransposeOpLowering : public OpRewritePattern<vector::TransposeOp> {
 public:
   using OpRewritePattern<vector::TransposeOp>::OpRewritePattern;
 

mlir/lib/ExecutionEngine/AsyncRuntime.cpp

 #define API __attribute__((visibility("default")))
 #endif
 
 // Visual Studio had a bug that fails to compile nested generic lambdas
 // inside an `extern "C"` function.
 //   https://developercommunity.visualstudio.com/content/problem/475494/clexe-error-with-lambda-inside-function-templates.html
 // The bug is fixed in VS2019 16.1. Separating the declaration and definition is
 // a work around for older versions of Visual Studio.
+// NOLINTNEXTLINE(*-identifier-naming): externally called.
 extern "C" API void __mlir_runner_init(llvm::StringMap<void *> &exportSymbols);
 
+// NOLINTNEXTLINE(*-identifier-naming): externally called.
 void __mlir_runner_init(llvm::StringMap<void *> &exportSymbols) {
   auto exportSymbol = [&](llvm::StringRef name, auto ptr) {
     assert(exportSymbols.count(name) == 0 && "symbol already exists");
     exportSymbols[name] = reinterpret_cast<void *>(ptr);
   };
 
   exportSymbol("mlirAsyncRuntimeAddRef",
                &mlir::runtime::mlirAsyncRuntimeAddRef);
void __mlir_runner_init(llvm::StringMap<void *> &exportSymbols) {
   exportSymbol("mlirAsyncRuntimeAwaitAllInGroup",
                &mlir::runtime::mlirAsyncRuntimeAwaitAllInGroup);
   exportSymbol("mlirAsyncRuntimeAwaitAllInGroupAndExecute",
                &mlir::runtime::mlirAsyncRuntimeAwaitAllInGroupAndExecute);
   exportSymbol("mlirAsyncRuntimePrintCurrentThreadId",
                &mlir::runtime::mlirAsyncRuntimePrintCurrentThreadId);
 }
 
+// NOLINTNEXTLINE(*-identifier-naming): externally called.
 extern "C" API void __mlir_runner_destroy() { resetDefaultAsyncRuntime(); }
 
 } // namespace runtime
 } // namespace mlir
 
 #endif // MLIR_ASYNCRUNTIME_DEFINE_FUNCTIONS

mlir/lib/ExecutionEngine/ExecutionEngine.cpp

 using llvm::orc::JITTargetMachineBuilder;
 using llvm::orc::MangleAndInterner;
 using llvm::orc::RTDyldObjectLinkingLayer;
 using llvm::orc::SymbolMap;
 using llvm::orc::ThreadSafeModule;
 using llvm::orc::TMOwningSimpleCompiler;
 
 /// Wrap a string into an llvm::StringError.
-static Error make_string_error(const Twine &message) {
+static Error makeStringError(const Twine &message) {
   return llvm::make_error<StringError>(message.str(),
                                        llvm::inconvertibleErrorCode());
 }
 
-void SimpleObjectCache::notifyObjectCompiled(const Module *M,
-                                             MemoryBufferRef ObjBuffer) {
-  cachedObjects[M->getModuleIdentifier()] = MemoryBuffer::getMemBufferCopy(
-      ObjBuffer.getBuffer(), ObjBuffer.getBufferIdentifier());
+void SimpleObjectCache::notifyObjectCompiled(const Module *m,
+                                             MemoryBufferRef objBuffer) {
+  cachedObjects[m->getModuleIdentifier()] = MemoryBuffer::getMemBufferCopy(
+      objBuffer.getBuffer(), objBuffer.getBufferIdentifier());
 }
 
-std::unique_ptr<MemoryBuffer> SimpleObjectCache::getObject(const Module *M) {
-  auto I = cachedObjects.find(M->getModuleIdentifier());
-  if (I == cachedObjects.end()) {
-    LLVM_DEBUG(dbgs() << "No object for " << M->getModuleIdentifier()
+std::unique_ptr<MemoryBuffer> SimpleObjectCache::getObject(const Module *m) {
+  auto i = cachedObjects.find(m->getModuleIdentifier());
+  if (i == cachedObjects.end()) {
+    LLVM_DEBUG(dbgs() << "No object for " << m->getModuleIdentifier()
                       << " in cache. Compiling.\n");
     return nullptr;
   }
-  LLVM_DEBUG(dbgs() << "Object for " << M->getModuleIdentifier()
+  LLVM_DEBUG(dbgs() << "Object for " << m->getModuleIdentifier()
                     << " loaded from cache.\n");
-  return MemoryBuffer::getMemBuffer(I->second->getMemBufferRef());
+  return MemoryBuffer::getMemBuffer(i->second->getMemBufferRef());
 }
 
 void SimpleObjectCache::dumpToObjectFile(StringRef outputFilename) {
   // Set up the output file.
   std::string errorMessage;
   auto file = openOutputFile(outputFilename, &errorMessage);
   if (!file) {
     llvm::errs() << errorMessage << "\n";
cantFail(mainJitDylib.define(
           mainJitDylib.getExecutionSession(), jit->getDataLayout())))));
 }
 
 // Setup LLVM target triple from the current machine.
 bool ExecutionEngine::setupTargetTriple(Module *llvmModule) {
   // Setup the machine properties from the current architecture.
   auto targetTriple = llvm::sys::getDefaultTargetTriple();
   std::string errorMessage;
-  auto target = llvm::TargetRegistry::lookupTarget(targetTriple, errorMessage);
+  const auto *target =
+      llvm::TargetRegistry::lookupTarget(targetTriple, errorMessage);
   if (!target) {
     errs() << "NO target: " << errorMessage << "\n";
     return true;
   }
 
   std::string cpu(llvm::sys::getHostCPUName());
   llvm::SubtargetFeatures features;
   llvm::StringMap<bool> hostFeatures;
if (func.isDeclaration()) {
       continue;
     }
     if (interfaceFunctions.count(&func)) {
       continue;
     }
 
     // Given a function `foo(<...>)`, define the interface function
     // `mlir_foo(i8**)`.
-    auto newType = llvm::FunctionType::get(
+    auto *newType = llvm::FunctionType::get(
         builder.getVoidTy(), builder.getInt8PtrTy()->getPointerTo(),
         /*isVarArg=*/false);
     auto newName = makePackedFunctionName(func.getName());
     auto funcCst = module->getOrInsertFunction(newName, newType);
     llvm::Function *interfaceFunc = cast<llvm::Function>(funcCst.getCallee());
     interfaceFunctions.insert(interfaceFunc);
 
     // Extract the arguments from the type-erased argument list and cast them to
     // the proper types.
-    auto bb = llvm::BasicBlock::Create(ctx);
+    auto *bb = llvm::BasicBlock::Create(ctx);
     bb->insertInto(interfaceFunc);
     builder.SetInsertPoint(bb);
     llvm::Value *argList = interfaceFunc->arg_begin();
     SmallVector<llvm::Value *, 8> args;
     args.reserve(llvm::size(func.args()));
     for (auto &indexedArg : llvm::enumerate(func.args())) {
       llvm::Value *argIndex = llvm::Constant::getIntegerValue(
           builder.getInt64Ty(), APInt(64, indexedArg.index()));
Expected<std::unique_ptr<ExecutionEngine>> ExecutionEngine::create(
   auto engine = std::make_unique<ExecutionEngine>(
       enableObjectCache, enableGDBNotificationListener,
       enablePerfNotificationListener);
 
   std::unique_ptr<llvm::LLVMContext> ctx(new llvm::LLVMContext);
   auto llvmModule = llvmModuleBuilder ? llvmModuleBuilder(m, *ctx)
                                       : translateModuleToLLVMIR(m, *ctx);
   if (!llvmModule)
-    return make_string_error("could not convert to LLVM IR");
+    return makeStringError("could not convert to LLVM IR");
   // FIXME: the triple should be passed to the translation or dialect conversion
   // instead of this.  Currently, the LLVM module created above has no triple
   // associated with it.
   setupTargetTriple(llvmModule.get());
   packFunctionArguments(llvmModule.get());
 
   auto dataLayout = llvmModule->getDataLayout();
 
   // Callback to create the object layer with symbol resolution to current
   // process and dynamically linked libraries.
   auto objectLinkingLayerCreator = [&](ExecutionSession &session,
-                                       const Triple &TT) {
+                                       const Triple &tt) {
     auto objectLayer = std::make_unique<RTDyldObjectLinkingLayer>(
         session, []() { return std::make_unique<SectionMemoryManager>(); });
 
     // Register JIT event listeners if they are enabled.
     if (engine->gdbListener)
       objectLayer->registerJITEventListener(*engine->gdbListener);
     if (engine->perfListener)
       objectLayer->registerJITEventListener(*engine->perfListener);
auto objectLinkingLayerCreator = [&](ExecutionSession &session,
     // Resolve symbols from shared libraries.
     for (auto libPath : sharedLibPaths) {
       auto mb = llvm::MemoryBuffer::getFile(libPath);
       if (!mb) {
         errs() << "Failed to create MemoryBuffer for: " << libPath
                << "\nError: " << mb.getError().message() << "\n";
         continue;
       }
-      auto &JD = session.createBareJITDylib(std::string(libPath));
+      auto &jd = session.createBareJITDylib(std::string(libPath));
       auto loaded = DynamicLibrarySearchGenerator::Load(
           libPath.data(), dataLayout.getGlobalPrefix());
       if (!loaded) {
         errs() << "Could not load " << libPath << ":\n  " << loaded.takeError()
                << "\n";
         continue;
       }
-      JD.addGenerator(std::move(*loaded));
-      cantFail(objectLayer->add(JD, std::move(mb.get())));
+      jd.addGenerator(std::move(*loaded));
+      cantFail(objectLayer->add(jd, std::move(mb.get())));
     }
 
     return objectLayer;
   };
 
   // Callback to inspect the cache and recompile on demand. This follows Lang's
   // LLJITWithObjectCache example.
-  auto compileFunctionCreator = [&](JITTargetMachineBuilder JTMB)
+  auto compileFunctionCreator = [&](JITTargetMachineBuilder jtmb)
       -> Expected<std::unique_ptr<IRCompileLayer::IRCompiler>> {
     if (jitCodeGenOptLevel)
-      JTMB.setCodeGenOptLevel(jitCodeGenOptLevel.getValue());
-    auto TM = JTMB.createTargetMachine();
-    if (!TM)
-      return TM.takeError();
-    return std::make_unique<TMOwningSimpleCompiler>(std::move(*TM),
+      jtmb.setCodeGenOptLevel(jitCodeGenOptLevel.getValue());
+    auto tm = jtmb.createTargetMachine();
+    if (!tm)
+      return tm.takeError();
+    return std::make_unique<TMOwningSimpleCompiler>(std::move(*tm),
                                                     engine->cache.get());
   };
 
   // Create the LLJIT by calling the LLJITBuilder with 2 callbacks.
   auto jit =
       cantFail(llvm::orc::LLJITBuilder()
                    .setCompileFunctionCreator(compileFunctionCreator)
                    .setObjectLinkingLayerCreator(objectLinkingLayerCreator)
Expected<void *> ExecutionEngine::lookup(StringRef name) const {
   // thanks to hand-rolled reference counting. Rewrap the error message into a
   // string before returning. Alternatively, ORC JIT should consider copying
   // the string into the error message.
   if (!expectedSymbol) {
     std::string errorMessage;
     llvm::raw_string_ostream os(errorMessage);
     llvm::handleAllErrors(expectedSymbol.takeError(),
                           [&os](llvm::ErrorInfoBase &ei) { ei.log(os); });
-    return make_string_error(os.str());
+    return makeStringError(os.str());
   }
 
   auto rawFPtr = expectedSymbol->getAddress();
-  auto fptr = reinterpret_cast<void *>(rawFPtr);
+  auto *fptr = reinterpret_cast<void *>(rawFPtr);
   if (!fptr)
-    return make_string_error("looked up function is null");
+    return makeStringError("looked up function is null");
   return fptr;
 }
 
 Error ExecutionEngine::invokePacked(StringRef name,
                                     MutableArrayRef<void *> args) {
   auto expectedFPtr = lookupPacked(name);
   if (!expectedFPtr)
     return expectedFPtr.takeError();
   auto fptr = *expectedFPtr;
 
   (*fptr)(args.data());
 
   return Error::success();
 }

mlir/lib/ExecutionEngine/JitRunner.cpp

if (!file) {
     return nullptr;
   }
 
   llvm::SourceMgr sourceMgr;
   sourceMgr.AddNewSourceBuffer(std::move(file), llvm::SMLoc());
   return OwningModuleRef(parseSourceFile(sourceMgr, context));
 }
 
-static inline Error make_string_error(const Twine &message) {
+static inline Error makeStringError(const Twine &message) {
   return llvm::make_error<llvm::StringError>(message.str(),
                                              llvm::inconvertibleErrorCode());
 }
 
 static Optional<unsigned> getCommandLineOptLevel(Options &options) {
   Optional<unsigned> optLevel;
   SmallVector<std::reference_wrapper<llvm::cl::opt<bool>>, 4> optFlags{
       options.optO0, options.optO1, options.optO2, options.optO3};
static Error compileAndExecute(Options &options, ModuleOp module,
   return Error::success();
 }
 
 static Error compileAndExecuteVoidFunction(Options &options, ModuleOp module,
                                            StringRef entryPoint,
                                            CompileAndExecuteConfig config) {
   auto mainFunction = module.lookupSymbol<LLVM::LLVMFuncOp>(entryPoint);
   if (!mainFunction || mainFunction.empty())
-    return make_string_error("entry point not found");
+    return makeStringError("entry point not found");
   void *empty = nullptr;
   return compileAndExecute(options, module, entryPoint, config, &empty);
 }
 
 template <typename Type>
 Error checkCompatibleReturnType(LLVM::LLVMFuncOp mainFunction);
 template <>
 Error checkCompatibleReturnType<int32_t>(LLVM::LLVMFuncOp mainFunction) {
   auto resultType = mainFunction.getType()
                         .cast<LLVM::LLVMFunctionType>()
                         .getReturnType()
                         .dyn_cast<IntegerType>();
   if (!resultType || resultType.getWidth() != 32)
-    return make_string_error("only single i32 function result supported");
+    return makeStringError("only single i32 function result supported");
   return Error::success();
 }
 template <>
 Error checkCompatibleReturnType<int64_t>(LLVM::LLVMFuncOp mainFunction) {
   auto resultType = mainFunction.getType()
                         .cast<LLVM::LLVMFunctionType>()
                         .getReturnType()
                         .dyn_cast<IntegerType>();
   if (!resultType || resultType.getWidth() != 64)
-    return make_string_error("only single i64 function result supported");
+    return makeStringError("only single i64 function result supported");
   return Error::success();
 }
 template <>
 Error checkCompatibleReturnType<float>(LLVM::LLVMFuncOp mainFunction) {
   if (!mainFunction.getType()
            .cast<LLVM::LLVMFunctionType>()
            .getReturnType()
            .isa<Float32Type>())
-    return make_string_error("only single f32 function result supported");
+    return makeStringError("only single f32 function result supported");
   return Error::success();
 }
 template <typename Type>
 Error compileAndExecuteSingleReturnFunction(Options &options, ModuleOp module,
                                             StringRef entryPoint,
                                             CompileAndExecuteConfig config) {
   auto mainFunction = module.lookupSymbol<LLVM::LLVMFuncOp>(entryPoint);
   if (!mainFunction || mainFunction.isExternal())
-    return make_string_error("entry point not found");
+    return makeStringError("entry point not found");
 
   if (mainFunction.getType().cast<LLVM::LLVMFunctionType>().getNumParams() != 0)
-    return make_string_error("function inputs not supported");
+    return makeStringError("function inputs not supported");
 
   if (Error error = checkCompatibleReturnType<Type>(mainFunction))
     return error;
 
   Type res;
   struct {
     void *data;
   } data;
auto compileAndExecuteFn =
           .Case("f32", compileAndExecuteSingleReturnFunction<float>)
           .Case("void", compileAndExecuteVoidFunction)
           .Default(nullptr);
 
   Error error = compileAndExecuteFn
                     ? compileAndExecuteFn(options, m.get(),
                                           options.mainFuncName.getValue(),
                                           compileAndExecuteConfig)
-                    : make_string_error("unsupported function type");
+                    : makeStringError("unsupported function type");
 
   int exitCode = EXIT_SUCCESS;
   llvm::handleAllErrors(std::move(error),
                         [&exitCode](const llvm::ErrorInfoBase &info) {
                           llvm::errs() << "Error: ";
                           info.log(llvm::errs());
                           llvm::errs() << '\n';
                           exitCode = EXIT_FAILURE;
                         });
 
   return exitCode;
 }

mlir/lib/ExecutionEngine/RunnerUtils.cpp

 // C++ runtime. These may be progressively migrated to CRunnerUtils.cpp over
 // time.
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/ExecutionEngine/RunnerUtils.h"
 #include <chrono>
 
+// NOLINTBEGIN(*-identifier-naming)
+
 extern "C" void
 _mlir_ciface_print_memref_shape_i8(UnrankedMemRefType<int8_t> *M) {
   std::cout << "Unranked Memref ";
   printMemRefMetaData(std::cout, DynamicMemRefType<int8_t>(*M));
   std::cout << "\n";
 }
 
 extern "C" void

 }
 
 extern "C" int64_t verifyMemRefF64(int64_t rank, void *actualPtr,
                                    void *expectedPtr) {
   UnrankedMemRefType<double> actualDesc = {rank, actualPtr};
   UnrankedMemRefType<double> expectedDesc = {rank, expectedPtr};
   return _mlir_ciface_verifyMemRefF64(&actualDesc, &expectedDesc);
 }
+
+// NOLINTEND(*-identifier-naming)

mlir/lib/IR/AffineMap.cpp

 /// Returns an AffineMap representing a permutation.
 AffineMap AffineMap::getPermutationMap(ArrayRef<unsigned> permutation,
                                        MLIRContext *context) {
   assert(!permutation.empty() &&
          "Cannot create permutation map from empty permutation vector");
   SmallVector<AffineExpr, 4> affExprs;
   for (auto index : permutation)
     affExprs.push_back(getAffineDimExpr(index, context));
-  auto m = std::max_element(permutation.begin(), permutation.end());
+  const auto *m = std::max_element(permutation.begin(), permutation.end());
   auto permutationMap = AffineMap::get(*m + 1, 0, affExprs, context);
   assert(permutationMap.isPermutation() && "Invalid permutation vector");
   return permutationMap;
 }
 
 template <typename AffineExprContainer>
 static SmallVector<AffineMap, 4>
 inferFromExprList(ArrayRef<AffineExprContainer> exprsList) {

mlir/lib/IR/AsmPrinter.cpp

if (resultGroupIt == opResultGroups.end()) {
     // If not, just use the first result.
     lookupResultNo = resultNo;
     lookupValue = owner->getResult(0);
     return;
   }
 
   // Find the correct index using a binary search, as the groups are ordered.
   ArrayRef<int> resultGroups = resultGroupIt->second;
-  auto it = llvm::upper_bound(resultGroups, resultNo);
+  const auto *it = llvm::upper_bound(resultGroups, resultNo);
   int groupResultNo = 0, groupSize = 0;
 
   // If there are no smaller elements, the last result group is the lookup.
   if (it == resultGroups.end()) {
     groupResultNo = resultGroups.back();
     groupSize = static_cast<int>(owner->getNumResults()) - resultGroups.back();
   } else {
     // Otherwise, the previous element is the lookup.
Impl(raw_ostream &os, OpPrintingFlags flags = llvm::None,
       : os(os), printerFlags(flags), state(state) {}
   explicit Impl(Impl &other)
       : Impl(other.os, other.printerFlags, other.state) {}
 
   /// Returns the output stream of the printer.
   raw_ostream &getStream() { return os; }
 
   template <typename Container, typename UnaryFunctor>
-  inline void interleaveComma(const Container &c, UnaryFunctor each_fn) const {
-    llvm::interleaveComma(c, os, each_fn);
+  inline void interleaveComma(const Container &c, UnaryFunctor eachFn) const {
+    llvm::interleaveComma(c, os, eachFn);
   }
 
   /// This enum describes the different kinds of elision for the type of an
   /// attribute when printing it.
   enum class AttrTypeElision {
     /// The type must not be elided,
     Never,
     /// The type may be elided when it matches the default used in the parser

mlir/lib/IR/Block.cpp

 /// block are moved to the new block, including the old terminator.  The
 /// original block is left without a terminator.
 ///
 /// The newly formed Block is returned, and the specified iterator is
 /// invalidated.
 Block *Block::splitBlock(iterator splitBefore) {
   // Start by creating a new basic block, and insert it immediate after this
   // one in the containing region.
-  auto newBB = new Block();
+  auto *newBB = new Block();
   getParent()->getBlocks().insert(std::next(Region::iterator(this)), newBB);
 
   // Move all of the operations from the split point to the end of the region
   // into the new block.
   newBB->getOperations().splice(newBB->end(), getOperations(), splitBefore,
                                 end());
   return newBB;
 }

mlir/lib/IR/BuiltinAttributes.cpp

 findDuplicateElement(ArrayRef<NamedAttribute> value) {
   const Optional<NamedAttribute> none{llvm::None};
   if (value.size() < 2)
     return none;
 
   if (value.size() == 2)
     return value[0].getName() == value[1].getName() ? value[0] : none;
 
-  auto it = std::adjacent_find(value.begin(), value.end(),
+  const auto *it = std::adjacent_find(value.begin(), value.end(),
                                       [](NamedAttribute l, NamedAttribute r) {
                                         return l.getName() == r.getName();
                                       });
   return it != value.end() ? *it : none;
 }
 
 bool DictionaryAttr::sort(ArrayRef<NamedAttribute> value,
                           SmallVectorImpl<NamedAttribute> &storage) {
   bool isSorted = dictionaryAttrSort</*inPlace=*/false>(value, storage);
   assert(!findDuplicateElement(storage) &&
          "DictionaryAttr element names must be unique");

mlir/lib/IR/MLIRContext.cpp

 #include <memory>
 
 #define DEBUG_TYPE "mlircontext"
 
 using namespace mlir;
 using namespace mlir::detail;
 
 using llvm::hash_combine;
-using llvm::hash_combine_range;
 
 //===----------------------------------------------------------------------===//
 // MLIRContext CommandLine Options
 //===----------------------------------------------------------------------===//
 
 namespace {
 /// This struct contains command line options that can be used to initialize
 /// various bits of an MLIRContext. This uses a struct wrapper to avoid the need

mlir/lib/IR/Operation.cpp

 }
 
 //===----------------------------------------------------------------------===//
 // ilist_traits for Operation
 //===----------------------------------------------------------------------===//
 
 auto llvm::ilist_detail::SpecificNodeAccess<
     typename llvm::ilist_detail::compute_node_options<
-        ::mlir::Operation>::type>::getNodePtr(pointer N) -> node_type * {
-  return NodeAccess::getNodePtr<OptionsT>(N);
+        ::mlir::Operation>::type>::getNodePtr(pointer n) -> node_type * {
+  return NodeAccess::getNodePtr<OptionsT>(n);
 }
 
 auto llvm::ilist_detail::SpecificNodeAccess<
     typename llvm::ilist_detail::compute_node_options<
-        ::mlir::Operation>::type>::getNodePtr(const_pointer N)
+        ::mlir::Operation>::type>::getNodePtr(const_pointer n)
     -> const node_type * {
-  return NodeAccess::getNodePtr<OptionsT>(N);
+  return NodeAccess::getNodePtr<OptionsT>(n);
 }
 
 auto llvm::ilist_detail::SpecificNodeAccess<
     typename llvm::ilist_detail::compute_node_options<
-        ::mlir::Operation>::type>::getValuePtr(node_type *N) -> pointer {
-  return NodeAccess::getValuePtr<OptionsT>(N);
+        ::mlir::Operation>::type>::getValuePtr(node_type *n) -> pointer {
+  return NodeAccess::getValuePtr<OptionsT>(n);
 }
 
 auto llvm::ilist_detail::SpecificNodeAccess<
     typename llvm::ilist_detail::compute_node_options<
-        ::mlir::Operation>::type>::getValuePtr(const node_type *N)
+        ::mlir::Operation>::type>::getValuePtr(const node_type *n)
     -> const_pointer {
-  return NodeAccess::getValuePtr<OptionsT>(N);
+  return NodeAccess::getValuePtr<OptionsT>(n);
 }
 
 void llvm::ilist_traits<::mlir::Operation>::deleteNode(Operation *op) {
   op->destroy();
 }
 
 Block *llvm::ilist_traits<::mlir::Operation>::getContainingBlock() {
-  size_t Offset(size_t(&((Block *)nullptr->*Block::getSublistAccess(nullptr))));
-  iplist<Operation> *Anchor(static_cast<iplist<Operation> *>(this));
-  return reinterpret_cast<Block *>(reinterpret_cast<char *>(Anchor) - Offset);
+  size_t offset(size_t(&((Block *)nullptr->*Block::getSublistAccess(nullptr))));
+  iplist<Operation> *anchor(static_cast<iplist<Operation> *>(this));
+  return reinterpret_cast<Block *>(reinterpret_cast<char *>(anchor) - offset);
 }
 
 /// This is a trait method invoked when an operation is added to a block.  We
 /// keep the block pointer up to date.
 void llvm::ilist_traits<::mlir::Operation>::addNodeToList(Operation *op) {
   assert(!op->getBlock() && "already in an operation block!");
   op->block = getContainingBlock();
 
LogicalResult OpTrait::impl::verifyNoRegionArguments(Operation *op) {
   for (Region &region : op->getRegions()) {
     if (region.empty())
       continue;
 
     if (region.getNumArguments() != 0) {
       if (op->getNumRegions() > 1)
         return op->emitOpError("region #")
                << region.getRegionNumber() << " should have no arguments";
-      else
-        return op->emitOpError("region should have no arguments");
     }
   }
   return success();
 }
 
 LogicalResult OpTrait::impl::verifyElementwise(Operation *op) {
   auto isMappableType = [](Type type) {
     return type.isa<VectorType, TensorType>();

mlir/lib/IR/OperationSupport.cpp

 }
 
 NamedAttrList::NamedAttrList(DictionaryAttr attributes)
     : NamedAttrList(attributes ? attributes.getValue()
                                : ArrayRef<NamedAttribute>()) {
   dictionarySorted.setPointerAndInt(attributes, true);
 }
 
-NamedAttrList::NamedAttrList(const_iterator in_start, const_iterator in_end) {
-  assign(in_start, in_end);
+NamedAttrList::NamedAttrList(const_iterator inStart, const_iterator inEnd) {
+  assign(inStart, inEnd);
 }
 
 ArrayRef<NamedAttribute> NamedAttrList::getAttrs() const { return attrs; }
 
 Optional<NamedAttribute> NamedAttrList::findDuplicate() const {
   Optional<NamedAttribute> duplicate =
       DictionaryAttr::findDuplicate(attrs, isSorted());
   // DictionaryAttr::findDuplicate will sort the list, so reset the sorted

 }
 
 /// Add an attribute with the specified name.
 void NamedAttrList::append(StringRef name, Attribute attr) {
   append(StringAttr::get(attr.getContext(), name), attr);
 }
 
 /// Replaces the attributes with new list of attributes.
-void NamedAttrList::assign(const_iterator in_start, const_iterator in_end) {
-  DictionaryAttr::sort(ArrayRef<NamedAttribute>{in_start, in_end}, attrs);
+void NamedAttrList::assign(const_iterator inStart, const_iterator inEnd) {
+  DictionaryAttr::sort(ArrayRef<NamedAttribute>{inStart, inEnd}, attrs);
   dictionarySorted.setPointerAndInt(nullptr, true);
 }
 
 void NamedAttrList::push_back(NamedAttribute newAttribute) {
   if (isSorted())
     dictionarySorted.setInt(attrs.empty() || attrs.back() < newAttribute);
   dictionarySorted.setPointer(nullptr);
   attrs.push_back(newAttribute);

mlir/lib/IR/Region.cpp

 }
 
 void Region::dropAllReferences() {
   for (Block &b : *this)
     b.dropAllReferences();
 }
 
 Region *llvm::ilist_traits<::mlir::Block>::getParentRegion() {
-  size_t Offset(
+  size_t offset(
       size_t(&((Region *)nullptr->*Region::getSublistAccess(nullptr))));
-  iplist<Block> *Anchor(static_cast<iplist<Block> *>(this));
-  return reinterpret_cast<Region *>(reinterpret_cast<char *>(Anchor) - Offset);
+  iplist<Block> *anchor(static_cast<iplist<Block> *>(this));
+  return reinterpret_cast<Region *>(reinterpret_cast<char *>(anchor) - offset);
 }
 
 /// This is a trait method invoked when a basic block is added to a region.
 /// We keep the region pointer up to date.
 void llvm::ilist_traits<::mlir::Block>::addNodeToList(Block *block) {
   assert(!block->getParent() && "already in a region!");
   block->parentValidOpOrderPair.setPointer(getParentRegion());
 }

mlir/lib/Interfaces/SideEffectInterfaces.cpp

if (auto effectInterface = dyn_cast<MemoryEffectOpInterface>(op)) {
             return isa<MemoryEffects::Read>(it.getEffect());
           })) {
         return false;
       }
       continue;
 
       // Otherwise, if the op has recursive side effects we can treat the
       // operation itself as having no effects.
-    } else if (hasRecursiveEffects) {
-      continue;
     }
+    if (hasRecursiveEffects)
+      continue;
 
     // If there were no effect interfaces, we treat this op as conservatively
     // having effects.
     return false;
   }
 
   // If we get here, none of the operations had effects that prevented marking
   // 'op' as dead.
   return true;
 }
 
 bool mlir::wouldOpBeTriviallyDead(Operation *op) {
   if (op->mightHaveTrait<OpTrait::IsTerminator>())
     return false;
   return wouldOpBeTriviallyDeadImpl(op);
 }

mlir/lib/Parser/AffineParser.cpp

ParseResult AffineParser::parseAffineMapOrIntegerSetInline(AffineMap &map,
   }
 
   // This is needed for parsing attributes as we wouldn't know whether we would
   // be parsing an integer set attribute or an affine map attribute.
   bool isArrow = getToken().is(Token::arrow);
   bool isColon = getToken().is(Token::colon);
   if (!isArrow && !isColon) {
     return emitError("expected '->' or ':'");
-  } else if (isArrow) {
+  }
+  if (isArrow) {
     parseToken(Token::arrow, "expected '->' or '['");
     map = parseAffineMapRange(numDims, numSymbols);
     return map ? success() : failure();
-  } else if (parseToken(Token::colon, "expected ':' or '['")) {
-    return failure();
   }
+  if (parseToken(Token::colon, "expected ':' or '['"))
+    return failure();
 
   if ((set = parseIntegerSetConstraints(numDims, numSymbols)))
     return success();
 
   return failure();
 }
 
 /// Parse an AffineMap where the dim and symbol identifiers are SSA ids.

mlir/lib/Pass/Pass.cpp

if (!op->hasTrait<OpTrait::IsIsolatedFromAbove>())
     return op->emitOpError() << "trying to schedule a pass on an operation not "
                                 "marked as 'IsolatedFromAbove'";
 
   // Initialize the pass state with a callback for the pass to dynamically
   // execute a pipeline on the currently visited operation.
   PassInstrumentor *pi = am.getPassInstrumentor();
   PassInstrumentation::PipelineParentInfo parentInfo = {llvm::get_threadid(),
                                                         pass};
-  auto dynamic_pipeline_callback = [&](OpPassManager &pipeline,
-                                       Operation *root) -> LogicalResult {
+  auto dynamicPipelineCallback = [&](OpPassManager &pipeline,
     if (!op->isAncestor(root))
       return root->emitOpError()
              << "Trying to schedule a dynamic pipeline on an "
                 "operation that isn't "
                 "nested under the current operation the pass is processing";
     assert(pipeline.getOpName() == root->getName().getStringRef());
 
     // Before running, make sure to coalesce any adjacent pass adaptors in the
     // pipeline.
     pipeline.getImpl().coalesceAdjacentAdaptorPasses();
 
     // Initialize the user provided pipeline and execute the pipeline.
     if (failed(pipeline.initialize(root->getContext(), parentInitGeneration)))
       return failure();
     AnalysisManager nestedAm = root == op ? am : am.nest(root);
     return OpToOpPassAdaptor::runPipeline(pipeline.getPasses(), root, nestedAm,
                                           verifyPasses, parentInitGeneration,
                                           pi, &parentInfo);
   };
-  pass->passState.emplace(op, am, dynamic_pipeline_callback);
+  pass->passState.emplace(op, am, dynamicPipelineCallback);
 
   // Instrument before the pass has run.
   if (pi)
     pi->runBeforePass(pass, op);
 
   // Invoke the virtual runOnOperation method.
   if (auto *adaptor = dyn_cast<OpToOpPassAdaptor>(pass))
     adaptor->runOnOperation(verifyPasses);

 /// Run the given operation and analysis manager on a provided op pass manager.
 LogicalResult OpToOpPassAdaptor::runPipeline(
     iterator_range<OpPassManager::pass_iterator> passes, Operation *op,
     AnalysisManager am, bool verifyPasses, unsigned parentInitGeneration,
     PassInstrumentor *instrumentor,
     const PassInstrumentation::PipelineParentInfo *parentInfo) {
   assert((!instrumentor || parentInfo) &&
          "expected parent info if instrumentor is provided");
-  auto scope_exit = llvm::make_scope_exit([&] {
+  auto scopeExit = llvm::make_scope_exit([&] {
     // Clear out any computed operation analyses. These analyses won't be used
     // any more in this pipeline, and this helps reduce the current working set
     // of memory. If preserving these analyses becomes important in the future
     // we can re-evaluate this.
     am.clear();
   });
 
   // Run the pipeline over the provided operation.
   if (instrumentor)
     instrumentor->runBeforePipeline(op->getName().getIdentifier(), *parentInfo);
   for (Pass &pass : passes)
     if (failed(run(&pass, op, am, verifyPasses, parentInitGeneration)))
       return failure();
   if (instrumentor)
     instrumentor->runAfterPipeline(op->getName().getIdentifier(), *parentInfo);
   return success();
 }
 
 /// Find an operation pass manager that can operate on an operation of the given
 /// type, or nullptr if one does not exist.
 static OpPassManager *findPassManagerFor(MutableArrayRef<OpPassManager> mgrs,
                                          StringRef name) {
-  auto it = llvm::find_if(
+  auto *it = llvm::find_if(
       mgrs, [&](OpPassManager &mgr) { return mgr.getOpName() == name; });
   return it == mgrs.end() ? nullptr : &*it;
 }
 
 /// Find an operation pass manager that can operate on an operation of the given
 /// type, or nullptr if one does not exist.
 static OpPassManager *findPassManagerFor(MutableArrayRef<OpPassManager> mgrs,
                                          StringAttr name,
                                          MLIRContext &context) {
-  auto it = llvm::find_if(
+  auto *it = llvm::find_if(
       mgrs, [&](OpPassManager &mgr) { return mgr.getOpName(context) == name; });
   return it == mgrs.end() ? nullptr : &*it;
 }
 
 OpToOpPassAdaptor::OpToOpPassAdaptor(OpPassManager &&mgr) {
   mgrs.emplace_back(std::move(mgr));
 }
 

mlir/lib/TableGen/Attribute.cpp

 StructFieldAttr::StructFieldAttr(const llvm::DefInit *init)
     : StructFieldAttr(init->getDef()) {}
 
 StringRef StructFieldAttr::getName() const {
   return def->getValueAsString("name");
 }
 
 Attribute StructFieldAttr::getType() const {
-  auto init = def->getValueInit("type");
+  auto *init = def->getValueInit("type");
   return Attribute(cast<llvm::DefInit>(init));
 }
 
 StructAttr::StructAttr(const llvm::Record *record) : Attribute(record) {
   assert(isSubClassOf("StructAttr") &&
          "must be subclass of TableGen 'StructAttr' class");
 }
 

mlir/lib/TableGen/Dialect.cpp

std::string Dialect::getCppClassName() const {
   // Simply use the name and remove any '_' tokens.
   std::string cppName = def->getName().str();
   llvm::erase_value(cppName, '_');
   return cppName;
 }
 
 static StringRef getAsStringOrEmpty(const llvm::Record &record,
                                     StringRef fieldName) {
-  if (auto valueInit = record.getValueInit(fieldName)) {
+  if (auto *valueInit = record.getValueInit(fieldName)) {
     if (llvm::isa<llvm::StringInit>(valueInit))
       return record.getValueAsString(fieldName);
   }
   return "";
 }
 
 StringRef Dialect::getSummary() const {
   return getAsStringOrEmpty(*def, "summary");

mlir/lib/TableGen/Operator.cpp

for (auto me = ecs.member_end(); mi != me; ++mi) {
           found = true;
         }
         continue;
       }
 
       if (getArg(*mi).is<NamedAttribute *>()) {
         // TODO: Handle attributes.
         continue;
-      } else {
-        resultTypeMapping[i].emplace_back(*mi);
-        found = true;
-      }
-    }
+      }
     return found;
   };
 
   for (const Trait &trait : traits) {
     const llvm::Record &def = trait.getDef();
     // If the infer type op interface was manually added, then treat it as
     // intention that the op needs special handling.
     // TODO: Reconsider whether to always generate, this is more conservative

mlir/lib/TableGen/Pattern.cpp

Operator &Pattern::getDialectOp(DagNode node) {
   return node.getDialectOp(recordOpMap);
 }
 
 std::vector<AppliedConstraint> Pattern::getConstraints() const {
   auto *listInit = def.getValueAsListInit("constraints");
   std::vector<AppliedConstraint> ret;
   ret.reserve(listInit->size());
 
-  for (auto it : *listInit) {
+  for (auto *it : *listInit) {
     auto *dagInit = dyn_cast<llvm::DagInit>(it);
     if (!dagInit)
       PrintFatalError(&def, "all elements in Pattern multi-entity "
                             "constraints should be DAG nodes");
 
     std::vector<std::string> entities;
     entities.reserve(dagInit->arg_size());
     for (auto *argName : dagInit->getArgNames()) {

mlir/lib/TableGen/Predicate.cpp

if (rootNode->kind == PredCombinerKind::SubstLeaves) {
     performSubstitutions(rootNode->prefix, substitutions);
     rootNode->suffix = std::string(concatPred.getSuffix());
     performSubstitutions(rootNode->suffix, substitutions);
   }
 
   // Build child subtrees.
   auto combined = static_cast<const CombinedPred &>(root);
   for (const auto *record : combined.getChildren()) {
-    auto childTree =
+    auto *childTree =
         buildPredicateTree(Pred(record), allocator, allSubstitutions);
     rootNode->children.push_back(childTree);
   }
   return rootNode;
 }
 
 // Simplify a predicate tree rooted at "node" using the predicates that are
 // known to be true(false).  For AND(OR) combined predicates, if any of the
propagateGroundTruth(PredNode *node,
 
   // Move child nodes into some local variable so that they can be optimized
   // separately and re-added if necessary.
   llvm::SmallVector<PredNode *, 4> children;
   std::swap(node->children, children);
 
   for (auto &child : children) {
     // First, simplify the child.  This maintains the predicate as it was.
-    auto simplifiedChild =
+    auto *simplifiedChild =
         propagateGroundTruth(child, knownTruePreds, knownFalsePreds);
 
     // Just add the child if we don't know how to simplify the current node.
     if (node->kind != PredCombinerKind::And &&
         node->kind != PredCombinerKind::Or) {
       node->children.push_back(simplifiedChild);
       continue;
     }
const auto &collapseList =
         node->kind == PredCombinerKind::And ? knownFalsePreds : knownTruePreds;
     const auto &eraseList =
         node->kind == PredCombinerKind::And ? knownTruePreds : knownFalsePreds;
     if (simplifiedChild->kind == collapseKind ||
         collapseList.count(simplifiedChild->predicate) != 0) {
       node->kind = collapseKind;
       node->children.clear();
       return node;
-    } else if (simplifiedChild->kind == eraseKind ||
-               eraseList.count(simplifiedChild->predicate) != 0) {
+    }
+    if (simplifiedChild->kind == eraseKind ||
       continue;
     }
     node->children.push_back(simplifiedChild);
   }
   return node;
 }
 
 // Combine a list of predicate expressions using a binary combiner.  If a list
if (root.kind == PredCombinerKind::SubstLeaves) {
     return childExpressions[0];
   }
 
   llvm::PrintFatalError(root.predicate->getLoc(), "unsupported predicate kind");
 }
 
 std::string CombinedPred::getConditionImpl() const {
   llvm::SpecificBumpPtrAllocator<PredNode> allocator;
-  auto predicateTree = buildPredicateTree(*this, allocator, {});
+  auto *predicateTree = buildPredicateTree(*this, allocator, {});
   predicateTree =
       propagateGroundTruth(predicateTree,
                            /*knownTruePreds=*/llvm::SmallPtrSet<Pred *, 2>(),
                            /*knownFalsePreds=*/llvm::SmallPtrSet<Pred *, 2>());
 
   return getCombinedCondition(*predicateTree);
 }
 

mlir/lib/TableGen/Trait.cpp

 using namespace mlir;
 using namespace mlir::tblgen;
 
 //===----------------------------------------------------------------------===//
 // Trait
 //===----------------------------------------------------------------------===//
 
 Trait Trait::create(const llvm::Init *init) {
-  auto def = cast<llvm::DefInit>(init)->getDef();
+  auto *def = cast<llvm::DefInit>(init)->getDef();
   if (def->isSubClassOf("PredTrait"))
     return Trait(Kind::Pred, def);
   if (def->isSubClassOf("GenInternalTrait"))
     return Trait(Kind::Internal, def);
   if (def->isSubClassOf("InterfaceTrait"))
     return Trait(Kind::Interface, def);
   assert(def->isSubClassOf("NativeTrait"));
   return Trait(Kind::Native, def);

mlir/lib/Target/LLVMIR/ConvertFromLLVMIR.cpp

Importer(MLIRContext *context, ModuleOp module)
         typeTranslator(*context) {
     b.setInsertionPointToStart(module.getBody());
   }
 
   /// Imports `f` into the current module.
   LogicalResult processFunction(llvm::Function *f);
 
   /// Imports GV as a GlobalOp, creating it if it doesn't exist.
-  GlobalOp processGlobal(llvm::GlobalVariable *GV);
+  GlobalOp processGlobal(llvm::GlobalVariable *gv);
 
 private:
   /// Returns personality of `f` as a FlatSymbolRefAttr.
   FlatSymbolRefAttr getPersonalityAsAttr(llvm::Function *f);
   /// Imports `bb` into `block`, which must be initially empty.
   LogicalResult processBasicBlock(llvm::BasicBlock *bb, Block *block);
   /// Imports `inst` and populates instMap[inst] with the imported Value.
   LogicalResult processInstruction(llvm::Instruction *inst);

 Location Importer::processDebugLoc(const llvm::DebugLoc &loc,
                                    llvm::Instruction *inst) {
   if (!loc && inst) {
     std::string s;
     llvm::raw_string_ostream os(s);
     os << "llvm-imported-inst-%";
     inst->printAsOperand(os, /*PrintType=*/false);
     return FileLineColLoc::get(context, os.str(), 0, 0);
-  } else if (!loc) {
+  }
+  if (!loc) {
     return unknownLoc;
   }
   // FIXME: Obtain the filename from DILocationInfo.
   return FileLineColLoc::get(context, "imported-bitcode", loc.getLine(),
                              loc.getCol());
 }
 
 Type Importer::processType(llvm::Type *type) {
if (isa<llvm::ConstantAggregate>(value)) {
     }
 
     return DenseElementsAttr::get(outerType, values);
   }
 
   return nullptr;
 }
 
-GlobalOp Importer::processGlobal(llvm::GlobalVariable *GV) {
-  auto it = globals.find(GV);
+GlobalOp Importer::processGlobal(llvm::GlobalVariable *gv) {
+  auto it = globals.find(gv);
   if (it != globals.end())
     return it->second;
 
   OpBuilder b(module.getBody(), getGlobalInsertPt());
   Attribute valueAttr;
-  if (GV->hasInitializer())
-    valueAttr = getConstantAsAttr(GV->getInitializer());
-  Type type = processType(GV->getValueType());
+  if (gv->hasInitializer())
+    valueAttr = getConstantAsAttr(gv->getInitializer());
+  Type type = processType(gv->getValueType());
   if (!type)
     return nullptr;
 
   uint64_t alignment = 0;
-  llvm::MaybeAlign maybeAlign = GV->getAlign();
+  llvm::MaybeAlign maybeAlign = gv->getAlign();
   if (maybeAlign.hasValue()) {
     llvm::Align align = maybeAlign.getValue();
     alignment = align.value();
   }
 
   GlobalOp op =
-      b.create<GlobalOp>(UnknownLoc::get(context), type, GV->isConstant(),
-                         convertLinkageFromLLVM(GV->getLinkage()),
-                         GV->getName(), valueAttr, alignment);
+      b.create<GlobalOp>(UnknownLoc::get(context), type, gv->isConstant(),
+                         convertLinkageFromLLVM(gv->getLinkage()),
+                         gv->getName(), valueAttr, alignment);
 
-  if (GV->hasInitializer() && !valueAttr) {
+  if (gv->hasInitializer() && !valueAttr) {
     Region &r = op.getInitializerRegion();
     currentEntryBlock = b.createBlock(&r);
     b.setInsertionPoint(currentEntryBlock, currentEntryBlock->begin());
-    Value v = processConstant(GV->getInitializer());
+    Value v = processConstant(gv->getInitializer());
     if (!v)
       return nullptr;
     b.create<ReturnOp>(op.getLoc(), ArrayRef<Value>({v}));
   }
-  if (GV->hasAtLeastLocalUnnamedAddr())
+  if (gv->hasAtLeastLocalUnnamedAddr())
     op.setUnnamedAddrAttr(UnnamedAddrAttr::get(
-        context, convertUnnamedAddrFromLLVM(GV->getUnnamedAddr())));
-  if (GV->hasSection())
-    op.setSectionAttr(b.getStringAttr(GV->getSection()));
+        context, convertUnnamedAddrFromLLVM(gv->getUnnamedAddr())));
+  if (gv->hasSection())
+    op.setSectionAttr(b.getStringAttr(gv->getSection()));
 
-  return globals[GV] = op;
+  return globals[gv] = op;
 }
 
 Value Importer::processConstant(llvm::Constant *c) {
   OpBuilder bEntry(currentEntryBlock, currentEntryBlock->begin());
   if (Attribute attr = getConstantAsAttr(c)) {
     // These constants can be represented as attributes.
     OpBuilder b(currentEntryBlock, currentEntryBlock->begin());
     Type type = processType(c->getType());
     if (!type)
       return nullptr;
     if (auto symbolRef = attr.dyn_cast<FlatSymbolRefAttr>())
       return instMap[c] = bEntry.create<AddressOfOp>(unknownLoc, type,
                                                      symbolRef.getValue());
     return instMap[c] = bEntry.create<ConstantOp>(unknownLoc, type, attr);
   }
   if (auto *cn = dyn_cast<llvm::ConstantPointerNull>(c)) {
     Type type = processType(cn->getType());
     if (!type)
       return nullptr;
     return instMap[c] = bEntry.create<NullOp>(unknownLoc, type);
   }
-  if (auto *GV = dyn_cast<llvm::GlobalVariable>(c))
+  if (auto *gv = dyn_cast<llvm::GlobalVariable>(c))
     return bEntry.create<AddressOfOp>(UnknownLoc::get(context),
-                                      processGlobal(GV));
+                                      processGlobal(gv));
 
   if (auto *ce = dyn_cast<llvm::ConstantExpr>(c)) {
     llvm::Instruction *i = ce->getAsInstruction();
     OpBuilder::InsertionGuard guard(b);
     b.setInsertionPoint(currentEntryBlock, currentEntryBlock->begin());
     if (failed(processInstruction(i)))
       return nullptr;
     assert(instMap.count(i));

 }
 
 // `br` branches to `target`. Return the branch arguments to `br`, in the
 // same order of the PHIs in `target`.
 LogicalResult
 Importer::processBranchArgs(llvm::Instruction *br, llvm::BasicBlock *target,
                             SmallVectorImpl<Value> &blockArguments) {
   for (auto inst = target->begin(); isa<llvm::PHINode>(inst); ++inst) {
-    auto *PN = cast<llvm::PHINode>(&*inst);
-    Value value = processValue(PN->getIncomingValueForBlock(br->getParent()));
+    auto *pn = cast<llvm::PHINode>(&*inst);
+    Value value = processValue(pn->getIncomingValueForBlock(br->getParent()));
     if (!value)
       return failure();
     blockArguments.push_back(value);
   }
   return success();
 }
 
 LogicalResult Importer::processInstruction(llvm::Instruction *inst) {
FlatSymbolRefAttr Importer::getPersonalityAsAttr(llvm::Function *f) {
   llvm::Constant *pf = f->getPersonalityFn();
 
   // If it directly has a name, we can use it.
   if (pf->hasName())
     return SymbolRefAttr::get(b.getContext(), pf->getName());
 
   // If it doesn't have a name, currently, only function pointers that are
   // bitcast to i8* are parsed.
-  if (auto ce = dyn_cast<llvm::ConstantExpr>(pf)) {
+  if (auto *ce = dyn_cast<llvm::ConstantExpr>(pf)) {
     if (ce->getOpcode() == llvm::Instruction::BitCast &&
         ce->getType() == llvm::Type::getInt8PtrTy(f->getContext())) {
-      if (auto func = dyn_cast<llvm::Function>(ce->getOperand(0)))
+      if (auto *func = dyn_cast<llvm::Function>(ce->getOperand(0)))
         return SymbolRefAttr::get(b.getContext(), func->getName());
     }
   }
   return FlatSymbolRefAttr();
 }
 
 LogicalResult Importer::processFunction(llvm::Function *f) {
   blocks.clear();

mlir/lib/Target/LLVMIR/Dialect/OpenACC/OpenACCToLLVMIRTranslation.cpp

 static llvm::Constant *createSourceLocStrFromLocation(Location loc,
                                                       OpenACCIRBuilder &builder,
                                                       StringRef name) {
   if (auto fileLoc = loc.dyn_cast<FileLineColLoc>()) {
     StringRef fileName = fileLoc.getFilename();
     unsigned lineNo = fileLoc.getLine();
     unsigned colNo = fileLoc.getColumn();
     return builder.getOrCreateSrcLocStr(name, fileName, lineNo, colNo);
-  } else {
-    std::string locStr;
-    llvm::raw_string_ostream locOS(locStr);
-    locOS << loc;
-    return builder.getOrCreateSrcLocStr(locOS.str());
-  }
-}
+  }
 
 /// Create the location struct from the operation location information.
 static llvm::Value *createSourceLocationInfo(OpenACCIRBuilder &builder,
                                              Operation *op) {
   auto loc = op->getLoc();
   auto funcOp = op->getParentOfType<LLVM::LLVMFuncOp>();
   StringRef funcName = funcOp ? funcOp.getName() : "unknown";
   llvm::Constant *locStr =
       createSourceLocStrFromLocation(loc, builder, funcName);
   return builder.getOrCreateIdent(locStr);
 }
 
 /// Create a constant string representing the mapping information extracted from
 /// the MLIR location information.
 static llvm::Constant *createMappingInformation(Location loc,
                                                 OpenACCIRBuilder &builder) {
   if (auto nameLoc = loc.dyn_cast<NameLoc>()) {
     StringRef name = nameLoc.getName();
     return createSourceLocStrFromLocation(nameLoc.getChildLoc(), builder, name);
-  } else {
-    return createSourceLocStrFromLocation(loc, builder, "unknown");
   }
+  return createSourceLocStrFromLocation(loc, builder, "unknown");
 }
 
 /// Return the runtime function used to lower the given operation.
 static llvm::Function *getAssociatedFunction(OpenACCIRBuilder &builder,
                                              Operation *op) {
   return llvm::TypeSwitch<Operation *, llvm::Function *>(op)
       .Case([&](acc::EnterDataOp) {
         return builder.getOrCreateRuntimeFunctionPtr(

mlir/lib/Target/LLVMIR/Dialect/OpenMP/OpenMPToLLVMIRTranslation.cpp

auto nextInsertionPoint =
       ompBuilder->createBarrier(contInsertPoint, llvm::omp::OMPD_for);
   tempTerminator->eraseFromParent();
   builder.restoreIP(nextInsertionPoint);
 
   return success();
 }
 
 // Convert an Atomic Ordering attribute to llvm::AtomicOrdering.
-llvm::AtomicOrdering convertAtomicOrdering(Optional<StringRef> AOAttr) {
-  if (!AOAttr.hasValue())
+llvm::AtomicOrdering convertAtomicOrdering(Optional<StringRef> aoAttr) {
+  if (!aoAttr.hasValue())
     return llvm::AtomicOrdering::Monotonic; // Default Memory Ordering
 
-  return StringSwitch<llvm::AtomicOrdering>(AOAttr.getValue())
+  return StringSwitch<llvm::AtomicOrdering>(aoAttr.getValue())
       .Case("seq_cst", llvm::AtomicOrdering::SequentiallyConsistent)
       .Case("acq_rel", llvm::AtomicOrdering::AcquireRelease)
       .Case("acquire", llvm::AtomicOrdering::Acquire)
       .Case("release", llvm::AtomicOrdering::Release)
       .Case("relaxed", llvm::AtomicOrdering::Monotonic)
       .Default(llvm::AtomicOrdering::Monotonic);
 }
 
 // Convert omp.atomic.read operation to LLVM IR.
 static LogicalResult
 convertOmpAtomicRead(Operation &opInst, llvm::IRBuilderBase &builder,
                      LLVM::ModuleTranslation &moduleTranslation) {
 
   auto readOp = cast<omp::AtomicReadOp>(opInst);
   llvm::OpenMPIRBuilder *ompBuilder = moduleTranslation.getOpenMPBuilder();
 
   // Set up the source location value for OpenMP runtime.
   llvm::DISubprogram *subprogram =
       builder.GetInsertBlock()->getParent()->getSubprogram();
   const llvm::DILocation *diLoc =
       moduleTranslation.translateLoc(opInst.getLoc(), subprogram);
   llvm::OpenMPIRBuilder::LocationDescription ompLoc(builder.saveIP(),
                                                     llvm::DebugLoc(diLoc));
-  llvm::AtomicOrdering AO = convertAtomicOrdering(readOp.memory_order());
+  llvm::AtomicOrdering ao = convertAtomicOrdering(readOp.memory_order());
   llvm::Value *address = moduleTranslation.lookupValue(readOp.address());
   llvm::OpenMPIRBuilder::InsertPointTy currentIP = builder.saveIP();
 
   // Insert alloca for result.
   llvm::OpenMPIRBuilder::InsertPointTy allocaIP =
       findAllocaInsertPoint(builder, moduleTranslation);
   builder.restoreIP(allocaIP);
   llvm::Value *v = builder.CreateAlloca(
       moduleTranslation.convertType(readOp.getResult().getType()));
   moduleTranslation.mapValue(readOp.getResult(), v);
 
   // Restore the IP and insert Atomic Read.
   builder.restoreIP(currentIP);
-  llvm::OpenMPIRBuilder::AtomicOpValue V = {v, false, false};
-  llvm::OpenMPIRBuilder::AtomicOpValue X = {address, false, false};
-  builder.restoreIP(ompBuilder->createAtomicRead(ompLoc, X, V, AO));
+  llvm::OpenMPIRBuilder::AtomicOpValue atomicV = {v, false, false};
+  llvm::OpenMPIRBuilder::AtomicOpValue x = {address, false, false};
+  builder.restoreIP(ompBuilder->createAtomicRead(ompLoc, x, atomicV, ao));
   return success();
 }
 
 /// Converts an OpenMP reduction operation using OpenMPIRBuilder. Expects the
 /// mapping between reduction variables and their private equivalents to have
 /// been stored on the ModuleTranslation stack. Currently only supports
 /// reduction within WsLoopOp, but can be easily extended.
 static LogicalResult

mlir/lib/Target/LLVMIR/Dialect/ROCDL/ROCDLToLLVMIRTranslation.cpp

 using namespace mlir::LLVM;
 using mlir::LLVM::detail::createIntrinsicCall;
 
 // Create a call to ROCm-Device-Library function
 // Currently this routine will work only for calling ROCDL functions that
 // take a single int32 argument. It is likely that the interface of this
 // function will change to make it more generic.
 static llvm::Value *createDeviceFunctionCall(llvm::IRBuilderBase &builder,
-                                             StringRef fn_name, int parameter) {
+                                             StringRef fnName, int parameter) {
   llvm::Module *module = builder.GetInsertBlock()->getModule();
-  llvm::FunctionType *function_type = llvm::FunctionType::get(
+  llvm::FunctionType *functionType = llvm::FunctionType::get(
       llvm::Type::getInt64Ty(module->getContext()), // return type.
       llvm::Type::getInt32Ty(module->getContext()), // parameter type.
       false);                                       // no variadic arguments.
   llvm::Function *fn = dyn_cast<llvm::Function>(
-      module->getOrInsertFunction(fn_name, function_type).getCallee());
-  llvm::Value *fn_op0 = llvm::ConstantInt::get(
+      module->getOrInsertFunction(fnName, functionType).getCallee());
+  llvm::Value *fnOp0 = llvm::ConstantInt::get(
       llvm::Type::getInt32Ty(module->getContext()), parameter);
-  return builder.CreateCall(fn, ArrayRef<llvm::Value *>(fn_op0));
+  return builder.CreateCall(fn, ArrayRef<llvm::Value *>(fnOp0));
 }
 
 namespace {
 /// Implementation of the dialect interface that converts operations belonging
 /// to the ROCDL dialect to LLVM IR.
 class ROCDLDialectLLVMIRTranslationInterface
     : public LLVMTranslationDialectInterface {
 public:

mlir/lib/Target/LLVMIR/ModuleTranslation.cpp

if (auto funcAttr = attr.dyn_cast<FlatSymbolRefAttr>())
     return llvm::ConstantExpr::getBitCast(
         moduleTranslation.lookupFunction(funcAttr.getValue()), llvmType);
   if (auto splatAttr = attr.dyn_cast<SplatElementsAttr>()) {
     llvm::Type *elementType;
     uint64_t numElements;
     if (auto *arrayTy = dyn_cast<llvm::ArrayType>(llvmType)) {
       elementType = arrayTy->getElementType();
       numElements = arrayTy->getNumElements();
-    } else if (auto fVectorTy = dyn_cast<llvm::FixedVectorType>(llvmType)) {
+    } else if (auto *fVectorTy = dyn_cast<llvm::FixedVectorType>(llvmType)) {
       elementType = fVectorTy->getElementType();
       numElements = fVectorTy->getNumElements();
-    } else if (auto sVectorTy = dyn_cast<llvm::ScalableVectorType>(llvmType)) {
+    } else if (auto *sVectorTy = dyn_cast<llvm::ScalableVectorType>(llvmType)) {
       elementType = sVectorTy->getElementType();
       numElements = sVectorTy->getMinNumElements();
     } else {
       llvm_unreachable("unrecognized constant vector type");
     }
     // Splat value is a scalar. Extract it only if the element type is not
     // another sequence type. The recursion terminates because each step removes
     // one outer sequential type.

mlir/lib/Tools/PDLL/Parser/Parser.cpp

if (parentType.isa<ast::OperationType>()) {
     unsigned index = 0;
     if (llvm::isDigit(name[0]) && !name.getAsInteger(/*Radix=*/10, index) &&
         index < tupleType.size()) {
       return tupleType.getElementTypes()[index];
     }
 
     // Handle named results.
     auto elementNames = tupleType.getElementNames();
-    auto it = llvm::find(elementNames, name);
+    const auto *it = llvm::find(elementNames, name);
     if (it != elementNames.end())
       return tupleType.getElementTypes()[it - elementNames.begin()];
   }
   return emitError(
       loc,
       llvm::formatv("invalid member access `{0}` on expression of type `{1}`",
                     name, parentType));
 }

mlir/lib/Tools/mlir-lsp-server/MLIRServer.cpp

static bool isDefOrUse(const AsmParserState::SMDefinition &def, llvm::SMLoc loc,
   // Check the main definition.
   if (contains(def.loc, loc)) {
     if (overlappedRange)
       *overlappedRange = def.loc;
     return true;
   }
 
   // Check the uses.
-  auto useIt = llvm::find_if(def.uses, [&](const llvm::SMRange &range) {
+  const auto *useIt = llvm::find_if(def.uses, [&](const llvm::SMRange &range) {
     return contains(range, loc);
   });
   if (useIt != def.uses.end()) {
     if (overlappedRange)
       *overlappedRange = *useIt;
     return true;
   }
   return false;

mlir/lib/Tools/mlir-reduce/MlirReduceMain.cpp

static LogicalResult loadModule(MLIRContext &context,
 
   return success();
 }
 
 LogicalResult mlir::mlirReduceMain(int argc, char **argv,
                                    MLIRContext &context) {
   // Override the default '-h' and use the default PrintHelpMessage() which
   // won't print options in categories.
-  static llvm::cl::opt<bool> Help("h", llvm::cl::desc("Alias for -help"),
+  static llvm::cl::opt<bool> help("h", llvm::cl::desc("Alias for -help"),
                                   llvm::cl::Hidden);
 
-  static llvm::cl::OptionCategory MLIRReduceCategory("mlir-reduce options");
+  static llvm::cl::OptionCategory mlirReduceCategory("mlir-reduce options");
 
   static llvm::cl::opt<std::string> inputFilename(
       llvm::cl::Positional, llvm::cl::desc("<input file>"),
-      llvm::cl::cat(MLIRReduceCategory));
+      llvm::cl::cat(mlirReduceCategory));
 
   static llvm::cl::opt<std::string> outputFilename(
       "o", llvm::cl::desc("Output filename for the reduced test case"),
-      llvm::cl::init("-"), llvm::cl::cat(MLIRReduceCategory));
+      llvm::cl::init("-"), llvm::cl::cat(mlirReduceCategory));
 
-  llvm::cl::HideUnrelatedOptions(MLIRReduceCategory);
+  llvm::cl::HideUnrelatedOptions(mlirReduceCategory);
 
   llvm::InitLLVM y(argc, argv);
 
   registerReducerPasses();
 
   PassPipelineCLParser parser("", "Reduction Passes to Run");
   llvm::cl::ParseCommandLineOptions(argc, argv,
                                     "MLIR test case reduction tool.\n");
 
-  if (Help) {
+  if (help) {
     llvm::cl::PrintHelpMessage();
     return success();
   }
 
   std::string errorMessage;
 
   auto output = openOutputFile(outputFilename, &errorMessage);
   if (!output)

mlir/lib/Transforms/LoopFusion.cpp

public:
   void removeEdge(unsigned srcId, unsigned dstId, Value value) {
     assert(inEdges.count(dstId) > 0);
     assert(outEdges.count(srcId) > 0);
     if (value.getType().isa<MemRefType>()) {
       assert(memrefEdgeCount.count(value) > 0);
       memrefEdgeCount[value]--;
     }
     // Remove 'srcId' from 'inEdges[dstId]'.
-    for (auto it = inEdges[dstId].begin(); it != inEdges[dstId].end(); ++it) {
+    for (auto *it = inEdges[dstId].begin(); it != inEdges[dstId].end(); ++it) {
       if ((*it).id == srcId && (*it).value == value) {
         inEdges[dstId].erase(it);
         break;
       }
     }
     // Remove 'dstId' from 'outEdges[srcId]'.
-    for (auto it = outEdges[srcId].begin(); it != outEdges[srcId].end(); ++it) {
+    for (auto *it = outEdges[srcId].begin(); it != outEdges[srcId].end();
+         ++it) {
       if ((*it).id == dstId && (*it).value == value) {
         outEdges[srcId].erase(it);
         break;
       }
     }
   }
 
   // Returns true if there is a path in the dependence graph from node 'srcId'

mlir/lib/Transforms/LoopInvariantCodeMotion.cpp

LogicalResult mlir::moveLoopInvariantCode(LoopLikeOpInterface looplike) {
 
   // We use two collections here as we need to preserve the order for insertion
   // and this is easiest.
   SmallPtrSet<Operation *, 8> willBeMovedSet;
   SmallVector<Operation *, 8> opsToMove;
 
   // Helper to check whether an operation is loop invariant wrt. SSA properties.
   auto isDefinedOutsideOfBody = [&](Value value) {
-    auto definingOp = value.getDefiningOp();
+    auto *definingOp = value.getDefiningOp();
     return (definingOp && !!willBeMovedSet.count(definingOp)) ||
            looplike.isDefinedOutsideOfLoop(value);
   };
 
   // Do not use walk here, as we do not want to go into nested regions and hoist
   // operations from there. These regions might have semantics unknown to this
   // rewriting. If the nested regions are loops, they will have been processed.
   for (auto &block : loopBody) {

mlir/lib/Transforms/NormalizeMemRefs.cpp

Operation *NormalizeMemRefs::createOpResultsNormalized(FuncOp funcOp,
   // affine map, `oldOp` is returned without modification.
   if (resultTypeNormalized) {
     OpBuilder bb(oldOp);
     for (auto &oldRegion : oldOp->getRegions()) {
       Region *newRegion = result.addRegion();
       newRegion->takeBody(oldRegion);
     }
     return bb.createOperation(result);
-  } else
-    return oldOp;
+  }
 }

mlir/lib/Transforms/PipelineDataTransfer.cpp

for (auto &op : *forOp.getBody()) {
     // Only DMAs incoming into higher memory spaces are pipelined for now.
     // TODO: handle outgoing DMA pipelining.
     if (!dmaStartOp.isDestMemorySpaceFaster())
       continue;
 
     // Check for dependence with outgoing DMAs. Doing this conservatively.
     // TODO: use the dependence analysis to check for
     // dependences between an incoming and outgoing DMA in the same iteration.
-    auto it = outgoingDmaOps.begin();
+    auto *it = outgoingDmaOps.begin();
     for (; it != outgoingDmaOps.end(); ++it) {
       if (it->getDstMemRef() == dmaStartOp.getSrcMemRef())
         break;
     }
     if (it != outgoingDmaOps.end())
       continue;
 
     // We only double buffer if the buffer is not live out of loop.

mlir/lib/Transforms/Utils/FoldUtils.cpp

LogicalResult OperationFolder::tryToFold(
     function_ref<void(Operation *)> processGeneratedConstants) {
   SmallVector<Attribute, 8> operandConstants;
   SmallVector<OpFoldResult, 8> foldResults;
 
   // If this is a commutative operation, move constants to be trailing operands.
   if (op->getNumOperands() >= 2 && op->hasTrait<OpTrait::IsCommutative>()) {
     std::stable_partition(
         op->getOpOperands().begin(), op->getOpOperands().end(),
-        [&](OpOperand &O) { return !matchPattern(O.get(), m_Constant()); });
+        [&](OpOperand &o) { return !matchPattern(o.get(), m_Constant()); });
   }
 
   // Check to see if any operands to the operation is constant and whether
   // the operation knows how to constant fold itself.
   operandConstants.assign(op->getNumOperands(), Attribute());
   for (unsigned i = 0, e = op->getNumOperands(); i != e; ++i)
     matchPattern(op->getOperand(i), m_Constant(&operandConstants[i]));
 

mlir/lib/Transforms/Utils/LoopFusionUtils.cpp

 /// Returns true if 'op' is a load or store operation which access a memref
 /// accessed 'values' and at least one of the access is a store operation.
 /// Returns false otherwise.
 static bool isDependentLoadOrStoreOp(Operation *op,
                                      DenseMap<Value, bool> &values) {
   if (auto loadOp = dyn_cast<AffineReadOpInterface>(op)) {
     return values.count(loadOp.getMemRef()) > 0 &&
            values[loadOp.getMemRef()] == true;
-  } else if (auto storeOp = dyn_cast<AffineWriteOpInterface>(op)) {
+  }
+  if (auto storeOp = dyn_cast<AffineWriteOpInterface>(op)) {
     return values.count(storeOp.getMemRef()) > 0;
   }
   return false;
 }
 
 // Returns the first operation in range ('opA', 'opB') which has a data
 // dependence on 'opA'. Returns 'nullptr' of no dependence exists.
 static Operation *getFirstDependentOpInRange(Operation *opA, Operation *opB) {

mlir/lib/Transforms/Utils/LoopUtils.cpp

block->walk(begin, end, [&](Operation *opInst) {
     // region in the other list if one exists (write in case of read and vice
     // versa) since there is a single bounding box for a memref across all reads
     // and writes that happen on it.
 
     // Attempts to update; returns true if 'region' exists in targetRegions.
     auto updateRegion =
         [&](const SmallMapVector<Value, std::unique_ptr<MemRefRegion>, 4>
                 &targetRegions) {
-          const auto it = targetRegions.find(region->memref);
+          const auto *const it = targetRegions.find(region->memref);
           if (it == targetRegions.end())
             return false;
 
           // Perform a union with the existing region.
           if (failed(it->second->unionBoundingBox(*region))) {
             LLVM_DEBUG(llvm::dbgs()
                        << "Memory region bounding box failed; "
                           "over-approximating to the entire memref\n");

mlir/test/lib/Analysis/TestAliasAnalysis.cpp

getOperation()->walk([&](Operation *op) {
       valsToCheck.append(op->result_begin(), op->result_end());
       for (Region &region : op->getRegions())
         for (Block &block : region)
           valsToCheck.append(block.args_begin(), block.args_end());
     });
 
     // Check for aliasing behavior between each of the values.
     for (auto it = valsToCheck.begin(), e = valsToCheck.end(); it != e; ++it)
-      for (auto innerIt = valsToCheck.begin(); innerIt != it; ++innerIt)
+      for (auto *innerIt = valsToCheck.begin(); innerIt != it; ++innerIt)
         printAliasResult(aliasAnalysis.alias(*innerIt, *it), *innerIt, *it);
   }
 
   /// Print the result of an alias query.
   void printAliasResult(AliasResult result, Value lhs, Value rhs) {
     printAliasOperand(lhs);
     llvm::errs() << " <-> ";
     printAliasOperand(rhs);

mlir/test/lib/Dialect/Math/TestPolynomialApproximation.cpp

Option<bool> enableAvx2{
       llvm::cl::desc("Enable approximations that emit AVX2 intrinsics via the "
                      "X86Vector dialect"),
       llvm::cl::init(false)};
 };
 } // namespace
 
 void TestMathPolynomialApproximationPass::runOnFunction() {
   RewritePatternSet patterns(&getContext());
-  MathPolynomialApproximationOptions approx_options;
-  approx_options.enableAvx2 = enableAvx2;
-  populateMathPolynomialApproximationPatterns(patterns, approx_options);
+  MathPolynomialApproximationOptions approxOptions;
+  approxOptions.enableAvx2 = enableAvx2;
+  populateMathPolynomialApproximationPatterns(patterns, approxOptions);
   (void)applyPatternsAndFoldGreedily(getOperation(), std::move(patterns));
 }
 
 namespace mlir {
 namespace test {
 void registerTestMathPolynomialApproximationPass() {
   PassRegistration<TestMathPolynomialApproximationPass>();
 }
 } // namespace test
 } // namespace mlir

mlir/test/lib/Dialect/Test/TestDialect.cpp

static ParseResult parseWrappingRegionOp(OpAsmParser &parser,
                                          OperationState &result) {
   if (parser.parseKeyword("wraps"))
     return failure();
 
   // Parse the wrapped op in a region
   Region &body = *result.addRegion();
   body.push_back(new Block);
   Block &block = body.back();
-  Operation *wrapped_op = parser.parseGenericOperation(&block, block.begin());
-  if (!wrapped_op)
+  Operation *wrappedOp = parser.parseGenericOperation(&block, block.begin());
+  if (!wrappedOp)
     return failure();
 
   // Create a return terminator in the inner region, pass as operand to the
   // terminator the returned values from the wrapped operation.
-  SmallVector<Value, 8> return_operands(wrapped_op->getResults());
+  SmallVector<Value, 8> returnOperands(wrappedOp->getResults());
   OpBuilder builder(parser.getContext());
   builder.setInsertionPointToEnd(&block);
-  builder.create<TestReturnOp>(wrapped_op->getLoc(), return_operands);
+  builder.create<TestReturnOp>(wrappedOp->getLoc(), returnOperands);
 
   // Get the results type for the wrapping op from the terminator operands.
-  Operation &return_op = body.back().back();
-  result.types.append(return_op.operand_type_begin(),
-                      return_op.operand_type_end());
+  Operation &returnOp = body.back().back();
+  result.types.append(returnOp.operand_type_begin(),
+                      returnOp.operand_type_end());
 
   // Use the location of the wrapped op for the "test.wrapping_region" op.
-  result.location = wrapped_op->getLoc();
+  result.location = wrappedOp->getLoc();
 
   return success();
 }
 
 static void print(OpAsmPrinter &p, WrappingRegionOp op) {
   p << " wraps ";
   p.printGenericOp(&op.getRegion().front().front());
 }

mlir/test/lib/Dialect/Test/TestOps.td

def OpFuncRef : TEST_Op<"op_funcref"> {
   let builders = [OpBuilder<(ins "::mlir::FuncOp":$function)>];
 }
 
 // Pattern add the argument plus a increasing static number hidden in
 // OpMTest function. That value is set into the optional argument.
 // That way, we will know if operations is called once or twice.
 def OpMGetNullAttr : NativeCodeCall<"Attribute()">;
 def OpMAttributeIsNull : Constraint<CPred<"! ($_self)">, "Attribute is null">;
-def OpMVal : NativeCodeCall<"OpMTest($_builder, $0)">;
+def OpMVal : NativeCodeCall<"opMTest($_builder, $0)">;
 def : Pat<(OpM $attr, $optAttr), (OpM $attr, (OpMVal $attr) ),
     [(OpMAttributeIsNull:$optAttr)]>;
 
 // Test `$_` for ignoring op argument match.
 def TestIgnoreArgMatchSrcOp : TEST_Op<"ignore_arg_match_src"> {
   let arguments = (ins
     AnyType:$a, AnyType:$b, AnyType:$c,
     AnyAttr:$d, AnyAttr:$e, AnyAttr:$f);

mlir/test/lib/Dialect/Test/TestPatterns.cpp

static SmallVector<Value, 2> bindMultipleNativeCodeCallResult(Value input1,
   return SmallVector<Value, 2>({input2, input1});
 }
 
 // Test that natives calls are only called once during rewrites.
 // OpM_Test will return Pi, increased by 1 for each subsequent calls.
 // This let us check the number of times OpM_Test was called by inspecting
 // the returned value in the MLIR output.
 static int64_t opMIncreasingValue = 314159265;
-static Attribute OpMTest(PatternRewriter &rewriter, Value val) {
+static Attribute opMTest(PatternRewriter &rewriter, Value val) {
   int64_t i = opMIncreasingValue++;
   return rewriter.getIntegerAttr(rewriter.getIntegerType(32), i);
 }
 
 namespace {
 #include "TestPatterns.inc"
 } // namespace
 

mlir/test/lib/Dialect/Tosa/TosaTestPasses.cpp

if (outputElementType.isSigned() ||
     return failure();
 
   double typeRangeMin = double(outputElementType.getStorageTypeMin() -
                                outputElementType.getZeroPoint()) *
                         outputElementType.getScale();
   double typeRangeMax = double(outputElementType.getStorageTypeMax() -
                                outputElementType.getZeroPoint()) *
                         outputElementType.getScale();
-  bool narrow_range = outputElementType.getStorageTypeMin() == 1 ? true : false;
+  bool narrowRange = outputElementType.getStorageTypeMin() == 1 ? true : false;
 
   auto dstQConstType = RankedTensorType::get(
       outputType.getShape(),
       buildQTypeFromMinMax(rewriter, outputElementType.getExpressedType(),
                            rewriter.getF64FloatAttr(typeRangeMin),
                            rewriter.getF64FloatAttr(typeRangeMax),
                            rewriter.getI32IntegerAttr(
                                outputElementType.getStorageTypeIntegralWidth()),
                            0, true /* signed */,
-                           rewriter.getBoolAttr(narrow_range)));
+                           rewriter.getBoolAttr(narrowRange)));
 
   ElementsAttr inputElems;
   if (!matchPattern(tosaNegateOp.input1(), m_Constant(&inputElems)))
     return failure();
 
   auto newConstOp =
       rewriter.create<tosa::ConstOp>(op->getLoc(), dstQConstType, inputElems);
   auto newNegateOp = rewriter.create<tosa::NegateOp>(

mlir/test/lib/IR/TestMatchers.cpp

static void test1(FuncOp f) {
   auto p6 = m_Op<arith::MulFOp>(m_Op<arith::MulFOp>(), m_Any());
   llvm::outs() << "Pattern mul(mul(*), *) matched " << countMatches(f, p6)
                << " times\n";
 
   auto p7 = m_Op<arith::MulFOp>(m_Op<arith::MulFOp>(), m_Op<arith::MulFOp>());
   llvm::outs() << "Pattern mul(mul(*), mul(*)) matched " << countMatches(f, p7)
                << " times\n";
 
-  auto mul_of_mulmul =
+  auto mulOfMulmul =
       m_Op<arith::MulFOp>(m_Op<arith::MulFOp>(), m_Op<arith::MulFOp>());
-  auto p8 = m_Op<arith::MulFOp>(mul_of_mulmul, mul_of_mulmul);
+  auto p8 = m_Op<arith::MulFOp>(mulOfMulmul, mulOfMulmul);
   llvm::outs()
       << "Pattern mul(mul(mul(*), mul(*)), mul(mul(*), mul(*))) matched "
       << countMatches(f, p8) << " times\n";
 
   // clang-format off
-  auto mul_of_muladd = m_Op<arith::MulFOp>(m_Op<arith::MulFOp>(), m_Op<arith::AddFOp>());
-  auto mul_of_anyadd = m_Op<arith::MulFOp>(m_Any(), m_Op<arith::AddFOp>());
+  auto mulOfMuladd = m_Op<arith::MulFOp>(m_Op<arith::MulFOp>(), m_Op<arith::AddFOp>());
+  auto mulOfAnyadd = m_Op<arith::MulFOp>(m_Any(), m_Op<arith::AddFOp>());
   auto p9 = m_Op<arith::MulFOp>(m_Op<arith::MulFOp>(
-                     mul_of_muladd, m_Op<arith::MulFOp>()),
-                   m_Op<arith::MulFOp>(mul_of_anyadd, mul_of_anyadd));
+                     mulOfMuladd, m_Op<arith::MulFOp>()),
+                   m_Op<arith::MulFOp>(mulOfAnyadd, mulOfAnyadd));
   // clang-format on
   llvm::outs() << "Pattern mul(mul(mul(mul(*), add(*)), mul(*)), mul(mul(*, "
                   "add(*)), mul(*, add(*)))) matched "
                << countMatches(f, p9) << " times\n";
 
   auto p10 = m_Op<arith::AddFOp>(a, b);
   llvm::outs() << "Pattern add(a, b) matched " << countMatches(f, p10)
                << " times\n";
static void test1(FuncOp f) {
   auto p14 = m_Op<arith::MulFOp>(a, m_Op<arith::AddFOp>(c, b));
   llvm::outs() << "Pattern mul(a, add(c, b)) matched " << countMatches(f, p14)
                << " times\n";
 
   auto p15 = m_Op<arith::MulFOp>(a, m_Op<arith::AddFOp>(b, c));
   llvm::outs() << "Pattern mul(a, add(b, c)) matched " << countMatches(f, p15)
                << " times\n";
 
-  auto mul_of_aany = m_Op<arith::MulFOp>(a, m_Any());
-  auto p16 = m_Op<arith::MulFOp>(mul_of_aany, m_Op<arith::AddFOp>(a, c));
+  auto mulOfAany = m_Op<arith::MulFOp>(a, m_Any());
+  auto p16 = m_Op<arith::MulFOp>(mulOfAany, m_Op<arith::AddFOp>(a, c));
   llvm::outs() << "Pattern mul(mul(a, *), add(a, c)) matched "
                << countMatches(f, p16) << " times\n";
 
-  auto p17 = m_Op<arith::MulFOp>(mul_of_aany, m_Op<arith::AddFOp>(c, b));
+  auto p17 = m_Op<arith::MulFOp>(mulOfAany, m_Op<arith::AddFOp>(c, b));
   llvm::outs() << "Pattern mul(mul(a, *), add(c, b)) matched "
                << countMatches(f, p17) << " times\n";
 }
 
 void test2(FuncOp f) {
   auto a = m_Val(f.getArgument(0));
   FloatAttr floatAttr;
   auto p =

mlir/test/lib/IR/TestOpaqueLoc.cpp

struct MyLocation {
     MyLocation(int id) : id(id) {}
     int getId() { return id; }
 
     int id;
   };
 
   void runOnOperation() override {
     std::vector<std::unique_ptr<MyLocation>> myLocs;
-    int last_it = 0;
+    int lastIt = 0;
 
     getOperation().getBody()->walk([&](Operation *op) {
-      myLocs.push_back(std::make_unique<MyLocation>(last_it++));
+      myLocs.push_back(std::make_unique<MyLocation>(lastIt++));
 
       Location loc = op->getLoc();
 
       /// Set opaque location without fallback location to test the
       /// corresponding get method.
       op->setLoc(
           OpaqueLoc::get<MyLocation *>(myLocs.back().get(), &getContext()));
 
       if (isa<FuncOp>(op) || op->hasTrait<OpTrait::IsTerminator>())
         return;
 
       OpBuilder builder(op);
 
       /// Add the same operation but with fallback location to test the
       /// corresponding get method and serialization.
-      Operation *op_cloned_1 = builder.clone(*op);
-      op_cloned_1->setLoc(
-          OpaqueLoc::get<MyLocation *>(myLocs.back().get(), loc));
+      Operation *opCloned1 = builder.clone(*op);
+      opCloned1->setLoc(OpaqueLoc::get<MyLocation *>(myLocs.back().get(), loc));
 
       /// Add the same operation but with void* instead of MyLocation* to test
       /// getUnderlyingLocationOrNull method.
-      Operation *op_cloned_2 = builder.clone(*op);
-      op_cloned_2->setLoc(OpaqueLoc::get<void *>(nullptr, loc));
+      Operation *opCloned2 = builder.clone(*op);
+      opCloned2->setLoc(OpaqueLoc::get<void *>(nullptr, loc));
     });
 
     ScopedDiagnosticHandler diagHandler(&getContext(), [](Diagnostic &diag) {
       auto &os = llvm::outs();
       if (diag.getLocation().isa<OpaqueLoc>()) {
         MyLocation *loc = OpaqueLoc::getUnderlyingLocationOrNull<MyLocation *>(
             diag.getLocation());
         if (loc)

mlir/test/lib/Transforms/TestLoopFusion.cpp

 
 using LoopFunc = function_ref<bool(AffineForOp, AffineForOp, unsigned, unsigned,
                                    unsigned, unsigned)>;
 
 // Run tests on all combinations of src/dst loop nests in 'depthToLoops'.
 // If 'return_on_change' is true, returns on first invocation of 'fn' which
 // returns true.
 static bool iterateLoops(ArrayRef<SmallVector<AffineForOp, 2>> depthToLoops,
-                         LoopFunc fn, bool return_on_change = false) {
+                         LoopFunc fn, bool returnOnChange = false) {
   bool changed = false;
   for (unsigned loopDepth = 0, end = depthToLoops.size(); loopDepth < end;
        ++loopDepth) {
     auto &loops = depthToLoops[loopDepth];
     unsigned numLoops = loops.size();
     for (unsigned j = 0; j < numLoops; ++j) {
       for (unsigned k = 0; k < numLoops; ++k) {
         if (j != k)
           changed |=
               fn(loops[j], loops[k], j, k, loopDepth, depthToLoops.size());
-        if (changed && return_on_change)
+        if (changed && returnOnChange)
           return true;
       }
     }
   }
   return changed;
 }
 
 void TestLoopFusion::runOnFunction() {

mlir/test/mlir-spirv-cpu-runner/mlir_test_spirv_cpu_runner_c_wrappers.cpp

 //===- mlir_test_spirv_cpu_runner_c_wrappers.cpp - Runner testing library -===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // A small library for SPIR-V cpu runner testing.
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/ExecutionEngine/RunnerUtils.h"
 
+// NOLINTBEGIN(*-identifier-naming)
+
 extern "C" void
 _mlir_ciface_fillI32Buffer(StridedMemRefType<int32_t, 1> *mem_ref,
                            int32_t value) {
   std::fill_n(mem_ref->basePtr, mem_ref->sizes[0], value);
 }
 
 extern "C" void
 _mlir_ciface_fillF32Buffer1D(StridedMemRefType<float, 1> *mem_ref,
                              float value) {
   std::fill_n(mem_ref->basePtr, mem_ref->sizes[0], value);
 }
 
 extern "C" void
 _mlir_ciface_fillF32Buffer2D(StridedMemRefType<float, 2> *mem_ref,
                              float value) {
   std::fill_n(mem_ref->basePtr, mem_ref->sizes[0] * mem_ref->sizes[1], value);
 }
 
 extern "C" void
 _mlir_ciface_fillF32Buffer3D(StridedMemRefType<float, 3> *mem_ref,
                              float value) {
   std::fill_n(mem_ref->basePtr,
               mem_ref->sizes[0] * mem_ref->sizes[1] * mem_ref->sizes[2], value);
 }
+
+// NOLINTEND(*-identifier-naming)

mlir/tools/mlir-linalg-ods-gen/mlir-linalg-ods-yaml-gen.cpp

 
 static LogicalResult generateOp(LinalgOpConfig &opConfig,
                                 GenerationContext &genContext) {
   // Switch on op type being generated.
   if (opConfig.structuredOp) {
     return success(
         succeeded(generateNamedGenericOpOds(opConfig, genContext)) &&
         succeeded(generateNamedGenericOpDefns(opConfig, genContext)));
-  } else {
-    return emitError(genContext.getLoc()) << "unsupported operation type";
   }
+  return emitError(genContext.getLoc()) << "unsupported operation type";
 }
 
 //===----------------------------------------------------------------------===//
 // Command line options and main
 //===----------------------------------------------------------------------===//
 
 static llvm::cl::opt<std::string>
     inputFilename(llvm::cl::Positional, llvm::cl::desc("<input file>"),

mlir/tools/mlir-tblgen/DialectGen.cpp

findSelectedDialect(ArrayRef<const llvm::Record *> dialectDefs) {
   }
 
   if (selectedDialect.getNumOccurrences() == 0) {
     llvm::errs() << "when more than 1 dialect is present, one must be selected "
                     "via '-dialect'\n";
     return llvm::None;
   }
 
-  auto dialectIt = llvm::find_if(dialectDefs, [](const llvm::Record *def) {
+  const auto *dialectIt =
+      llvm::find_if(dialectDefs, [](const llvm::Record *def) {
         return Dialect(def).getName() == selectedDialect;
       });
   if (dialectIt == dialectDefs.end()) {
     llvm::errs() << "selected dialect with '-dialect' does not exist\n";
     return llvm::None;
   }
   return Dialect(*dialectIt);
 }
 
 //===----------------------------------------------------------------------===//

mlir/tools/mlir-tblgen/LLVMIRIntrinsicGen.cpp

 #include "llvm/Support/PrettyStackTrace.h"
 #include "llvm/Support/Regex.h"
 #include "llvm/Support/Signals.h"
 #include "llvm/TableGen/Error.h"
 #include "llvm/TableGen/Main.h"
 #include "llvm/TableGen/Record.h"
 #include "llvm/TableGen/TableGenBackend.h"
 
-static llvm::cl::OptionCategory IntrinsicGenCat("Intrinsics Generator Options");
+static llvm::cl::OptionCategory intrinsicGenCat("Intrinsics Generator Options");
 
 static llvm::cl::opt<std::string>
     nameFilter("llvmir-intrinsics-filter",
                llvm::cl::desc("Only keep the intrinsics with the specified "
                               "substring in their record name"),
-               llvm::cl::cat(IntrinsicGenCat));
+               llvm::cl::cat(intrinsicGenCat));
 
 static llvm::cl::opt<std::string>
     opBaseClass("dialect-opclass-base",
                 llvm::cl::desc("The base class for the ops in the dialect we "
                                "are planning to emit"),
-                llvm::cl::init("LLVM_IntrOp"), llvm::cl::cat(IntrinsicGenCat));
+                llvm::cl::init("LLVM_IntrOp"), llvm::cl::cat(intrinsicGenCat));
 
 static llvm::cl::opt<std::string> accessGroupRegexp(
     "llvmir-intrinsics-access-group-regexp",
     llvm::cl::desc("Mark intrinsics that match the specified "
                    "regexp as taking an access group metadata"),
-    llvm::cl::cat(IntrinsicGenCat));
+    llvm::cl::cat(intrinsicGenCat));
 
 static llvm::cl::opt<std::string> aliasScopesRegexp(
     "llvmir-intrinsics-alias-scopes-regexp",
     llvm::cl::desc("Mark intrinsics that match the specified "
                    "regexp as taking alias.scopes and noalias metadata"),
-    llvm::cl::cat(IntrinsicGenCat));
+    llvm::cl::cat(intrinsicGenCat));
 
 // Used to represent the indices of overloadable operands/results.
 using IndicesTy = llvm::SmallBitVector;
 
 /// Return a CodeGen value type entry from a type record.
 static llvm::MVT::SimpleValueType getValueType(const llvm::Record *rec) {
   return (llvm::MVT::SimpleValueType)rec->getValueAsDef("VT")->getValueAsInt(
       "Value");
std::string getOperationName() const {
 
     name = record.getName();
     assert(name.startswith("int_") &&
            "LLVM intrinsic names are expected to start with 'int_'");
     name = name.drop_front(4);
     llvm::SmallVector<llvm::StringRef, 8> chunks;
     llvm::StringRef targetPrefix = record.getValueAsString("TargetPrefix");
     name.split(chunks, '_');
-    auto chunksBegin = chunks.begin();
+    auto *chunksBegin = chunks.begin();
     // Remove the target prefix from target specific intrinsics.
     if (!targetPrefix.empty()) {
       assert(targetPrefix == *chunksBegin &&
              "Intrinsic has TargetPrefix, but "
              "record name doesn't begin with it");
       assert(chunks.size() >= 2 &&
              "Intrinsic has TargetPrefix, but "
              "chunks has only one element meaning the intrinsic name is empty");

mlir/tools/mlir-tblgen/OpDefinitionsGen.cpp

for (const auto &namedAttr : emitHelper.getOp().getAttributes()) {
     std::string condition = attrPred.isNull() ? "" : attrPred.getCondition();
     // If the attribute's condition needs an op but none is available, then the
     // condition cannot be emitted.
     bool canEmitCondition =
         !condition.empty() && (!StringRef(condition).contains("$_op") ||
                                emitHelper.isEmittingForOp());
 
     // Prefix with `tblgen_` to avoid hiding the attribute accessor.
-    Twine varName = tblgenNamePrefix + attrName;
+    std::string varName = (tblgenNamePrefix + attrName).str();
 
     // If the attribute is not required and we cannot emit the condition, then
     // there is nothing to be done.
     if (allowMissingAttr && !canEmitCondition)
       continue;
 
     body << formatv("  {\n    auto {0} = {1};", varName,
                     emitHelper.getAttr(attrName));

mlir/tools/mlir-tblgen/SPIRVUtilsGen.cpp

 static void emitOperandDeserialization(const Operator &op, ArrayRef<SMLoc> loc,
                                        StringRef tabs, StringRef words,
                                        StringRef wordIndex, StringRef operands,
                                        StringRef attributes, raw_ostream &os) {
   // Process operands/attributes
   unsigned operandNum = 0;
   for (unsigned i = 0, e = op.getNumArgs(); i < e; ++i) {
     auto argument = op.getArg(i);
-    if (auto valueArg = argument.dyn_cast<NamedTypeConstraint *>()) {
+    if (auto *valueArg = argument.dyn_cast<NamedTypeConstraint *>()) {
       if (valueArg->isVariableLength()) {
         if (i != e - 1) {
           PrintFatalError(loc, "SPIR-V ops can have Variadic<..> or "
                                "Optional<...> arguments only if "
                                "it's the last argument");
         }
         os << tabs
            << formatv("for (; {0} < {1}.size(); ++{0})", wordIndex, words);
if (auto *valueArg = argument.dyn_cast<NamedTypeConstraint *>()) {
       os << tabs << formatv("  {0}.push_back(arg);\n", operands);
       if (!valueArg->isVariableLength()) {
         os << tabs << formatv("  {0}++;\n", wordIndex);
       }
       operandNum++;
       os << tabs << "}\n";
     } else {
       os << tabs << formatv("if ({0} < {1}.size()) {{\n", wordIndex, words);
-      auto attr = argument.get<NamedAttribute *>();
+      auto *attr = argument.get<NamedAttribute *>();
       auto newtabs = tabs.str() + "  ";
       emitAttributeDeserialization(
           (attr->attr.isOptional() ? attr->attr.getBaseAttr() : attr->attr),
           loc, newtabs, attributes, attr->name, words, wordIndex, os);
       os << "  }\n";
     }
   }
 

mlir/tools/mlir-tblgen/mlir-tblgen.cpp

 
 GenNameParser::GenNameParser(llvm::cl::Option &opt)
     : llvm::cl::parser<const GenInfo *>(opt) {
   for (const auto &kv : *generatorRegistry) {
     addLiteralOption(kv.getGenArgument(), &kv, kv.getGenDescription());
   }
 }
 
-void GenNameParser::printOptionInfo(const llvm::cl::Option &O,
-                                    size_t GlobalWidth) const {
-  GenNameParser *TP = const_cast<GenNameParser *>(this);
-  llvm::array_pod_sort(TP->Values.begin(), TP->Values.end(),
-                       [](const GenNameParser::OptionInfo *VT1,
-                          const GenNameParser::OptionInfo *VT2) {
-                         return VT1->Name.compare(VT2->Name);
+void GenNameParser::printOptionInfo(const llvm::cl::Option &o,
+                                    size_t globalWidth) const {
+  GenNameParser *tp = const_cast<GenNameParser *>(this);
+  llvm::array_pod_sort(tp->Values.begin(), tp->Values.end(),
+                       [](const GenNameParser::OptionInfo *vT1,
+                          const GenNameParser::OptionInfo *vT2) {
+                         return vT1->Name.compare(vT2->Name);
                        });
   using llvm::cl::parser;
-  parser<const GenInfo *>::printOptionInfo(O, GlobalWidth);
+  parser<const GenInfo *>::printOptionInfo(o, globalWidth);
 }
 
 // Generator that prints records.
 GenRegistration printRecords("print-records", "Print all records to stdout",
                              [](const RecordKeeper &records, raw_ostream &os) {
                                os << records;
                                return false;
                              });
 
 // Generator to invoke.
 const mlir::GenInfo *generator;
 
 // TableGenMain requires a function pointer so this function is passed in which
 // simply wraps the call to the generator.
-static bool MlirTableGenMain(raw_ostream &os, RecordKeeper &records) {
+static bool mlirTableGenMain(raw_ostream &os, RecordKeeper &records) {
   if (!generator) {
     os << records;
     return false;
   }
   return generator->invoke(records, os);
 }
 
 int main(int argc, char **argv) {
   llvm::InitLLVM y(argc, argv);
   llvm::cl::opt<const mlir::GenInfo *, false, mlir::GenNameParser> generator(
       "", llvm::cl::desc("Generator to run"));
   cl::ParseCommandLineOptions(argc, argv);
   ::generator = generator.getValue();
 
-  return TableGenMain(argv[0], &MlirTableGenMain);
+  return TableGenMain(argv[0], &mlirTableGenMain);
 }

mlir/unittests/ExecutionEngine/Invoke.cpp

TEST(MLIRExecutionEngine, SubtractFloat) {
   float result = -1;
   llvm::Error error =
       jit->invoke("foo", 43.0f, 1.0f, ExecutionEngine::result(result));
   ASSERT_TRUE(!error);
   ASSERT_EQ(result, 42.f);
 }
 
 TEST(NativeMemRefJit, ZeroRankMemref) {
-  OwningMemRef<float, 0> A({});
-  A[{}] = 42.;
-  ASSERT_EQ(*A->data, 42);
-  A[{}] = 0;
+  OwningMemRef<float, 0> a({});
+  a[{}] = 42.;
+  ASSERT_EQ(*a->data, 42);
+  a[{}] = 0;
   std::string moduleStr = R"mlir(
   func @zero_ranked(%arg0 : memref<f32>) attributes { llvm.emit_c_interface } {
     %cst42 = arith.constant 42.0 : f32
     memref.store %cst42, %arg0[] : memref<f32>
     return
   }
   )mlir";
   DialectRegistry registry;
   registerAllDialects(registry);
   registerLLVMDialectTranslation(registry);
   MLIRContext context(registry);
   auto module = parseSourceString(moduleStr, &context);
   ASSERT_TRUE(!!module);
   ASSERT_TRUE(succeeded(lowerToLLVMDialect(*module)));
   auto jitOrError = ExecutionEngine::create(*module);
   ASSERT_TRUE(!!jitOrError);
   auto jit = std::move(jitOrError.get());
 
-  llvm::Error error = jit->invoke("zero_ranked", &*A);
+  llvm::Error error = jit->invoke("zero_ranked", &*a);
   ASSERT_TRUE(!error);
-  EXPECT_EQ((A[{}]), 42.);
-  for (float &elt : *A)
-    EXPECT_EQ(&elt, &(A[{}]));
+  EXPECT_EQ((a[{}]), 42.);
+  for (float &elt : *a)
+    EXPECT_EQ(&elt, &(a[{}]));
 }
 
 TEST(NativeMemRefJit, RankOneMemref) {
   int64_t shape[] = {9};
-  OwningMemRef<float, 1> A(shape);
+  OwningMemRef<float, 1> a(shape);
   int count = 1;
-  for (float &elt : *A) {
-    EXPECT_EQ(&elt, &(A[{count - 1}]));
+  for (float &elt : *a) {
+    EXPECT_EQ(&elt, &(a[{count - 1}]));
     elt = count++;
   }
 
   std::string moduleStr = R"mlir(
   func @one_ranked(%arg0 : memref<?xf32>) attributes { llvm.emit_c_interface } {
     %cst42 = arith.constant 42.0 : f32
     %cst5 = arith.constant 5 : index
     memref.store %cst42, %arg0[%cst5] : memref<?xf32>
     return
   }
   )mlir";
   DialectRegistry registry;
   registerAllDialects(registry);
   registerLLVMDialectTranslation(registry);
   MLIRContext context(registry);
   auto module = parseSourceString(moduleStr, &context);
   ASSERT_TRUE(!!module);
   ASSERT_TRUE(succeeded(lowerToLLVMDialect(*module)));
   auto jitOrError = ExecutionEngine::create(*module);
   ASSERT_TRUE(!!jitOrError);
   auto jit = std::move(jitOrError.get());
 
-  llvm::Error error = jit->invoke("one_ranked", &*A);
+  llvm::Error error = jit->invoke("one_ranked", &*a);
   ASSERT_TRUE(!error);
   count = 1;
-  for (float &elt : *A) {
+  for (float &elt : *a) {
     if (count == 6)
       EXPECT_EQ(elt, 42.);
     else
       EXPECT_EQ(elt, count);
     count++;
   }
 }
 
 TEST(NativeMemRefJit, BasicMemref) {
-  constexpr int K = 3;
-  constexpr int M = 7;
+  constexpr int k = 3;
+  constexpr int m = 7;
   // Prepare arguments beforehand.
   auto init = [=](float &elt, ArrayRef<int64_t> indices) {
     assert(indices.size() == 2);
-    elt = M * indices[0] + indices[1];
+    elt = m * indices[0] + indices[1];
   };
-  int64_t shape[] = {K, M};
-  int64_t shapeAlloc[] = {K + 1, M + 1};
-  OwningMemRef<float, 2> A(shape, shapeAlloc, init);
-  ASSERT_EQ(A->sizes[0], K);
-  ASSERT_EQ(A->sizes[1], M);
-  ASSERT_EQ(A->strides[0], M + 1);
-  ASSERT_EQ(A->strides[1], 1);
-  for (int i = 0; i < K; ++i) {
-    for (int j = 0; j < M; ++j) {
-      EXPECT_EQ((A[{i, j}]), i * M + j);
-      EXPECT_EQ(&(A[{i, j}]), &((*A)[i][j]));
+  int64_t shape[] = {k, m};
+  int64_t shapeAlloc[] = {k + 1, m + 1};
+  OwningMemRef<float, 2> a(shape, shapeAlloc, init);
+  ASSERT_EQ(a->sizes[0], k);
+  ASSERT_EQ(a->sizes[1], m);
+  ASSERT_EQ(a->strides[0], m + 1);
+  ASSERT_EQ(a->strides[1], 1);
+  for (int i = 0; i < k; ++i) {
+    for (int j = 0; j < m; ++j) {
+      EXPECT_EQ((a[{i, j}]), i * m + j);
+      EXPECT_EQ(&(a[{i, j}]), &((*a)[i][j]));
     }
   }
   std::string moduleStr = R"mlir(
   func @rank2_memref(%arg0 : memref<?x?xf32>, %arg1 : memref<?x?xf32>) attributes { llvm.emit_c_interface } {
     %x = arith.constant 2 : index
     %y = arith.constant 1 : index
     %cst42 = arith.constant 42.0 : f32
     memref.store %cst42, %arg0[%y, %x] : memref<?x?xf32>
     memref.store %cst42, %arg1[%x, %y] : memref<?x?xf32>
     return
   }
   )mlir";
   DialectRegistry registry;
   registerAllDialects(registry);
   registerLLVMDialectTranslation(registry);
   MLIRContext context(registry);
   OwningModuleRef module = parseSourceString(moduleStr, &context);
   ASSERT_TRUE(!!module);
   ASSERT_TRUE(succeeded(lowerToLLVMDialect(*module)));
   auto jitOrError = ExecutionEngine::create(*module);
   ASSERT_TRUE(!!jitOrError);
   std::unique_ptr<ExecutionEngine> jit = std::move(jitOrError.get());
 
-  llvm::Error error = jit->invoke("rank2_memref", &*A, &*A);
+  llvm::Error error = jit->invoke("rank2_memref", &*a, &*a);
   ASSERT_TRUE(!error);
-  EXPECT_EQ(((*A)[1][2]), 42.);
-  EXPECT_EQ((A[{2, 1}]), 42.);
+  EXPECT_EQ(((*a)[1][2]), 42.);
+  EXPECT_EQ((a[{2, 1}]), 42.);
 }
 
 // A helper function that will be called from the JIT
-static void memref_multiply(::StridedMemRefType<float, 2> *memref,
-                            int32_t coefficient) {
+static void memrefMultiply(::StridedMemRefType<float, 2> *memref,
   for (float &elt : *memref)
     elt *= coefficient;
 }
 
 TEST(NativeMemRefJit, JITCallback) {
-  constexpr int K = 2;
-  constexpr int M = 2;
-  int64_t shape[] = {K, M};
-  int64_t shapeAlloc[] = {K + 1, M + 1};
-  OwningMemRef<float, 2> A(shape, shapeAlloc);
+  constexpr int k = 2;
+  constexpr int m = 2;
+  int64_t shape[] = {k, m};
+  int64_t shapeAlloc[] = {k + 1, m + 1};
+  OwningMemRef<float, 2> a(shape, shapeAlloc);
   int count = 1;
-  for (float &elt : *A)
+  for (float &elt : *a)
     elt = count++;
 
   std::string moduleStr = R"mlir(
   func private @callback(%arg0: memref<?x?xf32>, %coefficient: i32)  attributes { llvm.emit_c_interface }
   func @caller_for_callback(%arg0: memref<?x?xf32>, %coefficient: i32) attributes { llvm.emit_c_interface } {
     %unranked = memref.cast %arg0: memref<?x?xf32> to memref<*xf32>
     call @callback(%arg0, %coefficient) : (memref<?x?xf32>, i32) -> ()
     return
   }
   )mlir";
   DialectRegistry registry;
   registerAllDialects(registry);
   registerLLVMDialectTranslation(registry);
   MLIRContext context(registry);
   auto module = parseSourceString(moduleStr, &context);
   ASSERT_TRUE(!!module);
   ASSERT_TRUE(succeeded(lowerToLLVMDialect(*module)));
   auto jitOrError = ExecutionEngine::create(*module);
   ASSERT_TRUE(!!jitOrError);
   auto jit = std::move(jitOrError.get());
   // Define any extra symbols so they're available at runtime.
   jit->registerSymbols([&](llvm::orc::MangleAndInterner interner) {
     llvm::orc::SymbolMap symbolMap;
     symbolMap[interner("_mlir_ciface_callback")] =
-        llvm::JITEvaluatedSymbol::fromPointer(memref_multiply);
+        llvm::JITEvaluatedSymbol::fromPointer(memrefMultiply);
     return symbolMap;
   });
 
   int32_t coefficient = 3.;
-  llvm::Error error = jit->invoke("caller_for_callback", &*A, coefficient);
+  llvm::Error error = jit->invoke("caller_for_callback", &*a, coefficient);
   ASSERT_TRUE(!error);
   count = 1;
-  for (float elt : *A)
+  for (float elt : *a)
     ASSERT_EQ(elt, coefficient * count++);
 }
 
 #endif // _WIN32

mlir/unittests/IR/OperationSupportTest.cpp

TEST(NamedAttrListTest, TestAppendAssign) {
   MLIRContext ctx;
   NamedAttrList attrs;
   Builder b(&ctx);
 
   attrs.append("foo", b.getStringAttr("bar"));
   attrs.append("baz", b.getStringAttr("boo"));
 
   {
-    auto it = attrs.begin();
+    auto *it = attrs.begin();
     EXPECT_EQ(it->getName(), b.getStringAttr("foo"));
     EXPECT_EQ(it->getValue(), b.getStringAttr("bar"));
     ++it;
     EXPECT_EQ(it->getName(), b.getStringAttr("baz"));
     EXPECT_EQ(it->getValue(), b.getStringAttr("boo"));
   }
 
   attrs.append("foo", b.getStringAttr("zoo"));
   {
     auto dup = attrs.findDuplicate();
     ASSERT_TRUE(dup.hasValue());
   }
 
   SmallVector<NamedAttribute> newAttrs = {
       b.getNamedAttr("foo", b.getStringAttr("f")),
       b.getNamedAttr("zoo", b.getStringAttr("z")),
   };
   attrs.assign(newAttrs);
 
   auto dup = attrs.findDuplicate();
   ASSERT_FALSE(dup.hasValue());
 
   {
-    auto it = attrs.begin();
+    auto *it = attrs.begin();
     EXPECT_EQ(it->getName(), b.getStringAttr("foo"));
     EXPECT_EQ(it->getValue(), b.getStringAttr("f"));
     ++it;
     EXPECT_EQ(it->getName(), b.getStringAttr("zoo"));
     EXPECT_EQ(it->getValue(), b.getStringAttr("z"));
   }
 
   attrs.assign({});
   ASSERT_TRUE(attrs.empty());
 }
 } // namespace

mlir/unittests/TableGen/StructsGenTest.cpp

 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "gmock/gmock.h"
 #include <type_traits>
 
 namespace mlir {
 
 /// Pull in generated enum utility declarations and definitions.
-#include "StructAttrGenTest.h.inc"
+#include "StructAttrGenTest.h.inc" // NOLINT
 #include "StructAttrGenTest.cpp.inc"
 
 /// Helper that returns an example test::TestStruct for testing its
 /// implementation.
 static test::TestStruct getTestStruct(mlir::MLIRContext *context) {
   auto integerType = mlir::IntegerType::get(context, 32);
   auto integerAttr = mlir::IntegerAttr::get(integerType, 127);