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/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;
   }
 
-  Value applyfn__add(Value lhs, Value rhs) {
+  Value applyfnAdd(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");
   }
 
-  Value applyfn__exp(Value x) {
+  Value applyfnExp(Value x) {
     OpBuilder builder = getBuilder();
     if (isFloatingPoint(x))
       return builder.create<math::ExpOp>(x.getLoc(), x);
     llvm_unreachable("unsupported non numeric type");
   }
 
-  Value applyfn__log(Value x) {
+  Value applyfnLog(Value x) {
     OpBuilder builder = getBuilder();
     if (isFloatingPoint(x))
       return builder.create<math::LogOp>(x.getLoc(), x);
     llvm_unreachable("unsupported non numeric type");
   }
 
-  Value applyfn__sub(Value lhs, Value rhs) {
+  Value applyfnSub(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");
   }
 
-  Value applyfn__mul(Value lhs, Value rhs) {
+  Value applyfnMul(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");
   }
 
-  Value applyfn__max(Value lhs, Value rhs) {
+  Value applyfnMax(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");
   }
 
-  Value applyfn__max_unsigned(Value lhs, Value rhs) {
+  Value applyfnMaxUnsigned(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");
   }
 
-  Value applyfn__min(Value lhs, Value rhs) {
+  Value applyfnMin(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");
   }
 
-  Value applyfn__min_unsigned(Value lhs, Value rhs) {
+  Value applyfnMinUnsigned(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/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/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/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>()) {
     // 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>()) {
       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>()) {
       // 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>()) {

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,

 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;
   }
 }

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/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/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/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

struct TestOpAsmInterface : public OpAsmDialectInterface {
   void getAsmResultNames(Operation *op,
                          OpAsmSetValueNameFn setNameFn) const final {
     if (auto asmOp = dyn_cast<AsmDialectInterfaceOp>(op))
       setNameFn(asmOp, "result");
   }
 
   void getAsmBlockArgumentNames(Block *block,
                                 OpAsmSetValueNameFn setNameFn) const final {
-    auto op = block->getParentOp();
+    auto *op = block->getParentOp();
     auto arrayAttr = op->getAttrOfType<ArrayAttr>("arg_names");
     if (!arrayAttr)
       return;
     auto args = block->getArguments();
     auto e = std::min(arrayAttr.size(), args.size());
     for (unsigned i = 0; i < e; ++i) {
       if (auto strAttr = arrayAttr[i].dyn_cast<StringAttr>())
         setNameFn(args[i], strAttr.getValue());
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/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++));
+    getOperation().getBody()->walk([lastIt](Operation *op) {
+      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"
 
-extern "C" void
-_mlir_ciface_fillI32Buffer(StridedMemRefType<int32_t, 1> *mem_ref,
+extern "C" void mlirCifaceFillI32Buffer(StridedMemRefType<int32_t, 1> *memRef,
                                         int32_t value) {
-  std::fill_n(mem_ref->basePtr, mem_ref->sizes[0], value);
+  std::fill_n(memRef->basePtr, memRef->sizes[0], value);
 }
 
-extern "C" void
-_mlir_ciface_fillF32Buffer1D(StridedMemRefType<float, 1> *mem_ref,
+extern "C" void mlirCifaceFillF32Buffer1D(StridedMemRefType<float, 1> *memRef,
                                           float value) {
-  std::fill_n(mem_ref->basePtr, mem_ref->sizes[0], value);
+  std::fill_n(memRef->basePtr, memRef->sizes[0], value);
 }
 
-extern "C" void
-_mlir_ciface_fillF32Buffer2D(StridedMemRefType<float, 2> *mem_ref,
+extern "C" void mlirCifaceFillF32Buffer2D(StridedMemRefType<float, 2> *memRef,
                                           float value) {
-  std::fill_n(mem_ref->basePtr, mem_ref->sizes[0] * mem_ref->sizes[1], value);
+  std::fill_n(memRef->basePtr, memRef->sizes[0] * memRef->sizes[1], value);
 }
 
-extern "C" void
-_mlir_ciface_fillF32Buffer3D(StridedMemRefType<float, 3> *mem_ref,
+extern "C" void mlirCifaceFillF32Buffer3D(StridedMemRefType<float, 3> *memRef,
                                           float value) {
-  std::fill_n(mem_ref->basePtr,
-              mem_ref->sizes[0] * mem_ref->sizes[1] * mem_ref->sizes[2], value);
+  std::fill_n(memRef->basePtr,
+              memRef->sizes[0] * memRef->sizes[1] * memRef->sizes[2], value);
 }

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 {
+                                    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);
 }