Mass clang-format for MLIR codebase

[mehdi_amini]

Summary

Context: https://llvm.discourse.group/t/remove-mlir-custom-clang-format-configuration/647/14

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

for (int i = 0; i < curIndent; i++)
       llvm::errs() << "  ";
   }
   int curIndent = 0;
 };
 
 } // namespace
 
 /// Return a formatted string for the location of any node
-template <typename T> static std::string loc(T *node) {
+template <typename T>
+static std::string loc(T *node) {
   const auto &loc = node->loc();
   return (llvm::Twine("@") + *loc.file + ":" + llvm::Twine(loc.line) + ":" +
           llvm::Twine(loc.col))
       .str();
 }
 
 // Helper Macro to bump the indentation level and print the leading spaces for
 // the current indentations

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

for (int i = 0; i < curIndent; i++)
       llvm::errs() << "  ";
   }
   int curIndent = 0;
 };
 
 } // namespace
 
 /// Return a formatted string for the location of any node
-template <typename T> static std::string loc(T *node) {
+template <typename T>
+static std::string loc(T *node) {
   const auto &loc = node->loc();
   return (llvm::Twine("@") + *loc.file + ":" + llvm::Twine(loc.line) + ":" +
           llvm::Twine(loc.col))
       .str();
 }
 
 // Helper Macro to bump the indentation level and print the leading spaces for
 // the current indentations

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

for (int i = 0; i < curIndent; i++)
       llvm::errs() << "  ";
   }
   int curIndent = 0;
 };
 
 } // namespace
 
 /// Return a formatted string for the location of any node
-template <typename T> static std::string loc(T *node) {
+template <typename T>
+static std::string loc(T *node) {
   const auto &loc = node->loc();
   return (llvm::Twine("@") + *loc.file + ":" + llvm::Twine(loc.line) + ":" +
           llvm::Twine(loc.col))
       .str();
 }
 
 // Helper Macro to bump the indentation level and print the leading spaces for
 // the current indentations

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

for (int i = 0; i < curIndent; i++)
       llvm::errs() << "  ";
   }
   int curIndent = 0;
 };
 
 } // namespace
 
 /// Return a formatted string for the location of any node
-template <typename T> static std::string loc(T *node) {
+template <typename T>
+static std::string loc(T *node) {
   const auto &loc = node->loc();
   return (llvm::Twine("@") + *loc.file + ":" + llvm::Twine(loc.line) + ":" +
           llvm::Twine(loc.col))
       .str();
 }
 
 // Helper Macro to bump the indentation level and print the leading spaces for
 // the current indentations

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

for (int i = 0; i < curIndent; i++)
       llvm::errs() << "  ";
   }
   int curIndent = 0;
 };
 
 } // namespace
 
 /// Return a formatted string for the location of any node
-template <typename T> static std::string loc(T *node) {
+template <typename T>
+static std::string loc(T *node) {
   const auto &loc = node->loc();
   return (llvm::Twine("@") + *loc.file + ":" + llvm::Twine(loc.line) + ":" +
           llvm::Twine(loc.col))
       .str();
 }
 
 // Helper Macro to bump the indentation level and print the leading spaces for
 // the current indentations

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

for (int i = 0; i < curIndent; i++)
       llvm::errs() << "  ";
   }
   int curIndent = 0;
 };
 
 } // namespace
 
 /// Return a formatted string for the location of any node
-template <typename T> static std::string loc(T *node) {
+template <typename T>
+static std::string loc(T *node) {
   const auto &loc = node->loc();
   return (llvm::Twine("@") + *loc.file + ":" + llvm::Twine(loc.line) + ":" +
           llvm::Twine(loc.col))
       .str();
 }
 
 // Helper Macro to bump the indentation level and print the leading spaces for
 // the current indentations

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

for (int i = 0; i < curIndent; i++)
       llvm::errs() << "  ";
   }
   int curIndent = 0;
 };
 
 } // namespace
 
 /// Return a formatted string for the location of any node
-template <typename T> static std::string loc(T *node) {
+template <typename T>
+static std::string loc(T *node) {
   const auto &loc = node->loc();
   return (llvm::Twine("@") + *loc.file + ":" + llvm::Twine(loc.line) + ":" +
           llvm::Twine(loc.col))
       .str();
 }
 
 // Helper Macro to bump the indentation level and print the leading spaces for
 // the current indentations

mlir/include/mlir/ADT/TypeSwitch.h

 
 #include "mlir/Support/LLVM.h"
 #include "mlir/Support/STLExtras.h"
 #include "llvm/ADT/Optional.h"
 
 namespace mlir {
 namespace detail {
 
-template <typename DerivedT, typename T> class TypeSwitchBase {
+template <typename DerivedT, typename T>
+class TypeSwitchBase {
 public:
   TypeSwitchBase(const T &value) : value(value) {}
   TypeSwitchBase(TypeSwitchBase &&other) : value(other.value) {}
   ~TypeSwitchBase() = default;
 
   /// TypeSwitchBase is not copyable.
   TypeSwitchBase(const TypeSwitchBase &) = delete;
   void operator=(const TypeSwitchBase &) = delete;
   void operator=(TypeSwitchBase &&other) = delete;
 
   /// Invoke a case on the derived class with multiple case types.
   template <typename CaseT, typename CaseT2, typename... CaseTs,
             typename CallableT>
   DerivedT &Case(CallableT &&caseFn) {
     DerivedT &derived = static_cast<DerivedT &>(*this);
     return derived.template Case<CaseT>(caseFn)
         .template Case<CaseT2, CaseTs...>(caseFn);
   }
 
   /// Invoke a case on the derived class, inferring the type of the Case from
   /// the first input of the given callable.
   /// Note: This inference rules for this overload are very simple: strip
   ///       pointers and references.
-  template <typename CallableT> DerivedT &Case(CallableT &&caseFn) {
+  template <typename CallableT>
+  DerivedT &Case(CallableT &&caseFn) {
     using Traits = FunctionTraits<std::decay_t<CallableT>>;
     using CaseT = std::remove_cv_t<std::remove_pointer_t<
         std::remove_reference_t<typename Traits::template arg_t<0>>>>;
 
     DerivedT &derived = static_cast<DerivedT &>(*this);
     return derived.template Case<CaseT>(std::forward<CallableT>(caseFn));
   }
 
TypeSwitch<T, void> &Case(CallableT &&caseFn) {
     if (auto caseValue = BaseT::template castValue<CaseT>(this->value)) {
       caseFn(caseValue);
       foundMatch = true;
     }
     return *this;
   }
 
   /// As a default, invoke the given callable within the root value.
-  template <typename CallableT> void Default(CallableT &&defaultFn) {
+  template <typename CallableT>
+  void Default(CallableT &&defaultFn) {
     if (!foundMatch)
       defaultFn(this->value);
   }
 
 private:
   /// A flag detailing if we have already found a match.
   bool foundMatch = false;
 };
 } // end namespace mlir
 
 #endif // MLIR_SUPPORT_TYPESWITCH_H

mlir/include/mlir/Analysis/CallGraph.h

private:
   CallGraphNode externalNode;
 };
 
 } // end namespace mlir
 
 namespace llvm {
 // Provide graph traits for traversing call graphs using standard graph
 // traversals.
-template <> struct GraphTraits<const mlir::CallGraphNode *> {
+template <>
+struct GraphTraits<const mlir::CallGraphNode *> {
   using NodeRef = mlir::CallGraphNode *;
   static NodeRef getEntryNode(NodeRef node) { return node; }
 
   static NodeRef unwrap(const mlir::CallGraphNode::Edge &edge) {
     return edge.getTarget();
   }
 
   // ChildIteratorType/begin/end - Allow iteration over all nodes in the graph.

mlir/include/mlir/Analysis/Dominance.h

 extern template class llvm::DominatorTreeBase<mlir::Block, false>;
 extern template class llvm::DominatorTreeBase<mlir::Block, true>;
 
 namespace mlir {
 using DominanceInfoNode = llvm::DomTreeNodeBase<Block>;
 class Operation;
 
 namespace detail {
-template <bool IsPostDom> class DominanceInfoBase {
+template <bool IsPostDom>
+class DominanceInfoBase {
   using base = llvm::DominatorTreeBase<Block, IsPostDom>;
 
 public:
   DominanceInfoBase(Operation *op) { recalculate(op); }
   DominanceInfoBase(DominanceInfoBase &&) = default;
   DominanceInfoBase &operator=(DominanceInfoBase &&) = default;
 
   DominanceInfoBase(const DominanceInfoBase &) = delete;

 };
 
 } //  end namespace mlir
 
 namespace llvm {
 
 /// DominatorTree GraphTraits specialization so the DominatorTree can be
 /// iterated by generic graph iterators.
-template <> struct GraphTraits<mlir::DominanceInfoNode *> {
+template <>
+struct GraphTraits<mlir::DominanceInfoNode *> {
   using ChildIteratorType = mlir::DominanceInfoNode::iterator;
   using NodeRef = mlir::DominanceInfoNode *;
 
   static NodeRef getEntryNode(NodeRef N) { return N; }
   static inline ChildIteratorType child_begin(NodeRef N) { return N->begin(); }
   static inline ChildIteratorType child_end(NodeRef N) { return N->end(); }
 };
 
-template <> struct GraphTraits<const mlir::DominanceInfoNode *> {
+template <>
+struct GraphTraits<const mlir::DominanceInfoNode *> {
   using ChildIteratorType = mlir::DominanceInfoNode::const_iterator;
   using NodeRef = const mlir::DominanceInfoNode *;
 
   static NodeRef getEntryNode(NodeRef N) { return N; }
   static inline ChildIteratorType child_begin(NodeRef N) { return N->begin(); }
   static inline ChildIteratorType child_end(NodeRef N) { return N->end(); }
 };
 
 } // end namespace llvm
 #endif

mlir/include/mlir/Conversion/AVX512ToLLVM/ConvertAVX512ToLLVM.h

 //===- ConvertAVX512ToLLVM.h - Conversion Patterns from AVX512 to LLVM ----===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_EDGE_CONVERSION_AVX512TOLLVM_CONVERTAVX512TOLLVM_H_
 #define MLIR_EDGE_CONVERSION_AVX512TOLLVM_CONVERTAVX512TOLLVM_H_
 
 #include <memory>
 
 namespace mlir {
 class LLVMTypeConverter;
 class ModuleOp;
-template <typename T> class OpPassBase;
+template <typename T>
+class OpPassBase;
 class OwningRewritePatternList;
 
 /// Collect a set of patterns to convert from the AVX512 dialect to LLVM.
 void populateAVX512ToLLVMConversionPatterns(LLVMTypeConverter &converter,
                                             OwningRewritePatternList &patterns);
 
 /// Create a pass to convert AVX512 operations to the LLVMIR dialect.
 std::unique_ptr<OpPassBase<ModuleOp>> createConvertAVX512ToLLVMPass();
 
 } // namespace mlir
 
 #endif // MLIR_EDGE_CONVERSION_AVX512TOLLVM_CONVERTAVX512TOLLVM_H_

mlir/include/mlir/Conversion/GPUToCUDA/GPUToCUDAPass.h

 #include <string>
 #include <vector>
 
 namespace mlir {
 
 class Location;
 class ModuleOp;
 
-template <typename T> class OpPassBase;
+template <typename T>
+class OpPassBase;
 
 namespace gpu {
 class GPUModuleOp;
 } // namespace gpu
 
 namespace LLVM {
 class LLVMDialect;
 } // namespace LLVM

mlir/include/mlir/Conversion/GPUToNVVM/GPUToNVVMPass.h

 //===- GPUToNVVMPass.h - Convert GPU kernel to NVVM dialect -----*- C++ -*-===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 #ifndef MLIR_CONVERSION_GPUTONVVM_GPUTONVVMPASS_H_
 #define MLIR_CONVERSION_GPUTONVVM_GPUTONVVMPASS_H_
 
 #include <memory>
 
 namespace mlir {
 class LLVMTypeConverter;
 class OwningRewritePatternList;
 
-template <typename OpT> class OpPassBase;
+template <typename OpT>
+class OpPassBase;
 
 namespace gpu {
 class GPUModuleOp;
 }
 
 /// Collect a set of patterns to convert from the GPU dialect to NVVM.
 void populateGpuToNVVMConversionPatterns(LLVMTypeConverter &converter,
                                          OwningRewritePatternList &patterns);
 
 /// Creates a pass that lowers GPU dialect operations to NVVM counterparts.
 std::unique_ptr<OpPassBase<gpu::GPUModuleOp>> createLowerGpuOpsToNVVMOpsPass();
 
 } // namespace mlir
 
 #endif // MLIR_CONVERSION_GPUTONVVM_GPUTONVVMPASS_H_

mlir/include/mlir/Conversion/GPUToROCDL/GPUToROCDLPass.h

 
 #include <memory>
 
 namespace mlir {
 
 namespace gpu {
 class GPUModuleOp;
 } // namespace gpu
-template <typename OpT> class OpPassBase;
+template <typename OpT>
+class OpPassBase;
 
 /// Creates a pass that lowers GPU dialect operations to ROCDL counterparts.
 std::unique_ptr<OpPassBase<gpu::GPUModuleOp>> createLowerGpuOpsToROCDLOpsPass();
 
 } // namespace mlir
 
 #endif // MLIR_CONVERSION_GPUTOROCDL_GPUTOROCDLPASS_H_

mlir/include/mlir/Conversion/GPUToSPIRV/ConvertGPUToSPIRVPass.h

 
 #include "mlir/Support/LLVM.h"
 
 #include <memory>
 
 namespace mlir {
 
 class ModuleOp;
-template <typename T> class OpPassBase;
+template <typename T>
+class OpPassBase;
 
 /// Pass to convert GPU Ops to SPIR-V ops. For a gpu.func to be converted, it
 /// should have a spv.entry_point_abi attribute.
 std::unique_ptr<OpPassBase<ModuleOp>> createConvertGPUToSPIRVPass();
 
 } // namespace mlir
 #endif // MLIR_CONVERSION_GPUTOSPIRV_CONVERTGPUTOSPIRVPASS_H

mlir/include/mlir/Conversion/GPUToVulkan/ConvertGPUToVulkanPass.h

 
 #include "mlir/Support/LLVM.h"
 
 #include <memory>
 
 namespace mlir {
 
 class ModuleOp;
-template <typename T> class OpPassBase;
+template <typename T>
+class OpPassBase;
 
 std::unique_ptr<OpPassBase<ModuleOp>>
 createConvertVulkanLaunchFuncToVulkanCallsPass();
 
 std::unique_ptr<OpPassBase<mlir::ModuleOp>>
 createConvertGpuLaunchFuncToVulkanLaunchFuncPass();
 
 } // namespace mlir
 #endif // MLIR_CONVERSION_GPUTOVULKAN_CONVERTGPUTOVULKANPASS_H

mlir/include/mlir/Conversion/LinalgToLLVM/LinalgToLLVM.h

 //===- LinalgToLLVM.h - Utils to convert from the linalg dialect ----------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 #ifndef MLIR_CONVERSION_LINALGTOLLVM_LINALGTOLLVM_H_
 #define MLIR_CONVERSION_LINALGTOLLVM_LINALGTOLLVM_H_
 
 #include "mlir/Conversion/StandardToLLVM/ConvertStandardToLLVM.h"
 #include "mlir/Transforms/DialectConversion.h"
 
 namespace mlir {
 class MLIRContext;
 class ModuleOp;
-template <typename T> class OpPassBase;
+template <typename T>
+class OpPassBase;
 
 /// Populate the given list with patterns that convert from Linalg to LLVM.
 void populateLinalgToLLVMConversionPatterns(LLVMTypeConverter &converter,
                                             OwningRewritePatternList &patterns,
                                             MLIRContext *ctx);
 
 /// Create a pass to convert Linalg operations to the LLVMIR dialect.
 std::unique_ptr<OpPassBase<ModuleOp>> createConvertLinalgToLLVMPass();
 
 } // namespace mlir
 
 #endif // MLIR_CONVERSION_LINALGTOLLVM_LINALGTOLLVM_H_

mlir/include/mlir/Conversion/LoopsToGPU/LoopsToGPUPass.h

 //===- LoopsToGPUPass.h - Pass converting loops to GPU kernels --*- C++ -*-===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 #ifndef MLIR_CONVERSION_LOOPSTOGPU_LOOPSTOGPUPASS_H_
 #define MLIR_CONVERSION_LOOPSTOGPU_LOOPSTOGPUPASS_H_
 
 #include "mlir/Support/LLVM.h"
 
 #include <memory>
 
 namespace mlir {
 class FuncOp;
-template <typename T> class OpPassBase;
+template <typename T>
+class OpPassBase;
 class Pass;
 
 /// Create a pass that converts loop nests into GPU kernels.  It considers
 /// top-level affine.for and linalg.for operations as roots of loop nests and
 /// converts them to the gpu.launch operations if possible.
 ///
 /// No check on the size of the block or grid, or on the validity of
 /// parallelization is performed, it is under the responsibility of the caller

mlir/include/mlir/Conversion/StandardToLLVM/ConvertStandardToLLVMPass.h

 //===- ConvertStandardToLLVMPass.h - Pass entrypoint ------------*- C++ -*-===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_CONVERSION_STANDARDTOLLVM_CONVERTSTANDARDTOLLVMPASS_H_
 #define MLIR_CONVERSION_STANDARDTOLLVM_CONVERTSTANDARDTOLLVMPASS_H_
 
 #include <memory>
 
 namespace mlir {
 class LLVMTypeConverter;
 class ModuleOp;
-template <typename T> class OpPassBase;
+template <typename T>
+class OpPassBase;
 class OwningRewritePatternList;
 
 /// Collect a set of patterns to convert memory-related operations from the
 /// Standard dialect to the LLVM dialect, excluding non-memory-related
 /// operations and FuncOp.
 void populateStdToLLVMMemoryConversionPatters(
     LLVMTypeConverter &converter, OwningRewritePatternList &patterns,
     bool useAlloca);

mlir/include/mlir/Conversion/VectorToLLVM/ConvertVectorToLLVM.h

 //===- ConvertVectorToLLVM.h - Utils to convert from the vector dialect ---===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 #ifndef MLIR_CONVERSION_VECTORTOLLVM_CONVERTVECTORTOLLVM_H_
 #define MLIR_CONVERSION_VECTORTOLLVM_CONVERTVECTORTOLLVM_H_
 
 #include "mlir/Transforms/DialectConversion.h"
 
 namespace mlir {
 class LLVMTypeConverter;
 class ModuleOp;
-template <typename T> class OpPassBase;
+template <typename T>
+class OpPassBase;
 
 /// Collect a set of patterns to convert from Vector contractions to LLVM Matrix
 /// Intrinsics. To lower to assembly, the LLVM flag -lower-matrix-intrinsics
 /// will be needed when invoking LLVM.
 void populateVectorToLLVMMatrixConversionPatterns(
     LLVMTypeConverter &converter, OwningRewritePatternList &patterns);
 
 /// Collect a set of patterns to convert from the Vector dialect to LLVM.

mlir/include/mlir/Conversion/VectorToLoops/ConvertVectorToLoops.h

 //===- ConvertVectorToLoops.h - Utils to convert from the vector dialect --===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 #ifndef MLIR_CONVERSION_VECTORTOLLVM_CONVERTVECTORTOLOOPS_H_
 #define MLIR_CONVERSION_VECTORTOLLVM_CONVERTVECTORTOLOOPS_H_
 
 #include "mlir/Transforms/DialectConversion.h"
 
 namespace mlir {
 class MLIRContext;
 class ModuleOp;
-template <typename T> class OpPassBase;
+template <typename T>
+class OpPassBase;
 
 /// Collect a set of patterns to convert from the Vector dialect to loops + std.
 void populateVectorToAffineLoopsConversionPatterns(
     MLIRContext *context, OwningRewritePatternList &patterns);
 
 /// Create a pass to convert vector operations to affine loops + std dialect.
 OpPassBase<ModuleOp> *createLowerVectorToLoopsPass();
 
 } // namespace mlir
 
 #endif // MLIR_CONVERSION_VECTORTOLLVM_CONVERTVECTORTOLOOPS_H_

mlir/include/mlir/Dialect/Affine/Passes.h

 #include <limits>
 
 namespace mlir {
 
 class AffineForOp;
 class FuncOp;
 class ModuleOp;
 class Pass;
-template <typename T> class OpPassBase;
+template <typename T>
+class OpPassBase;
 
 /// Creates a simplification pass for affine structures (maps and sets). In
 /// addition, this pass also normalizes memrefs to have the trivial (identity)
 /// layout map.
 std::unique_ptr<OpPassBase<FuncOp>> createSimplifyAffineStructuresPass();
 
 /// Creates a loop invariant code motion pass that hoists loop invariant
 /// operations out of affine loops.

mlir/include/mlir/Dialect/FxpMathOps/Passes.h

 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_DIALECT_FXPMATHOPS_PASSES_H
 #define MLIR_DIALECT_FXPMATHOPS_PASSES_H
 
 namespace mlir {
 class FuncOp;
-template <typename T> class OpPassBase;
+template <typename T>
+class OpPassBase;
 
 namespace fxpmath {
 
 /// Creates a pass that lowers uniform-quantized real math ops to integer
 /// arithmetic. This will leave unrecognized real math ops as-is and is
 /// typically followed by a pass that lowers any unrecognized ops to a pure
 /// floating point form.
 OpPassBase<FuncOp> *createLowerUniformRealMathPass();

mlir/include/mlir/Dialect/GPU/Passes.h

 #define MLIR_DIALECT_GPU_PASSES_H_
 
 #include <memory>
 
 namespace mlir {
 
 class MLIRContext;
 class ModuleOp;
-template <typename T> class OpPassBase;
+template <typename T>
+class OpPassBase;
 class OwningRewritePatternList;
 
 std::unique_ptr<OpPassBase<ModuleOp>> createGpuKernelOutliningPass();
 
 /// Collect a set of patterns to rewrite ops within the GPU dialect.
 void populateGpuRewritePatterns(MLIRContext *context,
                                 OwningRewritePatternList &patterns);
 
 } // namespace mlir
 
 #endif // MLIR_DIALECT_GPU_PASSES_H_

mlir/include/mlir/Dialect/Linalg/EDSC/Builders.h

public:
   edsc::ValueHandle operator()(std::function<void(void)> fun = nullptr);
 
 private:
   SmallVector<LoopRangeBuilder, 4> loops;
 };
 
 /// Helper template class for building loop.for and affine.loop nests from
 /// ranges.
-template <typename LoopTy> class GenericLoopNestRangeBuilder {
+template <typename LoopTy>
+class GenericLoopNestRangeBuilder {
 public:
   GenericLoopNestRangeBuilder(ArrayRef<edsc::ValueHandle *> ivs,
                               ArrayRef<Value> ranges);
   void operator()(std::function<void(void)> fun = nullptr) { (*builder)(fun); }
 
 private:
   using LoopOrAffineLoopBuilder =
       typename std::conditional_t<std::is_same<LoopTy, AffineForOp>::value,

mlir/include/mlir/Dialect/Linalg/IR/LinalgTraits.h

 namespace OpTrait {
 namespace linalg {
 
 /// This class provides the API for ops that are known to have a specified
 /// number of inputs, all passed as operands. Use as a trait as follows:
 ///
 ///   class DotOp : public Op<DotOp, OpTrait::NInputs<2>::Impl> {
 ///
-template <unsigned N> class NInputs {
+template <unsigned N>
+class NInputs {
 public:
   template <typename ConcreteType>
   class Impl : public OpTrait::TraitBase<ConcreteType, NInputs<N>::Impl> {
   public:
     static unsigned getNumInputs() { return N; }
   };
 };
 
 /// This class provides the API for ops that are known to have a specified
 /// number of outputs, all passed as operands. Use as a trait as follows:
 ///
 ///   class DotOp : public Op<DotOp, OpTrait::NOutputs<2>::Impl> {
 ///
-template <unsigned N> class NOutputs {
+template <unsigned N>
+class NOutputs {
 public:
   template <typename ConcreteType>
   class Impl : public OpTrait::TraitBase<ConcreteType, NOutputs<N>::Impl> {
   public:
     static unsigned getNumOutputs() { return N; }
   };
 };
 

mlir/include/mlir/Dialect/Linalg/Passes.h

 #define MLIR_DIALECT_LINALG_PASSES_H_
 
 #include "mlir/Support/LLVM.h"
 #include "llvm/ADT/ArrayRef.h"
 
 namespace mlir {
 class FuncOp;
 class ModuleOp;
-template <typename T> class OpPassBase;
+template <typename T>
+class OpPassBase;
 
 std::unique_ptr<OpPassBase<FuncOp>> createLinalgFusionPass();
 
 std::unique_ptr<OpPassBase<FuncOp>>
 createLinalgTilingPass(ArrayRef<int64_t> tileSizes = {});
 
 std::unique_ptr<OpPassBase<FuncOp>>
 createLinalgTilingToParallelLoopsPass(ArrayRef<int64_t> tileSizes = {});

mlir/include/mlir/Dialect/Quant/Passes.h

 
 #ifndef MLIR_DIALECT_QUANT_PASSES_H
 #define MLIR_DIALECT_QUANT_PASSES_H
 
 #include <memory>
 
 namespace mlir {
 class FuncOp;
-template <typename T> class OpPassBase;
+template <typename T>
+class OpPassBase;
 
 namespace quant {
 
 /// Creates a pass that converts quantization simulation operations (i.e.
 /// FakeQuant and those like it) to casts into/out of supported QuantizedTypes.
 std::unique_ptr<OpPassBase<FuncOp>> createConvertSimulatedQuantPass();
 
 /// Creates a pass that converts constants followed by a qbarrier to a

mlir/include/mlir/Dialect/SDBM/SDBMExpr.h

public:
   /// Negate the given SDBM expression.
   SDBMExpr operator-();
 
   /// Prints the SDBM expression.
   void print(raw_ostream &os) const;
   void dump() const;
 
   /// LLVM-style casts.
-  template <typename U> bool isa() const { return U::isClassFor(*this); }
-  template <typename U> U dyn_cast() const {
+  template <typename U>
+  bool isa() const {
+    return U::isClassFor(*this);
+  }
+  template <typename U>
+  U dyn_cast() const {
     if (!isa<U>())
       return {};
     return U(const_cast<SDBMExpr *>(this)->impl);
   }
-  template <typename U> U cast() const {
+  template <typename U>
+  U cast() const {
     assert(isa<U>() && "cast to incorrect subtype");
     return U(const_cast<SDBMExpr *>(this)->impl);
   }
 
   /// Support for LLVM hashing.
   ::llvm::hash_code hash_value() const { return ::llvm::hash_value(impl); }
 
   /// Returns the kind of the SDBM expression.
static bool isClassFor(const SDBMExpr &expr) {
     return expr.getKind() == SDBMExprKind::Neg;
   }
 
   SDBMDirectExpr getVar() const;
 };
 
 /// A visitor class for SDBM expressions.  Calls the kind-specific function
 /// depending on the kind of expression it visits.
-template <typename Derived, typename Result = void> class SDBMVisitor {
+template <typename Derived, typename Result = void>
+class SDBMVisitor {
 public:
   /// Visit the given SDBM expression, dispatching to kind-specific functions.
   Result visit(SDBMExpr expr) {
     auto *derived = static_cast<Derived *>(this);
     switch (expr.getKind()) {
     case SDBMExprKind::Add:
     case SDBMExprKind::Diff:
     case SDBMExprKind::DimId:
Result visitVarying(SDBMVaryingExpr expr) {
     else if (auto neg = expr.dyn_cast<SDBMNegExpr>())
       return derived->visitNeg(neg);
     else if (auto diff = expr.dyn_cast<SDBMDiffExpr>())
       return derived->visitDiff(diff);
 
     llvm_unreachable("unhandled subtype of varying SDBM expression");
   }
 
-  template <bool isPreorder> void walk(SDBMExpr expr) {
+  template <bool isPreorder>
+  void walk(SDBMExpr expr) {
     if (isPreorder)
       visit(expr);
     if (auto sumExpr = expr.dyn_cast<SDBMSumExpr>()) {
       walk<isPreorder>(sumExpr.getLHS());
       walk<isPreorder>(sumExpr.getRHS());
     } else if (auto diffExpr = expr.dyn_cast<SDBMDiffExpr>()) {
       walk<isPreorder>(diffExpr.getLHS());
       walk<isPreorder>(diffExpr.getRHS());
inline SDBMExpr stripe(SDBMExpr expr, int64_t factor) {
   return stripe(expr, SDBMConstantExpr::get(expr.getDialect(), factor));
 }
 } // namespace ops_assertions
 
 } // end namespace mlir
 
 namespace llvm {
 // SDBMExpr hash just like pointers.
-template <> struct DenseMapInfo<mlir::SDBMExpr> {
+template <>
+struct DenseMapInfo<mlir::SDBMExpr> {
   static mlir::SDBMExpr getEmptyKey() {
     auto *pointer = llvm::DenseMapInfo<void *>::getEmptyKey();
     return mlir::SDBMExpr(static_cast<mlir::SDBMExpr::ImplType *>(pointer));
   }
   static mlir::SDBMExpr getTombstoneKey() {
     auto *pointer = llvm::DenseMapInfo<void *>::getTombstoneKey();
     return mlir::SDBMExpr(static_cast<mlir::SDBMExpr::ImplType *>(pointer));
   }
   static unsigned getHashValue(mlir::SDBMExpr expr) {
     return expr.hash_value();
   }
   static bool isEqual(mlir::SDBMExpr lhs, mlir::SDBMExpr rhs) {
     return lhs == rhs;
   }
 };
 
 // SDBMDirectExpr hash just like pointers.
-template <> struct DenseMapInfo<mlir::SDBMDirectExpr> {
+template <>
+struct DenseMapInfo<mlir::SDBMDirectExpr> {
   static mlir::SDBMDirectExpr getEmptyKey() {
     auto *pointer = llvm::DenseMapInfo<void *>::getEmptyKey();
     return mlir::SDBMDirectExpr(
         static_cast<mlir::SDBMExpr::ImplType *>(pointer));
   }
   static mlir::SDBMDirectExpr getTombstoneKey() {
     auto *pointer = llvm::DenseMapInfo<void *>::getTombstoneKey();
     return mlir::SDBMDirectExpr(
         static_cast<mlir::SDBMExpr::ImplType *>(pointer));
   }
   static unsigned getHashValue(mlir::SDBMDirectExpr expr) {
     return expr.hash_value();
   }
   static bool isEqual(mlir::SDBMDirectExpr lhs, mlir::SDBMDirectExpr rhs) {
     return lhs == rhs;
   }
 };
 
 // SDBMTermExpr hash just like pointers.
-template <> struct DenseMapInfo<mlir::SDBMTermExpr> {
+template <>
+struct DenseMapInfo<mlir::SDBMTermExpr> {
   static mlir::SDBMTermExpr getEmptyKey() {
     auto *pointer = llvm::DenseMapInfo<void *>::getEmptyKey();
     return mlir::SDBMTermExpr(static_cast<mlir::SDBMExpr::ImplType *>(pointer));
   }
   static mlir::SDBMTermExpr getTombstoneKey() {
     auto *pointer = llvm::DenseMapInfo<void *>::getTombstoneKey();
     return mlir::SDBMTermExpr(static_cast<mlir::SDBMExpr::ImplType *>(pointer));
   }
   static unsigned getHashValue(mlir::SDBMTermExpr expr) {
     return expr.hash_value();
   }
   static bool isEqual(mlir::SDBMTermExpr lhs, mlir::SDBMTermExpr rhs) {
     return lhs == rhs;
   }
 };
 
 // SDBMConstantExpr hash just like pointers.
-template <> struct DenseMapInfo<mlir::SDBMConstantExpr> {
+template <>
+struct DenseMapInfo<mlir::SDBMConstantExpr> {
   static mlir::SDBMConstantExpr getEmptyKey() {
     auto *pointer = llvm::DenseMapInfo<void *>::getEmptyKey();
     return mlir::SDBMConstantExpr(
         static_cast<mlir::SDBMExpr::ImplType *>(pointer));
   }
   static mlir::SDBMConstantExpr getTombstoneKey() {
     auto *pointer = llvm::DenseMapInfo<void *>::getTombstoneKey();
     return mlir::SDBMConstantExpr(

mlir/include/mlir/EDSC/Builders.h

public:
   }
 
   /// Emits a `load` when converting to a ValueHandle.
   operator ValueHandle() const {
     return Load(getBase(), {indices.begin(), indices.end()});
   }
 
   /// Emits a `load` when converting to a Value.
-  Value operator*(void)const {
+  Value operator*(void) const {
     return Load(getBase(), {indices.begin(), indices.end()}).getValue();
   }
 
   ValueHandle getBase() const { return base; }
 
   /// Arithmetic operator overloadings.
   ValueHandle operator+(ValueHandle e);
   ValueHandle operator-(ValueHandle e);

mlir/include/mlir/ExecutionEngine/ExecutionEngine.h

 #include "llvm/ExecutionEngine/Orc/LLJIT.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/Support/Error.h"
 
 #include <functional>
 #include <memory>
 
 namespace llvm {
-template <typename T> class Expected;
+template <typename T>
+class Expected;
 class Module;
 class ExecutionEngine;
 class JITEventListener;
 class MemoryBuffer;
 } // namespace llvm
 
 namespace mlir {
 

mlir/include/mlir/ExecutionEngine/RunnerUtils.h

 
 ////////////////////////////////////////////////////////////////////////////////
 // Templated instantiation follows.
 ////////////////////////////////////////////////////////////////////////////////
 namespace impl {
 template <typename T, int M, int... Dims>
 std::ostream &operator<<(std::ostream &os, const Vector<T, M, Dims...> &v);
 
-template <int... Dims> struct StaticSizeMult {
+template <int... Dims>
+struct StaticSizeMult {
   static constexpr int value = 1;
 };
 
-template <int N, int... Dims> struct StaticSizeMult<N, Dims...> {
+template <int N, int... Dims>
+struct StaticSizeMult<N, Dims...> {
   static constexpr int value = N * StaticSizeMult<Dims...>::value;
 };
 
 static inline void printSpace(std::ostream &os, int count) {
   for (int i = 0; i < count; ++i) {
     os << ' ';
   }
 }
 
-template <typename T, int M, int... Dims> struct VectorDataPrinter {
+template <typename T, int M, int... Dims>
+struct VectorDataPrinter {
   static void print(std::ostream &os, const Vector<T, M, Dims...> &val);
 };
 
 template <typename T, int M, int... Dims>
 void VectorDataPrinter<T, M, Dims...>::print(std::ostream &os,
                                              const Vector<T, M, Dims...> &val) {
   static_assert(M > 0, "0 dimensioned tensor");
   static_assert(sizeof(val) == M * StaticSizeMult<Dims...>::value * sizeof(T),

 }
 
 template <typename T, int M, int... Dims>
 std::ostream &operator<<(std::ostream &os, const Vector<T, M, Dims...> &v) {
   VectorDataPrinter<T, M, Dims...>::print(os, v);
   return os;
 }
 
-template <typename T, int N> struct MemRefDataPrinter {
+template <typename T, int N>
+struct MemRefDataPrinter {
   static void print(std::ostream &os, T *base, int64_t rank, int64_t offset,
                     int64_t *sizes, int64_t *strides);
   static void printFirst(std::ostream &os, T *base, int64_t rank,
                          int64_t offset, int64_t *sizes, int64_t *strides);
   static void printLast(std::ostream &os, T *base, int64_t rank, int64_t offset,
                         int64_t *sizes, int64_t *strides);
 };
 
-template <typename T> struct MemRefDataPrinter<T, 0> {
+template <typename T>
+struct MemRefDataPrinter<T, 0> {
   static void print(std::ostream &os, T *base, int64_t rank, int64_t offset,
                     int64_t *sizes = nullptr, int64_t *strides = nullptr);
 };
 
 template <typename T, int N>
 void MemRefDataPrinter<T, N>::printFirst(std::ostream &os, T *base,
                                          int64_t rank, int64_t offset,
                                          int64_t *sizes, int64_t *strides) {

 
 template <typename T>
 void MemRefDataPrinter<T, 0>::print(std::ostream &os, T *base, int64_t rank,
                                     int64_t offset, int64_t *sizes,
                                     int64_t *strides) {
   os << base[offset];
 }
 
-template <typename T, int N> void printMemRef(StridedMemRefType<T, N> &M) {
+template <typename T, int N>
+void printMemRef(StridedMemRefType<T, N> &M) {
   static_assert(N > 0, "Expected N > 0");
   printMemRefMetaData(std::cout, M);
   std::cout << " data = " << std::endl;
   MemRefDataPrinter<T, N>::print(std::cout, M.data, N, M.offset, M.sizes,
                                  M.strides);
   std::cout << std::endl;
 }
 
-template <typename T> void printMemRef(StridedMemRefType<T, 0> &M) {
+template <typename T>
+void printMemRef(StridedMemRefType<T, 0> &M) {
   printMemRefMetaData(std::cout, M);
   std::cout << " data = " << std::endl;
   std::cout << "[";
   MemRefDataPrinter<T, 0>::print(std::cout, M.data, 0, M.offset);
   std::cout << "]" << std::endl;
 }
 } // namespace impl
 

mlir/include/mlir/IR/AffineExpr.h

public:
   bool operator==(AffineExpr other) const { return expr == other.expr; }
   bool operator!=(AffineExpr other) const { return !(*this == other); }
   bool operator==(int64_t v) const;
   bool operator!=(int64_t v) const { return !(*this == v); }
   explicit operator bool() const { return expr; }
 
   bool operator!() const { return expr == nullptr; }
 
-  template <typename U> bool isa() const;
-  template <typename U> U dyn_cast() const;
-  template <typename U> U dyn_cast_or_null() const;
-  template <typename U> U cast() const;
+  template <typename U>
+  bool isa() const;
+  template <typename U>
+  U dyn_cast() const;
+  template <typename U>
+  U dyn_cast_or_null() const;
+  template <typename U>
+  U cast() const;
 
   MLIRContext *getContext() const;
 
   /// Return the classification for this type.
   AffineExprKind getKind() const;
 
   void print(raw_ostream &os) const;
   void dump() const;

 /// format [dims, symbols, locals, constant term].
 AffineExpr getAffineExprFromFlatForm(ArrayRef<int64_t> flatExprs,
                                      unsigned numDims, unsigned numSymbols,
                                      ArrayRef<AffineExpr> localExprs,
                                      MLIRContext *context);
 
 raw_ostream &operator<<(raw_ostream &os, AffineExpr &expr);
 
-template <typename U> bool AffineExpr::isa() const {
+template <typename U>
+bool AffineExpr::isa() const {
   if (std::is_same<U, AffineBinaryOpExpr>::value)
     return getKind() <= AffineExprKind::LAST_AFFINE_BINARY_OP;
   if (std::is_same<U, AffineDimExpr>::value)
     return getKind() == AffineExprKind::DimId;
   if (std::is_same<U, AffineSymbolExpr>::value)
     return getKind() == AffineExprKind::SymbolId;
   if (std::is_same<U, AffineConstantExpr>::value)
     return getKind() == AffineExprKind::Constant;
 }
-template <typename U> U AffineExpr::dyn_cast() const {
+template <typename U>
+U AffineExpr::dyn_cast() const {
   if (isa<U>())
     return U(expr);
   return U(nullptr);
 }
-template <typename U> U AffineExpr::dyn_cast_or_null() const {
+template <typename U>
+U AffineExpr::dyn_cast_or_null() const {
   return (!*this || !isa<U>()) ? U(nullptr) : U(expr);
 }
-template <typename U> U AffineExpr::cast() const {
+template <typename U>
+U AffineExpr::cast() const {
   assert(isa<U>());
   return U(expr);
 }
 
 /// Simplify an affine expression by flattening and some amount of
 /// simple analysis. This has complexity linear in the number of nodes in
 /// 'expr'. Returns the simplified expression, which is the same as the input
 ///  expression if it can't be simplified.
 AffineExpr simplifyAffineExpr(AffineExpr expr, unsigned numDims,
                               unsigned numSymbols);
 
 namespace detail {
-template <int N> void bindDims(MLIRContext *ctx) {}
+template <int N>
+void bindDims(MLIRContext *ctx) {}
 
 template <int N, typename AffineExprTy, typename... AffineExprTy2>
 void bindDims(MLIRContext *ctx, AffineExprTy &e, AffineExprTy2 &... exprs) {
   e = getAffineDimExpr(N, ctx);
   bindDims<N + 1, AffineExprTy2 &...>(ctx, exprs...);
 }
 } // namespace detail
 
 /// Bind a list of AffineExpr references to DimExpr at positions:
 ///   [0 .. sizeof...(exprs)]
 template <typename... AffineExprTy>
 void bindDims(MLIRContext *ctx, AffineExprTy &... exprs) {
   detail::bindDims<0>(ctx, exprs...);
 }
 
 } // namespace mlir
 
 namespace llvm {
 
 // AffineExpr hash just like pointers
-template <> struct DenseMapInfo<mlir::AffineExpr> {
+template <>
+struct DenseMapInfo<mlir::AffineExpr> {
   static mlir::AffineExpr getEmptyKey() {
     auto pointer = llvm::DenseMapInfo<void *>::getEmptyKey();
     return mlir::AffineExpr(static_cast<mlir::AffineExpr::ImplType *>(pointer));
   }
   static mlir::AffineExpr getTombstoneKey() {
     auto pointer = llvm::DenseMapInfo<void *>::getTombstoneKey();
     return mlir::AffineExpr(static_cast<mlir::AffineExpr::ImplType *>(pointer));
   }

mlir/include/mlir/IR/AffineExprVisitor.h

 /// Note that if you don't implement visitXXX for some affine expression type,
 /// the visitXXX method for Instruction superclass will be invoked.
 ///
 /// Note that this class is specifically designed as a template to avoid
 /// virtual function call overhead. Defining and using a AffineExprVisitor is
 /// just as efficient as having your own switch instruction over the instruction
 /// opcode.
 
-template <typename SubClass, typename RetTy = void> class AffineExprVisitor {
+template <typename SubClass, typename RetTy = void>
+class AffineExprVisitor {
   //===--------------------------------------------------------------------===//
   // Interface code - This is the public interface of the AffineExprVisitor
   // that you use to visit affine expressions...
 public:
   // Function to walk an AffineExpr (in post order).
   RetTy walkPostOrder(AffineExpr expr) {
     static_assert(std::is_base_of<AffineExprVisitor, SubClass>::value,
                   "Must instantiate with a derived type of AffineExprVisitor");

mlir/include/mlir/IR/AffineMap.h

inline raw_ostream &operator<<(raw_ostream &os, AffineMap map) {
   map.print(os);
   return os;
 }
 } // end namespace mlir
 
 namespace llvm {
 
 // AffineExpr hash just like pointers
-template <> struct DenseMapInfo<mlir::AffineMap> {
+template <>
+struct DenseMapInfo<mlir::AffineMap> {
   static mlir::AffineMap getEmptyKey() {
     auto pointer = llvm::DenseMapInfo<void *>::getEmptyKey();
     return mlir::AffineMap(static_cast<mlir::AffineMap::ImplType *>(pointer));
   }
   static mlir::AffineMap getTombstoneKey() {
     auto pointer = llvm::DenseMapInfo<void *>::getTombstoneKey();
     return mlir::AffineMap(static_cast<mlir::AffineMap::ImplType *>(pointer));
   }

mlir/include/mlir/IR/Attributes.h

#include "DialectSymbolRegistry.def"
   Attribute &operator=(const Attribute &other) = default;
 
   bool operator==(Attribute other) const { return impl == other.impl; }
   bool operator!=(Attribute other) const { return !(*this == other); }
   explicit operator bool() const { return impl; }
 
   bool operator!() const { return impl == nullptr; }
 
-  template <typename U> bool isa() const;
-  template <typename U> U dyn_cast() const;
-  template <typename U> U dyn_cast_or_null() const;
-  template <typename U> U cast() const;
+  template <typename U>
+  bool isa() const;
+  template <typename U>
+  U dyn_cast() const;
+  template <typename U>
+  U dyn_cast_or_null() const;
+  template <typename U>
+  U cast() const;
 
   // Support dyn_cast'ing Attribute to itself.
   static bool classof(Attribute) { return true; }
 
   /// Return the classification for this attribute.
   unsigned getKind() const { return impl->getKind(); }
 
   /// Return the type of this attribute.
public:
   static bool kindof(unsigned kind) { return kind == StandardAttributes::Unit; }
 };
 
 //===----------------------------------------------------------------------===//
 // Elements Attributes
 //===----------------------------------------------------------------------===//
 
 namespace detail {
-template <typename T> class ElementsAttrIterator;
-template <typename T> class ElementsAttrRange;
+template <typename T>
+class ElementsAttrIterator;
+template <typename T>
+class ElementsAttrRange;
 } // namespace detail
 
 /// A base attribute that represents a reference to a static shaped tensor or
 /// vector constant.
 class ElementsAttr : public Attribute {
 public:
   using Attribute::Attribute;
-  template <typename T> using iterator = detail::ElementsAttrIterator<T>;
-  template <typename T> using iterator_range = detail::ElementsAttrRange<T>;
+  template <typename T>
+  using iterator = detail::ElementsAttrIterator<T>;
+  template <typename T>
+  using iterator_range = detail::ElementsAttrRange<T>;
 
   /// Return the type of this ElementsAttr, guaranteed to be a vector or tensor
   /// with static shape.
   ShapedType getType() const;
 
   /// Return the value at the given index. The index is expected to refer to a
   /// valid element.
   Attribute getValue(ArrayRef<uint64_t> index) const;
 
   /// Return the value of type 'T' at the given index, where 'T' corresponds to
   /// an Attribute type.
-  template <typename T> T getValue(ArrayRef<uint64_t> index) const {
+  template <typename T>
+  T getValue(ArrayRef<uint64_t> index) const {
     return getValue(index).template cast<T>();
   }
 
   /// Return the elements of this attribute as a value of type 'T'. Note:
   /// Aborts if the subclass is OpaqueElementsAttrs, these attrs do not support
   /// iteration.
-  template <typename T> iterator_range<T> getValues() const;
+  template <typename T>
+  iterator_range<T> getValues() const;
 
   /// Return if the given 'index' refers to a valid element in this attribute.
   bool isValidIndex(ArrayRef<uint64_t> index) const;
 
   /// Returns the number of elements held by this attribute.
   int64_t getNumElements() const;
 
   /// Generates a new ElementsAttr by mapping each int value to a new
getSplatValue() const {
     return getSplatValue().template cast<T>();
   }
 
   /// Return the value at the given index. The 'index' is expected to refer to a
   /// valid element.
   Attribute getValue(ArrayRef<uint64_t> index) const {
     return getValue<Attribute>(index);
   }
-  template <typename T> T getValue(ArrayRef<uint64_t> index) const {
+  template <typename T>
+  T getValue(ArrayRef<uint64_t> index) const {
     // Skip to the element corresponding to the flattened index.
     return *std::next(getValues<T>().begin(), getFlattenedIndex(index));
   }
 
   /// Return the held element values as a range of integer or floating-point
   /// values.
   template <typename T, typename = typename std::enable_if<
                             (!std::is_same<T, bool>::value &&
static SparseElementsAttr get(ShapedType type, DenseElementsAttr indices,
                                 DenseElementsAttr values);
 
   DenseIntElementsAttr getIndices() const;
 
   DenseElementsAttr getValues() const;
 
   /// Return the values of this attribute in the form of the given type 'T'. 'T'
   /// may be any of Attribute, APInt, APFloat, c++ integer/float types, etc.
-  template <typename T> llvm::iterator_range<iterator<T>> getValues() const {
+  template <typename T>
+  llvm::iterator_range<iterator<T>> getValues() const {
     auto zeroValue = getZeroValue<T>();
     auto valueIt = getValues().getValues<T>().begin();
     const std::vector<ptrdiff_t> flatSparseIndices(getFlattenedSparseIndices());
     // TODO(riverriddle): Move-capture flatSparseIndices when c++14 is
     // available.
     std::function<T(ptrdiff_t)> mapFn = [=](ptrdiff_t index) {
       // Try to map the current index to one of the sparse indices.
       for (unsigned i = 0, e = flatSparseIndices.size(); i != e; ++i)
case StandardAttributes::DenseElements:
       return ProcessFn<DenseIteratorT>()(args...);
     case StandardAttributes::SparseElements:
       return ProcessFn<SparseIteratorT>()(args...);
     }
     llvm_unreachable("unexpected attribute kind");
   }
 
   /// Utility functors used to generically implement the iterators methods.
-  template <typename ItT> struct PlusAssign {
+  template <typename ItT>
+  struct PlusAssign {
     void operator()(ItT &it, ptrdiff_t offset) { it += offset; }
   };
-  template <typename ItT> struct Minus {
+  template <typename ItT>
+  struct Minus {
     ptrdiff_t operator()(const ItT &lhs, const ItT &rhs) { return lhs - rhs; }
   };
-  template <typename ItT> struct MinusAssign {
+  template <typename ItT>
+  struct MinusAssign {
     void operator()(ItT &it, ptrdiff_t offset) { it -= offset; }
   };
-  template <typename ItT> struct Dereference {
+  template <typename ItT>
+  struct Dereference {
     T operator()(ItT &it) { return *it; }
   };
-  template <typename ItT> struct ConstructIter {
+  template <typename ItT>
+  struct ConstructIter {
     void operator()(ItT &dest, const ItT &it) { ::new (&dest) ItT(it); }
   };
-  template <typename ItT> struct DestructIter {
+  template <typename ItT>
+  struct DestructIter {
     void operator()(ItT &it) { it.~ItT(); }
   };
 
 public:
   ElementsAttrIterator(const ElementsAttrIterator<T> &rhs)
       : attrKind(rhs.attrKind) {
     process<void, ConstructIter>(it, rhs.it);
   }
auto ElementsAttr::getValues() const -> iterator_range<T> {
   }
   llvm_unreachable("unexpected attribute kind");
 }
 
 //===----------------------------------------------------------------------===//
 // Attributes Utils
 //===----------------------------------------------------------------------===//
 
-template <typename U> bool Attribute::isa() const {
+template <typename U>
+bool Attribute::isa() const {
   assert(impl && "isa<> used on a null attribute.");
   return U::classof(*this);
 }
-template <typename U> U Attribute::dyn_cast() const {
+template <typename U>
+U Attribute::dyn_cast() const {
   return isa<U>() ? U(impl) : U(nullptr);
 }
-template <typename U> U Attribute::dyn_cast_or_null() const {
+template <typename U>
+U Attribute::dyn_cast_or_null() const {
   return (impl && isa<U>()) ? U(impl) : U(nullptr);
 }
-template <typename U> U Attribute::cast() const {
+template <typename U>
+U Attribute::cast() const {
   assert(isa<U>());
   return U(impl);
 }
 
 // Make Attribute hashable.
 inline ::llvm::hash_code hash_value(Attribute arg) {
   return ::llvm::hash_value(arg.impl);
 }
private:
   DictionaryAttr attrs;
 };
 
 } // end namespace mlir.
 
 namespace llvm {
 
 // Attribute hash just like pointers.
-template <> struct DenseMapInfo<mlir::Attribute> {
+template <>
+struct DenseMapInfo<mlir::Attribute> {
   static mlir::Attribute getEmptyKey() {
     auto pointer = llvm::DenseMapInfo<void *>::getEmptyKey();
     return mlir::Attribute(static_cast<mlir::Attribute::ImplType *>(pointer));
   }
   static mlir::Attribute getTombstoneKey() {
     auto pointer = llvm::DenseMapInfo<void *>::getTombstoneKey();
     return mlir::Attribute(static_cast<mlir::Attribute::ImplType *>(pointer));
   }
   static unsigned getHashValue(mlir::Attribute val) {
     return mlir::hash_value(val);
   }
   static bool isEqual(mlir::Attribute LHS, mlir::Attribute RHS) {
     return LHS == RHS;
   }
 };
 
 /// Allow LLVM to steal the low bits of Attributes.
-template <> struct PointerLikeTypeTraits<mlir::Attribute> {
+template <>
+struct PointerLikeTypeTraits<mlir::Attribute> {
   static inline void *getAsVoidPointer(mlir::Attribute attr) {
     return const_cast<void *>(attr.getAsOpaquePointer());
   }
   static inline mlir::Attribute getFromVoidPointer(void *ptr) {
     return mlir::Attribute::getFromOpaquePointer(ptr);
   }
   static constexpr int NumLowBitsAvailable = 3;
 };

mlir/include/mlir/IR/Block.h

 #ifndef MLIR_IR_BLOCK_H
 #define MLIR_IR_BLOCK_H
 
 #include "mlir/IR/BlockSupport.h"
 #include "mlir/IR/Visitors.h"
 
 namespace mlir {
 class TypeRange;
-template <typename ValueRangeT> class ValueTypeRange;
+template <typename ValueRangeT>
+class ValueTypeRange;
 
 /// `Block` represents an ordered list of `Operation`s.
 class Block : public IRObjectWithUseList<BlockOperand>,
               public llvm::ilist_node_with_parent<Block, Region> {
 public:
   explicit Block() {}
   ~Block();
 
op_iterator(op_filter_iterator<OpT> it)
               it, &unwrap) {}
 
     /// Allow implicit conversion to the underlying block iterator.
     operator Block::iterator() const { return this->wrapped(); }
   };
 
   /// Return an iterator range over the operations within this block that are of
   /// 'OpT'.
-  template <typename OpT> iterator_range<op_iterator<OpT>> getOps() {
+  template <typename OpT>
+  iterator_range<op_iterator<OpT>> getOps() {
     auto endIt = end();
     return {op_filter_iterator<OpT>(begin(), endIt),
             op_filter_iterator<OpT>(endIt, endIt)};
   }
-  template <typename OpT> op_iterator<OpT> op_begin() {
+  template <typename OpT>
+  op_iterator<OpT> op_begin() {
     return op_filter_iterator<OpT>(begin(), end());
   }
-  template <typename OpT> op_iterator<OpT> op_end() {
+  template <typename OpT>
+  op_iterator<OpT> op_end() {
     return op_filter_iterator<OpT>(end(), end());
   }
 
   /// Return an iterator range over the operation within this block excluding
   /// the terminator operation at the end.
   iterator_range<iterator> without_terminator() {
     if (begin() == end())
       return {begin(), end()};

mlir/include/mlir/IR/BlockAndValueMapping.h

public:
   /// does not exist then return the provided value.
   Block *lookupOrDefault(Block *from) const {
     return lookupOrValue(from, from);
   }
   Value lookupOrDefault(Value from) const { return lookupOrValue(from, from); }
 
   /// Lookup a mapped value within the map. This asserts the provided value
   /// exists within the map.
-  template <typename T> T lookup(T from) const {
+  template <typename T>
+  T lookup(T from) const {
     auto result = lookupOrNull(from);
     assert(result && "expected 'from' to be contained within the map");
     return result;
   }
 
   /// Clears all mappings held by the mapper.
   void clear() { valueMap.clear(); }
 

mlir/include/mlir/IR/BlockSupport.h

protected:
   static node_type *getNodePtr(pointer N);
   static const node_type *getNodePtr(const_pointer N);
 
   static pointer getValuePtr(node_type *N);
   static const_pointer getValuePtr(const node_type *N);
 };
 } // end namespace ilist_detail
 
-template <> struct ilist_traits<::mlir::Operation> {
+template <>
+struct ilist_traits<::mlir::Operation> {
   using Operation = ::mlir::Operation;
   using op_iterator = simple_ilist<Operation>::iterator;
 
   static void deleteNode(Operation *op);
   void addNodeToList(Operation *op);
   void removeNodeFromList(Operation *op);
   void transferNodesFromList(ilist_traits<Operation> &otherList,
                              op_iterator first, op_iterator last);

mlir/include/mlir/IR/Builders.h

public:
   IntegerType getI1Type();
   IntegerType getIntegerType(unsigned width);
   IntegerType getIntegerType(unsigned width, bool isSigned);
   FunctionType getFunctionType(ArrayRef<Type> inputs, ArrayRef<Type> results);
   TupleType getTupleType(ArrayRef<Type> elementTypes);
   NoneType getNoneType();
 
   /// Get or construct an instance of the type 'ty' with provided arguments.
-  template <typename Ty, typename... Args> Ty getType(Args... args) {
+  template <typename Ty, typename... Args>
+  Ty getType(Args... args) {
     return Ty::get(context, args...);
   }
 
   // Attributes.
   NamedAttribute getNamedAttr(StringRef name, Attribute val);
 
   UnitAttr getUnitAttr();
   BoolAttr getBoolAttr(bool value);
public:
   /// empty. Operands are remapped using `mapper` (if present), and `mapper` is
   /// updated to contain the results.
   Operation *cloneWithoutRegions(Operation &op, BlockAndValueMapping &mapper) {
     return insert(op.cloneWithoutRegions(mapper));
   }
   Operation *cloneWithoutRegions(Operation &op) {
     return insert(op.cloneWithoutRegions());
   }
-  template <typename OpT> OpT cloneWithoutRegions(OpT op) {
+  template <typename OpT>
+  OpT cloneWithoutRegions(OpT op) {
     return cast<OpT>(cloneWithoutRegions(*op.getOperation()));
   }
 
 private:
   Block *block = nullptr;
   Block::iterator insertPoint;
 };
 
 } // namespace mlir
 
 #endif

mlir/include/mlir/IR/Diagnostics.h

public:
 
   /// Stream in an Identifier.
   Diagnostic &operator<<(Identifier val);
 
   /// Stream in an OperationName.
   Diagnostic &operator<<(OperationName val);
 
   /// Stream in a range.
-  template <typename T> Diagnostic &operator<<(iterator_range<T> range) {
+  template <typename T>
+  Diagnostic &operator<<(iterator_range<T> range) {
     return appendRange(range);
   }
-  template <typename T> Diagnostic &operator<<(ArrayRef<T> range) {
+  template <typename T>
+  Diagnostic &operator<<(ArrayRef<T> range) {
     return appendRange(range);
   }
 
   /// Append a range to the diagnostic. The default delimiter between elements
   /// is ','.
   template <typename T, template <typename> class Container>
   Diagnostic &appendRange(const Container<T> &c, const char *delim = ", ") {
     interleave(
         c, [&](const detail::ValueOfRange<Container<T>> &a) { *this << a; },
         [&]() { *this << delim; });
     return *this;
   }
 
   /// Append arguments to the diagnostic.
   template <typename Arg1, typename Arg2, typename... Args>
   Diagnostic &append(Arg1 &&arg1, Arg2 &&arg2, Args &&... args) {
     append(std::forward<Arg1>(arg1));
     return append(std::forward<Arg2>(arg2), std::forward<Args>(args)...);
   }
   /// Append one argument to the diagnostic.
-  template <typename Arg> Diagnostic &append(Arg &&arg) {
+  template <typename Arg>
+  Diagnostic &append(Arg &&arg) {
     *this << std::forward<Arg>(arg);
     return *this;
   }
 
   /// Outputs this diagnostic to a stream.
   void print(raw_ostream &os) const;
 
   /// Converts the diagnostic to a string.
InFlightDiagnostic(InFlightDiagnostic &&rhs)
     rhs.abandon();
   }
   ~InFlightDiagnostic() {
     if (isInFlight())
       report();
   }
 
   /// Stream operator for new diagnostic arguments.
-  template <typename Arg> InFlightDiagnostic &operator<<(Arg &&arg) & {
+  template <typename Arg>
+  InFlightDiagnostic &operator<<(Arg &&arg) & {
     return append(std::forward<Arg>(arg));
   }
-  template <typename Arg> InFlightDiagnostic &&operator<<(Arg &&arg) && {
+  template <typename Arg>
+  InFlightDiagnostic &&operator<<(Arg &&arg) && {
     return std::move(append(std::forward<Arg>(arg)));
   }
 
   /// Append arguments to the diagnostic.
-  template <typename... Args> InFlightDiagnostic &append(Args &&... args) & {
+  template <typename... Args>
+  InFlightDiagnostic &append(Args &&... args) & {
     assert(isActive() && "diagnostic not active");
     if (isInFlight())
       impl->append(std::forward<Args>(args)...);
     return *this;
   }
-  template <typename... Args> InFlightDiagnostic &&append(Args &&... args) && {
+  template <typename... Args>
+  InFlightDiagnostic &&append(Args &&... args) && {
     return std::move(append(std::forward<Args>(args)...));
   }
 
   /// Attaches a note to this diagnostic.
   Diagnostic &attachNote(Optional<Location> noteLoc = llvm::None) {
     assert(isActive() && "diagnostic not active");
     return impl->attachNote(noteLoc);
   }
public:
   ScopedDiagnosticHandler(MLIRContext *ctx, FuncTy &&handler)
       : handlerID(0), ctx(ctx) {
     setHandler(std::forward<FuncTy>(handler));
   }
   ~ScopedDiagnosticHandler();
 
 protected:
   /// Set the handler to manage via RAII.
-  template <typename FuncTy> void setHandler(FuncTy &&handler) {
+  template <typename FuncTy>
+  void setHandler(FuncTy &&handler) {
     auto &diagEngine = ctx->getDiagEngine();
     if (handlerID)
       diagEngine.eraseHandler(handlerID);
     handlerID = diagEngine.registerHandler(std::forward<FuncTy>(handler));
   }
 
 private:
   /// The unique id for the scoped handler.

mlir/include/mlir/IR/Dialect.h

public:
   //===--------------------------------------------------------------------===//
 
   /// Lookup an interface for the given ID if one is registered, otherwise
   /// nullptr.
   const DialectInterface *getRegisteredInterface(ClassID *interfaceID) {
     auto it = registeredInterfaces.find(interfaceID);
     return it != registeredInterfaces.end() ? it->getSecond().get() : nullptr;
   }
-  template <typename InterfaceT> const InterfaceT *getRegisteredInterface() {
+  template <typename InterfaceT>
+  const InterfaceT *getRegisteredInterface() {
     return static_cast<const InterfaceT *>(
         getRegisteredInterface(InterfaceT::getInterfaceID()));
   }
 
 protected:
   /// The constructor takes a unique namespace for this dialect as well as the
   /// context to bind to.
   /// Note: The namespace must not contain '.' characters.
   /// Note: All operations belonging to this dialect must have names starting
   ///       with the namespace followed by '.'.
   /// Example:
   ///       - "tf" for the TensorFlow ops like "tf.add".
   Dialect(StringRef name, MLIRContext *context);
 
   /// This method is used by derived classes to add their operations to the set.
   ///
-  template <typename... Args> void addOperations() {
+  template <typename... Args>
+  void addOperations() {
     (void)std::initializer_list<int>{
         0, (addOperation(AbstractOperation::get<Args>(*this)), 0)...};
   }
 
   void addOperation(AbstractOperation opInfo);
 
   /// This method is used by derived classes to add their types to the set.
-  template <typename... Args> void addTypes() {
+  template <typename... Args>
+  void addTypes() {
     (void)std::initializer_list<int>{0, (addSymbol(Args::getClassID()), 0)...};
   }
 
   /// This method is used by derived classes to add their attributes to the set.
-  template <typename... Args> void addAttributes() {
+  template <typename... Args>
+  void addAttributes() {
     (void)std::initializer_list<int>{0, (addSymbol(Args::getClassID()), 0)...};
   }
 
   /// Enable support for unregistered operations.
   void allowUnknownOperations(bool allow = true) { unknownOpsAllowed = allow; }
 
   /// Enable support for unregistered types.
   void allowUnknownTypes(bool allow = true) { unknownTypesAllowed = allow; }
 
   /// Register a dialect interface with this dialect instance.
   void addInterface(std::unique_ptr<DialectInterface> interface);
 
   /// Register a set of dialect interfaces with this dialect instance.
-  template <typename... Args> void addInterfaces() {
+  template <typename... Args>
+  void addInterfaces() {
     (void)std::initializer_list<int>{
         0, (addInterface(std::make_unique<Args>(this)), 0)...};
   }
 
 private:
   // Register a symbol(e.g. type) with its given unique class identifier.
   void addSymbol(const ClassID *const classID);
 
private:
   friend void registerDialect();
 };
 /// Registers all dialects and hooks from the global registries with the
 /// specified MLIRContext.
 void registerAllDialects(MLIRContext *context);
 
 /// Utility to register a dialect. Client can register their dialect with the
 /// global registry by calling registerDialect<MyDialect>();
-template <typename ConcreteDialect> void registerDialect() {
+template <typename ConcreteDialect>
+void registerDialect() {
   Dialect::registerDialectAllocator(ClassID::getID<ConcreteDialect>(),
                                     [](MLIRContext *ctx) {
                                       // Just allocate the dialect, the context
                                       // takes ownership of it.
                                       new ConcreteDialect(ctx);
                                     });
 }
 
 /// DialectRegistration provides a global initializer that registers a Dialect
 /// allocation routine.
 ///
 /// Usage:
 ///
 ///   // At namespace scope.
 ///   static DialectRegistration<MyDialect> Unused;
-template <typename ConcreteDialect> struct DialectRegistration {
+template <typename ConcreteDialect>
+struct DialectRegistration {
   DialectRegistration() { registerDialect<ConcreteDialect>(); }
 };
 
 } // namespace mlir
 
 #endif

mlir/include/mlir/IR/DialectHooks.h

 }
 
 /// DialectHooksRegistration provides a global initializer that registers
 /// a dialect hooks setter routine.
 /// Usage:
 ///
 ///   // At namespace scope.
 ///   static DialectHooksRegistration<MyHooks> Unused("dialect_namespace");
-template <typename ConcreteHooks> struct DialectHooksRegistration {
+template <typename ConcreteHooks>
+struct DialectHooksRegistration {
   DialectHooksRegistration(StringRef dialectName) {
     registerDialectHooks<ConcreteHooks>(dialectName);
   }
 };
 
 } // namespace mlir
 
 #endif

mlir/include/mlir/IR/DialectImplementation.h

public:
   // These methods emit an error and return failure or success. This allows
   // these to be chained together into a linear sequence of || expressions in
   // many cases.
 
   /// Parse a floating point value from the stream.
   virtual ParseResult parseFloat(double &result) = 0;
 
   /// Parse an integer value from the stream.
-  template <typename IntT> ParseResult parseInteger(IntT &result) {
+  template <typename IntT>
+  ParseResult parseInteger(IntT &result) {
     auto loc = getCurrentLocation();
     OptionalParseResult parseResult = parseOptionalInteger(result);
     if (!parseResult.hasValue())
       return emitError(loc, "expected integer value");
     return *parseResult;
   }
 
   /// Parse an optional integer value from the stream.
public:
   //===--------------------------------------------------------------------===//
   // Type Parsing
   //===--------------------------------------------------------------------===//
 
   /// Parse a type.
   virtual ParseResult parseType(Type &result) = 0;
 
   /// Parse a type of a specific kind, e.g. a FunctionType.
-  template <typename TypeType> ParseResult parseType(TypeType &result) {
+  template <typename TypeType>
+  ParseResult parseType(TypeType &result) {
     llvm::SMLoc loc = getCurrentLocation();
 
     // Parse any kind of type.
     Type type;
     if (parseType(type))
       return failure();
 
     // Check for the right kind of attribute.

mlir/include/mlir/IR/DialectInterface.h

iterator(InterfaceVectorT::const_iterator it)
               InterfaceVectorT::const_iterator,
               const InterfaceT &(*)(const DialectInterface *)>(it, &remapIt) {}
 
     /// Allow access to the constructor.
     friend DialectInterfaceCollectionBase;
   };
 
   /// Iterator access to the held interfaces.
-  template <typename InterfaceT> iterator<InterfaceT> interface_begin() const {
+  template <typename InterfaceT>
+  iterator<InterfaceT> interface_begin() const {
     return iterator<InterfaceT>(orderedInterfaces.begin());
   }
-  template <typename InterfaceT> iterator<InterfaceT> interface_end() const {
+  template <typename InterfaceT>
+  iterator<InterfaceT> interface_end() const {
     return iterator<InterfaceT>(orderedInterfaces.end());
   }
 
 private:
   /// A set of registered dialect interface instances.
   InterfaceSetT interfaces;
   /// An ordered list of the registered interface instances, necessary for
   /// deterministic iteration.

mlir/include/mlir/IR/Function.h

LogicalResult verifyType() {
     return success();
   }
 };
 } // end namespace mlir
 
 namespace llvm {
 
 // Functions hash just like pointers.
-template <> struct DenseMapInfo<mlir::FuncOp> {
+template <>
+struct DenseMapInfo<mlir::FuncOp> {
   static mlir::FuncOp getEmptyKey() {
     auto pointer = llvm::DenseMapInfo<void *>::getEmptyKey();
     return mlir::FuncOp::getFromOpaquePointer(pointer);
   }
   static mlir::FuncOp getTombstoneKey() {
     auto pointer = llvm::DenseMapInfo<void *>::getTombstoneKey();
     return mlir::FuncOp::getFromOpaquePointer(pointer);
   }
   static unsigned getHashValue(mlir::FuncOp val) {
     return hash_value(val.getAsOpaquePointer());
   }
   static bool isEqual(mlir::FuncOp LHS, mlir::FuncOp RHS) { return LHS == RHS; }
 };
 
 /// Allow stealing the low bits of FuncOp.
-template <> struct PointerLikeTypeTraits<mlir::FuncOp> {
+template <>
+struct PointerLikeTypeTraits<mlir::FuncOp> {
 public:
   static inline void *getAsVoidPointer(mlir::FuncOp I) {
     return const_cast<void *>(I.getAsOpaquePointer());
   }
   static inline mlir::FuncOp getFromVoidPointer(void *P) {
     return mlir::FuncOp::getFromOpaquePointer(P);
   }
   static constexpr int NumLowBitsAvailable = 3;
 };
 
 } // namespace llvm
 
 #endif // MLIR_IR_FUNCTION_H

mlir/include/mlir/IR/IntegerSet.h

 inline ::llvm::hash_code hash_value(IntegerSet arg) {
   return ::llvm::hash_value(arg.set);
 }
 
 } // end namespace mlir
 namespace llvm {
 
 // IntegerSet hash just like pointers
-template <> struct DenseMapInfo<mlir::IntegerSet> {
+template <>
+struct DenseMapInfo<mlir::IntegerSet> {
   static mlir::IntegerSet getEmptyKey() {
     auto pointer = llvm::DenseMapInfo<void *>::getEmptyKey();
     return mlir::IntegerSet(static_cast<mlir::IntegerSet::ImplType *>(pointer));
   }
   static mlir::IntegerSet getTombstoneKey() {
     auto pointer = llvm::DenseMapInfo<void *>::getTombstoneKey();
     return mlir::IntegerSet(static_cast<mlir::IntegerSet::ImplType *>(pointer));
   }

mlir/include/mlir/IR/Location.h

public:
   /// Return the context this location is uniqued in.
   MLIRContext *getContext() const { return impl.getContext(); }
 
   /// Access the impl location attribute.
   operator LocationAttr() const { return impl; }
   LocationAttr *operator->() const { return const_cast<LocationAttr *>(&impl); }
 
   /// Type casting utilities on the underlying location.
-  template <typename U> bool isa() const { return impl.isa<U>(); }
-  template <typename U> U dyn_cast() const { return impl.dyn_cast<U>(); }
-  template <typename U> U cast() const { return impl.cast<U>(); }
+  template <typename U>
+  bool isa() const {
+    return impl.isa<U>();
+  }
+  template <typename U>
+  U dyn_cast() const {
+    return impl.dyn_cast<U>();
+  }
+  template <typename U>
+  U cast() const {
+    return impl.cast<U>();
+  }
 
   /// Comparison operators.
   bool operator==(Location rhs) const { return impl == rhs.impl; }
   bool operator!=(Location rhs) const { return !(*this == rhs); }
 
   /// Print the location.
   void print(raw_ostream &os) const { impl.print(os); }
   void dump() const { impl.dump(); }
public:
   /// an object and an additional MLIR location.
   template <typename T>
   static Location get(T underlyingLocation, Location fallbackLocation) {
     return get(reinterpret_cast<uintptr_t>(underlyingLocation),
                ClassID::getID<T>(), fallbackLocation);
   }
 
   /// Returns a pointer to some data structure that opaque location stores.
-  template <typename T> static T getUnderlyingLocation(Location location) {
+  template <typename T>
+  static T getUnderlyingLocation(Location location) {
     assert(isa<T>(location));
     return reinterpret_cast<T>(
         location.cast<mlir::OpaqueLoc>().getUnderlyingLocation());
   }
 
   /// Returns a pointer to some data structure that opaque location stores.
   /// Returns nullptr if provided location is not opaque location or if it
   /// contains a pointer of different type.
   template <typename T>
   static T getUnderlyingLocationOrNull(Location location) {
     return isa<T>(location)
                ? reinterpret_cast<T>(
                      location.cast<mlir::OpaqueLoc>().getUnderlyingLocation())
                : T(nullptr);
   }
 
   /// Checks whether provided location is opaque location and contains a pointer
   /// to an object of particular type.
-  template <typename T> static bool isa(Location location) {
+  template <typename T>
+  static bool isa(Location location) {
     auto opaque_loc = location.dyn_cast<OpaqueLoc>();
     return opaque_loc && opaque_loc.getClassId() == ClassID::getID<T>();
   }
 
   /// Returns a pointer to the corresponding object.
   uintptr_t getUnderlyingLocation() const;
 
   /// Returns a ClassID* that represents the underlying objects c++ type.
inline ::llvm::hash_code hash_value(Location arg) {
   return hash_value(arg.impl);
 }
 
 } // end namespace mlir
 
 namespace llvm {
 
 // Type hash just like pointers.
-template <> struct DenseMapInfo<mlir::Location> {
+template <>
+struct DenseMapInfo<mlir::Location> {
   static mlir::Location getEmptyKey() {
     auto pointer = llvm::DenseMapInfo<void *>::getEmptyKey();
     return mlir::Location::getFromOpaquePointer(pointer);
   }
   static mlir::Location getTombstoneKey() {
     auto pointer = llvm::DenseMapInfo<void *>::getTombstoneKey();
     return mlir::Location::getFromOpaquePointer(pointer);
   }
   static unsigned getHashValue(mlir::Location val) {
     return mlir::hash_value(val);
   }
   static bool isEqual(mlir::Location LHS, mlir::Location RHS) {
     return LHS == RHS;
   }
 };
 
 /// We align LocationStorage by 8, so allow LLVM to steal the low bits.
-template <> struct PointerLikeTypeTraits<mlir::Location> {
+template <>
+struct PointerLikeTypeTraits<mlir::Location> {
 public:
   static inline void *getAsVoidPointer(mlir::Location I) {
     return const_cast<void *>(I.getAsOpaquePointer());
   }
   static inline mlir::Location getFromVoidPointer(void *P) {
     return mlir::Location::getFromOpaquePointer(P);
   }
   static constexpr int NumLowBitsAvailable =
       PointerLikeTypeTraits<mlir::Attribute>::NumLowBitsAvailable;
 };
 
 } // namespace llvm
 
 #endif

mlir/include/mlir/IR/MLIRContext.h

public:
   std::vector<Dialect *> getRegisteredDialects();
 
   /// Get a registered IR dialect with the given namespace. If an exact match is
   /// not found, then return nullptr.
   Dialect *getRegisteredDialect(StringRef name);
 
   /// Get a registered IR dialect for the given derived dialect type. The
   /// derived type must provide a static 'getDialectNamespace' method.
-  template <typename T> T *getRegisteredDialect() {
+  template <typename T>
+  T *getRegisteredDialect() {
     return static_cast<T *>(getRegisteredDialect(T::getDialectNamespace()));
   }
 
   /// Return information about all registered operations.  This isn't very
   /// efficient: typically you should ask the operations about their properties
   /// directly.
   std::vector<AbstractOperation *> getRegisteredOperations();
 

mlir/include/mlir/IR/Matchers.h

 
 /// The matcher that matches operations that have the `ConstantLike` trait.
 struct constant_op_matcher {
   bool match(Operation *op) { return op->hasTrait<OpTrait::ConstantLike>(); }
 };
 
 /// The matcher that matches operations that have the `ConstantLike` trait, and
 /// binds the folded attribute value.
-template <typename AttrT> struct constant_op_binder {
+template <typename AttrT>
+struct constant_op_binder {
   AttrT *bind_value;
 
   /// Creates a matcher instance that binds the constant attribute value to
   /// bind_value if match succeeds.
   constant_op_binder(AttrT *bind_value) : bind_value(bind_value) {}
   /// Creates a matcher instance that doesn't bind if match succeeds.
   constant_op_binder() : bind_value(nullptr) {}
 
if (type.isa<VectorType>() || type.isa<RankedTensorType>()) {
       }
     }
     return false;
   }
 };
 
 /// The matcher that matches a given target constant scalar / vector splat /
 /// tensor splat integer value.
-template <int64_t TargetValue> struct constant_int_value_matcher {
+template <int64_t TargetValue>
+struct constant_int_value_matcher {
   bool match(Operation *op) {
     APInt value;
     return constant_int_op_binder(&value).match(op) && TargetValue == value;
   }
 };
 
 /// The matcher that matches anything except the given target constant scalar /
 /// vector splat / tensor splat integer value.
-template <int64_t TargetNotValue> struct constant_int_not_value_matcher {
+template <int64_t TargetNotValue>
+struct constant_int_not_value_matcher {
   bool match(Operation *op) {
     APInt value;
     return constant_int_op_binder(&value).match(op) && TargetNotValue != value;
   }
 };
 
 /// The matcher that matches a certain kind of op.
-template <typename OpClass> struct op_matcher {
+template <typename OpClass>
+struct op_matcher {
   bool match(Operation *op) { return isa<OpClass>(op); }
 };
 
 /// Trait to check whether T provides a 'match' method with type
 /// `OperationOrValue`.
 template <typename T, typename OperationOrValue>
 using has_operation_or_value_matcher_t =
     decltype(std::declval<T>().match(std::declval<OperationOrValue>()));

 }
 
 /// Matches a constant scalar / vector splat / tensor splat integer one.
 inline detail::constant_int_value_matcher<1> m_One() {
   return detail::constant_int_value_matcher<1>();
 }
 
 /// Matches the given OpClass.
-template <typename OpClass> inline detail::op_matcher<OpClass> m_Op() {
+template <typename OpClass>
+inline detail::op_matcher<OpClass> m_Op() {
   return detail::op_matcher<OpClass>();
 }
 
 /// Matches a constant scalar / vector splat / tensor splat integer zero.
 inline detail::constant_int_value_matcher<0> m_Zero() {
   return detail::constant_int_value_matcher<0>();
 }
 

mlir/include/mlir/IR/Module.h

public:
   using iterator = Block::iterator;
 
   iterator begin() { return getBody()->begin(); }
   iterator end() { return getBody()->end(); }
   Operation &front() { return *begin(); }
 
   /// This returns a range of operations of the given type 'T' held within the
   /// module.
-  template <typename T> iterator_range<Block::op_iterator<T>> getOps() {
+  template <typename T>
+  iterator_range<Block::op_iterator<T>> getOps() {
     return getBody()->getOps<T>();
   }
 
   /// Insert the operation into the back of the body, before the terminator.
   void push_back(Operation *op) {
     insert(Block::iterator(getBody()->getTerminator()), op);
   }
 
private:
   ModuleOp module;
 };
 
 } // end namespace mlir
 
 namespace llvm {
 
 /// Allow stealing the low bits of ModuleOp.
-template <> struct PointerLikeTypeTraits<mlir::ModuleOp> {
+template <>
+struct PointerLikeTypeTraits<mlir::ModuleOp> {
 public:
   static inline void *getAsVoidPointer(mlir::ModuleOp I) {
     return const_cast<void *>(I.getAsOpaquePointer());
   }
   static inline mlir::ModuleOp getFromVoidPointer(void *P) {
     return mlir::ModuleOp::getFromOpaquePointer(P);
   }
   static constexpr int NumLowBitsAvailable = 3;
 };
 
 } // end namespace llvm
 
 #endif // MLIR_IR_MODULE_H

mlir/include/mlir/IR/OpDefinition.h

 #include "mlir/IR/Operation.h"
 #include "llvm/Support/PointerLikeTypeTraits.h"
 #include <type_traits>
 
 namespace mlir {
 class Builder;
 
 namespace OpTrait {
-template <typename ConcreteType> class OneResult;
+template <typename ConcreteType>
+class OneResult;
 }
 
 /// This class represents success/failure for operation parsing. It is
 /// essentially a simple wrapper class around LogicalResult that allows for
 /// explicit conversion to bool. This allows for the parser to chain together
 /// parse rules without the clutter of "failed/succeeded".
 class ParseResult : public LogicalResult {
 public:
public:
   /// Return the operation that this refers to.
   Operation *getOperation() { return state; }
 
   /// Returns the closest surrounding operation that contains this operation
   /// or nullptr if this is a top-level operation.
   Operation *getParentOp() { return getOperation()->getParentOp(); }
 
   /// Return the closest surrounding parent operation that is of type 'OpTy'.
-  template <typename OpTy> OpTy getParentOfType() {
+  template <typename OpTy>
+  OpTy getParentOfType() {
     return getOperation()->getParentOfType<OpTy>();
   }
 
   /// Return the context this operation belongs to.
   MLIRContext *getContext() { return getOperation()->getContext(); }
 
   /// Print the operation to the given stream.
   void print(raw_ostream &os, OpPrintingFlags flags = llvm::None) {
dialect_attr_iterator dialect_attr_begin() {
     return state->dialect_attr_begin();
   }
   dialect_attr_iterator dialect_attr_end() { return state->dialect_attr_end(); }
 
   /// Return an attribute with the specified name.
   Attribute getAttr(StringRef name) { return state->getAttr(name); }
 
   /// If the operation has an attribute of the specified type, return it.
-  template <typename AttrClass> AttrClass getAttrOfType(StringRef name) {
+  template <typename AttrClass>
+  AttrClass getAttrOfType(StringRef name) {
     return getAttr(name).dyn_cast_or_null<AttrClass>();
   }
 
   /// If the an attribute exists with the specified name, change it to the new
   /// value.  Otherwise, add a new attribute with the specified name/value.
   void setAttr(Identifier name, Attribute value) {
     state->setAttr(name, value);
   }
   void setAttr(StringRef name, Attribute value) {
     setAttr(Identifier::get(name, getContext()), value);
   }
 
   /// Set the attributes held by this operation.
   void setAttrs(ArrayRef<NamedAttribute> attributes) {
     state->setAttrs(attributes);
   }
   void setAttrs(NamedAttributeList newAttrs) { state->setAttrs(newAttrs); }
 
   /// Set the dialect attributes for this operation, and preserve all dependent.
-  template <typename DialectAttrs> void setDialectAttrs(DialectAttrs &&attrs) {
+  template <typename DialectAttrs>
+  void setDialectAttrs(DialectAttrs &&attrs) {
     state->setDialectAttrs(std::move(attrs));
   }
 
   /// Remove the attribute with the specified name if it exists.  The return
   /// value indicates whether the attribute was present or not.
   NamedAttributeList::RemoveResult removeAttr(Identifier name) {
     return state->removeAttr(name);
   }
public:
   }
 };
 
 /// This class provides the API for ops that are known to have a specified
 /// number of operands.  This is used as a trait like this:
 ///
 ///   class FooOp : public Op<FooOp, OpTrait::NOperands<2>::Impl> {
 ///
-template <unsigned N> class NOperands {
+template <unsigned N>
+class NOperands {
 public:
   static_assert(N > 1, "use ZeroOperands/OneOperand for N < 2");
 
   template <typename ConcreteType>
   class Impl
       : public detail::MultiOperandTraitBase<ConcreteType, NOperands<N>::Impl> {
   public:
     static LogicalResult verifyTrait(Operation *op) {
       return impl::verifyNOperands(op, N);
     }
   };
 };
 
 /// This class provides the API for ops that are known to have a at least a
 /// specified number of operands.  This is used as a trait like this:
 ///
 ///   class FooOp : public Op<FooOp, OpTrait::AtLeastNOperands<2>::Impl> {
 ///
-template <unsigned N> class AtLeastNOperands {
+template <unsigned N>
+class AtLeastNOperands {
 public:
   template <typename ConcreteType>
   class Impl : public detail::MultiOperandTraitBase<ConcreteType,
                                                     AtLeastNOperands<N>::Impl> {
   public:
     static LogicalResult verifyTrait(Operation *op) {
       return impl::verifyAtLeastNOperands(op, N);
     }
struct MultiResultTraitBase : public TraitBase<ConcreteType, TraitType> {
   /// Return the number of results.
   unsigned getNumResults() { return this->getOperation()->getNumResults(); }
 
   /// Return the result at index 'i'.
   Value getResult(unsigned i) { return this->getOperation()->getResult(i); }
 
   /// Replace all uses of results of this operation with the provided 'values'.
   /// 'values' may correspond to an existing operation, or a range of 'Value'.
-  template <typename ValuesT> void replaceAllUsesWith(ValuesT &&values) {
+  template <typename ValuesT>
+  void replaceAllUsesWith(ValuesT &&values) {
     this->getOperation()->replaceAllUsesWith(std::forward<ValuesT>(values));
   }
 
   /// Return the type of the `i`-th result.
   Type getType(unsigned i) { return getResult(i).getType(); }
 
   /// Result iterator access.
   result_iterator result_begin() {
public:
   }
 };
 
 /// This class provides the API for ops that are known to have a specified
 /// number of results.  This is used as a trait like this:
 ///
 ///   class FooOp : public Op<FooOp, OpTrait::NResults<2>::Impl> {
 ///
-template <unsigned N> class NResults {
+template <unsigned N>
+class NResults {
 public:
   static_assert(N > 1, "use ZeroResult/OneResult for N < 2");
 
   template <typename ConcreteType>
   class Impl
       : public detail::MultiResultTraitBase<ConcreteType, NResults<N>::Impl> {
   public:
     static LogicalResult verifyTrait(Operation *op) {
       return impl::verifyNResults(op, N);
     }
   };
 };
 
 /// This class provides the API for ops that are known to have at least a
 /// specified number of results.  This is used as a trait like this:
 ///
 ///   class FooOp : public Op<FooOp, OpTrait::AtLeastNResults<2>::Impl> {
 ///
-template <unsigned N> class AtLeastNResults {
+template <unsigned N>
+class AtLeastNResults {
 public:
   template <typename ConcreteType>
   class Impl : public detail::MultiResultTraitBase<ConcreteType,
                                                    AtLeastNResults<N>::Impl> {
   public:
     static LogicalResult verifyTrait(Operation *op) {
       return impl::verifyAtLeastNResults(op, N);
     }
for (auto &region : op->getRegions())
       if (!region.isIsolatedFromAbove(op->getLoc()))
         return failure();
     return success();
   }
 };
 
 /// This class provides APIs and verifiers for ops with regions having a single
 /// block that must terminate with `TerminatorOpType`.
-template <typename TerminatorOpType> struct SingleBlockImplicitTerminator {
+template <typename TerminatorOpType>
+struct SingleBlockImplicitTerminator {
   template <typename ConcreteType>
   class Impl : public TraitBase<ConcreteType, Impl> {
   public:
     static LogicalResult verifyTrait(Operation *op) {
       for (unsigned i = 0, e = op->getNumRegions(); i < e; ++i) {
         Region &region = op->getRegion(i);
 
         // Empty regions are fine.
static void ensureTerminator(Region &region, Builder &builder,
                                  Location loc) {
       ::mlir::impl::template ensureRegionTerminator<TerminatorOpType>(
           region, builder, loc);
     }
   };
 };
 
 /// This class provides a verifier for ops that are expecting a specific parent.
-template <typename ParentOpType> struct HasParent {
+template <typename ParentOpType>
+struct HasParent {
   template <typename ConcreteType>
   class Impl : public TraitBase<ConcreteType, Impl> {
   public:
     static LogicalResult verifyTrait(Operation *op) {
       if (isa<ParentOpType>(op->getParentOp()))
         return success();
       return op->emitOpError() << "expects parent op '"
                                << ParentOpType::getOperationName() << "'";
const void *getAsOpaquePointer() const {
     return static_cast<const void *>((Operation *)*this);
   }
   static ConcreteOpType getFromOpaquePointer(const void *pointer) {
     return ConcreteOpType(
         reinterpret_cast<Operation *>(const_cast<void *>(pointer)));
   }
 
 private:
-  template <typename... Types> struct BaseVerifier;
+  template <typename... Types>
+  struct BaseVerifier;
 
   template <typename First, typename... Rest>
   struct BaseVerifier<First, Rest...> {
     static LogicalResult verifyTrait(Operation *op) {
       return failure(failed(First::verifyTrait(op)) ||
                      failed(BaseVerifier<Rest...>::verifyTrait(op)));
     }
   };
 
-  template <typename...> struct BaseVerifier {
+  template <typename...>
+  struct BaseVerifier {
     static LogicalResult verifyTrait(Operation *op) { return success(); }
   };
 
-  template <typename... Types> struct BaseProperties;
+  template <typename... Types>
+  struct BaseProperties;
 
   template <typename First, typename... Rest>
   struct BaseProperties<First, Rest...> {
     static AbstractOperation::OperationProperties getTraitProperties() {
       return First::getTraitProperties() |
              BaseProperties<Rest...>::getTraitProperties();
     }
   };
 
-  template <typename...> struct BaseProperties {
+  template <typename...>
+  struct BaseProperties {
     static AbstractOperation::OperationProperties getTraitProperties() {
       return 0;
     }
   };
 
   /// Returns true if this operation contains the trait for the given classID.
   static bool hasTrait(ClassID *traitID) {
     return llvm::is_contained(llvm::makeArrayRef({ClassID::getID<Traits>()...}),

 ///      }
 ///    };
 ///  };
 ///
 template <typename ConcreteType, typename Traits>
 class OpInterface : public Op<ConcreteType> {
 public:
   using Concept = typename Traits::Concept;
-  template <typename T> using Model = typename Traits::template Model<T>;
+  template <typename T>
+  using Model = typename Traits::template Model<T>;
 
   OpInterface(Operation *op = nullptr)
       : Op<ConcreteType>(op), impl(op ? getInterfaceFor(op) : nullptr) {
     assert((!op || impl) &&
            "instantiating an interface with an unregistered operation");
   }
 
   /// Support 'classof' by checking if the given operation defines the concrete

mlir/include/mlir/IR/Operation.h

public:
   /// the instruction is unlinked.
   Region *getParentRegion();
 
   /// Returns the closest surrounding operation that contains this operation
   /// or nullptr if this is a top-level operation.
   Operation *getParentOp();
 
   /// Return the closest surrounding parent operation that is of type 'OpTy'.
-  template <typename OpTy> OpTy getParentOfType() {
+  template <typename OpTy>
+  OpTy getParentOfType() {
     auto *op = this;
     while ((op = op->getParentOp()))
       if (auto parentOp = dyn_cast<OpTy>(op))
         return parentOp;
     return OpTy();
   }
 
   /// Return true if this operation is a proper ancestor of the `other`
public:
   /// Using a NamedAttributeList is more efficient as it does not require new
   /// uniquing in the MLIRContext.
   void setAttrs(NamedAttributeList newAttrs) { attrs = newAttrs; }
 
   /// Return the specified attribute if present, null otherwise.
   Attribute getAttr(Identifier name) { return attrs.get(name); }
   Attribute getAttr(StringRef name) { return attrs.get(name); }
 
-  template <typename AttrClass> AttrClass getAttrOfType(Identifier name) {
+  template <typename AttrClass>
+  AttrClass getAttrOfType(Identifier name) {
     return getAttr(name).dyn_cast_or_null<AttrClass>();
   }
 
-  template <typename AttrClass> AttrClass getAttrOfType(StringRef name) {
+  template <typename AttrClass>
+  AttrClass getAttrOfType(StringRef name) {
     return getAttr(name).dyn_cast_or_null<AttrClass>();
   }
 
   /// If the an attribute exists with the specified name, change it to the new
   /// value.  Otherwise, add a new attribute with the specified name/value.
   void setAttr(Identifier name, Attribute value) { attrs.set(name, value); }
   void setAttr(StringRef name, Attribute value) {
     setAttr(Identifier::get(name, getContext()), value);
public:
   /// - the elements in "operands" will correspond directly to the operands of
   /// the operation, but may be null if non-constant. If folding is successful,
   /// this fills in the `results` vector. If not, `results` is unspecified.
   LogicalResult fold(ArrayRef<Attribute> operands,
                      SmallVectorImpl<OpFoldResult> &results);
 
   /// Returns if the operation was registered with a particular trait, e.g.
   /// hasTrait<OperandsAreSignlessIntegerLike>().
-  template <template <typename T> class Trait> bool hasTrait() {
+  template <template <typename T> class Trait>
+  bool hasTrait() {
     auto *absOp = getAbstractOperation();
     return absOp ? absOp->hasTrait<Trait>() : false;
   }
 
   //===--------------------------------------------------------------------===//
   // Operation Walkers
   //===--------------------------------------------------------------------===//
 
inline raw_ostream &operator<<(raw_ostream &os, Operation &op) {
   op.print(os);
   return os;
 }
 
 } // end namespace mlir
 
 namespace llvm {
 /// Provide isa functionality for operation casts.
-template <typename T> struct isa_impl<T, ::mlir::Operation> {
+template <typename T>
+struct isa_impl<T, ::mlir::Operation> {
   static inline bool doit(const ::mlir::Operation &op) {
     return T::classof(const_cast<::mlir::Operation *>(&op));
   }
 };
 
 /// Provide specializations for operation casts as the resulting T is value
 /// typed.
-template <typename T> struct cast_retty_impl<T, ::mlir::Operation *> {
+template <typename T>
+struct cast_retty_impl<T, ::mlir::Operation *> {
   using ret_type = T;
 };
-template <typename T> struct cast_retty_impl<T, ::mlir::Operation> {
+template <typename T>
+struct cast_retty_impl<T, ::mlir::Operation> {
   using ret_type = T;
 };
 template <class T>
 struct cast_convert_val<T, ::mlir::Operation, ::mlir::Operation> {
   static T doit(::mlir::Operation &val) { return T(&val); }
 };
 template <class T>
 struct cast_convert_val<T, ::mlir::Operation *, ::mlir::Operation *> {
   static T doit(::mlir::Operation *val) { return T(val); }
 };
 } // end namespace llvm
 
 #endif // MLIR_IR_OPERATION_H

mlir/include/mlir/IR/OperationSupport.h

 class Pattern;
 class Region;
 class ResultRange;
 class RewritePattern;
 class SuccessorRange;
 class Type;
 class Value;
 class ValueRange;
-template <typename ValueRangeT> class ValueTypeRange;
+template <typename ValueRangeT>
+class ValueTypeRange;
 
 /// This is an adaptor from a list of values to named operands of OpTy.  In a
 /// generic operation context, e.g., in dialect conversions, an ordered array of
 /// `Value`s is treated as operands of `OpTy`.  This adaptor takes a reference
 /// to the array and provides accessors with the same names as `OpTy` for
 /// operands.  This makes possible to create function templates that operate on
 /// either OpTy or OperandAdaptor<OpTy> seamlessly.
-template <typename OpTy> using OperandAdaptor = typename OpTy::OperandAdaptor;
+template <typename OpTy>
+using OperandAdaptor = typename OpTy::OperandAdaptor;
 
 class OwningRewritePatternList;
 
 //===----------------------------------------------------------------------===//
 // AbstractOperation
 //===----------------------------------------------------------------------===//
 
 enum class OperationProperty {
public:
   /// Returns whether the operation has a particular property.
   bool hasProperty(OperationProperty property) const {
     return opProperties & static_cast<OperationProperties>(property);
   }
 
   /// Returns an instance of the concept object for the given interface if it
   /// was registered to this operation, null otherwise. This should not be used
   /// directly.
-  template <typename T> typename T::Concept *getInterface() const {
+  template <typename T>
+  typename T::Concept *getInterface() const {
     return reinterpret_cast<typename T::Concept *>(
         getRawInterface(T::getInterfaceID()));
   }
 
   /// Returns if the operation has a particular trait.
-  template <template <typename T> class Trait> bool hasTrait() const {
+  template <template <typename T> class Trait>
+  bool hasTrait() const {
     return hasRawTrait(ClassID::getID<Trait>());
   }
 
   /// Look up the specified operation in the specified MLIRContext and return a
   /// pointer to it if present.  Otherwise, return a null pointer.
   static const AbstractOperation *lookup(StringRef opName,
                                          MLIRContext *context);
 
   /// This constructor is used by Dialect objects when they register the list of
   /// operations they contain.
-  template <typename T> static AbstractOperation get(Dialect &dialect) {
+  template <typename T>
+  static AbstractOperation get(Dialect &dialect) {
     return AbstractOperation(
         T::getOperationName(), dialect, T::getOperationProperties(),
         ClassID::getID<T>(), T::parseAssembly, T::printAssembly,
         T::verifyInvariants, T::foldHook, T::getCanonicalizationPatterns,
         T::getRawInterface, T::hasTrait);
   }
 
 private:
private:
 
   /// Allow access to `offset_base` and `dereference_iterator`.
   friend RangeBaseT;
 };
 } // end namespace mlir
 
 namespace llvm {
 // Identifiers hash just like pointers, there is no need to hash the bytes.
-template <> struct DenseMapInfo<mlir::OperationName> {
+template <>
+struct DenseMapInfo<mlir::OperationName> {
   static mlir::OperationName getEmptyKey() {
     auto pointer = llvm::DenseMapInfo<void *>::getEmptyKey();
     return mlir::OperationName::getFromOpaquePointer(pointer);
   }
   static mlir::OperationName getTombstoneKey() {
     auto pointer = llvm::DenseMapInfo<void *>::getTombstoneKey();
     return mlir::OperationName::getFromOpaquePointer(pointer);
   }
   static unsigned getHashValue(mlir::OperationName Val) {
     return DenseMapInfo<void *>::getHashValue(Val.getAsOpaquePointer());
   }
   static bool isEqual(mlir::OperationName LHS, mlir::OperationName RHS) {
     return LHS == RHS;
   }
 };
 
 /// The pointer inside of an identifier comes from a StringMap, so its alignment
 /// is always at least 4 and probably 8 (on 64-bit machines).  Allow LLVM to
 /// steal the low bits.
-template <> struct PointerLikeTypeTraits<mlir::OperationName> {
+template <>
+struct PointerLikeTypeTraits<mlir::OperationName> {
 public:
   static inline void *getAsVoidPointer(mlir::OperationName I) {
     return const_cast<void *>(I.getAsOpaquePointer());
   }
   static inline mlir::OperationName getFromVoidPointer(void *P) {
     return mlir::OperationName::getFromOpaquePointer(P);
   }
   static constexpr int NumLowBitsAvailable = PointerLikeTypeTraits<
       mlir::OperationName::RepresentationUnion>::NumLowBitsAvailable;
 };
 
 } // end namespace llvm
 
 #endif

mlir/include/mlir/IR/PatternMatch.h

protected:
   /// A list of the potential operations that may be generated when rewriting
   /// an op with this pattern.
   SmallVector<OperationName, 2> generatedOps;
 };
 
 /// OpRewritePattern is a wrapper around RewritePattern that allows for
 /// matching and rewriting against an instance of a derived operation class as
 /// opposed to a raw Operation.
-template <typename SourceOp> struct OpRewritePattern : public RewritePattern {
+template <typename SourceOp>
+struct OpRewritePattern : public RewritePattern {
   /// Patterns must specify the root operation name they match against, and can
   /// also specify the benefit of the pattern matching.
   OpRewritePattern(MLIRContext *context, PatternBenefit benefit = 1)
       : RewritePattern(SourceOp::getOperationName(), benefit, context) {}
 
   /// Wrappers around the RewritePattern methods that pass the derived op type.
   void rewrite(Operation *op, PatternRewriter &rewriter) const final {
     rewrite(cast<SourceOp>(op), rewriter);

mlir/include/mlir/IR/Region.h

public:
   /// attached to a top-level operation.
   Region *getParentRegion();
 
   /// Return the parent operation this region is attached to.
   Operation *getParentOp();
 
   /// Find the first parent operation of the given type, or nullptr if there is
   /// no ancestor operation.
-  template <typename ParentT> ParentT getParentOfType() {
+  template <typename ParentT>
+  ParentT getParentOfType() {
     auto *region = this;
     do {
       if (auto parent = dyn_cast_or_null<ParentT>(region->container))
         return parent;
     } while ((region = region->getParentRegion()));
     return ParentT();
   }
 

mlir/include/mlir/IR/RegionGraphTraits.h

 
 #ifndef MLIR_IR_REGIONGRAPHTRAITS_H
 #define MLIR_IR_REGIONGRAPHTRAITS_H
 
 #include "mlir/IR/Region.h"
 #include "llvm/ADT/GraphTraits.h"
 
 namespace llvm {
-template <> struct GraphTraits<mlir::Block *> {
+template <>
+struct GraphTraits<mlir::Block *> {
   using ChildIteratorType = mlir::Block::succ_iterator;
   using Node = mlir::Block;
   using NodeRef = Node *;
 
   static NodeRef getEntryNode(NodeRef bb) { return bb; }
 
   static ChildIteratorType child_begin(NodeRef node) {
     return node->succ_begin();
   }
   static ChildIteratorType child_end(NodeRef node) { return node->succ_end(); }
 };
 
-template <> struct GraphTraits<Inverse<mlir::Block *>> {
+template <>
+struct GraphTraits<Inverse<mlir::Block *>> {
   using ChildIteratorType = mlir::Block::pred_iterator;
   using Node = mlir::Block;
   using NodeRef = Node *;
   static NodeRef getEntryNode(Inverse<NodeRef> inverseGraph) {
     return inverseGraph.Graph;
   }
   static inline ChildIteratorType child_begin(NodeRef node) {
     return node->pred_begin();

mlir/include/mlir/IR/StorageUniquerSupport.h

public:
   using Base = StorageUserBase<ConcreteT, BaseT, StorageT, UniquerT>;
   using ImplType = StorageT;
 
   /// Return a unique identifier for the concrete type.
   static ClassID *getClassID() { return ClassID::getID<ConcreteT>(); }
 
   /// Provide a default implementation of 'classof' that invokes a 'kindof'
   /// method on the concrete type.
-  template <typename T> static bool classof(T val) {
+  template <typename T>
+  static bool classof(T val) {
     static_assert(std::is_convertible<ConcreteT, T>::value,
                   "casting from a non-convertible type");
     return ConcreteT::kindof(val.getKind());
   }
 
 protected:
   /// Get or create a new ConcreteT instance within the ctx. This
   /// function is guaranteed to return a non null object and will assert if

mlir/include/mlir/IR/SymbolTable.h

 class SymbolTable {
 public:
   /// Build a symbol table with the symbols within the given operation.
   SymbolTable(Operation *symbolTableOp);
 
   /// Look up a symbol with the specified name, returning null if no such
   /// name exists. Names never include the @ on them.
   Operation *lookup(StringRef name) const;
-  template <typename T> T lookup(StringRef name) const {
+  template <typename T>
+  T lookup(StringRef name) const {
     return dyn_cast_or_null<T>(lookup(name));
   }
 
   /// Erase the given symbol from the table.
   void erase(Operation *symbol);
 
   /// Insert a new symbol into the table, and rename it as necessary to avoid
   /// collisions. Also insert at the specified location in the body of the
public:
   }
 
   /// Look up a symbol with the specified name, returning null if no such
   /// name exists. Symbol names never include the @ on them. Note: This
   /// performs a linear scan of held symbols.
   Operation *lookupSymbol(StringRef name) {
     return mlir::SymbolTable::lookupSymbolIn(this->getOperation(), name);
   }
-  template <typename T> T lookupSymbol(StringRef name) {
+  template <typename T>
+  T lookupSymbol(StringRef name) {
     return dyn_cast_or_null<T>(lookupSymbol(name));
   }
 };
 
 /// A trait used to define a symbol that can be used on operations within a
 /// symbol table. Operations using this trait must adhere to the following:
 ///   * Have a StringAttr attribute named 'SymbolTable::getSymbolAttrName()'.
 template <typename ConcreteType>

mlir/include/mlir/IR/TypeSupport.h

return ctx->getTypeUniquer().get<typename T::ImplType>(
         [&](TypeStorage *storage) {
           storage->initializeDialect(lookupDialectForType<T>(ctx));
         },
         kind, std::forward<Args>(args)...);
   }
 
 private:
   /// Get the dialect that the type 'T' was registered with.
-  template <typename T> static Dialect &lookupDialectForType(MLIRContext *ctx) {
+  template <typename T>
+  static Dialect &lookupDialectForType(MLIRContext *ctx) {
     return lookupDialectForType(ctx, T::getClassID());
   }
 
   /// Get the dialect that registered the type with the provided typeid.
   static Dialect &lookupDialectForType(MLIRContext *ctx,
                                        const ClassID *const typeID);
 };
 } // namespace detail
 
 } // end namespace mlir
 
 #endif

mlir/include/mlir/IR/Types.h

#include "DialectSymbolRegistry.def"
   Type &operator=(const Type &other) = default;
 
   bool operator==(Type other) const { return impl == other.impl; }
   bool operator!=(Type other) const { return !(*this == other); }
   explicit operator bool() const { return impl; }
 
   bool operator!() const { return impl == nullptr; }
 
-  template <typename U> bool isa() const;
-  template <typename U> U dyn_cast() const;
-  template <typename U> U dyn_cast_or_null() const;
-  template <typename U> U cast() const;
+  template <typename U>
+  bool isa() const;
+  template <typename U>
+  U dyn_cast() const;
+  template <typename U>
+  U dyn_cast_or_null() const;
+  template <typename U>
+  U cast() const;
 
   // Support type casting Type to itself.
   static bool classof(Type) { return true; }
 
   /// Return the classification for this type.
   unsigned getKind() const;
 
   /// Return the LLVMContext in which this type was uniqued.
public:
   static bool kindof(unsigned kind) { return kind == Kind::Opaque; }
 };
 
 // Make Type hashable.
 inline ::llvm::hash_code hash_value(Type arg) {
   return ::llvm::hash_value(arg.impl);
 }
 
-template <typename U> bool Type::isa() const {
+template <typename U>
+bool Type::isa() const {
   assert(impl && "isa<> used on a null type.");
   return U::classof(*this);
 }
-template <typename U> U Type::dyn_cast() const {
+template <typename U>
+U Type::dyn_cast() const {
   return isa<U>() ? U(impl) : U(nullptr);
 }
-template <typename U> U Type::dyn_cast_or_null() const {
+template <typename U>
+U Type::dyn_cast_or_null() const {
   return (impl && isa<U>()) ? U(impl) : U(nullptr);
 }
-template <typename U> U Type::cast() const {
+template <typename U>
+U Type::cast() const {
   assert(isa<U>());
   return U(impl);
 }
 
 } // end namespace mlir
 
 namespace llvm {
 
 // Type hash just like pointers.
-template <> struct DenseMapInfo<mlir::Type> {
+template <>
+struct DenseMapInfo<mlir::Type> {
   static mlir::Type getEmptyKey() {
     auto pointer = llvm::DenseMapInfo<void *>::getEmptyKey();
     return mlir::Type(static_cast<mlir::Type::ImplType *>(pointer));
   }
   static mlir::Type getTombstoneKey() {
     auto pointer = llvm::DenseMapInfo<void *>::getTombstoneKey();
     return mlir::Type(static_cast<mlir::Type::ImplType *>(pointer));
   }
   static unsigned getHashValue(mlir::Type val) { return mlir::hash_value(val); }
   static bool isEqual(mlir::Type LHS, mlir::Type RHS) { return LHS == RHS; }
 };
 
 /// We align TypeStorage by 8, so allow LLVM to steal the low bits.
-template <> struct PointerLikeTypeTraits<mlir::Type> {
+template <>
+struct PointerLikeTypeTraits<mlir::Type> {
 public:
   static inline void *getAsVoidPointer(mlir::Type I) {
     return const_cast<void *>(I.getAsOpaquePointer());
   }
   static inline mlir::Type getFromVoidPointer(void *P) {
     return mlir::Type::getFromOpaquePointer(P);
   }
   static constexpr int NumLowBitsAvailable = 3;
 };
 
 } // namespace llvm
 
 #endif // MLIR_IR_TYPES_H

mlir/include/mlir/IR/UseDefLists.h

 #include "llvm/ADT/PointerIntPair.h"
 #include "llvm/ADT/iterator_range.h"
 
 namespace mlir {
 
 class Block;
 class Operation;
 class Value;
-template <typename OperandType> class ValueUseIterator;
-template <typename OperandType> class FilteredValueUseIterator;
-template <typename UseIteratorT, typename OperandType> class ValueUserIterator;
+template <typename OperandType>
+class ValueUseIterator;
+template <typename OperandType>
+class FilteredValueUseIterator;
+template <typename UseIteratorT, typename OperandType>
+class ValueUserIterator;
 
 //===----------------------------------------------------------------------===//
 // IRObjectWithUseList
 //===----------------------------------------------------------------------===//
 
 /// This class represents a single IR object that contains a use list.
-template <typename OperandType> class IRObjectWithUseList {
+template <typename OperandType>
+class IRObjectWithUseList {
 public:
   ~IRObjectWithUseList() {
     assert(use_empty() && "Cannot destroy a value that still has uses!");
   }
 
   /// Drop all uses of this object from their respective owners.
   void dropAllUses() {
     while (!use_empty())

 protected:
   IRObjectWithUseList() {}
 
   /// Return the first operand that is using this value, for use by custom
   /// use/def iterators.
   OperandType *getFirstUse() const { return firstUse; }
 
 private:
-  template <typename DerivedT, typename IRValueTy> friend class IROperand;
+  template <typename DerivedT, typename IRValueTy>
+  friend class IROperand;
   OperandType *firstUse = nullptr;
 };
 
 //===----------------------------------------------------------------------===//
 // IRMultiObjectWithUseList
 //===----------------------------------------------------------------------===//
 
 /// This class represents multiple IR objects with a single use list. This class

 // IROperand
 //===----------------------------------------------------------------------===//
 
 /// A reference to a value, suitable for use as an operand of an operation.
 /// IRValueTy is the root type to use for values this tracks. Derived operand
 /// types are expected to provide the following:
 ///  * static IRObjectWithUseList *getUseList(IRValueTy value);
 ///    - Provide the use list that is attached to the given value.
-template <typename DerivedT, typename IRValueTy> class IROperand {
+template <typename DerivedT, typename IRValueTy>
+class IROperand {
 public:
   using ValueType = IRValueTy;
 
   IROperand(Operation *owner) : owner(owner) {}
   IROperand(Operation *owner, ValueType value) : value(value), owner(owner) {
     insertIntoCurrent();
   }
 

mlir/include/mlir/IR/Value.h

public:
   using ImplType = llvm::PointerIntPair<void *, 2, Kind, ImplTypeTraits>;
 
 public:
   constexpr Value(std::nullptr_t) : ownerAndKind() {}
   Value(ImplType ownerAndKind = {}) : ownerAndKind(ownerAndKind) {}
   Value(const Value &) = default;
   Value &operator=(const Value &) = default;
 
-  template <typename U> bool isa() const {
+  template <typename U>
+  bool isa() const {
     assert(*this && "isa<> used on a null type.");
     return U::classof(*this);
   }
-  template <typename U> U dyn_cast() const {
+  template <typename U>
+  U dyn_cast() const {
     return isa<U>() ? U(ownerAndKind) : U(nullptr);
   }
-  template <typename U> U dyn_cast_or_null() const {
+  template <typename U>
+  U dyn_cast_or_null() const {
     return (*this && isa<U>()) ? U(ownerAndKind) : U(nullptr);
   }
-  template <typename U> U cast() const {
+  template <typename U>
+  U cast() const {
     assert(isa<U>());
     return U(ownerAndKind);
   }
 
   operator bool() const { return ownerAndKind.getPointer(); }
   bool operator==(const Value &other) const {
     return ownerAndKind == other.ownerAndKind;
   }

 inline ::llvm::hash_code hash_value(Value arg) {
   return ::llvm::hash_value(arg.ownerAndKind.getOpaqueValue());
 }
 
 } // namespace mlir
 
 namespace llvm {
 
-template <> struct DenseMapInfo<mlir::Value> {
+template <>
+struct DenseMapInfo<mlir::Value> {
   static mlir::Value getEmptyKey() {
     auto pointer = llvm::DenseMapInfo<void *>::getEmptyKey();
     return mlir::Value::getFromOpaquePointer(pointer);
   }
   static mlir::Value getTombstoneKey() {
     auto pointer = llvm::DenseMapInfo<void *>::getTombstoneKey();
     return mlir::Value::getFromOpaquePointer(pointer);
   }
   static unsigned getHashValue(mlir::Value val) {
     return mlir::hash_value(val);
   }
   static bool isEqual(mlir::Value lhs, mlir::Value rhs) { return lhs == rhs; }
 };
 
 /// Allow stealing the low bits of a value.
-template <> struct PointerLikeTypeTraits<mlir::Value> {
+template <>
+struct PointerLikeTypeTraits<mlir::Value> {
 public:
   static inline void *getAsVoidPointer(mlir::Value I) {
     return const_cast<void *>(I.getAsOpaquePointer());
   }
   static inline mlir::Value getFromVoidPointer(void *P) {
     return mlir::Value::getFromOpaquePointer(P);
   }
   enum {
     NumLowBitsAvailable =
         PointerLikeTypeTraits<mlir::Value::ImplType>::NumLowBitsAvailable
   };
 };
 
-template <> struct DenseMapInfo<mlir::BlockArgument> {
+template <>
+struct DenseMapInfo<mlir::BlockArgument> {
   static mlir::BlockArgument getEmptyKey() {
     auto pointer = llvm::DenseMapInfo<void *>::getEmptyKey();
     return mlir::BlockArgument(
         mlir::Value::ImplType::getFromOpaqueValue(pointer));
   }
   static mlir::BlockArgument getTombstoneKey() {
     auto pointer = llvm::DenseMapInfo<void *>::getTombstoneKey();
     return mlir::BlockArgument(
         mlir::Value::ImplType::getFromOpaqueValue(pointer));
   }
   static unsigned getHashValue(mlir::BlockArgument val) {
     return mlir::hash_value(val);
   }
   static bool isEqual(mlir::BlockArgument LHS, mlir::BlockArgument RHS) {
     return LHS == RHS;
   }
 };
 
 /// Allow stealing the low bits of a value.
-template <> struct PointerLikeTypeTraits<mlir::BlockArgument> {
+template <>
+struct PointerLikeTypeTraits<mlir::BlockArgument> {
 public:
   static inline void *getAsVoidPointer(mlir::Value I) {
     return const_cast<void *>(I.getAsOpaquePointer());
   }
   static inline mlir::BlockArgument getFromVoidPointer(void *P) {
     return mlir::Value::getFromOpaquePointer(P).cast<mlir::BlockArgument>();
   }
   enum {
     NumLowBitsAvailable =
         PointerLikeTypeTraits<mlir::Value>::NumLowBitsAvailable
   };
 };
 } // end namespace llvm
 
 #endif

mlir/include/mlir/IR/Visitors.h

public:
   static WalkResult advance() { return {Advance}; }
 
   /// Returns if the walk was interrupted.
   bool wasInterrupted() const { return result == Interrupt; }
 };
 
 namespace detail {
 /// Helper templates to deduce the first argument of a callback parameter.
-template <typename Ret, typename Arg> Arg first_argument_type(Ret (*)(Arg));
+template <typename Ret, typename Arg>
+Arg first_argument_type(Ret (*)(Arg));
 template <typename Ret, typename F, typename Arg>
 Arg first_argument_type(Ret (F::*)(Arg));
 template <typename Ret, typename F, typename Arg>
 Arg first_argument_type(Ret (F::*)(Arg) const);
 template <typename F>
 decltype(first_argument_type(&F::operator())) first_argument_type(F);
 
 /// Type definition of the first argument to the given callable 'T'.

mlir/include/mlir/InitAllPasses.h

 #include "mlir/Conversion/GPUToSPIRV/ConvertGPUToSPIRVPass.h"
 #include "mlir/Conversion/GPUToVulkan/ConvertGPUToVulkanPass.h"
 #include "mlir/Conversion/LinalgToLLVM/LinalgToLLVM.h"
 #include "mlir/Conversion/LinalgToSPIRV/LinalgToSPIRVPass.h"
 #include "mlir/Conversion/LoopsToGPU/LoopsToGPUPass.h"
 #include "mlir/Conversion/StandardToSPIRV/ConvertStandardToSPIRVPass.h"
 #include "mlir/Dialect/Affine/Passes.h"
 #include "mlir/Dialect/FxpMathOps/Passes.h"
-#include "mlir/Dialect/FxpMathOps/Passes.h"
 #include "mlir/Dialect/GPU/Passes.h"
 #include "mlir/Dialect/LLVMIR/Transforms/LegalizeForExport.h"
 #include "mlir/Dialect/Linalg/Passes.h"
 #include "mlir/Dialect/LoopOps/Passes.h"
 #include "mlir/Dialect/Quant/Passes.h"
 #include "mlir/Dialect/SPIRV/Passes.h"
 #include "mlir/Quantizer/Transforms/Passes.h"
 #include "mlir/Transforms/LocationSnapshot.h"

mlir/include/mlir/Interfaces/SideEffects.h

public:
   protected:
     Base() : BaseEffect(BaseT::getEffectID()){};
   };
 
   /// Return the unique identifier for the base effects class.
   ClassID *getEffectID() const { return id; }
 
   /// Returns a unique instance for the given effect class.
-  template <typename DerivedEffect> static DerivedEffect *get() {
+  template <typename DerivedEffect>
+  static DerivedEffect *get() {
     static_assert(std::is_base_of<Effect, DerivedEffect>::value,
                   "expected DerivedEffect to inherit from Effect");
 
     static DerivedEffect instance;
     return &instance;
   }
 
 protected:

 struct DefaultResource : public Resource::Base<DefaultResource> {
   StringRef getName() final { return "<Default>"; }
 };
 
 /// This class represents a specific instance of an effect. It contains the
 /// effect being applied, a resource that corresponds to where the effect is
 /// applied, and an optional value(either operand, result, or region entry
 /// argument) that the effect is applied to.
-template <typename EffectT> class EffectInstance {
+template <typename EffectT>
+class EffectInstance {
 public:
   EffectInstance(EffectT *effect, Resource *resource = DefaultResource::get())
       : effect(effect), resource(resource) {}
   EffectInstance(EffectT *effect, Value value,
                  Resource *resource = DefaultResource::get())
       : effect(effect), resource(resource), value(value) {}
 
   /// Return the effect being applied.

mlir/include/mlir/Pass/AnalysisManager.h

public:
 
   /// Returns true if all analyses were marked preserved.
   bool isAll() const { return preservedIDs.count(&allAnalysesID); }
 
   /// Returns true if no analyses were marked preserved.
   bool isNone() const { return preservedIDs.empty(); }
 
   /// Preserve the given analyses.
-  template <typename AnalysisT> void preserve() {
+  template <typename AnalysisT>
+  void preserve() {
     preserve(AnalysisID::getID<AnalysisT>());
   }
   template <typename AnalysisT, typename AnalysisT2, typename... OtherAnalysesT>
   void preserve() {
     preserve<AnalysisT>();
     preserve<AnalysisT2, OtherAnalysesT...>();
   }
   void preserve(const AnalysisID *id) { preservedIDs.insert(id); }
 
   /// Returns if the given analysis has been marked as preserved. Note that this
   /// simply checks for the presence of a given analysis ID and should not be
   /// used as a general preservation checker.
-  template <typename AnalysisT> bool isPreserved() const {
+  template <typename AnalysisT>
+  bool isPreserved() const {
     return isPreserved(AnalysisID::getID<AnalysisT>());
   }
   bool isPreserved(const AnalysisID *id) const {
     return preservedIDs.count(id);
   }
 
 private:
   /// An identifier used to represent all potential analyses.
struct AnalysisConcept {
   /// set, returns true if it should truly be invalidated. This allows for more
   /// fine-tuned invalidation in cases where an analysis wasn't explicitly
   /// marked preserved, but may be preserved(or invalidated) based upon other
   /// properties such as analyses sets.
   virtual bool isInvalidated(const PreservedAnalyses &pa) = 0;
 };
 
 /// A derived analysis model used to hold a specific analysis object.
-template <typename AnalysisT> struct AnalysisModel : public AnalysisConcept {
+template <typename AnalysisT>
+struct AnalysisModel : public AnalysisConcept {
   template <typename... Args>
   explicit AnalysisModel(Args &&... args)
       : analysis(std::forward<Args>(args)...) {}
 
   /// A hook used to query analyses for invalidation.
   bool isInvalidated(const PreservedAnalyses &pa) final {
     return analysis_impl::isInvalidated(analysis, pa);
   }
 
   /// The actual analysis object.
   AnalysisT analysis;
 };
 
 /// This class represents a cache of analyses for a single operation. All
 /// computation, caching, and invalidation of analyses takes place here.
 class AnalysisMap {
   /// A mapping between an analysis id and an existing analysis instance.
   using ConceptMap =
       DenseMap<const AnalysisID *, std::unique_ptr<AnalysisConcept>>;
 
   /// Utility to return the name of the given analysis class.
-  template <typename AnalysisT> static StringRef getAnalysisName() {
+  template <typename AnalysisT>
+  static StringRef getAnalysisName() {
     StringRef name = llvm::getTypeName<AnalysisT>();
     if (!name.consume_front("mlir::"))
       name.consume_front("(anonymous namespace)::");
     return name;
   }
 
 public:
   explicit AnalysisMap(Operation *ir) : ir(ir) {}
 
   /// Get an analysis for the current IR unit, computing it if necessary.
-  template <typename AnalysisT> AnalysisT &getAnalysis(PassInstrumentor *pi) {
+  template <typename AnalysisT>
+  AnalysisT &getAnalysis(PassInstrumentor *pi) {
     auto *id = AnalysisID::getID<AnalysisT>();
 
     typename ConceptMap::iterator it;
     bool wasInserted;
     std::tie(it, wasInserted) = analyses.try_emplace(id);
 
     // If we don't have a cached analysis for this function, compute it directly
     // and add it to the cache.
while (auto *parentAM = curParent.dyn_cast<const AnalysisManager *>()) {
       if (parentAM->impl->getOperation() == parentOp)
         return parentAM->getCachedAnalysis<AnalysisT>();
       curParent = parentAM->parent;
     }
     return None;
   }
 
   // Query for the given analysis for the current operation.
-  template <typename AnalysisT> AnalysisT &getAnalysis() {
+  template <typename AnalysisT>
+  AnalysisT &getAnalysis() {
     return impl->analyses.getAnalysis<AnalysisT>(getPassInstrumentor());
   }
 
   // Query for a cached entry of the given analysis on the current operation.
   template <typename AnalysisT>
   Optional<std::reference_wrapper<AnalysisT>> getCachedAnalysis() const {
     return impl->analyses.getCachedAnalysis<AnalysisT>();
   }
 
   /// Query for a analysis of a child operation, constructing it if necessary.
-  template <typename AnalysisT> AnalysisT &getChildAnalysis(Operation *op) {
+  template <typename AnalysisT>
+  AnalysisT &getChildAnalysis(Operation *op) {
     return slice(op).template getAnalysis<AnalysisT>();
   }
 
   /// Query for a cached analysis of a child operation, or return null.
   template <typename AnalysisT>
   Optional<std::reference_wrapper<AnalysisT>>
   getCachedChildAnalysis(Operation *op) const {
     assert(op->getParentOp() == impl->getOperation());

mlir/include/mlir/Pass/Pass.h

 public:
   virtual ~Pass() = default;
 
   /// Returns the unique identifier that corresponds to this pass.
   const PassID *getPassID() const { return passID; }
 
   /// Returns the pass info for the specified pass class or null if unknown.
   static const PassInfo *lookupPassInfo(const PassID *passID);
-  template <typename PassT> static const PassInfo *lookupPassInfo() {
+  template <typename PassT>
+  static const PassInfo *lookupPassInfo() {
     return lookupPassInfo(PassID::getID<PassT>());
   }
 
   /// Returns the pass info for this pass.
   const PassInfo *lookupPassInfo() const { return lookupPassInfo(getPassID()); }
 
   /// Returns the derived pass name.
   virtual StringRef getName() = 0;
protected:
 
   /// Signal that some invariant was broken when running. The IR is allowed to
   /// be in an invalid state.
   void signalPassFailure() {
     this->getPassState().irAndPassFailed.setInt(true);
   }
 
   /// Query an analysis for the current ir unit.
-  template <typename AnalysisT> AnalysisT &getAnalysis() {
+  template <typename AnalysisT>
+  AnalysisT &getAnalysis() {
     return this->getAnalysisManager().template getAnalysis<AnalysisT>();
   }
 
   /// Query a cached instance of an analysis for the current ir unit if one
   /// exists.
   template <typename AnalysisT>
   Optional<std::reference_wrapper<AnalysisT>> getCachedAnalysis() {
     return this->getAnalysisManager().template getCachedAnalysis<AnalysisT>();
   }
 
   /// Mark all analyses as preserved.
   void markAllAnalysesPreserved() {
     this->getPassState().preservedAnalyses.preserveAll();
   }
 
   /// Mark the provided analyses as preserved.
-  template <typename... AnalysesT> void markAnalysesPreserved() {
+  template <typename... AnalysesT>
+  void markAnalysesPreserved() {
     this->getPassState().preservedAnalyses.template preserve<AnalysesT...>();
   }
   void markAnalysesPreserved(const AnalysisID *id) {
     this->getPassState().preservedAnalyses.preserve(id);
   }
 
   /// Returns the derived pass name.
   StringRef getName() override {
protected:
   Optional<std::reference_wrapper<AnalysisT>>
   getCachedChildAnalysis(Operation *child) {
     return this->getAnalysisManager()
         .template getCachedChildAnalysis<AnalysisT>(child);
   }
 
   /// Returns the analysis for the given child operation, or creates it if it
   /// doesn't exist.
-  template <typename AnalysisT> AnalysisT &getChildAnalysis(Operation *child) {
+  template <typename AnalysisT>
+  AnalysisT &getChildAnalysis(Operation *child) {
     return this->getAnalysisManager().template getChildAnalysis<AnalysisT>(
         child);
   }
 };
 } // end namespace detail
 
 /// Utility base class for OpPass below to denote an opaque pass operating on a
 /// specific operation type.
-template <typename OpT> class OpPassBase : public Pass {
+template <typename OpT>
+class OpPassBase : public Pass {
 public:
   using Pass::Pass;
 
   /// Support isa/dyn_cast functionality.
   static bool classof(const Pass *pass) {
     return pass->getOpName() == OpT::getOperationName();
   }
 };

 ///   - A 'void runOnOperation()' method.
 template <typename PassT>
 struct OperationPass<PassT, void> : public detail::PassModel<PassT, Pass> {};
 
 /// A model for providing function pass specific utilities.
 ///
 /// Derived function passes are expected to provide the following:
 ///   - A 'void runOnFunction()' method.
-template <typename T> struct FunctionPass : public OperationPass<T, FuncOp> {
+template <typename T>
+struct FunctionPass : public OperationPass<T, FuncOp> {
   /// The polymorphic API that runs the pass over the currently held function.
   virtual void runOnFunction() = 0;
 
   /// The polymorphic API that runs the pass over the currently held operation.
   void runOnOperation() final {
     if (!getFunction().isExternal())
       runOnFunction();
   }
 
   /// Return the current module being transformed.
   FuncOp getFunction() { return this->getOperation(); }
 };
 
 /// A model for providing module pass specific utilities.
 ///
 /// Derived module passes are expected to provide the following:
 ///   - A 'void runOnModule()' method.
-template <typename T> struct ModulePass : public OperationPass<T, ModuleOp> {
+template <typename T>
+struct ModulePass : public OperationPass<T, ModuleOp> {
   /// The polymorphic API that runs the pass over the currently held module.
   virtual void runOnModule() = 0;
 
   /// The polymorphic API that runs the pass over the currently held operation.
   void runOnOperation() final { runOnModule(); }
 
   /// Return the current module being transformed.
   ModuleOp getModule() { return this->getOperation(); }
 };
 } // end namespace mlir
 
 #endif // MLIR_PASS_PASS_H

mlir/include/mlir/Pass/PassInstrumentation.h

 
 private:
   std::unique_ptr<detail::PassInstrumentorImpl> impl;
 };
 
 } // end namespace mlir
 
 namespace llvm {
-template <> struct DenseMapInfo<mlir::PassInstrumentation::PipelineParentInfo> {
+template <>
+struct DenseMapInfo<mlir::PassInstrumentation::PipelineParentInfo> {
   using T = mlir::PassInstrumentation::PipelineParentInfo;
   using PairInfo = DenseMapInfo<std::pair<uint64_t, void *>>;
 
   static T getEmptyKey() {
     auto pair = PairInfo::getEmptyKey();
     return {pair.first, reinterpret_cast<mlir::Pass *>(pair.second)};
   }
   static T getTombstoneKey() {

mlir/include/mlir/Pass/PassManager.h

public:
 
   /// Run the held passes over the given operation.
   LogicalResult run(Operation *op, AnalysisManager am);
 
   /// Nest a new operation pass manager for the given operation kind under this
   /// pass manager.
   OpPassManager &nest(const OperationName &nestedName);
   OpPassManager &nest(StringRef nestedName);
-  template <typename OpT> OpPassManager &nest() {
+  template <typename OpT>
+  OpPassManager &nest() {
     return nest(OpT::getOperationName());
   }
 
   /// Add the given pass to this pass manager. If this pass has a concrete
   /// operation type, it must be the same type as this pass manager.
   void addPass(std::unique_ptr<Pass> pass);
 
   /// Add the given pass to a nested pass manager for the given operation kind
   /// `OpT`.
-  template <typename OpT> void addNestedPass(std::unique_ptr<Pass> pass) {
+  template <typename OpT>
+  void addNestedPass(std::unique_ptr<Pass> pass) {
     nest<OpT>().addPass(std::move(pass));
   }
 
   /// Returns the number of passes held by this manager.
   size_t size() const;
 
   /// Return an instance of the context.
   MLIRContext *getContext() const;

mlir/include/mlir/Pass/PassOptions.h

 ///
 /// Usage:
 ///
 /// struct MyPipelineOptions : PassPipelineOptions<MyPassOptions> {
 ///   ListOption<int> someListFlag{
 ///        *this, "flag-name", llvm::cl::MiscFlags::CommaSeparated,
 ///        llvm::cl::desc("...")};
 /// };
-template <typename T> class PassPipelineOptions : public detail::PassOptions {
+template <typename T>
+class PassPipelineOptions : public detail::PassOptions {
 public:
   /// Factory that parses the provided options and returns a unique_ptr to the
   /// struct.
   static std::unique_ptr<T> createFromString(StringRef options) {
     auto result = std::make_unique<T>();
     if (failed(result->parseFromString(options)))
       return nullptr;
     return result;
   }
 };
 
 /// A default empty option struct to be used for passes that do not need to take
 /// any options.
 struct EmptyPipelineOptions : public PassPipelineOptions<EmptyPipelineOptions> {
 };
 
 } // end namespace mlir
 
 #endif // MLIR_PASS_PASSOPTIONS_H_
-

mlir/include/mlir/Pass/PassRegistry.h

 /// optional and provides a callback to construct a pass that does not have
 /// a default constructor.
 ///
 /// Usage:
 ///
 ///   /// At namespace scope.
 ///   static PassRegistration<MyPass> reg("my-pass", "My Pass Description.");
 ///
-template <typename ConcretePass> struct PassRegistration {
+template <typename ConcretePass>
+struct PassRegistration {
   PassRegistration(StringRef arg, StringRef description,
                    const PassAllocatorFunction &constructor) {
     registerPass(arg, description, PassID::getID<ConcretePass>(), constructor);
   }
 
   PassRegistration(StringRef arg, StringRef description)
       : PassRegistration(arg, description,
                          [] { return std::make_unique<ConcretePass>(); }) {}
registerPassPipeline(
         [](function_ref<void(const detail::PassOptions &)> optHandler) {
           optHandler(Options());
         });
   }
 };
 
 /// Convenience specialization of PassPipelineRegistration for EmptyPassOptions
 /// that does not pass an empty options struct to the pass builder function.
-template <> struct PassPipelineRegistration<EmptyPipelineOptions> {
+template <>
+struct PassPipelineRegistration<EmptyPipelineOptions> {
   PassPipelineRegistration(StringRef arg, StringRef description,
                            std::function<void(OpPassManager &)> builder) {
     registerPassPipeline(
         arg, description,
         [builder](OpPassManager &pm, StringRef optionsStr) {
           if (!optionsStr.empty())
             return failure();
           builder(pm);

mlir/include/mlir/Quantizer/Support/ConstraintAnalysisGraph.h

public:
   iterator incoming_end() { return incoming.end(); }
 
   virtual void propagate(SolverContext &solverContext,
                          const TargetConfiguration &config) {}
 
   /// Prints the node label, suitable for one-line display.
   virtual void printLabel(raw_ostream &os) const;
 
-  template <typename T> void findChildrenOfKind(SmallVectorImpl<T *> &found) {
+  template <typename T>
+  void findChildrenOfKind(SmallVectorImpl<T *> &found) {
     for (CAGNode *child : *this) {
       T *ofKind = dyn_cast<T>(child);
       if (ofKind) {
         found.push_back(ofKind);
       }
     }
   }
 

mlir/include/mlir/Support/DebugStringHelper.h

 
 #include "llvm/ADT/Twine.h"
 #include "llvm/Support/raw_os_ostream.h"
 #include "llvm/Support/raw_ostream.h"
 
 namespace mlir {
 
 // Simple helper function that returns a string as printed from a op.
-template <typename T> static std::string debugString(T &op) {
+template <typename T>
+static std::string debugString(T &op) {
   std::string instr_str;
   llvm::raw_string_ostream os(instr_str);
   op.print(os);
   return os.str();
 }
 
 } // namespace mlir
 
 inline std::ostream &operator<<(std::ostream &out, const llvm::Twine &twine) {
   llvm::raw_os_ostream rout(out);
   rout << twine;
   return out;
 }
 
 #endif // MLIR_DEBUGSTRINGHELPER_H_

mlir/include/mlir/Support/LLVM.h

 #include "llvm/Support/Casting.h"
 
 // Forward declarations.
 namespace llvm {
 // Containers.
 class StringRef;
 class StringLiteral;
 class Twine;
-template <typename T> class SmallPtrSetImpl;
-template <typename T, unsigned N> class SmallPtrSet;
-template <typename T> class SmallVectorImpl;
-template <typename T, unsigned N> class SmallVector;
-template <unsigned N> class SmallString;
-template <typename T> class ArrayRef;
-template <typename T> class MutableArrayRef;
-template <typename T> class TinyPtrVector;
-template <typename T> class Optional;
-template <typename... PT> class PointerUnion;
+template <typename T>
+class SmallPtrSetImpl;
+template <typename T, unsigned N>
+class SmallPtrSet;
+template <typename T>
+class SmallVectorImpl;
+template <typename T, unsigned N>
+class SmallVector;
+template <unsigned N>
+class SmallString;
+template <typename T>
+class ArrayRef;
+template <typename T>
+class MutableArrayRef;
+template <typename T>
+class TinyPtrVector;
+template <typename T>
+class Optional;
+template <typename... PT>
+class PointerUnion;
 namespace detail {
-template <typename KeyT, typename ValueT> struct DenseMapPair;
+template <typename KeyT, typename ValueT>
+struct DenseMapPair;
 }
-template <typename T> struct DenseMapInfo;
-template <typename ValueT, typename ValueInfoT> class DenseSet;
+template <typename T>
+struct DenseMapInfo;
+template <typename ValueT, typename ValueInfoT>
+class DenseSet;
 template <typename KeyT, typename ValueT, typename KeyInfoT, typename BucketT>
 class DenseMap;
-template <typename Fn> class function_ref;
-template <typename IteratorT> class iterator_range;
+template <typename Fn>
+class function_ref;
+template <typename IteratorT>
+class iterator_range;
 
 // Other common classes.
 class raw_ostream;
 class APInt;
 class APFloat;
 } // end namespace llvm
 
 namespace mlir {

 using llvm::ArrayRef;
 using llvm::DenseMapInfo;
 template <typename KeyT, typename ValueT,
           typename KeyInfoT = DenseMapInfo<KeyT>,
           typename BucketT = llvm::detail::DenseMapPair<KeyT, ValueT>>
 using DenseMap = llvm::DenseMap<KeyT, ValueT, KeyInfoT, BucketT>;
 template <typename ValueT, typename ValueInfoT = DenseMapInfo<ValueT>>
 using DenseSet = llvm::DenseSet<ValueT, ValueInfoT>;
-template <typename Fn> using function_ref = llvm::function_ref<Fn>;
+template <typename Fn>
+using function_ref = llvm::function_ref<Fn>;
 using llvm::iterator_range;
 using llvm::MutableArrayRef;
 using llvm::None;
 using llvm::Optional;
 using llvm::PointerUnion;
 using llvm::SmallPtrSet;
 using llvm::SmallPtrSetImpl;
 using llvm::SmallString;

mlir/include/mlir/Support/STLExtras.h

inline void interleaveComma(const Container &c, raw_ostream &os) {
   interleaveComma(c, os, [&](const T &a) { os << a; });
 }
 
 /// A special type used to provide an address for a given class that can act as
 /// a unique identifier during pass registration.
 /// Note: We specify an explicit alignment here to allow use with PointerIntPair
 /// and other utilities/data structures that require a known pointer alignment.
 struct alignas(8) ClassID {
-  template <typename T> static ClassID *getID() {
+  template <typename T>
+  static ClassID *getID() {
     static ClassID id;
     return &id;
   }
-  template <template <typename T> class Trait> static ClassID *getID() {
+  template <template <typename T> class Trait>
+  static ClassID *getID() {
     static ClassID id;
     return &id;
   }
 };
 
 /// Utilities for detecting if a given trait holds for some set of arguments
 /// 'Args'. For example, the given trait could be used to detect if a given type
 /// has a copy assignment operator:
 ///   template<class T>
 ///   using has_copy_assign_t = decltype(std::declval<T&>()
 ///                                                 = std::declval<const T&>());
 ///   bool fooHasCopyAssign = is_detected<has_copy_assign_t, FooClass>::value;
 namespace detail {
-template <typename...> using void_t = void;
-template <class, template <class...> class Op, class... Args> struct detector {
+template <typename...>
+using void_t = void;
+template <class, template <class...> class Op, class... Args>
+struct detector {
   using value_t = std::false_type;
 };
 template <template <class...> class Op, class... Args>
 struct detector<void_t<Op<Args...>>, Op, Args...> {
   using value_t = std::true_type;
 };
 } // end namespace detail
 
public:
   iterator begin() const { return iterator(base, 0); }
   iterator end() const { return iterator(base, count); }
   ReferenceT operator[](unsigned index) const {
     assert(index < size() && "invalid index for value range");
     return DerivedT::dereference_iterator(base, index);
   }
 
   /// Compare this range with another.
-  template <typename OtherT> bool operator==(const OtherT &other) {
+  template <typename OtherT>
+  bool operator==(const OtherT &other) {
     return size() == llvm::size(other) &&
            std::equal(begin(), end(), other.begin());
   }
 
   /// Return the size of this range.
   size_t size() const { return count; }
 
   /// Return if the range is empty.
public:
   DerivedT take_back(size_t n = 1) const {
     return n < size() ? drop_front(size() - n)
                       : static_cast<const DerivedT &>(*this);
   }
 
   /// Allow conversion to SmallVector if necessary.
   /// TODO(riverriddle) Remove this when SmallVector accepts different range
   /// types in its constructor.
-  template <typename SVT, unsigned N> operator SmallVector<SVT, N>() const {
+  template <typename SVT, unsigned N>
+  operator SmallVector<SVT, N>() const {
     return {begin(), end()};
   }
 
 protected:
   indexed_accessor_range_base(const indexed_accessor_range_base &) = default;
   indexed_accessor_range_base(indexed_accessor_range_base &&) = default;
   indexed_accessor_range_base &
   operator=(const indexed_accessor_range_base &) = default;
public:
   static ReferenceT
   dereference_iterator(const std::pair<BaseT, ptrdiff_t> &base,
                        ptrdiff_t index) {
     return DerivedT::dereference(base.first, base.second + index);
   }
 };
 
 /// Given a container of pairs, return a range over the second elements.
-template <typename ContainerTy> auto make_second_range(ContainerTy &&c) {
+template <typename ContainerTy>
+auto make_second_range(ContainerTy &&c) {
   return llvm::map_range(
       std::forward<ContainerTy>(c),
       [](decltype((*std::begin(c))) elt) -> decltype((elt.second)) {
         return elt.second;
       });
 }
 
 /// A range class that repeats a specific value for a set number of times.

 
 /// Make a range that repeats the given value 'n' times.
 template <typename ValueTy>
 RepeatRange<ValueTy> make_repeated_range(const ValueTy &value, size_t n) {
   return RepeatRange<ValueTy>(value, n);
 }
 
 /// Returns true of the given range only contains a single element.
-template <typename ContainerTy> bool has_single_element(ContainerTy &&c) {
+template <typename ContainerTy>
+bool has_single_element(ContainerTy &&c) {
   auto it = std::begin(c), e = std::end(c);
   return it != e && std::next(it) == e;
 }
 
 //===----------------------------------------------------------------------===//
 //     Extra additions to <type_traits>
 //===----------------------------------------------------------------------===//
 
static inline unsigned llvm_combineHashValue(unsigned a, unsigned b) {
   key += (key << 3);
   key ^= (key >> 15);
   key += ~(key << 27);
   key ^= (key >> 31);
   return (unsigned)key;
 }
 
 namespace llvm {
-template <typename... Ts> struct DenseMapInfo<std::tuple<Ts...>> {
+template <typename... Ts>
+struct DenseMapInfo<std::tuple<Ts...>> {
   using Tuple = std::tuple<Ts...>;
 
   static inline Tuple getEmptyKey() {
     return Tuple(DenseMapInfo<Ts>::getEmptyKey()...);
   }
 
   static inline Tuple getTombstoneKey() {
     return Tuple(DenseMapInfo<Ts>::getTombstoneKey()...);

mlir/include/mlir/Support/StorageUniquer.h

public:
   };
 
   /// This is a utility allocator used to allocate memory for instances of
   /// derived types.
   class StorageAllocator {
   public:
     /// Copy the specified array of elements into memory managed by our bump
     /// pointer allocator.  This assumes the elements are all PODs.
-    template <typename T> ArrayRef<T> copyInto(ArrayRef<T> elements) {
+    template <typename T>
+    ArrayRef<T> copyInto(ArrayRef<T> elements) {
       if (elements.empty())
         return llvm::None;
       auto result = allocator.Allocate<T>(elements.size());
       std::uninitialized_copy(elements.begin(), elements.end(), result);
       return ArrayRef<T>(result, elements.size());
     }
 
     /// Copy the provided string into memory managed by our bump pointer
     /// allocator.
     StringRef copyInto(StringRef str) {
       auto result = copyInto(ArrayRef<char>(str.data(), str.size()));
       return StringRef(result.data(), str.size());
     }
 
     /// Allocate an instance of the provided type.
-    template <typename T> T *allocate() { return allocator.Allocate<T>(); }
+    template <typename T>
+    T *allocate() {
+      return allocator.Allocate<T>();
+    }
 
     /// Allocate 'size' bytes of 'alignment' aligned memory.
     void *allocate(size_t size, size_t alignment) {
       return allocator.Allocate(size, alignment);
     }
 
   private:
     /// The raw allocator for type storage objects.

mlir/include/mlir/TableGen/Format.h

public:
 
   std::string str() const {
     std::string result;
     llvm::raw_string_ostream s(result);
     format(s);
     return s.str();
   }
 
-  template <unsigned N> SmallString<N> sstr() const {
+  template <unsigned N>
+  SmallString<N> sstr() const {
     SmallString<N> result;
     llvm::raw_svector_ostream s(result);
     format(s);
     return result;
   }
 
-  template <unsigned N> operator SmallString<N>() const { return sstr<N>(); }
+  template <unsigned N>
+  operator SmallString<N>() const {
+    return sstr<N>();
+  }
 
   operator std::string() const { return str(); }
 };
 
-template <typename Tuple> class FmtObject : public FmtObjectBase {
+template <typename Tuple>
+class FmtObject : public FmtObjectBase {
   // Storage for the parameter adapters.  Since the base class erases the type
   // of the parameters, we have to own the storage for the parameters here, and
   // have the base class store type-erased pointers into this tuple.
   Tuple parameters;
 
 public:
   FmtObject(StringRef fmt, const FmtContext *ctx, Tuple &&params)
       : FmtObjectBase(fmt, ctx, std::tuple_size<Tuple>::value),

mlir/include/mlir/Transforms/DialectConversion.h

public:
   virtual ~ConversionTarget() = default;
 
   //===--------------------------------------------------------------------===//
   // Legality Registration
   //===--------------------------------------------------------------------===//
 
   /// Register a legality action for the given operation.
   void setOpAction(OperationName op, LegalizationAction action);
-  template <typename OpT> void setOpAction(LegalizationAction action) {
+  template <typename OpT>
+  void setOpAction(LegalizationAction action) {
     setOpAction(OperationName(OpT::getOperationName(), &ctx), action);
   }
 
   /// Register the given operations as legal.
-  template <typename OpT> void addLegalOp() {
+  template <typename OpT>
+  void addLegalOp() {
     setOpAction<OpT>(LegalizationAction::Legal);
   }
-  template <typename OpT, typename OpT2, typename... OpTs> void addLegalOp() {
+  template <typename OpT, typename OpT2, typename... OpTs>
+  void addLegalOp() {
     addLegalOp<OpT>();
     addLegalOp<OpT2, OpTs...>();
   }
 
   /// Register the given operation as dynamically legal, i.e. requiring custom
   /// handling by the target via 'isDynamicallyLegal'.
-  template <typename OpT> void addDynamicallyLegalOp() {
+  template <typename OpT>
+  void addDynamicallyLegalOp() {
     setOpAction<OpT>(LegalizationAction::Dynamic);
   }
   template <typename OpT, typename OpT2, typename... OpTs>
   void addDynamicallyLegalOp() {
     addDynamicallyLegalOp<OpT>();
     addDynamicallyLegalOp<OpT2, OpTs...>();
   }
 
public:
   typename std::enable_if<!is_invocable<Callable, Operation *>::value>::type
   addDynamicallyLegalOp(Callable &&callback) {
     addDynamicallyLegalOp<OpT>(
         [=](Operation *op) { return callback(cast<OpT>(op)); });
   }
 
   /// Register the given operation as illegal, i.e. this operation is known to
   /// not be supported by this target.
-  template <typename OpT> void addIllegalOp() {
+  template <typename OpT>
+  void addIllegalOp() {
     setOpAction<OpT>(LegalizationAction::Illegal);
   }
-  template <typename OpT, typename OpT2, typename... OpTs> void addIllegalOp() {
+  template <typename OpT, typename OpT2, typename... OpTs>
+  void addIllegalOp() {
     addIllegalOp<OpT>();
     addIllegalOp<OpT2, OpTs...>();
   }
 
   /// Mark an operation, that *must* have either been set as `Legal` or
   /// `DynamicallyLegal`, as being recursively legal. This means that in
   /// addition to the operation itself, all of the operations nested within are
   /// also considered legal. An optional dynamic legality callback may be
void setDialectAction(ArrayRef<StringRef> dialectNames,
                         LegalizationAction action);
 
   /// Register the operations of the given dialects as legal.
   template <typename... Names>
   void addLegalDialect(StringRef name, Names... names) {
     SmallVector<StringRef, 2> dialectNames({name, names...});
     setDialectAction(dialectNames, LegalizationAction::Legal);
   }
-  template <typename... Args> void addLegalDialect() {
+  template <typename... Args>
+  void addLegalDialect() {
     SmallVector<StringRef, 2> dialectNames({Args::getDialectNamespace()...});
     setDialectAction(dialectNames, LegalizationAction::Legal);
   }
 
   /// Register the operations of the given dialects as dynamically legal, i.e.
   /// requiring custom handling by the target via 'isDynamicallyLegal'.
   template <typename... Names>
   void addDynamicallyLegalDialect(StringRef name, Names... names) {
public:
 
   /// Register the operations of the given dialects as illegal, i.e.
   /// operations of this dialect are not supported by the target.
   template <typename... Names>
   void addIllegalDialect(StringRef name, Names... names) {
     SmallVector<StringRef, 2> dialectNames({name, names...});
     setDialectAction(dialectNames, LegalizationAction::Illegal);
   }
-  template <typename... Args> void addIllegalDialect() {
+  template <typename... Args>
+  void addIllegalDialect() {
     SmallVector<StringRef, 2> dialectNames({Args::getDialectNamespace()...});
     setDialectAction(dialectNames, LegalizationAction::Illegal);
   }
 
   //===--------------------------------------------------------------------===//
   // Legality Querying
   //===--------------------------------------------------------------------===//
 

mlir/include/mlir/Transforms/Passes.h

 #include <limits>
 
 namespace mlir {
 
 class AffineForOp;
 class FuncOp;
 class ModuleOp;
 class Pass;
-template <typename T> class OpPassBase;
+template <typename T>
+class OpPassBase;
 
 /// Creates an instance of the Canonicalizer pass.
 std::unique_ptr<Pass> createCanonicalizerPass();
 
 /// Creates a pass to perform common sub expression elimination.
 std::unique_ptr<Pass> createCSEPass();
 
 /// Creates a loop fusion pass which fuses loops. Buffers of size less than or

mlir/include/mlir/Transforms/ViewOpGraph.h

 
 #include "mlir/Support/LLVM.h"
 #include "llvm/Support/GraphWriter.h"
 #include "llvm/Support/raw_ostream.h"
 
 namespace mlir {
 class Block;
 class ModuleOp;
-template <typename T> class OpPassBase;
+template <typename T>
+class OpPassBase;
 
 /// Displays the graph in a window. This is for use from the debugger and
 /// depends on Graphviz to generate the graph.
 void viewGraph(Block &block, const Twine &name, bool shortNames = false,
                const Twine &title = "",
                llvm::GraphProgram::Name program = llvm::GraphProgram::DOT);
 
 raw_ostream &writeGraph(raw_ostream &os, Block &block, bool shortNames = false,

mlir/include/mlir/Transforms/ViewRegionGraph.h

 #define MLIR_TRANSFORMS_VIEWFUNCTIONGRAPH_H_
 
 #include "mlir/Support/LLVM.h"
 #include "llvm/Support/GraphWriter.h"
 #include "llvm/Support/raw_ostream.h"
 
 namespace mlir {
 class FuncOp;
-template <typename T> class OpPassBase;
+template <typename T>
+class OpPassBase;
 class Region;
 
 /// Displays the CFG in a window. This is for use from the debugger and
 /// depends on Graphviz to generate the graph.
 void viewGraph(Region &region, const Twine &name, bool shortNames = false,
                const Twine &title = "",
                llvm::GraphProgram::Name program = llvm::GraphProgram::DOT);
 

mlir/lib/Analysis/Liveness.cpp

bool updateLiveIn() {
 
     inValues = newIn;
     return true;
   }
 
   /// Updates live-out information of the current block.
   /// It iterates over all successors and unifies their live-in
   /// values with the current live-out values.
-  template <typename SourceT> void updateLiveOut(SourceT &source) {
+  template <typename SourceT>
+  void updateLiveOut(SourceT &source) {
     for (Block *succ : block->getSuccessors()) {
       BlockInfoBuilder &builder = source[succ];
       llvm::set_union(outValues, builder.inValues);
     }
   }
 
   /// The current block.
   Block *block;

mlir/lib/Conversion/AffineToStandard/AffineToStandard.cpp

 public:
   /// This internal class expects arguments to be non-null, checks must be
   /// performed at the call site.
   AffineApplyExpander(OpBuilder &builder, ValueRange dimValues,
                       ValueRange symbolValues, Location loc)
       : builder(builder), dimValues(dimValues), symbolValues(symbolValues),
         loc(loc) {}
 
-  template <typename OpTy> Value buildBinaryExpr(AffineBinaryOpExpr expr) {
+  template <typename OpTy>
+  Value buildBinaryExpr(AffineBinaryOpExpr expr) {
     auto lhs = visit(expr.getLHS());
     auto rhs = visit(expr.getRHS());
     if (!lhs || !rhs)
       return nullptr;
     auto op = builder.create<OpTy>(loc, lhs, rhs);
     return op.getResult();
   }
 

mlir/lib/Conversion/GPUToCUDA/ConvertLaunchFuncToCudaCalls.cpp

 public:
   // Run the dialect converter on the module.
   void runOnModule() override {
     // Cache the LLVMDialect for the current module.
     llvmDialect = getContext().getRegisteredDialect<LLVM::LLVMDialect>();
     // Cache the used LLVM types.
     initializeCachedTypes();
 
-    getModule().walk([this](mlir::gpu::LaunchFuncOp op) {
-      translateGpuLaunchCalls(op);
-    });
+    getModule().walk(
+        [this](mlir::gpu::LaunchFuncOp op) { translateGpuLaunchCalls(op); });
 
     // GPU kernel modules are no longer necessary since we have a global
     // constant with the CUBIN data.
     for (auto m :
          llvm::make_early_inc_range(getModule().getOps<gpu::GPUModuleOp>()))
       m.erase();
   }
 

mlir/lib/Conversion/GPUToNVVM/LowerGpuOpsToNVVMOps.cpp

 
 #include "../GPUCommon/IndexIntrinsicsOpLowering.h"
 #include "../GPUCommon/OpToFuncCallLowering.h"
 
 using namespace mlir;
 
 namespace {
 
-
 struct GPUShuffleOpLowering : public ConvertToLLVMPattern {
   explicit GPUShuffleOpLowering(LLVMTypeConverter &lowering_)
       : ConvertToLLVMPattern(gpu::ShuffleOp::getOperationName(),
                              lowering_.getDialect()->getContext(), lowering_) {}
 
   /// Lowers a shuffle to the corresponding NVVM op.
   ///
   /// Convert the `width` argument into an activeMask (a bitmask which specifies

mlir/lib/Conversion/GPUToVulkan/ConvertGPULaunchFuncToVulkanLaunchFunc.cpp

if (auto memRefType = type.dyn_cast_or_null<MemRefType>())
       return memRefType.hasRank() && memRefType.getRank() == 1;
     return false;
   }
 
   /// Declares the vulkan launch function. Returns an error if the any type of
   /// operand is unsupported by Vulkan runtime.
   LogicalResult declareVulkanLaunchFunc(Location loc,
                                         gpu::LaunchFuncOp launchOp);
-
 };
 
 } // anonymous namespace
 
 void ConvertGpuLaunchFuncToVulkanLaunchFunc::runOnModule() {
   bool done = false;
   getModule().walk([this, &done](gpu::LaunchFuncOp op) {
     if (done) {

mlir/lib/Conversion/LinalgToLLVM/LinalgToLLVM.cpp

LogicalResult matchAndRewrite(LinalgOp op,
     rewriter.replaceOpWithNewOp<mlir::CallOp>(
         op, libraryCallName.getValue(), ArrayRef<Type>{}, op.getOperands());
     return success();
   }
 };
 
 /// Conversion pattern specialization for CopyOp. This kicks in when both input
 /// and output permutations are left unspecified or are the identity.
-template <> class LinalgOpConversion<CopyOp> : public OpRewritePattern<CopyOp> {
+template <>
+class LinalgOpConversion<CopyOp> : public OpRewritePattern<CopyOp> {
 public:
   using OpRewritePattern<CopyOp>::OpRewritePattern;
 
   LogicalResult matchAndRewrite(CopyOp op,
                                 PatternRewriter &rewriter) const override {
     auto inputPerm = op.inputPermutation();
     if (inputPerm.hasValue() && !inputPerm->isIdentity())
       return failure();

mlir/lib/Conversion/StandardToLLVM/StandardToLLVM.cpp

 //===- StandardToLLVM.cpp - Standard to LLVM dialect conversion -----------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements a pass to convert MLIR standard and builtin dialects
 // into the LLVM IR dialect.
 //
 //===----------------------------------------------------------------------===//
 
-#include "mlir/Conversion/StandardToLLVM/ConvertStandardToLLVM.h"
 #include "mlir/ADT/TypeSwitch.h"
+#include "mlir/Conversion/StandardToLLVM/ConvertStandardToLLVM.h"
 #include "mlir/Conversion/StandardToLLVM/ConvertStandardToLLVMPass.h"
 #include "mlir/Dialect/LLVMIR/LLVMDialect.h"
 #include "mlir/Dialect/StandardOps/IR/Ops.h"
 #include "mlir/IR/Attributes.h"
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/MLIRContext.h"
 #include "mlir/IR/Module.h"
 #include "mlir/IR/PatternMatch.h"

mlir/lib/Dialect/AVX512/IR/AVX512Dialect.cpp

 #include "mlir/Dialect/AVX512/AVX512.cpp.inc"
       >();
 }
 
 namespace mlir {
 namespace avx512 {
 #define GET_OP_CLASSES
 #include "mlir/Dialect/AVX512/AVX512.cpp.inc"
-}  // namespace avx512
+} // namespace avx512
 } // namespace mlir
-

mlir/lib/Dialect/Affine/IR/AffineOps.cpp

 #include "mlir/Dialect/Affine/IR/AffineOps.cpp.inc"
                 >();
   addInterfaces<AffineInlinerInterface>();
 }
 
 /// Materialize a single constant operation from a given attribute value with
 /// the desired resultant type.
 Operation *AffineDialect::materializeConstant(OpBuilder &builder,
-                                                 Attribute value, Type type,
-                                                 Location loc) {
   return builder.create<ConstantOp>(loc, type, value);
 }
 
 /// A utility function to check if a given region is attached to a function.
 static bool isFunctionRegion(Region *region) {
   return llvm::isa<FuncOp>(region->getParentOp());
 }
 

mlir/lib/Dialect/Affine/Transforms/SimplifyAffineStructures.cpp

 //===- SimplifyAffineStructures.cpp ---------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements a pass to simplify affine structures.
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Analysis/AffineStructures.h"
-#include "mlir/IR/IntegerSet.h"
-#include "mlir/Pass/Pass.h"
-#include "mlir/Dialect/Affine/IR/AffineValueMap.h"
 #include "mlir/Dialect/Affine/IR/AffineOps.h"
+#include "mlir/Dialect/Affine/IR/AffineValueMap.h"
 #include "mlir/Dialect/Affine/Passes.h"
 #include "mlir/Dialect/StandardOps/IR/Ops.h"
+#include "mlir/IR/IntegerSet.h"
+#include "mlir/Pass/Pass.h"
 #include "mlir/Transforms/Utils.h"
 
 #define DEBUG_TYPE "simplify-affine-structure"
 
 using namespace mlir;
 
 namespace {
 

mlir/lib/Dialect/FxpMathOps/Transforms/UniformKernelUtils.h

for (unsigned checkWidth : checkWidths) {
     if (w == checkWidth)
       return true;
   }
   return false;
 }
 
 /// Computes the log2(x), rounded to an integral value. Returns whether 'x' can
 /// be considered an exact integral value.
-template <typename F> bool integralLog2(F x, int &log2Result) {
+template <typename F>
+bool integralLog2(F x, int &log2Result) {
   const F xLog2 = std::log(x) * (1.0 / std::log(2.0));
   const F xLog2Rounded = std::round(xLog2);
   const F xLog2Frac = xLog2 - xLog2Rounded;
   log2Result = static_cast<int>(xLog2Rounded);
   // Allow small comparison slop below the level that would make a difference
   // for 2^16 levels.
   return std::abs(xLog2Frac) < 1e-6;
 }

mlir/lib/Dialect/GPU/IR/GPUDialect.cpp

auto walkResult = module.walk([&module](LaunchFuncOp launchOp) -> WalkResult {
     }
 
     return success();
   });
 
   return walkResult.wasInterrupted() ? failure() : success();
 }
 
-template <typename T> static LogicalResult verifyIndexOp(T op) {
+template <typename T>
+static LogicalResult verifyIndexOp(T op) {
   auto dimension = op.dimension();
   if (dimension != "x" && dimension != "y" && dimension != "z")
     return op.emitError("dimension \"") << dimension << "\" is invalid";
   return success();
 }
 
 static LogicalResult verifyAllReduce(gpu::AllReduceOp allReduce) {
   if (allReduce.body().empty() != allReduce.op().hasValue())

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

void rewrite() {
     create<gpu::BarrierOp>();
     Value result = create<LoadOp>(valueType, buffer, zero);
 
     rewriter.replaceOp(reduceOp, result);
   }
 
 private:
   // Shortcut to create an op from rewriter using loc as the first argument.
-  template <typename T, typename... Args> T create(Args... args) {
+  template <typename T, typename... Args>
+  T create(Args... args) {
     return rewriter.create<T>(loc, std::forward<Args>(args)...);
   }
 
   // Creates dimension op of type T, with the result casted to int32.
-  template <typename T> Value getDimOp(StringRef dimension) {
+  template <typename T>
+  Value getDimOp(StringRef dimension) {
     Value dim = create<T>(indexType, rewriter.getStringAttr(dimension));
     return create<IndexCastOp>(int32Type, dim);
   }
 
   /// Adds type to funcOp's workgroup attributions.
   Value createWorkgroupBuffer() {
     int workgroupMemoryAddressSpace = 3;
     auto bufferType =
if (opName == "min") {
       return isFloatingPoint
                  ? getCmpFactory<CmpFOp, CmpFPredicate, CmpFPredicate::ULT>()
                  : getCmpFactory<CmpIOp, CmpIPredicate, CmpIPredicate::ult>();
     }
     return AccumulatorFactory();
   }
 
   /// Returns an accumulator factory that creates an op of type T.
-  template <typename T> AccumulatorFactory getFactory() {
+  template <typename T>
+  AccumulatorFactory getFactory() {
     return [&](Value lhs, Value rhs) {
       return create<T>(lhs.getType(), lhs, rhs);
     };
   }
 
   /// Returns an accumulator for comparaison such as min, max. T is the type
   /// of the compare op.
   template <typename T, typename PredicateEnum, PredicateEnum predicate>

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

static int parseOptionalKeywordAlternative(OpAsmParser &parser,
   for (auto en : llvm::enumerate(keywords)) {
     if (succeeded(parser.parseOptionalKeyword(en.value())))
       return en.index();
   }
   return -1;
 }
 
 namespace {
-template <typename Ty> struct EnumTraits {};
+template <typename Ty>
+struct EnumTraits {};
 
 #define REGISTER_ENUM_TYPE(Ty)                                                 \
-  template <> struct EnumTraits<Ty> {                                          \
+  template <>                                                                  \
+  struct EnumTraits<Ty> {                                                      \
     static StringRef stringify(Ty value) { return stringify##Ty(value); }      \
     static unsigned getMaxEnumVal() { return getMaxEnumValFor##Ty(); }         \
   }
 
 REGISTER_ENUM_TYPE(Linkage);
 } // end namespace
 
 template <typename EnumTy>

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

 }
 
 namespace mlir {
 namespace NVVM {
 #define GET_OP_CLASSES
 #include "mlir/Dialect/LLVMIR/NVVMOps.cpp.inc"
 } // namespace NVVM
 } // namespace mlir
-

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

 }
 
 namespace mlir {
 namespace ROCDL {
 #define GET_OP_CLASSES
 #include "mlir/Dialect/LLVMIR/ROCDLOps.cpp.inc"
 } // namespace ROCDL
 } // namespace mlir
-

mlir/lib/Dialect/Linalg/Analysis/DependenceAnalysis.cpp

for (auto dstView : dst.getInputs()) {   // R
       if (aliases.alias(srcView, dstView)) { // if alias, fill RAW
         addDependenceElem(DependenceType::RAW,
                           LinalgOpView{src.getOperation(), srcView},
                           LinalgOpView{dst.getOperation(), dstView});
       }
     }
     // WAW graph
     for (auto dstView : dst.getOutputBuffers()) { // W
-      if (aliases.alias(srcView, dstView)) { // if alias, fill WAW
+      if (aliases.alias(srcView, dstView)) {      // if alias, fill WAW
         addDependenceElem(DependenceType::WAW,
                           LinalgOpView{src.getOperation(), srcView},
                           LinalgOpView{dst.getOperation(), dstView});
       }
     }
   }
   for (auto srcView : src.getInputs()) { // R
     // RAR graph
     for (auto dstView : dst.getInputs()) {   // R
       if (aliases.alias(srcView, dstView)) { // if alias, fill RAR
         addDependenceElem(DependenceType::RAR,
                           LinalgOpView{src.getOperation(), srcView},
                           LinalgOpView{dst.getOperation(), dstView});
       }
     }
     // WAR graph
     for (auto dstView : dst.getOutputBuffers()) { // W
-      if (aliases.alias(srcView, dstView)) { // if alias, fill WAR
+      if (aliases.alias(srcView, dstView)) {      // if alias, fill WAR
         addDependenceElem(DependenceType::WAR,
                           LinalgOpView{src.getOperation(), srcView},
                           LinalgOpView{dst.getOperation(), dstView});
       }
     }
   }
 }
 

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

if (!tensorResultTypes.empty())
     result.addTypes(tensorResultTypes);
   return parser.resolveOperands(operandsInfo, operandTypes,
                                 parser.getCurrentLocation(), result.operands);
 }
 
 template <typename GenericOpType>
 static LogicalResult verifyBlockArgs(GenericOpType op, Block &block);
 
-template <> LogicalResult verifyBlockArgs(GenericOp op, Block &block) {
+template <>
+LogicalResult verifyBlockArgs(GenericOp op, Block &block) {
   auto nOperands = op.getNumOperands();
   if (block.getNumArguments() != nOperands)
     return op.emitOpError("expected number of block arguments to match number "
                           "of operands");
 
   // Note: the number and type of yield values are checked in the YieldOp.
   auto nInputViews = op.getNumInputs();
   for (unsigned i = 0; i < nOperands; ++i) {
     auto viewType = op.getShapedType(i);
     if (viewType.getElementType() != block.getArgument(i).getType())
       return op.emitOpError("expected block argument ")
              << (i + 1) << " of the same type as elemental type of "
              << ((i < nInputViews) ? "input " : "output ")
              << "operand: " << viewType;
   }
   return success();
 }
 
-template <> LogicalResult verifyBlockArgs(IndexedGenericOp op, Block &block) {
+template <>
+LogicalResult verifyBlockArgs(IndexedGenericOp op, Block &block) {
   auto nInputViews = op.getNumInputs();
   auto nLoops = op.getNumLoops();
   auto nOperands = op.getNumOperands();
   if (block.getNumArguments() != nOperands + nLoops)
     return op.emitOpError(
         "expected number of block arguments to match number of operands + "
         "number of loops");
 
for (unsigned idx = 0; idx < nOutputs; ++idx) {
     if (funType.getResult(idx) != shapedType.getElementType())
       return op.emitOpError("expected function result ")
              << (idx + 1) << " of the same type as elemental type "
              << shapedType.getElementType() << " of output " << (idx + 1);
   }
   return success();
 }
 
-template <> LogicalResult verifyFuncArgs(GenericOp op, FunctionType funType) {
+template <>
+LogicalResult verifyFuncArgs(GenericOp op, FunctionType funType) {
   auto nOperands = op.getNumOperands();
   if (funType.getNumInputs() != nOperands)
     return op.emitOpError(
         "expected function arguments to match number of operands");
   if (funType.getNumResults() != op.getNumOutputs())
     return op.emitOpError("expected function results(")
            << funType.getNumResults() << ") to match number of outputs("
            << op.getNumOutputs() << ")";

mlir/lib/Dialect/LoopOps/LoopOps.cpp

 }
 
 //===----------------------------------------------------------------------===//
 // IfOp
 //===----------------------------------------------------------------------===//
 
 void IfOp::build(Builder *builder, OperationState &result, Value cond,
                  bool withElseRegion) {
-    build(builder, result, /*resultTypes=*/llvm::None, cond, withElseRegion);
 }
 
 void IfOp::build(Builder *builder, OperationState &result,
                  TypeRange resultTypes, Value cond, bool withElseRegion) {
   result.addOperands(cond);
   result.addTypes(resultTypes);
 
   Region *thenRegion = result.addRegion();

mlir/lib/Dialect/SPIRV/SPIRVCanonicalization.cpp

return std::next(block->begin()) == block->end() &&
            isa<spirv::BranchConditionalOp>(block->front());
   }
 
   bool isSameAttrList(spirv::StoreOp lhs, spirv::StoreOp rhs) const {
     return lhs.getOperation()->getAttrList().getDictionary() ==
            rhs.getOperation()->getAttrList().getDictionary();
   }
 
-
   // Returns a source value for the given block.
   Value getSrcValue(Block *block) const {
     auto storeOp = cast<spirv::StoreOp>(block->front());
     return storeOp.value();
   }
 
   // Returns a destination value for the given block.
   Value getDstPtr(Block *block) const {

mlir/lib/Dialect/SPIRV/SPIRVTypes.cpp

default:
     llvm_unreachable("invalid composite type");
   }
 }
 
 //===----------------------------------------------------------------------===//
 // ImageType
 //===----------------------------------------------------------------------===//
 
-template <typename T> static constexpr unsigned getNumBits() { return 0; }
-template <> constexpr unsigned getNumBits<Dim>() {
+template <typename T>
+static constexpr unsigned getNumBits() {
+  return 0;
+}
+template <>
+constexpr unsigned getNumBits<Dim>() {
   static_assert((1 << 3) > getMaxEnumValForDim(),
                 "Not enough bits to encode Dim value");
   return 3;
 }
-template <> constexpr unsigned getNumBits<ImageDepthInfo>() {
+template <>
+constexpr unsigned getNumBits<ImageDepthInfo>() {
   static_assert((1 << 2) > getMaxEnumValForImageDepthInfo(),
                 "Not enough bits to encode ImageDepthInfo value");
   return 2;
 }
-template <> constexpr unsigned getNumBits<ImageArrayedInfo>() {
+template <>
+constexpr unsigned getNumBits<ImageArrayedInfo>() {
   static_assert((1 << 1) > getMaxEnumValForImageArrayedInfo(),
                 "Not enough bits to encode ImageArrayedInfo value");
   return 1;
 }
-template <> constexpr unsigned getNumBits<ImageSamplingInfo>() {
+template <>
+constexpr unsigned getNumBits<ImageSamplingInfo>() {
   static_assert((1 << 1) > getMaxEnumValForImageSamplingInfo(),
                 "Not enough bits to encode ImageSamplingInfo value");
   return 1;
 }
-template <> constexpr unsigned getNumBits<ImageSamplerUseInfo>() {
+template <>
+constexpr unsigned getNumBits<ImageSamplerUseInfo>() {
   static_assert((1 << 2) > getMaxEnumValForImageSamplerUseInfo(),
                 "Not enough bits to encode ImageSamplerUseInfo value");
   return 2;
 }
-template <> constexpr unsigned getNumBits<ImageFormat>() {
+template <>
+constexpr unsigned getNumBits<ImageFormat>() {
   static_assert((1 << 6) > getMaxEnumValForImageFormat(),
                 "Not enough bits to encode ImageFormat value");
   return 6;
 }
 
 struct spirv::detail::ImageTypeStorage : public TypeStorage {
 private:
   /// Define a bit-field struct to pack the enum values

mlir/lib/Dialect/SPIRV/Serialization/Deserializer.cpp

private:
   LogicalResult
   dispatchToExtensionSetAutogenDeserialization(StringRef extensionSetName,
                                                uint32_t instructionID,
                                                ArrayRef<uint32_t> words);
 
   /// Method to deserialize an operation in the SPIR-V dialect that is a mirror
   /// of an instruction in the SPIR-V spec. This is auto generated if hasOpcode
   /// == 1 and autogenSerialization == 1 in ODS.
-  template <typename OpTy> LogicalResult processOp(ArrayRef<uint32_t> words) {
+  template <typename OpTy>
+  LogicalResult processOp(ArrayRef<uint32_t> words) {
     return emitError(unknownLoc, "unsupported deserialization for ")
            << OpTy::getOperationName() << " op";
   }
 
 private:
   /// The SPIR-V binary module.
   ArrayRef<uint32_t> binary;
 
LogicalResult Deserializer::processConstantNull(ArrayRef<uint32_t> operands) {
   if (resultType.isIntOrFloat() || resultType.isa<VectorType>()) {
     auto attr = opBuilder.getZeroAttr(resultType);
     // For normal constants, we just record the attribute (and its type) for
     // later materialization at use sites.
     constantMap.try_emplace(resultID, attr, resultType);
     return success();
   }
 
-    return emitError(unknownLoc, "unsupported OpConstantNull type: ")
-           << resultType;
 }
 
 //===----------------------------------------------------------------------===//
 // Control flow
 //===----------------------------------------------------------------------===//
 
 Block *Deserializer::getOrCreateBlock(uint32_t id) {
   if (auto *block = getBlock(id)) {

mlir/lib/Dialect/SPIRV/Serialization/Serializer.cpp

 
 /// Encodes an SPIR-V instruction with the given `opcode` and `operands` into
 /// the given `binary` vector.
 static LogicalResult encodeInstructionInto(SmallVectorImpl<uint32_t> &binary,
                                            spirv::Opcode op,
                                            ArrayRef<uint32_t> operands) {
   uint32_t wordCount = 1 + operands.size();
   binary.push_back(spirv::getPrefixedOpcode(wordCount, op));
-    binary.append(operands.begin(), operands.end());
   return success();
 }
 
 /// A pre-order depth-first visitor function for processing basic blocks.
 ///
 /// Visits the basic blocks starting from the given `headerBlock` in pre-order
 /// depth-first manner and calls `blockHandler` on each block. Skips handling
 /// blocks in the `skipBlocks` list. If `skipHeader` is true, `blockHandler`
private:
   /// SPIR-V dialect that is a mirror of an instruction in the SPIR-V spec.
   /// This is auto-generated from ODS. Dispatch is handled for all operations
   /// in SPIR-V dialect that have hasOpcode == 1.
   LogicalResult dispatchToAutogenSerialization(Operation *op);
 
   /// Method to serialize an operation in the SPIR-V dialect that is a mirror of
   /// an instruction in the SPIR-V spec. This is auto generated if hasOpcode ==
   /// 1 and autogenSerialization == 1 in ODS.
-  template <typename OpTy> LogicalResult processOp(OpTy op) {
+  template <typename OpTy>
+  LogicalResult processOp(OpTy op) {
     return op.emitError("unsupported op serialization");
   }
 
   //===--------------------------------------------------------------------===//
   // Utilities
   //===--------------------------------------------------------------------===//
 
   /// Emits an OpDecorate instruction to decorate the given `target` with the

mlir/lib/Dialect/Vector/VectorOps.cpp

 #define GET_OP_LIST
 #include "mlir/Dialect/Vector/VectorOps.cpp.inc"
       >();
 }
 
 /// Materialize a single constant operation from a given attribute value with
 /// the desired resultant type.
 Operation *VectorDialect::materializeConstant(OpBuilder &builder,
-                                                 Attribute value, Type type,
-                                                 Location loc) {
   return builder.create<ConstantOp>(loc, type, value);
 }
 
 IntegerType vector::getVectorSubscriptType(Builder &builder) {
   return builder.getIntegerType(64);
 }
 
 ArrayAttr vector::getVectorSubscriptAttr(Builder &builder,

mlir/lib/Pass/IRPrinting.cpp

public:
   bool operator==(const OperationFingerPrint &other) const {
     return hash == other.hash;
   }
   bool operator!=(const OperationFingerPrint &other) const {
     return !(*this == other);
   }
 
 private:
-  template <typename T> void addDataToHash(llvm::SHA1 &hasher, const T &data) {
+  template <typename T>
+  void addDataToHash(llvm::SHA1 &hasher, const T &data) {
     hasher.update(
         ArrayRef<uint8_t>(reinterpret_cast<const uint8_t *>(&data), sizeof(T)));
   }
 
   SmallString<20> hash;
 };
 
 //===----------------------------------------------------------------------===//

mlir/lib/Transforms/Utils/GreedyPatternRewriteDriver.cpp

for (auto result : op->getResults())
         addToWorklist(user);
   }
 
 private:
   // Look over the provided operands for any defining operations that should
   // be re-added to the worklist. This function should be called when an
   // operation is modified or removed, as it may trigger further
   // simplifications.
-  template <typename Operands> void addToWorklist(Operands &&operands) {
+  template <typename Operands>
+  void addToWorklist(Operands &&operands) {
     for (Value operand : operands) {
       // If the use count of this operand is now < 2, we re-add the defining
       // operation to the worklist.
       // TODO(riverriddle) This is based on the fact that zero use operations
       // may be deleted, and that single use values often have more
       // canonicalization opportunities.
       if (!operand.use_empty() && !operand.hasOneUse())
         continue;

mlir/lib/Transforms/ViewOpGraph.cpp

static llvm::cl::opt<int> elideIfLarger(
     llvm::cl::init(16));
 
 using namespace mlir;
 
 namespace llvm {
 
 // Specialize GraphTraits to treat Block as a graph of Operations as nodes and
 // uses as edges.
-template <> struct GraphTraits<Block *> {
+template <>
+struct GraphTraits<Block *> {
   using GraphType = Block *;
   using NodeRef = Operation *;
 
   using ChildIteratorType = Operation::user_iterator;
   static ChildIteratorType child_begin(NodeRef n) { return n->user_begin(); }
   static ChildIteratorType child_end(NodeRef n) { return n->user_end(); }
 
   // Operation's destructor is private so use Operation* instead and use
   // mapped iterator.
   static Operation *AddressOf(Operation &op) { return &op; }
   using nodes_iterator = mapped_iterator<Block::iterator, decltype(&AddressOf)>;
   static nodes_iterator nodes_begin(Block *b) {
     return nodes_iterator(b->begin(), &AddressOf);
   }
   static nodes_iterator nodes_end(Block *b) {
     return nodes_iterator(b->end(), &AddressOf);
   }
 };
 
 // Specialize DOTGraphTraits to produce more readable output.
-template <> struct DOTGraphTraits<Block *> : public DefaultDOTGraphTraits {
+template <>
+struct DOTGraphTraits<Block *> : public DefaultDOTGraphTraits {
   using DefaultDOTGraphTraits::DefaultDOTGraphTraits;
   static std::string getNodeLabel(Operation *op, Block *);
 };
 
 std::string DOTGraphTraits<Block *>::getNodeLabel(Operation *op, Block *b) {
   // Reuse the print output for the node labels.
   std::string ostr;
   raw_string_ostream os(ostr);

mlir/lib/Transforms/ViewRegionGraph.cpp

 #include "mlir/IR/RegionGraphTraits.h"
 #include "mlir/Pass/Pass.h"
 
 using namespace mlir;
 
 namespace llvm {
 
 // Specialize DOTGraphTraits to produce more readable output.
-template <> struct DOTGraphTraits<Region *> : public DefaultDOTGraphTraits {
+template <>
+struct DOTGraphTraits<Region *> : public DefaultDOTGraphTraits {
   using DefaultDOTGraphTraits::DefaultDOTGraphTraits;
 
   static std::string getNodeLabel(Block *Block, Region *);
 };
 
 std::string DOTGraphTraits<Region *>::getNodeLabel(Block *Block, Region *) {
   // Reuse the print output for the node labels.
   std::string outStreamStr;

mlir/test/lib/IR/TestMatchers.cpp

 namespace {
 /// This is a test pass for verifying matchers.
 struct TestMatchers : public FunctionPass<TestMatchers> {
   void runOnFunction() override;
 };
 } // end anonymous namespace
 
 // This could be done better but is not worth the variadic template trouble.
-template <typename Matcher> unsigned countMatches(FuncOp f, Matcher &matcher) {
+template <typename Matcher>
+unsigned countMatches(FuncOp f, Matcher &matcher) {
   unsigned count = 0;
   f.walk([&count, &matcher](Operation *op) {
     if (matcher.match(op))
       ++count;
   });
   return count;
 }
 

mlir/test/lib/Transforms/TestVectorToLoopsConversion.cpp

 #include "mlir/IR/PatternMatch.h"
 #include "mlir/Pass/Pass.h"
 #include "mlir/Transforms/Passes.h"
 
 using namespace mlir;
 
 namespace {
 
-struct TestVectorToLoopsPass
-    : public FunctionPass<TestVectorToLoopsPass> {
+struct TestVectorToLoopsPass : public FunctionPass<TestVectorToLoopsPass> {
   void runOnFunction() override {
     OwningRewritePatternList patterns;
     auto *context = &getContext();
     populateVectorToAffineLoopsConversionPatterns(context, patterns);
     applyPatternsGreedily(getFunction(), patterns);
   }
 };
 

mlir/tools/mlir-cpu-runner/mlir-cpu-runner.cpp

 //===- mlir-cpu-runner.cpp - MLIR CPU Execution Driver---------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // Main entry point to a command line utility that executes an MLIR file on the
 // CPU by  translating MLIR to LLVM IR before JIT-compiling and executing the
 // latter.
 //
 //===----------------------------------------------------------------------===//
 
+#include "mlir/ExecutionEngine/OptUtils.h"
 #include "mlir/InitAllDialects.h"
 #include "mlir/Support/JitRunner.h"
 #include "llvm/Support/InitLLVM.h"
 #include "llvm/Support/TargetSelect.h"
-#include "mlir/ExecutionEngine/OptUtils.h"
 
 int main(int argc, char **argv) {
   mlir::registerAllDialects();
   llvm::InitLLVM y(argc, argv);
   llvm::InitializeNativeTarget();
   llvm::InitializeNativeTargetAsmPrinter();
   mlir::initializeLLVMPasses();
 
   return mlir::JitRunnerMain(argc, argv, nullptr);
 }

mlir/tools/mlir-cuda-runner/cuda-runtime-wrappers.cpp

 // Allows to register byte array with the CUDA runtime. Helpful until we have
 // transfer functions implemented.
 extern "C" void mcuMemHostRegister(void *ptr, uint64_t sizeBytes) {
   reportErrorIfAny(cuMemHostRegister(ptr, sizeBytes, /*flags=*/0),
                    "MemHostRegister");
 }
 
 // A struct that corresponds to how MLIR represents memrefs.
-template <typename T, int N> struct MemRefType {
+template <typename T, int N>
+struct MemRefType {
   T *basePtr;
   T *data;
   int64_t offset;
   int64_t sizes[N];
   int64_t strides[N];
 };
 
 // Allows to register a MemRef with the CUDA runtime. Initializes array with

mlir/tools/mlir-opt/mlir-opt.cpp

 //===- mlir-opt.cpp - MLIR Optimizer Driver -------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // Main entry function for mlir-opt for when built as standalone binary.
 //
 //===----------------------------------------------------------------------===//
 
-#include "mlir/InitAllDialects.h"
-#include "mlir/InitAllPasses.h"
 #include "mlir/IR/Dialect.h"
 #include "mlir/IR/MLIRContext.h"
+#include "mlir/InitAllDialects.h"
+#include "mlir/InitAllPasses.h"
 #include "mlir/Pass/Pass.h"
 #include "mlir/Pass/PassManager.h"
 #include "mlir/Support/FileUtilities.h"
 #include "mlir/Support/MlirOptMain.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/InitLLVM.h"
 #include "llvm/Support/SourceMgr.h"
 #include "llvm/Support/ToolOutputFile.h"
int main(int argc, char **argv) {
   // Register any pass manager command line options.
   registerPassManagerCLOptions();
   PassPipelineCLParser passPipeline("", "Compiler passes to run");
 
   // Parse pass names in main to ensure static initialization completed.
   cl::ParseCommandLineOptions(argc, argv, "MLIR modular optimizer driver\n");
 
   MLIRContext context;
-  if(showDialects) {
+  if (showDialects) {
     llvm::outs() << "Registered Dialects:\n";
-    for(Dialect *dialect : context.getRegisteredDialects()) {
+    for (Dialect *dialect : context.getRegisteredDialects()) {
       llvm::outs() << dialect->getNamespace() << "\n";
     }
     return 0;
   }
 
   // Set up the input file.
   std::string errorMessage;
   auto file = openInputFile(inputFilename, &errorMessage);

mlir/tools/mlir-tblgen/OpFormatGen.cpp

 }
 
 //===----------------------------------------------------------------------===//
 // FormatParser
 //===----------------------------------------------------------------------===//
 
 /// Function to find an element within the given range that has the same name as
 /// 'name'.
-template <typename RangeT> static auto findArg(RangeT &&range, StringRef name) {
+template <typename RangeT>
+static auto findArg(RangeT &&range, StringRef name) {
   auto it = llvm::find_if(range, [=](auto &arg) { return arg.name == name; });
   return it != range.end() ? &*it : nullptr;
 }
 
 namespace {
 /// This class implements a parser for an instance of an operation assembly
 /// format.
 class FormatParser {

mlir/tools/mlir-tblgen/RewriterGen.cpp

 
 using llvm::formatv;
 using llvm::Record;
 using llvm::RecordKeeper;
 
 #define DEBUG_TYPE "mlir-tblgen-rewritergen"
 
 namespace llvm {
-template <> struct format_provider<mlir::tblgen::Pattern::IdentifierLine> {
+template <>
+struct format_provider<mlir::tblgen::Pattern::IdentifierLine> {
   static void format(const mlir::tblgen::Pattern::IdentifierLine &v,
                      raw_ostream &os, StringRef style) {
     os << v.first << ":" << v.second;
   }
 };
 } // end namespace llvm
 
 //===----------------------------------------------------------------------===//

mlir/tools/mlir-vulkan-runner/VulkanRuntime.cpp

vkFreeCommandBuffers(device, commandPool, commandBuffers.size(),
                        commandBuffers.data());
   vkDestroyQueryPool(device, queryPool, nullptr);
   vkDestroyCommandPool(device, commandPool, nullptr);
   vkFreeDescriptorSets(device, descriptorPool, descriptorSets.size(),
                        descriptorSets.data());
   vkDestroyDescriptorPool(device, descriptorPool, nullptr);
   vkDestroyPipeline(device, pipeline, nullptr);
   vkDestroyPipelineLayout(device, pipelineLayout, nullptr);
-  for (auto &descriptorSetLayout: descriptorSetLayouts) {
+  for (auto &descriptorSetLayout : descriptorSetLayouts) {
     vkDestroyDescriptorSetLayout(device, descriptorSetLayout, nullptr);
   }
   vkDestroyShaderModule(device, shaderModule, nullptr);
 
   // For each descriptor set.
   for (auto &deviceMemoryBufferMapPair : deviceMemoryBufferMap) {
     auto &deviceMemoryBuffers = deviceMemoryBufferMapPair.second;
     // For each descirptor binding.

mlir/unittests/ADT/TypeSwitchTest.cpp

 using namespace mlir;
 
 namespace {
 /// Utility classes to setup casting functionality.
 struct Base {
   enum Kind { DerivedA, DerivedB, DerivedC, DerivedD, DerivedE };
   Kind kind;
 };
-template <Base::Kind DerivedKind> struct DerivedImpl : Base {
+template <Base::Kind DerivedKind>
+struct DerivedImpl : Base {
   DerivedImpl() : Base{DerivedKind} {}
   static bool classof(const Base *base) { return base->kind == DerivedKind; }
 };
 struct DerivedA : public DerivedImpl<Base::DerivedA> {};
 struct DerivedB : public DerivedImpl<Base::DerivedB> {};
 struct DerivedC : public DerivedImpl<Base::DerivedC> {};
 struct DerivedD : public DerivedImpl<Base::DerivedD> {};
 struct DerivedE : public DerivedImpl<Base::DerivedE> {};