[mlir][IR][NFC] Move context/location parameters of builtin Type::get methods to the start of the parameter list

[rriddle]

Summary

This better matches the rest of the infrastructure, is much simpler, and makes it easier to move these types to being declaratively specified.

[mehdi_amini]

Nice cleanup!

flang/include/flang/Optimizer/Dialect/FIROps.td

let printer = [{
     if (arg_operand_begin() != arg_operand_end()) {
       p << ", ";
       p.printOperands(args());
     }
     p << ')';
     p.printOptionalAttrDict(getAttrs(), {"fn_type", "method"});
     auto resTy{getResultTypes()};
     llvm::SmallVector<mlir::Type, 8> argTy(getOperandTypes());
-    p << " : " << mlir::FunctionType::get(argTy, resTy, getContext());
+    p << " : " << mlir::FunctionType::get(getContext(), argTy, resTy);
   }];
 
   let extraClassDeclaration = [{
     mlir::FunctionType getFunctionType();
     operand_range getArgOperands() {
       return {arg_operand_begin(), arg_operand_end()};
     }
     operand_iterator arg_operand_begin() { return operand_begin() + 1; }

flang/lib/Lower/ConvertType.cpp

 }
 
 // two argument template
 template <Fortran::common::TypeCategory TC, int KIND>
 mlir::Type genFIRType(mlir::MLIRContext *context) {
   if constexpr (TC == Fortran::common::TypeCategory::Integer) {
     auto bits{Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer,
                                       KIND>::Scalar::bits};
-    return mlir::IntegerType::get(bits, context);
+    return mlir::IntegerType::get(context, bits);
   } else if constexpr (TC == Fortran::common::TypeCategory::Logical ||
                        TC == Fortran::common::TypeCategory::Character ||
                        TC == Fortran::common::TypeCategory::Complex) {
     return genFIRType<TC>(context, KIND);
   } else {
     return {};
   }
 }
private:
 
   template <typename A>
   mlir::Type gen(const Fortran::evaluate::Relational<A> &) {
     return genFIRType<Fortran::common::TypeCategory::Logical, 1>(context);
   }
 
   // some sequence of `n` bytes
   mlir::Type gen(const Fortran::evaluate::StaticDataObject::Pointer &ptr) {
-    mlir::Type byteTy{mlir::IntegerType::get(8, context)};
+    mlir::Type byteTy{mlir::IntegerType::get(context, 8)};
     return fir::SequenceType::get(trivialShape(ptr->itemBytes()), byteTy);
   }
 
   mlir::Type gen(const Fortran::evaluate::Substring &ss) {
     return genVariant(ss.GetBaseObject());
   }
 
   mlir::Type gen(const Fortran::evaluate::NullPointer &) {

flang/lib/Lower/IntrinsicCall.cpp

 static constexpr RuntimeFunction pgmathPrecise[] = {
 #define PGMATH_PRECISE
 #define PGMATH_USE_ALL_TYPES(name, func) RUNTIME_STATIC_DESCRIPTION(name, func)
 #include "../runtime/pgmath.h.inc"
 };
 
 static mlir::FunctionType genF32F32FuncType(mlir::MLIRContext *context) {
   auto t = mlir::FloatType::getF32(context);
-  return mlir::FunctionType::get({t}, {t}, context);
+  return mlir::FunctionType::get(context, {t}, {t});
 }
 
 static mlir::FunctionType genF64F64FuncType(mlir::MLIRContext *context) {
   auto t = mlir::FloatType::getF64(context);
-  return mlir::FunctionType::get({t}, {t}, context);
+  return mlir::FunctionType::get(context, {t}, {t});
 }
 
 template <int Bits>
 static mlir::FunctionType genIntF64FuncType(mlir::MLIRContext *context) {
   auto t = mlir::FloatType::getF64(context);
-  auto r = mlir::IntegerType::get(Bits, context);
-  return mlir::FunctionType::get({t}, {r}, context);
+  auto r = mlir::IntegerType::get(context, Bits);
+  return mlir::FunctionType::get(context, {t}, {r});
 }
 
 template <int Bits>
 static mlir::FunctionType genIntF32FuncType(mlir::MLIRContext *context) {
   auto t = mlir::FloatType::getF32(context);
-  auto r = mlir::IntegerType::get(Bits, context);
-  return mlir::FunctionType::get({t}, {r}, context);
+  auto r = mlir::IntegerType::get(context, Bits);
+  return mlir::FunctionType::get(context, {t}, {r});
 }
 
 // TODO : Fill-up this table with more intrinsic.
 // Note: These are also defined as operations in LLVM dialect. See if this
 // can be use and has advantages.
 static constexpr RuntimeFunction llvmIntrinsics[] = {
     {"abs", "llvm.fabs.f32", genF32F32FuncType},
     {"abs", "llvm.fabs.f64", genF64F64FuncType},

 
 /// Helpers to get function type from arguments and result type.
 static mlir::FunctionType
 getFunctionType(mlir::Type resultType, llvm::ArrayRef<mlir::Value> arguments,
                 Fortran::lower::FirOpBuilder &builder) {
   llvm::SmallVector<mlir::Type, 2> argumentTypes;
   for (auto &arg : arguments)
     argumentTypes.push_back(arg.getType());
-  return mlir::FunctionType::get(argumentTypes, resultType,
-                                 builder.getModule().getContext());
+  return mlir::FunctionType::get(builder.getModule().getContext(),
+                                 argumentTypes, resultType);
 }
 
 /// fir::ExtendedValue to mlir::Value translation layer
 
 fir::ExtendedValue toExtendedValue(mlir::Value val,
                                    Fortran::lower::FirOpBuilder &builder,
                                    mlir::Location loc) {
   assert(val && "optional unhandled here");
IntrinsicLibrary::genLenTrim(mlir::Type resultType,
   return builder.createConvert(loc, resultType, len);
 }
 
 // MERGE
 mlir::Value IntrinsicLibrary::genMerge(mlir::Type,
                                        llvm::ArrayRef<mlir::Value> args) {
   assert(args.size() == 3);
 
-  auto i1Type = mlir::IntegerType::get(1, builder.getContext());
+  auto i1Type = mlir::IntegerType::get(builder.getContext(), 1);
   auto mask = builder.createConvert(loc, i1Type, args[2]);
   return builder.create<mlir::SelectOp>(loc, mask, args[0], args[1]);
 }
 
 // MOD
 mlir::Value IntrinsicLibrary::genMod(mlir::Type resultType,
                                      llvm::ArrayRef<mlir::Value> args) {
   assert(args.size() == 2);

flang/lib/Lower/RTBuilder.h

 ///
 /// For example, when `T` is `int`, return a function that returns the MLIR
 /// standard type `i32` when `sizeof(int)` is 4.
 template <typename T>
 static constexpr TypeBuilderFunc getModel();
 template <>
 constexpr TypeBuilderFunc getModel<int>() {
   return [](mlir::MLIRContext *context) -> mlir::Type {
-    return mlir::IntegerType::get(8 * sizeof(int), context);
+    return mlir::IntegerType::get(context, 8 * sizeof(int));
   };
 }
 template <>
 constexpr TypeBuilderFunc getModel<int &>() {
   return [](mlir::MLIRContext *context) -> mlir::Type {
     TypeBuilderFunc f{getModel<int>()};
     return fir::ReferenceType::get(f(context));
   };
 }
 template <>
 constexpr TypeBuilderFunc getModel<Fortran::runtime::io::Iostat>() {
   return [](mlir::MLIRContext *context) -> mlir::Type {
-    return mlir::IntegerType::get(8 * sizeof(Fortran::runtime::io::Iostat),
-                                  context);
+    return mlir::IntegerType::get(context,
+                                  8 * sizeof(Fortran::runtime::io::Iostat));
   };
 }
 template <>
 constexpr TypeBuilderFunc getModel<char *>() {
   return [](mlir::MLIRContext *context) -> mlir::Type {
-    return fir::ReferenceType::get(mlir::IntegerType::get(8, context));
+    return fir::ReferenceType::get(mlir::IntegerType::get(context, 8));
   };
 }
 template <>
 constexpr TypeBuilderFunc getModel<const char *>() {
   return getModel<char *>();
 }
 template <>
 constexpr TypeBuilderFunc getModel<const char16_t *>() {
   return [](mlir::MLIRContext *context) -> mlir::Type {
-    return fir::ReferenceType::get(mlir::IntegerType::get(16, context));
+    return fir::ReferenceType::get(mlir::IntegerType::get(context, 16));
   };
 }
 template <>
 constexpr TypeBuilderFunc getModel<const char32_t *>() {
   return [](mlir::MLIRContext *context) -> mlir::Type {
-    return fir::ReferenceType::get(mlir::IntegerType::get(32, context));
+    return fir::ReferenceType::get(mlir::IntegerType::get(context, 32));
   };
 }
 template <>
 constexpr TypeBuilderFunc getModel<void **>() {
   return [](mlir::MLIRContext *context) -> mlir::Type {
     return fir::ReferenceType::get(
-        fir::PointerType::get(mlir::IntegerType::get(8, context)));
+        fir::PointerType::get(mlir::IntegerType::get(context, 8)));
   };
 }
 template <>
 constexpr TypeBuilderFunc getModel<std::int64_t>() {
   return [](mlir::MLIRContext *context) -> mlir::Type {
-    return mlir::IntegerType::get(64, context);
+    return mlir::IntegerType::get(context, 64);
   };
 }
 template <>
 constexpr TypeBuilderFunc getModel<std::int64_t &>() {
   return [](mlir::MLIRContext *context) -> mlir::Type {
     TypeBuilderFunc f{getModel<std::int64_t>()};
     return fir::ReferenceType::get(f(context));
   };
 }
 template <>
 constexpr TypeBuilderFunc getModel<std::size_t>() {
   return [](mlir::MLIRContext *context) -> mlir::Type {
-    return mlir::IntegerType::get(8 * sizeof(std::size_t), context);
+    return mlir::IntegerType::get(context, 8 * sizeof(std::size_t));
   };
 }
 template <>
 constexpr TypeBuilderFunc getModel<Fortran::runtime::io::IoStatementState *>() {
   return getModel<char *>();
 }
 template <>
 constexpr TypeBuilderFunc getModel<double>() {
constexpr TypeBuilderFunc getModel<float &>() {
   return [](mlir::MLIRContext *context) -> mlir::Type {
     TypeBuilderFunc f{getModel<float>()};
     return fir::ReferenceType::get(f(context));
   };
 }
 template <>
 constexpr TypeBuilderFunc getModel<bool>() {
   return [](mlir::MLIRContext *context) -> mlir::Type {
-    return mlir::IntegerType::get(1, context);
+    return mlir::IntegerType::get(context, 1);
   };
 }
 template <>
 constexpr TypeBuilderFunc getModel<bool &>() {
   return [](mlir::MLIRContext *context) -> mlir::Type {
     TypeBuilderFunc f{getModel<bool>()};
     return fir::ReferenceType::get(f(context));
   };
struct RuntimeTableKey<RT(ATs...)> {
   static constexpr FuncTypeBuilderFunc getTypeModel() {
     return [](mlir::MLIRContext *ctxt) {
       TypeBuilderFunc ret = getModel<RT>();
       std::array<TypeBuilderFunc, sizeof...(ATs)> args = {getModel<ATs>()...};
       mlir::Type retTy = ret(ctxt);
       llvm::SmallVector<mlir::Type, sizeof...(ATs)> argTys;
       for (auto f : args)
         argTys.push_back(f(ctxt));
-      return mlir::FunctionType::get(argTys, {retTy}, ctxt);
+      return mlir::FunctionType::get(ctxt, argTys, {retTy});
     };
   }
 };
 
 //===----------------------------------------------------------------------===//
 // Runtime table building (constexpr folded)
 //===----------------------------------------------------------------------===//
 

flang/lib/Optimizer/Dialect/FIROps.cpp

 // BoxDimsOp
 //===----------------------------------------------------------------------===//
 
 /// Get the result types packed in a tuple tuple
 mlir::Type fir::BoxDimsOp::getTupleType() {
   // note: triple, but 4 is nearest power of 2
   llvm::SmallVector<mlir::Type, 4> triple{
       getResult(0).getType(), getResult(1).getType(), getResult(2).getType()};
-  return mlir::TupleType::get(triple, getContext());
+  return mlir::TupleType::get(getContext(), triple);
 }
 
 //===----------------------------------------------------------------------===//
 // CallOp
 //===----------------------------------------------------------------------===//
 
 static void printCallOp(mlir::OpAsmPrinter &p, fir::CallOp &op) {
   auto callee = op.callee();
   bool isDirect = callee.hasValue();
   p << op.getOperationName() << ' ';
   if (isDirect)
     p << callee.getValue();
   else
     p << op.getOperand(0);
   p << '(' << op->getOperands().drop_front(isDirect ? 0 : 1) << ')';
   p.printOptionalAttrDict(op.getAttrs(), {fir::CallOp::calleeAttrName()});
   auto resultTypes{op.getResultTypes()};
   llvm::SmallVector<Type, 8> argTypes(
       llvm::drop_begin(op.getOperandTypes(), isDirect ? 0 : 1));
-  p << " : " << FunctionType::get(argTypes, resultTypes, op.getContext());
+  p << " : " << FunctionType::get(op.getContext(), argTypes, resultTypes);
 }
 
 static mlir::ParseResult parseCallOp(mlir::OpAsmParser &parser,
                                      mlir::OperationState &result) {
   llvm::SmallVector<mlir::OpAsmParser::OperandType, 8> operands;
   if (parser.parseOperandList(operands))
     return mlir::failure();
 
fir::GlobalOp fir::createGlobalOp(mlir::Location loc, mlir::ModuleOp module,
   mlir::OpBuilder modBuilder(module.getBodyRegion());
   return modBuilder.create<fir::GlobalOp>(loc, name, type, attrs);
 }
 
 // Tablegen operators
 
 #define GET_OP_CLASSES
 #include "flang/Optimizer/Dialect/FIROps.cpp.inc"
-

mlir/include/mlir/Dialect/AVX512/AVX512.td

 
 class AVX512_Op<string mnemonic, list<OpTrait> traits = []> :
   Op<AVX512_Dialect, mnemonic, traits> {}
 
 def MaskRndScaleOp : AVX512_Op<"mask.rndscale", [NoSideEffect,
   AllTypesMatch<["src", "a", "dst"]>,
   TypesMatchWith<"imm has the same number of bits as elements in dst",
                  "dst", "imm",
-                 "IntegerType::get(($_self.cast<VectorType>().getShape()[0]),"
-                 "  $_self.getContext())">]> {
+                 "IntegerType::get($_self.getContext(), "
+                 "($_self.cast<VectorType>().getShape()[0]))">]> {
   let summary = "Masked roundscale op";
   let description = [{
     The mask.rndscale op is an AVX512 specific op that can lower to the proper
     LLVMAVX512 operation: `llvm.mask.rndscale.ps.512` or
     `llvm.mask.rndscale.pd.512` instruction depending on the type of vectors it
     is applied to.
 
     #### From the Intel Intrinsics Guide:
def MaskRndScaleOp : AVX512_Op<"mask.rndscale", [NoSideEffect,
   let assemblyFormat =
     "$src `,` $k `,` $a `,` $imm `,` $rounding attr-dict `:` type($dst)";
 }
 
 def MaskScaleFOp : AVX512_Op<"mask.scalef", [NoSideEffect,
   AllTypesMatch<["src", "a", "b", "dst"]>,
   TypesMatchWith<"k has the same number of bits as elements in dst",
                  "dst", "k",
-                 "IntegerType::get(($_self.cast<VectorType>().getShape()[0]),"
-                 "  $_self.getContext())">]> {
+                 "IntegerType::get($_self.getContext(), "
+                 "($_self.cast<VectorType>().getShape()[0]))">]> {
   let summary = "ScaleF op";
   let description = [{
     The `mask.scalef` op is an AVX512 specific op that can lower to the proper
     LLVMAVX512 operation: `llvm.mask.scalef.ps.512` or
     `llvm.mask.scalef.pd.512` depending on the type of MLIR vectors it is
     applied to.
 
     #### From the Intel Intrinsics Guide:

mlir/include/mlir/Dialect/Linalg/IR/LinalgStructuredOpsInterface.td

let extraClassDeclaration = [{
     void setNumOutputBuffers(unsigned num) { setOperandSegmentAt(1, num); }
     void setNumInitTensors(unsigned num) { setOperandSegmentAt(2, num); }
 
     private:
     void setOperandSegmentAt(unsigned idx, unsigned val) {
       auto attr = (*this)->getAttr("operand_segment_sizes")
         .cast<DenseIntElementsAttr>();
       unsigned i = 0;
-      auto newAttr = attr.mapValues(IntegerType::get(32, getContext()),
+      auto newAttr = attr.mapValues(IntegerType::get(getContext(), 32),
         [&](const APInt &v) { return (i++ == idx) ? APInt(32, val) : v; });
       getOperation()->setAttr("operand_segment_sizes", newAttr);
     }
   }];
 }
 
 #endif // LINALG_IR_STRUCTURED_OPS_INTERFACE

mlir/include/mlir/IR/BuiltinTypes.h

public:
   using Base::Base;
 
   /// Get or create a ComplexType with the provided element type.
   static ComplexType get(Type elementType);
 
   /// Get or create a ComplexType with the provided element type.  This emits
   /// and error at the specified location and returns null if the element type
   /// isn't supported.
-  static ComplexType getChecked(Type elementType, Location location);
+  static ComplexType getChecked(Location location, Type elementType);
 
   /// Verify the construction of an integer type.
   static LogicalResult verifyConstructionInvariants(Location loc,
                                                     Type elementType);
 
   Type getElementType();
 };
 
enum SignednessSemantics : uint32_t {
     Signed,   /// Signed integer
     Unsigned, /// Unsigned integer
   };
 
   /// Get or create a new IntegerType of the given width within the context.
   /// The created IntegerType is signless (i.e., no signedness semantics).
   /// Assume the width is within the allowed range and assert on failures. Use
   /// getChecked to handle failures gracefully.
-  static IntegerType get(unsigned width, MLIRContext *context);
+  static IntegerType get(MLIRContext *context, unsigned width);
 
   /// Get or create a new IntegerType of the given width within the context.
   /// The created IntegerType has signedness semantics as indicated via
   /// `signedness`. Assume the width is within the allowed range and assert on
   /// failures. Use getChecked to handle failures gracefully.
-  static IntegerType get(unsigned width, SignednessSemantics signedness,
-                         MLIRContext *context);
+  static IntegerType get(MLIRContext *context, unsigned width,
+                         SignednessSemantics signedness);
 
   /// Get or create a new IntegerType of the given width within the context,
   /// defined at the given, potentially unknown, location.  The created
   /// IntegerType is signless (i.e., no signedness semantics). If the width is
   /// outside the allowed range, emit errors and return a null type.
-  static IntegerType getChecked(unsigned width, Location location);
+  static IntegerType getChecked(Location location, unsigned width);
 
   /// Get or create a new IntegerType of the given width within the context,
   /// defined at the given, potentially unknown, location. The created
   /// IntegerType has signedness semantics as indicated via `signedness`. If the
   /// width is outside the allowed range, emit errors and return a null type.
-  static IntegerType getChecked(unsigned width, SignednessSemantics signedness,
-                                Location location);
+  static IntegerType getChecked(Location location, unsigned width,
+                                SignednessSemantics signedness);
 
   /// Verify the construction of an integer type.
   static LogicalResult
   verifyConstructionInvariants(Location loc, unsigned width,
                                SignednessSemantics signedness);
 
   /// Return the bitwidth of this integer type.
   unsigned getWidth() const;

 //===----------------------------------------------------------------------===//
 
 /// Function types map from a list of inputs to a list of results.
 class FunctionType
     : public Type::TypeBase<FunctionType, Type, detail::FunctionTypeStorage> {
 public:
   using Base::Base;
 
-  static FunctionType get(TypeRange inputs, TypeRange results,
-                          MLIRContext *context);
+  static FunctionType get(MLIRContext *context, TypeRange inputs,
+                          TypeRange results);
 
   /// Input types.
   unsigned getNumInputs() const;
   Type getInput(unsigned i) const { return getInputs()[i]; }
   ArrayRef<Type> getInputs() const;
 
   /// Result types.
   unsigned getNumResults() const;

 /// represented in their raw string form, and can only usefully be tested for
 /// type equality.
 class OpaqueType
     : public Type::TypeBase<OpaqueType, Type, detail::OpaqueTypeStorage> {
 public:
   using Base::Base;
 
   /// Get or create a new OpaqueType with the provided dialect and string data.
-  static OpaqueType get(Identifier dialect, StringRef typeData,
-                        MLIRContext *context);
+  static OpaqueType get(MLIRContext *context, Identifier dialect,
+                        StringRef typeData);
 
   /// Get or create a new OpaqueType with the provided dialect and string data.
   /// If the given identifier is not a valid namespace for a dialect, then a
   /// null type is returned.
-  static OpaqueType getChecked(Identifier dialect, StringRef typeData,
-                               MLIRContext *context, Location location);
+  static OpaqueType getChecked(Location location, Identifier dialect,
+                               StringRef typeData);
 
   /// Returns the dialect namespace of the opaque type.
   Identifier getDialectNamespace() const;
 
   /// Returns the raw type data of the opaque type.
   StringRef getTypeData() const;
 
   /// Verify the construction of an opaque type.
public:
   /// Get or create a new VectorType of the provided shape and element type.
   /// Assumes the arguments define a well-formed VectorType.
   static VectorType get(ArrayRef<int64_t> shape, Type elementType);
 
   /// Get or create a new VectorType of the provided shape and element type
   /// declared at the given, potentially unknown, location.  If the VectorType
   /// defined by the arguments would be ill-formed, emit errors and return
   /// nullptr-wrapping type.
-  static VectorType getChecked(ArrayRef<int64_t> shape, Type elementType,
-                               Location location);
+  static VectorType getChecked(Location location, ArrayRef<int64_t> shape,
+                               Type elementType);
 
   /// Verify the construction of a vector type.
   static LogicalResult verifyConstructionInvariants(Location loc,
                                                     ArrayRef<int64_t> shape,
                                                     Type elementType);
 
   /// Returns true of the given type can be used as an element of a vector type.
   /// In particular, vectors can consist of integer or float primitives.
public:
   /// Get or create a new RankedTensorType of the provided shape and element
   /// type. Assumes the arguments define a well-formed type.
   static RankedTensorType get(ArrayRef<int64_t> shape, Type elementType);
 
   /// Get or create a new RankedTensorType of the provided shape and element
   /// type declared at the given, potentially unknown, location.  If the
   /// RankedTensorType defined by the arguments would be ill-formed, emit errors
   /// and return a nullptr-wrapping type.
-  static RankedTensorType getChecked(ArrayRef<int64_t> shape, Type elementType,
-                                     Location location);
+  static RankedTensorType getChecked(Location location, ArrayRef<int64_t> shape,
+                                     Type elementType);
 
   /// Verify the construction of a ranked tensor type.
   static LogicalResult verifyConstructionInvariants(Location loc,
                                                     ArrayRef<int64_t> shape,
                                                     Type elementType);
 
   ArrayRef<int64_t> getShape() const;
 };
public:
   /// Get or create a new UnrankedTensorType of the provided shape and element
   /// type. Assumes the arguments define a well-formed type.
   static UnrankedTensorType get(Type elementType);
 
   /// Get or create a new UnrankedTensorType of the provided shape and element
   /// type declared at the given, potentially unknown, location.  If the
   /// UnrankedTensorType defined by the arguments would be ill-formed, emit
   /// errors and return a nullptr-wrapping type.
-  static UnrankedTensorType getChecked(Type elementType, Location location);
+  static UnrankedTensorType getChecked(Location location, Type elementType);
 
   /// Verify the construction of a unranked tensor type.
   static LogicalResult verifyConstructionInvariants(Location loc,
                                                     Type elementType);
 
   ArrayRef<int64_t> getShape() const { return llvm::None; }
 };
 
static MemRefType get(ArrayRef<int64_t> shape, Type elementType,
                         unsigned memorySpace = 0);
 
   /// Get or create a new MemRefType based on shape, element type, affine
   /// map composition, and memory space declared at the given location.
   /// If the location is unknown, the last argument should be an instance of
   /// UnknownLoc.  If the MemRefType defined by the arguments would be
   /// ill-formed, emits errors (to the handler registered with the context or to
   /// the error stream) and returns nullptr.
-  static MemRefType getChecked(ArrayRef<int64_t> shape, Type elementType,
+  static MemRefType getChecked(Location location, ArrayRef<int64_t> shape,
+                               Type elementType,
                                ArrayRef<AffineMap> affineMapComposition,
-                               unsigned memorySpace, Location location);
+                               unsigned memorySpace);
 
   ArrayRef<int64_t> getShape() const;
 
   /// Returns an array of affine map pointers representing the memref affine
   /// map composition.
   ArrayRef<AffineMap> getAffineMaps() const;
 
   // TODO: merge these two special values in a single one used everywhere.
public:
   /// Get or create a new UnrankedMemRefType of the provided element
   /// type and memory space
   static UnrankedMemRefType get(Type elementType, unsigned memorySpace);
 
   /// Get or create a new UnrankedMemRefType of the provided element
   /// type and memory space declared at the given, potentially unknown,
   /// location. If the UnrankedMemRefType defined by the arguments would be
   /// ill-formed, emit errors and return a nullptr-wrapping type.
-  static UnrankedMemRefType getChecked(Type elementType, unsigned memorySpace,
-                                       Location location);
+  static UnrankedMemRefType getChecked(Location location, Type elementType,
+                                       unsigned memorySpace);
 
   /// Verify the construction of a unranked memref type.
   static LogicalResult verifyConstructionInvariants(Location loc,
                                                     Type elementType,
                                                     unsigned memorySpace);
 
   ArrayRef<int64_t> getShape() const { return llvm::None; }
 };

 /// operations in the place of tuples.
 class TupleType
     : public Type::TypeBase<TupleType, Type, detail::TupleTypeStorage> {
 public:
   using Base::Base;
 
   /// Get or create a new TupleType with the provided element types. Assumes the
   /// arguments define a well-formed type.
-  static TupleType get(TypeRange elementTypes, MLIRContext *context);
+  static TupleType get(MLIRContext *context, TypeRange elementTypes);
 
   /// Get or create an empty tuple type.
   static TupleType get(MLIRContext *context);
 
   /// Return the elements types for this tuple.
   ArrayRef<Type> getTypes() const;
 
   /// Accumulate the types contained in this tuple and tuples nested within it.

mlir/include/mlir/IR/OpBase.td

 }
 
 def AnyComplex : Type<CPred<"$_self.isa<::mlir::ComplexType>()">,
                             "complex-type">;
 
 class OpaqueType<string dialect, string name, string description>
   : Type<CPred<"isOpaqueTypeWithName($_self, \""#dialect#"\", \""#name#"\")">,
          description>,
-    BuildableType<"::mlir::OpaqueType::get($_builder.getIdentifier(\""
-                  # dialect # "\"), \"" # name # "\", $_builder.getContext())">;
+    BuildableType<"::mlir::OpaqueType::get($_builder.getContext(), "
+                  "$_builder.getIdentifier(\"" # dialect # "\"), \""
+                  # name # "\")">;
 
 // Function Type
 
 // Any function type.
 def FunctionType : Type<CPred<"$_self.isa<::mlir::FunctionType>()">,
                               "function type">;
 
 // A container type is a type that has another type embedded within it.

mlir/lib/CAPI/IR/BuiltinTypes.cpp

 // Integer types.
 //===----------------------------------------------------------------------===//
 
 bool mlirTypeIsAInteger(MlirType type) {
   return unwrap(type).isa<IntegerType>();
 }
 
 MlirType mlirIntegerTypeGet(MlirContext ctx, unsigned bitwidth) {
-  return wrap(IntegerType::get(bitwidth, unwrap(ctx)));
+  return wrap(IntegerType::get(unwrap(ctx), bitwidth));
 }
 
 MlirType mlirIntegerTypeSignedGet(MlirContext ctx, unsigned bitwidth) {
-  return wrap(IntegerType::get(bitwidth, IntegerType::Signed, unwrap(ctx)));
+  return wrap(IntegerType::get(unwrap(ctx), bitwidth, IntegerType::Signed));
 }
 
 MlirType mlirIntegerTypeUnsignedGet(MlirContext ctx, unsigned bitwidth) {
-  return wrap(IntegerType::get(bitwidth, IntegerType::Unsigned, unwrap(ctx)));
+  return wrap(IntegerType::get(unwrap(ctx), bitwidth, IntegerType::Unsigned));
 }
 
 unsigned mlirIntegerTypeGetWidth(MlirType type) {
   return unwrap(type).cast<IntegerType>().getWidth();
 }
 
 bool mlirIntegerTypeIsSignless(MlirType type) {
   return unwrap(type).cast<IntegerType>().isSignless();
MlirType mlirVectorTypeGet(intptr_t rank, const int64_t *shape,
   return wrap(
       VectorType::get(llvm::makeArrayRef(shape, static_cast<size_t>(rank)),
                       unwrap(elementType)));
 }
 
 MlirType mlirVectorTypeGetChecked(intptr_t rank, const int64_t *shape,
                                   MlirType elementType, MlirLocation loc) {
   return wrap(VectorType::getChecked(
-      llvm::makeArrayRef(shape, static_cast<size_t>(rank)), unwrap(elementType),
-      unwrap(loc)));
+      unwrap(loc), llvm::makeArrayRef(shape, static_cast<size_t>(rank)),
+      unwrap(elementType)));
 }
 
 //===----------------------------------------------------------------------===//
 // Ranked / Unranked tensor type.
 //===----------------------------------------------------------------------===//
 
 bool mlirTypeIsATensor(MlirType type) { return unwrap(type).isa<TensorType>(); }
 
return wrap(RankedTensorType::get(
       llvm::makeArrayRef(shape, static_cast<size_t>(rank)),
       unwrap(elementType)));
 }
 
 MlirType mlirRankedTensorTypeGetChecked(intptr_t rank, const int64_t *shape,
                                         MlirType elementType,
                                         MlirLocation loc) {
   return wrap(RankedTensorType::getChecked(
-      llvm::makeArrayRef(shape, static_cast<size_t>(rank)), unwrap(elementType),
-      unwrap(loc)));
+      unwrap(loc), llvm::makeArrayRef(shape, static_cast<size_t>(rank)),
+      unwrap(elementType)));
 }
 
 MlirType mlirUnrankedTensorTypeGet(MlirType elementType) {
   return wrap(UnrankedTensorType::get(unwrap(elementType)));
 }
 
 MlirType mlirUnrankedTensorTypeGetChecked(MlirType elementType,
                                           MlirLocation loc) {
-  return wrap(UnrankedTensorType::getChecked(unwrap(elementType), unwrap(loc)));
+  return wrap(UnrankedTensorType::getChecked(unwrap(loc), unwrap(elementType)));
 }
 
 //===----------------------------------------------------------------------===//
 // Ranked / Unranked MemRef type.
 //===----------------------------------------------------------------------===//
 
 bool mlirTypeIsAMemRef(MlirType type) { return unwrap(type).isa<MemRefType>(); }
 
return wrap(
                       unwrap(elementType), llvm::None, memorySpace));
 }
 
 MlirType mlirMemRefTypeContiguousGetChecked(MlirType elementType, intptr_t rank,
                                             const int64_t *shape,
                                             unsigned memorySpace,
                                             MlirLocation loc) {
   return wrap(MemRefType::getChecked(
-      llvm::makeArrayRef(shape, static_cast<size_t>(rank)), unwrap(elementType),
-      llvm::None, memorySpace, unwrap(loc)));
+      unwrap(loc), llvm::makeArrayRef(shape, static_cast<size_t>(rank)),
+      unwrap(elementType), llvm::None, memorySpace));
 }
 
 intptr_t mlirMemRefTypeGetNumAffineMaps(MlirType type) {
   return static_cast<intptr_t>(
       unwrap(type).cast<MemRefType>().getAffineMaps().size());
 }
 
 MlirAffineMap mlirMemRefTypeGetAffineMap(MlirType type, intptr_t pos) {

 
 MlirType mlirUnrankedMemRefTypeGet(MlirType elementType, unsigned memorySpace) {
   return wrap(UnrankedMemRefType::get(unwrap(elementType), memorySpace));
 }
 
 MlirType mlirUnrankedMemRefTypeGetChecked(MlirType elementType,
                                           unsigned memorySpace,
                                           MlirLocation loc) {
-  return wrap(UnrankedMemRefType::getChecked(unwrap(elementType), memorySpace,
-                                             unwrap(loc)));
+  return wrap(UnrankedMemRefType::getChecked(unwrap(loc), unwrap(elementType),
+                                             memorySpace));
 }
 
 unsigned mlirUnrankedMemrefGetMemorySpace(MlirType type) {
   return unwrap(type).cast<UnrankedMemRefType>().getMemorySpace();
 }
 
 //===----------------------------------------------------------------------===//
 // Tuple type.
 //===----------------------------------------------------------------------===//
 
 bool mlirTypeIsATuple(MlirType type) { return unwrap(type).isa<TupleType>(); }
 
 MlirType mlirTupleTypeGet(MlirContext ctx, intptr_t numElements,
                           MlirType const *elements) {
   SmallVector<Type, 4> types;
   ArrayRef<Type> typeRef = unwrapList(numElements, elements, types);
-  return wrap(TupleType::get(typeRef, unwrap(ctx)));
+  return wrap(TupleType::get(unwrap(ctx), typeRef));
 }
 
 intptr_t mlirTupleTypeGetNumTypes(MlirType type) {
   return unwrap(type).cast<TupleType>().size();
 }
 
 MlirType mlirTupleTypeGetType(MlirType type, intptr_t pos) {
   return wrap(unwrap(type).cast<TupleType>().getType(static_cast<size_t>(pos)));

 
 MlirType mlirFunctionTypeGet(MlirContext ctx, intptr_t numInputs,
                              MlirType const *inputs, intptr_t numResults,
                              MlirType const *results) {
   SmallVector<Type, 4> inputsList;
   SmallVector<Type, 4> resultsList;
   (void)unwrapList(numInputs, inputs, inputsList);
   (void)unwrapList(numResults, results, resultsList);
-  return wrap(FunctionType::get(inputsList, resultsList, unwrap(ctx)));
+  return wrap(FunctionType::get(unwrap(ctx), inputsList, resultsList));
 }
 
 intptr_t mlirFunctionTypeGetNumInputs(MlirType type) {
   return unwrap(type).cast<FunctionType>().getNumInputs();
 }
 
 intptr_t mlirFunctionTypeGetNumResults(MlirType type) {
   return unwrap(type).cast<FunctionType>().getNumResults();

mlir/lib/Conversion/AsyncToLLVM/AsyncToLLVM.cpp

 static constexpr const char *kAwaitAllAndExecute =
     "mlirAsyncRuntimeAwaitAllInGroupAndExecute";
 
 namespace {
 // Async Runtime API function types.
 struct AsyncAPI {
   static FunctionType addOrDropRefFunctionType(MLIRContext *ctx) {
     auto ref = LLVM::LLVMType::getInt8PtrTy(ctx);
-    auto count = IntegerType::get(32, ctx);
-    return FunctionType::get({ref, count}, {}, ctx);
+    auto count = IntegerType::get(ctx, 32);
+    return FunctionType::get(ctx, {ref, count}, {});
   }
 
   static FunctionType createTokenFunctionType(MLIRContext *ctx) {
-    return FunctionType::get({}, {TokenType::get(ctx)}, ctx);
+    return FunctionType::get(ctx, {}, {TokenType::get(ctx)});
   }
 
   static FunctionType createGroupFunctionType(MLIRContext *ctx) {
-    return FunctionType::get({}, {GroupType::get(ctx)}, ctx);
+    return FunctionType::get(ctx, {}, {GroupType::get(ctx)});
   }
 
   static FunctionType emplaceTokenFunctionType(MLIRContext *ctx) {
-    return FunctionType::get({TokenType::get(ctx)}, {}, ctx);
+    return FunctionType::get(ctx, {TokenType::get(ctx)}, {});
   }
 
   static FunctionType awaitTokenFunctionType(MLIRContext *ctx) {
-    return FunctionType::get({TokenType::get(ctx)}, {}, ctx);
+    return FunctionType::get(ctx, {TokenType::get(ctx)}, {});
   }
 
   static FunctionType awaitGroupFunctionType(MLIRContext *ctx) {
-    return FunctionType::get({GroupType::get(ctx)}, {}, ctx);
+    return FunctionType::get(ctx, {GroupType::get(ctx)}, {});
   }
 
   static FunctionType executeFunctionType(MLIRContext *ctx) {
     auto hdl = LLVM::LLVMType::getInt8PtrTy(ctx);
     auto resume = resumeFunctionType(ctx).getPointerTo();
-    return FunctionType::get({hdl, resume}, {}, ctx);
+    return FunctionType::get(ctx, {hdl, resume}, {});
   }
 
   static FunctionType addTokenToGroupFunctionType(MLIRContext *ctx) {
-    auto i64 = IntegerType::get(64, ctx);
-    return FunctionType::get({TokenType::get(ctx), GroupType::get(ctx)}, {i64},
-                             ctx);
+    auto i64 = IntegerType::get(ctx, 64);
+    return FunctionType::get(ctx, {TokenType::get(ctx), GroupType::get(ctx)},
+                             {i64});
   }
 
   static FunctionType awaitAndExecuteFunctionType(MLIRContext *ctx) {
     auto hdl = LLVM::LLVMType::getInt8PtrTy(ctx);
     auto resume = resumeFunctionType(ctx).getPointerTo();
-    return FunctionType::get({TokenType::get(ctx), hdl, resume}, {}, ctx);
+    return FunctionType::get(ctx, {TokenType::get(ctx), hdl, resume}, {});
   }
 
   static FunctionType awaitAllAndExecuteFunctionType(MLIRContext *ctx) {
     auto hdl = LLVM::LLVMType::getInt8PtrTy(ctx);
     auto resume = resumeFunctionType(ctx).getPointerTo();
-    return FunctionType::get({GroupType::get(ctx), hdl, resume}, {}, ctx);
+    return FunctionType::get(ctx, {GroupType::get(ctx), hdl, resume}, {});
   }
 
   // Auxiliary coroutine resume intrinsic wrapper.
   static LLVM::LLVMType resumeFunctionType(MLIRContext *ctx) {
     auto voidTy = LLVM::LLVMType::getVoidTy(ctx);
     auto i8Ptr = LLVM::LLVMType::getInt8PtrTy(ctx);
     return LLVM::LLVMType::getFunctionTy(voidTy, {i8Ptr}, false);
   }
public:
   LogicalResult
   matchAndRewrite(Operation *op, ArrayRef<Value> operands,
                   ConversionPatternRewriter &rewriter) const override {
     // Currently we can only add tokens to the group.
     auto addToGroup = cast<AddToGroupOp>(op);
     if (!addToGroup.operand().getType().isa<TokenType>())
       return failure();
 
-    auto i64 = IntegerType::get(64, op->getContext());
+    auto i64 = IntegerType::get(op->getContext(), 64);
     rewriter.replaceOpWithNewOp<CallOp>(op, kAddTokenToGroup, i64, operands);
     return success();
   }
 };
 } // namespace
 
 //===----------------------------------------------------------------------===//
 // async.await and async.await_all op lowerings to the corresponding async

mlir/lib/Conversion/GPUToVulkan/ConvertGPULaunchFuncToVulkanLaunchFunc.cpp

LogicalResult ConvertGpuLaunchFuncToVulkanLaunchFunc::declareVulkanLaunchFunc(
   // launch configuration.
   for (auto type :
        llvm::drop_begin(vulkanLaunchTypes, kVulkanLaunchNumConfigOperands)) {
     if (!isSupportedType(type))
       return launchOp.emitError() << type << " is unsupported to run on Vulkan";
   }
 
   // Declare vulkan launch function.
-  auto funcType = FunctionType::get(vulkanLaunchTypes, {}, loc->getContext());
+  auto funcType = builder.getFunctionType(vulkanLaunchTypes, {});
   builder.create<FuncOp>(loc, kVulkanLaunch, funcType).setPrivate();
 
   return success();
 }
 
 LogicalResult ConvertGpuLaunchFuncToVulkanLaunchFunc::createBinaryShader(
     ModuleOp module, std::vector<char> &binaryShader) {
   bool done = false;

mlir/lib/Conversion/LinalgToLLVM/LinalgToLLVM.cpp

 ///
 /// struct {
 ///   int64_t min;
 ///   int64_t max;
 ///   int64_t step;
 /// };
 static Type convertRangeType(RangeType t, LLVMTypeConverter &converter) {
   auto *context = t.getContext();
-  auto int64Ty = converter.convertType(IntegerType::get(64, context))
+  auto int64Ty = converter.convertType(IntegerType::get(context, 64))
                      .cast<LLVM::LLVMType>();
   return LLVMType::getStructTy(int64Ty, int64Ty, int64Ty);
 }
 
 namespace {
 /// EDSC-compatible wrapper for MemRefDescriptor.
 class BaseViewConversionHelper {
 public:

mlir/lib/Conversion/LinalgToStandard/LinalgToStandard.cpp

static FlatSymbolRefAttr getLibraryCallSymbolRef(Operation *op,
   if (module.lookupSymbol(fnName)) {
     return fnNameAttr;
   }
 
   SmallVector<Type, 4> inputTypes(extractOperandTypes(op));
   assert(op->getNumResults() == 0 &&
          "Library call for linalg operation can be generated only for ops that "
          "have void return types");
-  auto libFnType = FunctionType::get(inputTypes, {}, rewriter.getContext());
+  auto libFnType = rewriter.getFunctionType(inputTypes, {});
 
   OpBuilder::InsertionGuard guard(rewriter);
   // Insert before module terminator.
   rewriter.setInsertionPoint(module.getBody(),
                              std::prev(module.getBody()->end()));
   FuncOp funcOp =
       rewriter.create<FuncOp>(op->getLoc(), fnNameAttr.getValue(), libFnType);
   // Insert a function attribute that will trigger the emission of the

mlir/lib/Conversion/SPIRVToLLVM/ConvertSPIRVToLLVM.cpp

matchAndRewrite(spirv::ConstantOp constOp, ArrayRef<Value> operands,
 
     // SPIR-V constant can be a signed/unsigned integer, which has to be
     // casted to signless integer when converting to LLVM dialect. Removing the
     // sign bit may have unexpected behaviour. However, it is better to handle
     // it case-by-case, given that the purpose of the conversion is not to
     // cover all possible corner cases.
     if (isSignedIntegerOrVector(srcType) ||
         isUnsignedIntegerOrVector(srcType)) {
-      auto *context = rewriter.getContext();
-      auto signlessType = IntegerType::get(getBitWidth(srcType), context);
+      auto signlessType = rewriter.getIntegerType(getBitWidth(srcType));
 
       if (srcType.isa<VectorType>()) {
         auto dstElementsAttr = constOp.value().cast<DenseIntElementsAttr>();
         rewriter.replaceOpWithNewOp<LLVM::ConstantOp>(
             constOp, dstType,
             dstElementsAttr.mapValues(
                 signlessType, [&](const APInt &value) { return value; }));
         return success();

mlir/lib/Conversion/VectorToSCF/VectorToSCF.cpp

LogicalResult VectorTransferRewriter<TransferReadOp>::matchAndRewrite(
   StdIndexedValue local(tmp);
   loopNestBuilder(lbs, ubs, steps, [&](ValueRange loopIvs) {
     auto ivsStorage = llvm::to_vector<8>(loopIvs);
     // Swap the ivs which will reorder memory accesses.
     if (coalescedIdx >= 0)
       std::swap(ivsStorage.back(), ivsStorage[coalescedIdx]);
 
     ArrayRef<Value> ivs(ivsStorage);
-    Value pos = std_index_cast(IntegerType::get(32, ctx), ivs.back());
+    Value pos = std_index_cast(IntegerType::get(ctx, 32), ivs.back());
     Value inVector = local(ivs.drop_back());
     auto loadValue = [&](ArrayRef<Value> indices) {
       Value vector = vector_insert_element(remote(indices), inVector, pos);
       local(ivs.drop_back()) = vector;
     };
     auto loadPadding = [&](ArrayRef<Value>) {
       Value vector = vector_insert_element(transfer.padding(), inVector, pos);
       local(ivs.drop_back()) = vector;
LogicalResult VectorTransferRewriter<TransferWriteOp>::matchAndRewrite(
   loopNestBuilder(lbs, ubs, steps, [&](ValueRange loopIvs) {
     auto ivsStorage = llvm::to_vector<8>(loopIvs);
     // Swap the ivsStorage which will reorder memory accesses.
     if (coalescedIdx >= 0)
       std::swap(ivsStorage.back(), ivsStorage[coalescedIdx]);
 
     ArrayRef<Value> ivs(ivsStorage);
     Value pos =
-        std_index_cast(IntegerType::get(32, op->getContext()), ivs.back());
+        std_index_cast(IntegerType::get(op->getContext(), 32), ivs.back());
     auto storeValue = [&](ArrayRef<Value> indices) {
       Value scalar = vector_extract_element(local(ivs.drop_back()), pos);
       remote(indices) = scalar;
     };
     emitWithBoundsChecks(
         rewriter, cast<VectorTransferOpInterface>(transfer.getOperation()), ivs,
         memRefBoundsCapture, storeValue);
   });

mlir/lib/Dialect/Async/IR/Async.cpp

void ExecuteOp::build(OpBuilder &builder, OperationState &result,
 
   result.addOperands(dependencies);
   result.addOperands(operands);
 
   // Add derived `operand_segment_sizes` attribute based on parsed operands.
   int32_t numDependencies = dependencies.size();
   int32_t numOperands = operands.size();
   auto operandSegmentSizes = DenseIntElementsAttr::get(
-      VectorType::get({2}, IntegerType::get(32, result.getContext())),
+      VectorType::get({2}, builder.getIntegerType(32)),
       {numDependencies, numOperands});
   result.addAttribute(kOperandSegmentSizesAttr, operandSegmentSizes);
 
   // First result is always a token, and then `resultTypes` wrapped into
   // `async.value`.
   result.addTypes({TokenType::get(result.getContext())});
   for (Type type : resultTypes)
     result.addTypes(ValueType::get(type));

mlir/lib/Dialect/Async/Transforms/AsyncRefCounting.cpp

LogicalResult AsyncRefCountingPass::addAutomaticRefCounting(Value value) {
   // Set inserton point after the operation producing a value, or at the
   // beginning of the block if the value defined by the block argument.
   if (Operation *op = value.getDefiningOp())
     builder.setInsertionPointAfter(op);
   else
     builder.setInsertionPointToStart(value.getParentBlock());
 
   Location loc = value.getLoc();
-  auto i32 = IntegerType::get(32, ctx);
+  auto i32 = IntegerType::get(ctx, 32);
 
   // Drop the reference count immediately if the value has no uses.
   if (value.getUses().empty()) {
     builder.create<DropRefOp>(loc, value, IntegerAttr::get(i32, 1));
     return success();
   }
 
   // Use liveness analysis to find the placement of `drop_ref`operation.

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

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

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

static gpu::GPUFuncOp outlineKernelFuncImpl(gpu::LaunchOp launchOp,
 
   // Create the gpu.func operation.
   SmallVector<Type, 4> kernelOperandTypes;
   kernelOperandTypes.reserve(operands.size());
   for (Value operand : operands) {
     kernelOperandTypes.push_back(operand.getType());
   }
   FunctionType type =
-      FunctionType::get(kernelOperandTypes, {}, launchOp.getContext());
+      FunctionType::get(launchOp.getContext(), kernelOperandTypes, {});
   auto outlinedFunc = builder.create<gpu::GPUFuncOp>(loc, kernelFnName, type);
   outlinedFunc->setAttr(gpu::GPUDialect::getKernelFuncAttrName(),
                         builder.getUnitAttr());
   BlockAndValueMapping map;
 
   // Map the arguments corresponding to the launch parameters like blockIdx,
   // threadIdx, etc.
   Region &outlinedFuncBody = outlinedFunc.body();

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

 
 //===----------------------------------------------------------------------===//
 // Printing/parsing for LLVM::AllocaOp.
 //===----------------------------------------------------------------------===//
 
 static void printAllocaOp(OpAsmPrinter &p, AllocaOp &op) {
   auto elemTy = op.getType().cast<LLVM::LLVMType>().getPointerElementTy();
 
-  auto funcTy = FunctionType::get({op.arraySize().getType()}, {op.getType()},
-                                  op.getContext());
+  auto funcTy = FunctionType::get(op.getContext(), {op.arraySize().getType()},
+                                  {op.getType()});
 
   p << op.getOperationName() << ' ' << op.arraySize() << " x " << elemTy;
   if (op.alignment().hasValue() && *op.alignment() != 0)
     p.printOptionalAttrDict(op.getAttrs());
   else
     p.printOptionalAttrDict(op.getAttrs(), {"alignment"});
   p << " : " << funcTy;
 }
else
     p << op.getOperand(0);
 
   auto args = op.getOperands().drop_front(isDirect ? 0 : 1);
   p << '(' << args << ')';
   p.printOptionalAttrDict(op.getAttrs(), {"callee"});
 
   // Reconstruct the function MLIR function type from operand and result types.
   p << " : "
-    << FunctionType::get(args.getTypes(), op.getResultTypes(), op.getContext());
+    << FunctionType::get(op.getContext(), args.getTypes(), op.getResultTypes());
 }
 
 // <operation> ::= `llvm.call` (function-id | ssa-use) `(` ssa-use-list `)`
 //                 attribute-dict? `:` function-type
 static ParseResult parseCallOp(OpAsmParser &parser, OperationState &result) {
   SmallVector<OpAsmParser::OperandType, 8> operands;
   Type type;
   SymbolRefAttr funcAttr;

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

static Value allocBuffer(const LinalgPromotionOptions &options,
                          Type elementType, Value size, bool dynamicBuffers,
                          OperationFolder *folder,
                          Optional<unsigned> alignment = None) {
   auto *ctx = size.getContext();
   auto width = llvm::divideCeil(elementType.getIntOrFloatBitWidth(), 8);
   IntegerAttr alignment_attr;
   if (alignment.hasValue())
     alignment_attr =
-        IntegerAttr::get(IntegerType::get(64, ctx), alignment.getValue());
+        IntegerAttr::get(IntegerType::get(ctx, 64), alignment.getValue());
   if (!dynamicBuffers)
     if (auto cst = size.getDefiningOp<ConstantIndexOp>())
       return options.useAlloca
                  ? std_alloca(MemRefType::get(width * cst.getValue(),
-                                              IntegerType::get(8, ctx)),
+                                              IntegerType::get(ctx, 8)),
                               ValueRange{}, alignment_attr)
                        .value
                  : std_alloc(MemRefType::get(width * cst.getValue(),
-                                             IntegerType::get(8, ctx)),
+                                             IntegerType::get(ctx, 8)),
                              ValueRange{}, alignment_attr)
                        .value;
   Value mul =
       folded_std_muli(folder, folded_std_constant_index(folder, width), size);
   return options.useAlloca
-             ? std_alloca(MemRefType::get(-1, IntegerType::get(8, ctx)), mul,
+             ? std_alloca(MemRefType::get(-1, IntegerType::get(ctx, 8)), mul,
                           alignment_attr)
                    .value
-             : std_alloc(MemRefType::get(-1, IntegerType::get(8, ctx)), mul,
+             : std_alloc(MemRefType::get(-1, IntegerType::get(ctx, 8)), mul,
                          alignment_attr)
                    .value;
 }
 
 /// Default allocation callback function. This allocates a promoted buffer when
 /// no call back to do so is provided. The default is to allocate a
 /// memref<..xi8> and return a view to get a memref type of shape
 /// boundingSubViewSize.

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

 using namespace mlir::quant;
 
 static bool getDefaultStorageParams(unsigned numBits, bool narrowRange,
                                     bool isSigned, MLIRContext *ctx,
                                     Type &storageType, int64_t &qmin,
                                     int64_t &qmax) {
   // Hard-coded type mapping from TFLite.
   if (numBits <= 8) {
-    storageType = IntegerType::get(8, ctx);
+    storageType = IntegerType::get(ctx, 8);
     if (isSigned) {
       qmin = -128;
       qmax = 127;
     } else {
       qmin = 0;
       qmax = 255;
     }
   } else if (numBits <= 16) {
-    storageType = IntegerType::get(16, ctx);
+    storageType = IntegerType::get(ctx, 16);
     if (isSigned) {
       qmin = -32768;
       qmax = 32767;
     } else {
       qmin = 0;
       qmax = 65535;
     }
   } else if (numBits <= 32) {
-    storageType = IntegerType::get(32, ctx);
+    storageType = IntegerType::get(ctx, 32);
     if (isSigned) {
       qmin = std::numeric_limits<int32_t>::min();
       qmax = std::numeric_limits<int32_t>::max();
     } else {
       qmin = std::numeric_limits<uint32_t>::min();
       qmax = std::numeric_limits<uint32_t>::max();
     }
   } else {

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

UniformQuantizedPerAxisValueConverter::convert(DenseFPElementsAttr attr) {
 
   // Scan the elements of the dense elements attributes and quantize them by
   // using the right quantization parameters.
   int64_t flattenIndex = 0;
   auto shape = type.getShape();
   int64_t chunkSize =
       std::accumulate(std::next(shape.begin(), quantizationDim + 1),
                       shape.end(), 1, std::multiplies<int64_t>());
-  Type newElementType = IntegerType::get(storageBitWidth, attr.getContext());
+  Type newElementType = IntegerType::get(attr.getContext(), storageBitWidth);
   return attr.mapValues(newElementType, [&](const APFloat &old) {
     int chunkIndex = (flattenIndex++) / chunkSize;
     return converters[chunkIndex % dimSize].quantizeFloatToInt(old);
   });
 }

mlir/lib/Dialect/SCF/Transforms/Utils.cpp

auto outline = [&](Region &ifOrElseRegion, StringRef funcName) {
     OpBuilder::InsertionGuard g(b);
     b.setInsertionPoint(ifOp->getParentOfType<FuncOp>());
 
     llvm::SetVector<Value> captures;
     getUsedValuesDefinedAbove(ifOrElseRegion, captures);
 
     ValueRange values(captures.getArrayRef());
     FunctionType type =
-        FunctionType::get(values.getTypes(), ifOp.getResultTypes(), ctx);
+        FunctionType::get(ctx, values.getTypes(), ifOp.getResultTypes());
     auto outlinedFunc = b.create<FuncOp>(loc, funcName, type);
     b.setInsertionPointToStart(outlinedFunc.addEntryBlock());
     BlockAndValueMapping bvm;
     for (auto it : llvm::zip(values, outlinedFunc.getArguments()))
       bvm.map(std::get<0>(it), std::get<1>(it));
     for (Operation &op : ifOrElseRegion.front().without_terminator())
       b.clone(op, bvm);
 

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

 
 StringRef spirv::getEntryPointABIAttrName() { return "spv.entry_point_abi"; }
 
 spirv::EntryPointABIAttr
 spirv::getEntryPointABIAttr(ArrayRef<int32_t> localSize, MLIRContext *context) {
   assert(localSize.size() == 3);
   return spirv::EntryPointABIAttr::get(
       DenseElementsAttr::get<int32_t>(
-          VectorType::get(3, IntegerType::get(32, context)), localSize)
+          VectorType::get(3, IntegerType::get(context, 32)), localSize)
           .cast<DenseIntElementsAttr>(),
       context);
 }
 
 spirv::EntryPointABIAttr spirv::lookupEntryPointABI(Operation *op) {
   while (op && !op->hasTrait<OpTrait::FunctionLike>())
     op = op->getParentOp();
   if (!op)

mlir/lib/Dialect/SPIRV/Transforms/SPIRVConversion.cpp

 Type SPIRVTypeConverter::getIndexType(MLIRContext *context) {
   // Convert to 32-bit integers for now. Might need a way to control this in
   // future.
   // TODO: It is probably better to make it 64-bit integers. To
   // this some support is needed in SPIR-V dialect for Conversion
   // instructions. The Vulkan spec requires the builtins like
   // GlobalInvocationID, etc. to be 32-bit (unsigned) integers which should be
   // SExtended to 64-bit for index computations.
-  return IntegerType::get(32, context);
+  return IntegerType::get(context, 32);
 }
 
 /// Mapping between SPIR-V storage classes to memref memory spaces.
 ///
 /// Note: memref does not have a defined semantics for each memory space; it
 /// depends on the context where it is used. There are no particular reasons
 /// behind the number assignments; we try to follow NVVM conventions and largely
 /// give common storage classes a smaller number. The hope is use symbolic
convertScalarType(const spirv::TargetEnv &targetEnv, spirv::ScalarType type,
 
   if (auto floatType = type.dyn_cast<FloatType>()) {
     LLVM_DEBUG(llvm::dbgs() << type << " converted to 32-bit for SPIR-V\n");
     return Builder(targetEnv.getContext()).getF32Type();
   }
 
   auto intType = type.cast<IntegerType>();
   LLVM_DEBUG(llvm::dbgs() << type << " converted to 32-bit for SPIR-V\n");
-  return IntegerType::get(/*width=*/32, intType.getSignedness(),
-                          targetEnv.getContext());
+  return IntegerType::get(targetEnv.getContext(), /*width=*/32,
+                          intType.getSignedness());
 }
 
 /// Converts a vector `type` to a suitable type under the given `targetEnv`.
 static Optional<Type>
 convertVectorType(const spirv::TargetEnv &targetEnv, VectorType type,
                   Optional<spirv::StorageClass> storageClass = {}) {
   if (!spirv::CompositeType::isValid(type)) {
     // TODO: One-element vector types can be translated into scalar

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

LogicalResult CallOp::verifySymbolUses(SymbolTableCollection &symbolTable) {
   for (unsigned i = 0, e = fnType.getNumResults(); i != e; ++i)
     if (getResult(i).getType() != fnType.getResult(i))
       return emitOpError("result type mismatch");
 
   return success();
 }
 
 FunctionType CallOp::getCalleeType() {
-  return FunctionType::get(getOperandTypes(), getResultTypes(), getContext());
+  return FunctionType::get(getContext(), getOperandTypes(), getResultTypes());
 }
 
 //===----------------------------------------------------------------------===//
 // CallIndirectOp
 //===----------------------------------------------------------------------===//
 namespace {
 /// Fold indirect calls that have a constant function as the callee operand.
 struct SimplifyIndirectCallWithKnownCallee

 }
 
 //===----------------------------------------------------------------------===//
 // General helpers for comparison ops
 //===----------------------------------------------------------------------===//
 
 // Return the type of the same shape (scalar, vector or tensor) containing i1.
 static Type getI1SameShape(Type type) {
-  auto i1Type = IntegerType::get(1, type.getContext());
+  auto i1Type = IntegerType::get(type.getContext(), 1);
   if (auto tensorType = type.dyn_cast<RankedTensorType>())
     return RankedTensorType::get(tensorType.getShape(), i1Type);
   if (type.isa<UnrankedTensorType>())
     return UnrankedTensorType::get(i1Type);
   if (auto vectorType = type.dyn_cast<VectorType>())
     return VectorType::get(vectorType.getShape(), i1Type);
   return i1Type;
 }
OpFoldResult CmpFOp::fold(ArrayRef<Attribute> operands) {
   auto rhs = operands.back().dyn_cast_or_null<FloatAttr>();
 
   // TODO: We could actually do some intelligent things if we know only one
   // of the operands, but it's inf or nan.
   if (!lhs || !rhs)
     return {};
 
   auto val = applyCmpPredicate(getPredicate(), lhs.getValue(), rhs.getValue());
-  return IntegerAttr::get(IntegerType::get(1, getContext()), APInt(1, val));
+  return IntegerAttr::get(IntegerType::get(getContext(), 1), APInt(1, val));
 }
 
 //===----------------------------------------------------------------------===//
 // CondBranchOp
 //===----------------------------------------------------------------------===//
 
 namespace {
 /// cond_br true, ^bb1, ^bb2

mlir/lib/Dialect/Vector/VectorOps.cpp

for (auto it : llvm::zip(arrayAttr1, arrayAttr2, shape)) {
     ++index;
   }
   return success();
 }
 
 static ArrayAttr makeI64ArrayAttr(ArrayRef<int64_t> values,
                                   MLIRContext *context) {
   auto attrs = llvm::map_range(values, [context](int64_t v) -> Attribute {
-    return IntegerAttr::get(IntegerType::get(64, context), APInt(64, v));
+    return IntegerAttr::get(IntegerType::get(context, 64), APInt(64, v));
   });
   return ArrayAttr::get(llvm::to_vector<8>(attrs), context);
 }
 
 static LogicalResult verify(InsertStridedSliceOp op) {
   auto sourceVectorType = op.getSourceVectorType();
   auto destVectorType = op.getDestVectorType();
   auto offsets = op.offsets();
static ParseResult parseTupleOp(OpAsmParser &parser, OperationState &result) {
   SmallVector<Type, 4> types;
   auto loc = parser.getCurrentLocation();
   auto *ctx = parser.getBuilder().getContext();
   return failure(
       parser.parseOperandList(operandInfos) ||
       parser.parseOptionalAttrDict(result.attributes) ||
       parser.parseColonTypeList(types) ||
       parser.resolveOperands(operandInfos, types, loc, result.operands) ||
-      parser.addTypeToList(TupleType::get(types, ctx), result.types));
+      parser.addTypeToList(TupleType::get(ctx, types), result.types));
 }
 
 static void print(OpAsmPrinter &p, TupleOp op) {
   p << op.getOperationName() << ' ';
   p.printOperands(op.getOperands());
   p.printOptionalAttrDict(op.getAttrs());
   p << " : ";
   llvm::interleaveComma(op->getOperandTypes(), p);

mlir/lib/Dialect/Vector/VectorTransforms.cpp

static TupleType generateExtractSlicesOpResultType(VectorType vectorType,
   for (unsigned i = 0; i < sliceCount; ++i) {
     auto vectorOffsets = delinearize(sliceStrides, i);
     auto elementOffsets =
         computeElementOffsetsFromVectorSliceOffsets(sizes, vectorOffsets);
     auto sliceSizes = computeSliceSizes(shape, sizes, elementOffsets);
     // Create Vector type and add to 'vectorTypes[i]'.
     vectorTypes[i] = VectorType::get(sliceSizes, vectorType.getElementType());
   }
-  return TupleType::get(vectorTypes, builder.getContext());
+  return builder.getTupleType(vectorTypes);
 }
 
 // UnrolledVectorState aggregates per-operand/result vector state required for
 // unrolling.
 struct UnrolledVectorState {
   SmallVector<int64_t, 4> unrolledShape;
   SmallVector<int64_t, 4> unrollFactors;
   SmallVector<int64_t, 8> basis;

mlir/lib/IR/Builders.cpp

 FloatType Builder::getF16Type() { return FloatType::getF16(context); }
 
 FloatType Builder::getF32Type() { return FloatType::getF32(context); }
 
 FloatType Builder::getF64Type() { return FloatType::getF64(context); }
 
 IndexType Builder::getIndexType() { return IndexType::get(context); }
 
-IntegerType Builder::getI1Type() { return IntegerType::get(1, context); }
+IntegerType Builder::getI1Type() { return IntegerType::get(context, 1); }
 
-IntegerType Builder::getI32Type() { return IntegerType::get(32, context); }
+IntegerType Builder::getI32Type() { return IntegerType::get(context, 32); }
 
-IntegerType Builder::getI64Type() { return IntegerType::get(64, context); }
+IntegerType Builder::getI64Type() { return IntegerType::get(context, 64); }
 
 IntegerType Builder::getIntegerType(unsigned width) {
-  return IntegerType::get(width, context);
+  return IntegerType::get(context, width);
 }
 
 IntegerType Builder::getIntegerType(unsigned width, bool isSigned) {
   return IntegerType::get(
-      width, isSigned ? IntegerType::Signed : IntegerType::Unsigned, context);
+      context, width, isSigned ? IntegerType::Signed : IntegerType::Unsigned);
 }
 
 FunctionType Builder::getFunctionType(TypeRange inputs, TypeRange results) {
-  return FunctionType::get(inputs, results, context);
+  return FunctionType::get(context, inputs, results);
 }
 
 TupleType Builder::getTupleType(TypeRange elementTypes) {
-  return TupleType::get(elementTypes, context);
+  return TupleType::get(context, elementTypes);
 }
 
 NoneType Builder::getNoneType() { return NoneType::get(context); }
 
 //===----------------------------------------------------------------------===//
 // Attributes.
 //===----------------------------------------------------------------------===//
 

mlir/lib/IR/BuiltinDialect.cpp

FuncOp FuncOp::clone(BlockAndValueMapping &mapper) {
   // argument to the input type vector.
   bool isExternalFn = isExternal();
   if (!isExternalFn) {
     SmallVector<Type, 4> inputTypes;
     inputTypes.reserve(newType.getNumInputs());
     for (unsigned i = 0, e = getNumArguments(); i != e; ++i)
       if (!mapper.contains(getArgument(i)))
         inputTypes.push_back(newType.getInput(i));
-    newType = FunctionType::get(inputTypes, newType.getResults(), getContext());
+    newType = FunctionType::get(getContext(), inputTypes, newType.getResults());
   }
 
   // Create the new function.
   FuncOp newFunc = cast<FuncOp>(getOperation()->cloneWithoutRegions());
   newFunc.setType(newType);
 
   /// Set the argument attributes for arguments that aren't being replaced.
   for (unsigned i = 0, e = getNumArguments(), destI = 0; i != e; ++i)

mlir/lib/IR/BuiltinTypes.cpp

 //===----------------------------------------------------------------------===//
 /// ComplexType
 //===----------------------------------------------------------------------===//
 
 ComplexType ComplexType::get(Type elementType) {
   return Base::get(elementType.getContext(), elementType);
 }
 
-ComplexType ComplexType::getChecked(Type elementType, Location location) {
+ComplexType ComplexType::getChecked(Location location, Type elementType) {
   return Base::getChecked(location, elementType);
 }
 
 /// Verify the construction of an integer type.
 LogicalResult ComplexType::verifyConstructionInvariants(Location loc,
                                                         Type elementType) {
   if (!elementType.isIntOrFloat())
     return emitError(loc, "invalid element type for complex");

 
 IntegerType::SignednessSemantics IntegerType::getSignedness() const {
   return getImpl()->signedness;
 }
 
 IntegerType IntegerType::scaleElementBitwidth(unsigned scale) {
   if (!scale)
     return IntegerType();
-  return IntegerType::get(scale * getWidth(), getSignedness(), getContext());
+  return IntegerType::get(getContext(), scale * getWidth(), getSignedness());
 }
 
 //===----------------------------------------------------------------------===//
 // Float Type
 //===----------------------------------------------------------------------===//
 
 unsigned FloatType::getWidth() {
   if (isa<Float16Type, BFloat16Type>())
if (scale == 2)
       return FloatType::getF64(ctx);
   return FloatType();
 }
 
 //===----------------------------------------------------------------------===//
 // FunctionType
 //===----------------------------------------------------------------------===//
 
-FunctionType FunctionType::get(TypeRange inputs, TypeRange results,
-                               MLIRContext *context) {
+FunctionType FunctionType::get(MLIRContext *context, TypeRange inputs,
+                               TypeRange results) {
   return Base::get(context, inputs, results);
 }
 
 unsigned FunctionType::getNumInputs() const { return getImpl()->numInputs; }
 
 ArrayRef<Type> FunctionType::getInputs() const {
   return getImpl()->getInputs();
 }
FunctionType::getWithoutArgsAndResults(ArrayRef<unsigned> argIndices,
   if (!resultIndices.empty()) {
     unsigned originalNumResults = getNumResults();
     iterateIndicesExcept(originalNumResults, resultIndices, [&](unsigned i) {
       newResultTypesBuffer.emplace_back(getResult(i));
     });
     newResultTypes = newResultTypesBuffer;
   }
 
-  return get(newInputTypes, newResultTypes, getContext());
+  return get(getContext(), newInputTypes, newResultTypes);
 }
 
 //===----------------------------------------------------------------------===//
 // OpaqueType
 //===----------------------------------------------------------------------===//
 
-OpaqueType OpaqueType::get(Identifier dialect, StringRef typeData,
-                           MLIRContext *context) {
+OpaqueType OpaqueType::get(MLIRContext *context, Identifier dialect,
+                           StringRef typeData) {
   return Base::get(context, dialect, typeData);
 }
 
-OpaqueType OpaqueType::getChecked(Identifier dialect, StringRef typeData,
-                                  MLIRContext *context, Location location) {
+OpaqueType OpaqueType::getChecked(Location location, Identifier dialect,
+                                  StringRef typeData) {
   return Base::getChecked(location, dialect, typeData);
 }
 
 /// Returns the dialect namespace of the opaque type.
 Identifier OpaqueType::getDialectNamespace() const {
   return getImpl()->dialectNamespace;
 }
 

 //===----------------------------------------------------------------------===//
 // VectorType
 //===----------------------------------------------------------------------===//
 
 VectorType VectorType::get(ArrayRef<int64_t> shape, Type elementType) {
   return Base::get(elementType.getContext(), shape, elementType);
 }
 
-VectorType VectorType::getChecked(ArrayRef<int64_t> shape, Type elementType,
-                                  Location location) {
+VectorType VectorType::getChecked(Location location, ArrayRef<int64_t> shape,
+                                  Type elementType) {
   return Base::getChecked(location, shape, elementType);
 }
 
 LogicalResult VectorType::verifyConstructionInvariants(Location loc,
                                                        ArrayRef<int64_t> shape,
                                                        Type elementType) {
   if (shape.empty())
     return emitError(loc, "vector types must have at least one dimension");

 // RankedTensorType
 //===----------------------------------------------------------------------===//
 
 RankedTensorType RankedTensorType::get(ArrayRef<int64_t> shape,
                                        Type elementType) {
   return Base::get(elementType.getContext(), shape, elementType);
 }
 
-RankedTensorType RankedTensorType::getChecked(ArrayRef<int64_t> shape,
-                                              Type elementType,
-                                              Location location) {
+RankedTensorType RankedTensorType::getChecked(Location location,
+                                              ArrayRef<int64_t> shape,
+                                              Type elementType) {
   return Base::getChecked(location, shape, elementType);
 }
 
 LogicalResult RankedTensorType::verifyConstructionInvariants(
     Location loc, ArrayRef<int64_t> shape, Type elementType) {
   for (int64_t s : shape) {
     if (s < -1)
       return emitError(loc, "invalid tensor dimension size");
   }
   return checkTensorElementType(loc, elementType);
 }
 
 ArrayRef<int64_t> RankedTensorType::getShape() const {
   return getImpl()->getShape();
 }
 
 //===----------------------------------------------------------------------===//
 // UnrankedTensorType
 //===----------------------------------------------------------------------===//
 
 UnrankedTensorType UnrankedTensorType::get(Type elementType) {
   return Base::get(elementType.getContext(), elementType);
 }
 
-UnrankedTensorType UnrankedTensorType::getChecked(Type elementType,
-                                                  Location location) {
+UnrankedTensorType UnrankedTensorType::getChecked(Location location,
+                                                  Type elementType) {
   return Base::getChecked(location, elementType);
 }
 
 LogicalResult
 UnrankedTensorType::verifyConstructionInvariants(Location loc,
                                                  Type elementType) {
   return checkTensorElementType(loc, elementType);
 }

 }
 
 /// Get or create a new MemRefType based on shape, element type, affine
 /// map composition, and memory space declared at the given location.
 /// If the location is unknown, the last argument should be an instance of
 /// UnknownLoc.  If the MemRefType defined by the arguments would be
 /// ill-formed, emits errors (to the handler registered with the context or to
 /// the error stream) and returns nullptr.
-MemRefType MemRefType::getChecked(ArrayRef<int64_t> shape, Type elementType,
+MemRefType MemRefType::getChecked(Location location, ArrayRef<int64_t> shape,
+                                  Type elementType,
                                   ArrayRef<AffineMap> affineMapComposition,
-                                  unsigned memorySpace, Location location) {
+                                  unsigned memorySpace) {
   return getImpl(shape, elementType, affineMapComposition, memorySpace,
                  location);
 }
 
 /// Get or create a new MemRefType defined by the arguments.  If the resulting
 /// type would be ill-formed, return nullptr.  If the location is provided,
 /// emit detailed error messages.  To emit errors when the location is unknown,
 /// pass in an instance of UnknownLoc.

 // UnrankedMemRefType
 //===----------------------------------------------------------------------===//
 
 UnrankedMemRefType UnrankedMemRefType::get(Type elementType,
                                            unsigned memorySpace) {
   return Base::get(elementType.getContext(), elementType, memorySpace);
 }
 
-UnrankedMemRefType UnrankedMemRefType::getChecked(Type elementType,
-                                                  unsigned memorySpace,
-                                                  Location location) {
+UnrankedMemRefType UnrankedMemRefType::getChecked(Location location,
+                                                  Type elementType,
+                                                  unsigned memorySpace) {
   return Base::getChecked(location, elementType, memorySpace);
 }
 
 LogicalResult
 UnrankedMemRefType::verifyConstructionInvariants(Location loc, Type elementType,
                                                  unsigned memorySpace) {
   if (!BaseMemRefType::isValidElementType(elementType))
     return emitError(loc, "invalid memref element type");

 }
 
 //===----------------------------------------------------------------------===//
 /// TupleType
 //===----------------------------------------------------------------------===//
 
 /// Get or create a new TupleType with the provided element types. Assumes the
 /// arguments define a well-formed type.
-TupleType TupleType::get(TypeRange elementTypes, MLIRContext *context) {
+TupleType TupleType::get(MLIRContext *context, TypeRange elementTypes) {
   return Base::get(context, elementTypes);
 }
 
 /// Get or create an empty tuple type.
-TupleType TupleType::get(MLIRContext *context) { return get({}, context); }
+TupleType TupleType::get(MLIRContext *context) { return get(context, {}); }
 
 /// Return the elements types for this tuple.
 ArrayRef<Type> TupleType::getTypes() const { return getImpl()->getTypes(); }
 
 /// Accumulate the types contained in this tuple and tuples nested within it.
 /// Note that this only flattens nested tuples, not any other container type,
 /// e.g. a tuple<i32, tensor<i32>, tuple<f32, tuple<i64>>> is flattened to
 /// (i32, tensor<i32>, f32, i64)

mlir/lib/IR/Dialect.cpp

Attribute Dialect::parseAttribute(DialectAsmParser &parser, Type type) const {
   return Attribute();
 }
 
 /// Parse a type registered to this dialect.
 Type Dialect::parseType(DialectAsmParser &parser) const {
   // If this dialect allows unknown types, then represent this with OpaqueType.
   if (allowsUnknownTypes()) {
     auto ns = Identifier::get(getNamespace(), getContext());
-    return OpaqueType::get(ns, parser.getFullSymbolSpec(), getContext());
+    return OpaqueType::get(getContext(), ns, parser.getFullSymbolSpec());
   }
 
   parser.emitError(parser.getNameLoc())
       << "dialect '" << getNamespace() << "' provides no type parsing hook";
   return Type();
 }
 
 /// Utility function that returns if the given string is a valid dialect

mlir/lib/IR/MLIRContext.cpp

case 64:
     return context->getImpl().int64Ty;
   case 128:
     return context->getImpl().int128Ty;
   default:
     return IntegerType();
   }
 }
 
-IntegerType IntegerType::get(unsigned width, MLIRContext *context) {
-  return get(width, IntegerType::Signless, context);
+IntegerType IntegerType::get(MLIRContext *context, unsigned width) {
+  return get(context, width, IntegerType::Signless);
 }
 
-IntegerType IntegerType::get(unsigned width,
-                             IntegerType::SignednessSemantics signedness,
-                             MLIRContext *context) {
+IntegerType IntegerType::get(MLIRContext *context, unsigned width,
+                             IntegerType::SignednessSemantics signedness) {
   if (auto cached = getCachedIntegerType(width, signedness, context))
     return cached;
   return Base::get(context, width, signedness);
 }
 
-IntegerType IntegerType::getChecked(unsigned width, Location location) {
-  return getChecked(width, IntegerType::Signless, location);
+IntegerType IntegerType::getChecked(Location location, unsigned width) {
+  return getChecked(location, width, IntegerType::Signless);
 }
 
-IntegerType IntegerType::getChecked(unsigned width,
-                                    SignednessSemantics signedness,
-                                    Location location) {
+IntegerType IntegerType::getChecked(Location location, unsigned width,
+                                    SignednessSemantics signedness) {
   if (auto cached =
           getCachedIntegerType(width, signedness, location->getContext()))
     return cached;
   return Base::getChecked(location, width, signedness);
 }
 
 /// Get an instance of the NoneType.
 NoneType NoneType::get(MLIRContext *context) {

mlir/lib/IR/Operation.cpp

Operation::Operation(Location location, OperationName name,
   assert(llvm::all_of(resultTypes, [](Type t) { return t; }) &&
          "unexpected null result type");
   if (!resultTypes.empty()) {
     // If there is a single result it is stored in-place, otherwise use a tuple.
     hasSingleResult = resultTypes.size() == 1;
     if (hasSingleResult)
       resultType = resultTypes.front();
     else
-      resultType = TupleType::get(resultTypes, location->getContext());
+      resultType = TupleType::get(location->getContext(), resultTypes);
   }
 }
 
 // Operations are deleted through the destroy() member because they are
 // allocated via malloc.
 Operation::~Operation() {
   assert(block == nullptr && "operation destroyed but still in a block");
 

mlir/lib/IR/Value.cpp

void Value::setType(Type newType) {
   unsigned resultNo = result.getResultNumber();
 
   // Otherwise, rebuild the tuple if the new type is different from the current.
   auto curTypes = owner->resultType.cast<TupleType>().getTypes();
   if (curTypes[resultNo] == newType)
     return;
   auto newTypes = llvm::to_vector<4>(curTypes);
   newTypes[resultNo] = newType;
-  owner->resultType = TupleType::get(newTypes, newType.getContext());
+  owner->resultType = TupleType::get(newType.getContext(), newTypes);
 }
 
 /// If this value is the result of an Operation, return the operation that
 /// defines it.
 Operation *Value::getDefiningOp() const {
   if (auto result = dyn_cast<OpResult>())
     return result.getOwner();
   return nullptr;

mlir/lib/Parser/DialectSymbolParser.cpp

return parseExtendedSymbol<Type>(
               symbolData, state.context, state.symbols, [&](Parser &parser) {
                 CustomDialectAsmParser customParser(symbolData, parser);
                 return dialect->parseType(customParser);
               });
         }
 
         // Otherwise, form a new opaque type.
         return OpaqueType::getChecked(
-            Identifier::get(dialectName, state.context), symbolData,
-            state.context, getEncodedSourceLocation(loc));
+            getEncodedSourceLocation(loc),
+            Identifier::get(dialectName, state.context), symbolData);
       });
 }
 
 //===----------------------------------------------------------------------===//
 // mlir::parseAttribute/parseType
 //===----------------------------------------------------------------------===//
 
 /// Parses a symbol, of type 'T', and returns it if parsing was successful. If

mlir/lib/Parser/TypeParser.cpp

if (width.getValue() > IntegerType::kMaxWidth) {
       return nullptr;
     }
 
     IntegerType::SignednessSemantics signSemantics = IntegerType::Signless;
     if (Optional<bool> signedness = getToken().getIntTypeSignedness())
       signSemantics = *signedness ? IntegerType::Signed : IntegerType::Unsigned;
 
     consumeToken(Token::inttype);
-    return IntegerType::get(width.getValue(), signSemantics, getContext());
+    return IntegerType::get(getContext(), width.getValue(), signSemantics);
   }
 
   // float-type
   case Token::kw_bf16:
     consumeToken(Token::kw_bf16);
     return builder.getBF16Type();
   case Token::kw_f16:
     consumeToken(Token::kw_f16);
if (consumeIf(Token::greater))
     return TupleType::get(getContext());
 
   // Parse the element types and the '>'.
   SmallVector<Type, 4> types;
   if (parseTypeListNoParens(types) ||
       parseToken(Token::greater, "expected '>' in tuple type"))
     return nullptr;
 
-  return TupleType::get(types, getContext());
+  return TupleType::get(getContext(), types);
 }
 
 /// Parse a vector type.
 ///
 ///   vector-type ::= `vector` `<` non-empty-static-dimension-list type `>`
 ///   non-empty-static-dimension-list ::= decimal-literal `x`
 ///                                       static-dimension-list
 ///   static-dimension-list ::= (decimal-literal `x`)*

mlir/lib/Target/LLVMIR/ConvertFromLLVMIR.cpp

Type Importer::getStdTypeForAttr(LLVMType type) {
   return nullptr;
 }
 
 // Get the given constant as an attribute. Not all constants can be represented
 // as attributes.
 Attribute Importer::getConstantAsAttr(llvm::Constant *value) {
   if (auto *ci = dyn_cast<llvm::ConstantInt>(value))
     return b.getIntegerAttr(
-        IntegerType::get(ci->getType()->getBitWidth(), context),
+        IntegerType::get(context, ci->getType()->getBitWidth()),
         ci->getValue());
   if (auto *c = dyn_cast<llvm::ConstantDataArray>(value))
     if (c->isString())
       return b.getStringAttr(c->getAsString());
   if (auto *c = dyn_cast<llvm::ConstantFP>(value)) {
     if (c->getType()->isDoubleTy())
       return b.getFloatAttr(FloatType::getF64(context), c->getValueAPF());
     else if (c->getType()->isFloatingPointTy())

mlir/lib/Target/SPIRV/Deserialization.cpp

case spirv::Opcode::OpTypeInt: {
     // to preserve or validate.
     // 0 indicates unsigned, or no signedness semantics
     // 1 indicates signed semantics."
     //
     // So we cannot differentiate signless and unsigned integers; always use
     // signless semantics for such cases.
     auto sign = operands[2] == 1 ? IntegerType::SignednessSemantics::Signed
                                  : IntegerType::SignednessSemantics::Signless;
-    typeMap[operands[0]] = IntegerType::get(operands[1], sign, context);
+    typeMap[operands[0]] = IntegerType::get(context, operands[1], sign);
   } break;
   case spirv::Opcode::OpTypeFloat: {
     if (operands.size() != 2)
       return emitError(unknownLoc, "OpTypeFloat must have bitwidth parameter");
 
     Type floatTy;
     switch (operands[1]) {
     case 16:
if (!ty) {
       return emitError(unknownLoc, "unknown argument type in OpTypeFunction");
     }
     argTypes.push_back(ty);
   }
   ArrayRef<Type> returnTypes;
   if (!isVoidType(returnType)) {
     returnTypes = llvm::makeArrayRef(returnType);
   }
-  typeMap[operands[0]] = FunctionType::get(argTypes, returnTypes, context);
+  typeMap[operands[0]] = FunctionType::get(context, argTypes, returnTypes);
   return success();
 }
 
 LogicalResult
 Deserializer::processCooperativeMatrixType(ArrayRef<uint32_t> operands) {
   if (operands.size() != 5) {
     return emitError(unknownLoc, "OpTypeCooperativeMatrix must have element "
                                  "type and row x column parameters");

mlir/lib/Target/SPIRV/Serialization.cpp

if (auto cooperativeMatrixType =
           type.dyn_cast<spirv::CooperativeMatrixNVType>()) {
     uint32_t elementTypeID = 0;
     if (failed(processTypeImpl(loc, cooperativeMatrixType.getElementType(),
                                elementTypeID, serializationCtx))) {
       return failure();
     }
     typeEnum = spirv::Opcode::OpTypeCooperativeMatrixNV;
     auto getConstantOp = [&](uint32_t id) {
-      auto attr = IntegerAttr::get(IntegerType::get(32, type.getContext()), id);
+      auto attr = IntegerAttr::get(IntegerType::get(type.getContext(), 32), id);
       return prepareConstantInt(loc, attr);
     };
     operands.push_back(elementTypeID);
     operands.push_back(
         getConstantOp(static_cast<uint32_t>(cooperativeMatrixType.getScope())));
     operands.push_back(getConstantOp(cooperativeMatrixType.getRows()));
     operands.push_back(getConstantOp(cooperativeMatrixType.getColumns()));
     return success();

mlir/lib/Transforms/BufferResultsToOutParams.cpp

if (resultType.value().isa<BaseMemRefType>()) {
       erasedResultIndices.push_back(resultType.index());
       erasedResultTypes.push_back(resultType.value());
     }
   }
 
   // Add the new arguments to the function type.
   auto newArgTypes = llvm::to_vector<6>(
       llvm::concat<const Type>(functionType.getInputs(), erasedResultTypes));
-  auto newFunctionType = FunctionType::get(
-      newArgTypes, functionType.getResults(), func.getContext());
+  auto newFunctionType = FunctionType::get(func.getContext(), newArgTypes,
+                                           functionType.getResults());
   func.setType(newFunctionType);
 
   // Transfer the result attributes to arg attributes.
   for (int i = 0, e = erasedResultTypes.size(); i < e; i++)
     func.setArgAttrs(functionType.getNumInputs() + i,
                      func.getResultAttrs(erasedResultIndices[i]));
 
   // Erase the results.

mlir/lib/Transforms/NormalizeMemRefs.cpp

funcOp.walk([&](ReturnOp returnOp) {
         // results case where some are normalized, some aren't.
         if (memrefType.getAffineMaps().empty())
           resultTypes[operandEn.index()] = memrefType;
       }
     });
 
     // We create a new function type and modify the function signature with this
     // new type.
-    newFuncType = FunctionType::get(/*inputs=*/argTypes,
-                                    /*results=*/resultTypes,
-                                    /*context=*/&getContext());
+    newFuncType = FunctionType::get(&getContext(), /*inputs=*/argTypes,
+                                    /*results=*/resultTypes);
   }
 
   // Since we update the function signature, it might affect the result types at
   // the caller site. Since this result might even be used by the caller
   // function in ReturnOps, the caller function's signature will also change.
   // Hence we record the caller function in 'funcOpsToUpdate' to update their
   // signature as well.
   llvm::SmallDenseSet<FuncOp, 8> funcOpsToUpdate;
for (unsigned resIndex :
       // Computing a new memref type after normalizing the old memref to have an
       // identity map layout.
       MemRefType newMemRefType = normalizeMemRefType(memrefType, b,
                                                      /*numSymbolicOperands=*/0);
       resultTypes.push_back(newMemRefType);
       continue;
     }
 
-    FunctionType newFuncType = FunctionType::get(/*inputs=*/inputTypes,
-                                                 /*results=*/resultTypes,
-                                                 /*context=*/&getContext());
+    FunctionType newFuncType =
+        FunctionType::get(&getContext(), /*inputs=*/inputTypes,
+                          /*results=*/resultTypes);
     // Setting the new function signature for this external function.
     funcOp.setType(newFuncType);
   }
   updateFunctionSignature(funcOp, moduleOp);
 }
 
 /// Create an operation containing normalized memrefs in the operation results.
 /// When the results of `oldOp` have memrefs with affine map, the memrefs are

mlir/lib/Transforms/Utils/DialectConversion.cpp

matchAndRewrite(FuncOp funcOp, ArrayRef<Value> operands,
     if (failed(typeConverter->convertSignatureArgs(type.getInputs(), result)) ||
         failed(typeConverter->convertTypes(type.getResults(), newResults)) ||
         failed(rewriter.convertRegionTypes(&funcOp.getBody(), *typeConverter,
                                            &result)))
       return failure();
 
     // Update the function signature in-place.
     rewriter.updateRootInPlace(funcOp, [&] {
-      funcOp.setType(FunctionType::get(result.getConvertedTypes(), newResults,
-                                       funcOp.getContext()));
+      funcOp.setType(FunctionType::get(funcOp.getContext(),
+                                       result.getConvertedTypes(), newResults));
     });
     return success();
   }
 };
 } // end anonymous namespace
 
 void mlir::populateFuncOpTypeConversionPattern(
     OwningRewritePatternList &patterns, MLIRContext *ctx,

mlir/test/EDSC/builder-api-test.cpp

static MLIRContext &globalContext() {
   context.allowUnregisteredDialects();
   return context;
 }
 
 static FuncOp makeFunction(StringRef name, ArrayRef<Type> results = {},
                            ArrayRef<Type> args = {}) {
   auto &ctx = globalContext();
   auto function = FuncOp::create(UnknownLoc::get(&ctx), name,
-                                 FunctionType::get(args, results, &ctx));
+                                 FunctionType::get(&ctx, args, results));
   function.addEntryBlock();
   return function;
 }
 
 TEST_FUNC(builder_dynamic_for_func_args) {
   auto indexType = IndexType::get(&globalContext());
   auto f32Type = FloatType::getF32(&globalContext());
   auto f =
TEST_FUNC(builder_blocks) {
   // CHECK-NEXT: }
   // clang-format on
   f.print(llvm::outs(), OpPrintingFlags().useLocalScope());
   f.erase();
 }
 
 TEST_FUNC(builder_cond_branch) {
   auto f = makeFunction("builder_cond_branch", {},
-                        {IntegerType::get(1, &globalContext())});
+                        {IntegerType::get(&globalContext(), 1)});
 
   OpBuilder builder(f.getBody());
   ScopedContext scope(builder, f.getLoc());
   Value c32(std_constant_int(32, 32)), c64(std_constant_int(64, 64)),
       c42(std_constant_int(42, 32));
   ReturnOp ret = std_ret();
 
   Block *b1 = buildInNewBlock(c32.getType(), [&](ValueRange) { std_ret(); });
TEST_FUNC(insertion_in_block) {
   // CHECK: {{.*}} = constant 1 : i32
   // clang-format on
   f.print(llvm::outs(), OpPrintingFlags().useLocalScope());
   f.erase();
 }
 
 TEST_FUNC(zero_and_std_sign_extendi_op_i1_to_i8) {
   using namespace edsc::op;
-  auto i1Type = IntegerType::get(1, &globalContext());
-  auto i8Type = IntegerType::get(8, &globalContext());
+  auto i1Type = IntegerType::get(&globalContext(), 1);
+  auto i8Type = IntegerType::get(&globalContext(), 8);
   auto memrefType = MemRefType::get({}, i1Type, {}, 0);
   auto f = makeFunction("zero_and_std_sign_extendi_op", {},
                         {memrefType, memrefType});
 
   OpBuilder builder(f.getBody());
   ScopedContext scope(builder, f.getLoc());
   AffineIndexedValue A(f.getArgument(0));
   AffineIndexedValue B(f.getArgument(1));
   // clang-format off
   edsc::intrinsics::std_zero_extendi(A, i8Type);
   edsc::intrinsics::std_sign_extendi(B, i8Type);
   // CHECK-LABEL: @zero_and_std_sign_extendi_op
   //      CHECK:     %[[SRC1:.*]] = affine.load
   //      CHECK:     zexti %[[SRC1]] : i1 to i8
   //      CHECK:     %[[SRC2:.*]] = affine.load
   //      CHECK:     sexti %[[SRC2]] : i1 to i8
   // clang-format on
   f.print(llvm::outs(), OpPrintingFlags().useLocalScope());
   f.erase();
 }
 
 TEST_FUNC(operator_or) {
-  auto i1Type = IntegerType::get(/*width=*/1, &globalContext());
+  auto i1Type = IntegerType::get(&globalContext(), /*width=*/1);
   auto f = makeFunction("operator_or", {}, {i1Type, i1Type});
 
   OpBuilder builder(f.getBody());
   ScopedContext scope(builder, f.getLoc());
 
   using op::operator||;
   Value lhs(f.getArgument(0));
   Value rhs(f.getArgument(1));
   lhs || rhs;
 
   // clang-format off
   // CHECK-LABEL: @operator_or
   //       CHECK: [[ARG0:%.*]]: i1, [[ARG1:%.*]]: i1
   //       CHECK: or [[ARG0]], [[ARG1]]
   // clang-format on
   f.print(llvm::outs(), OpPrintingFlags().useLocalScope());
   f.erase();
 }
 
 TEST_FUNC(operator_and) {
-  auto i1Type = IntegerType::get(/*width=*/1, &globalContext());
+  auto i1Type = IntegerType::get(&globalContext(), /*width=*/1);
   auto f = makeFunction("operator_and", {}, {i1Type, i1Type});
 
   OpBuilder builder(f.getBody());
   ScopedContext scope(builder, f.getLoc());
 
   using op::operator&&;
   using op::negate;
   Value lhs(f.getArgument(0));
TEST_FUNC(fptrunc_f32_bf16) {
   //  CHECK-NEXT: {{.*}} = fptrunc
   // clang-format on
   f.print(llvm::outs(), OpPrintingFlags().useLocalScope());
   f.erase();
 }
 
 TEST_FUNC(select_op_i32) {
   using namespace edsc::op;
-  auto i32Type = IntegerType::get(32, &globalContext());
+  auto i32Type = IntegerType::get(&globalContext(), 32);
   auto memrefType = MemRefType::get(
       {ShapedType::kDynamicSize, ShapedType::kDynamicSize}, i32Type, {}, 0);
   auto f = makeFunction("select_op", {}, {memrefType});
 
   OpBuilder builder(f.getBody());
   ScopedContext scope(builder, f.getLoc());
   Value zero = std_constant_index(0), one = std_constant_index(1);
   MemRefBoundsCapture vA(f.getArgument(0));

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

LogicalResult OpWithShapedTypeInferTypeInterfaceOp::inferReturnTypeComponents(
   // Create return type consisting of the last element of the first operand.
   auto operandType = *operands.getTypes().begin();
   auto sval = operandType.dyn_cast<ShapedType>();
   if (!sval) {
     return emitOptionalError(location, "only shaped type operands allowed");
   }
   int64_t dim =
       sval.hasRank() ? sval.getShape().front() : ShapedType::kDynamicSize;
-  auto type = IntegerType::get(17, context);
+  auto type = IntegerType::get(context, 17);
   inferredReturnShapes.push_back(ShapedTypeComponents({dim}, type));
   return success();
 }
 
 LogicalResult OpWithShapedTypeInferTypeInterfaceOp::reifyReturnTypeShapes(
     OpBuilder &builder, llvm::SmallVectorImpl<Value> &shapes) {
   shapes = SmallVector<Value, 1>{
       builder.createOrFold<DimOp>(getLoc(), getOperand(0), 0)};

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

static LogicalResult convertType(Type t, SmallVectorImpl<Type> &results) {
     // Convert I64 to F64.
     if (t.isSignlessInteger(64)) {
       results.push_back(FloatType::getF64(t.getContext()));
       return success();
     }
 
     // Convert I42 to I43.
     if (t.isInteger(42)) {
-      results.push_back(IntegerType::get(43, t.getContext()));
+      results.push_back(IntegerType::get(t.getContext(), 43));
       return success();
     }
 
     // Split F32 into F16,F16.
     if (t.isF32()) {
       results.assign(2, FloatType::getF16(t.getContext()));
       return success();
     }

mlir/test/lib/Transforms/TestDecomposeCallGraphTypes.cpp

decomposer.addDecomposeValueConversion([](OpBuilder &builder, Location loc,
       return success();
     });
 
     typeConverter.addArgumentMaterialization(
         [](OpBuilder &builder, TupleType resultType, ValueRange inputs,
            Location loc) -> Optional<Value> {
           if (inputs.size() == 1)
             return llvm::None;
-          TypeRange TypeRange = inputs.getTypes();
-          SmallVector<Type, 2> types(TypeRange.begin(), TypeRange.end());
-          TupleType tuple = TupleType::get(types, builder.getContext());
+          TupleType tuple = builder.getTupleType(inputs.getTypes());
           Value value = builder.create<test::MakeTupleOp>(loc, tuple, inputs);
           return value;
         });
 
     populateDecomposeCallGraphTypesPatterns(context, typeConverter, decomposer,
                                             patterns);
 
     if (failed(applyPartialConversion(module, target, std::move(patterns))))

mlir/unittests/Dialect/Quant/QuantizationUtilsTest.cpp

ElementsAttr getTestSparseElementsAttr(MLIRContext *ctx,
                                        ArrayRef<int64_t> shape) {
   auto eleType = FloatType::getF32(ctx);
   ShapedType tensorType;
   if (shape.size() == 1 && shape[0] == -1) {
     tensorType = UnrankedTensorType::get(eleType);
   } else {
     tensorType = RankedTensorType::get(shape, eleType);
   }
-  auto indicesType = RankedTensorType::get({1, 2}, IntegerType::get(64, ctx));
+  auto indicesType = RankedTensorType::get({1, 2}, IntegerType::get(ctx, 64));
   auto indices =
       DenseIntElementsAttr::get(indicesType, {APInt(64, 0), APInt(64, 0)});
   auto valuesType = RankedTensorType::get({1}, eleType);
   auto values = DenseFPElementsAttr::get(valuesType, {APFloat(0.0f)});
   return SparseElementsAttr::get(tensorType, indices, values);
 }
 
 UniformQuantizedType getTestQuantizedType(Type storageType, MLIRContext *ctx) {
   return UniformQuantizedType::get(/*flags=*/false, storageType,
                                    FloatType::getF32(ctx), /*scale=*/1.0,
                                    /*zeroPoint=*/0, /*storageTypeMin=*/0,
                                    /*storageTypeMax=*/255);
 }
 
 TEST(QuantizationUtilsTest, convertFloatAttrUniform) {
   MLIRContext ctx;
   ctx.getOrLoadDialect<QuantizationDialect>();
-  IntegerType convertedType = IntegerType::get(8, &ctx);
+  IntegerType convertedType = IntegerType::get(&ctx, 8);
   auto quantizedType = getTestQuantizedType(convertedType, &ctx);
   TestUniformQuantizedValueConverter converter(quantizedType);
 
   auto realValue = getTestFloatAttr(1.0, &ctx);
   Type typeResult;
   auto valueResult =
       quantizeAttrUniform(realValue, quantizedType, converter, typeResult);
 
   EXPECT_EQ(valueResult.cast<IntegerAttr>().getInt(), 5);
   EXPECT_EQ(
       valueResult.cast<IntegerAttr>().getType().cast<IntegerType>().getWidth(),
       convertedType.getWidth());
 }
 
 TEST(QuantizationUtilsTest, convertRankedDenseAttrUniform) {
   MLIRContext ctx;
   ctx.getOrLoadDialect<QuantizationDialect>();
-  IntegerType convertedType = IntegerType::get(8, &ctx);
+  IntegerType convertedType = IntegerType::get(&ctx, 8);
   auto quantizedType = getTestQuantizedType(convertedType, &ctx);
   TestUniformQuantizedValueConverter converter(quantizedType);
   auto realValue = getTestElementsAttr<DenseElementsAttr, ArrayRef<Attribute>>(
       &ctx, {1, 2}, {getTestFloatAttr(1.0, &ctx), getTestFloatAttr(2.0, &ctx)});
 
   Type returnedType;
   auto returnedValue =
       quantizeAttrUniform(realValue, quantizedType, converter, returnedType);
 
   // Check Elements attribute shape and kind are not changed.
   auto tensorType = returnedType.cast<TensorType>();
   auto expectedTensorType = realValue.getType().cast<TensorType>();
   EXPECT_EQ(tensorType.getShape(), expectedTensorType.getShape());
   EXPECT_EQ(tensorType.getElementType(), convertedType);
   EXPECT_TRUE(returnedValue.isa<DenseIntElementsAttr>());
 
   // Check Elements attribute element value is expected.
   auto firstValue = returnedValue.cast<ElementsAttr>().getValue({0, 0});
   EXPECT_EQ(firstValue.cast<IntegerAttr>().getInt(), 5);
 }
 
 TEST(QuantizationUtilsTest, convertRankedSplatAttrUniform) {
   MLIRContext ctx;
   ctx.getOrLoadDialect<QuantizationDialect>();
-  IntegerType convertedType = IntegerType::get(8, &ctx);
+  IntegerType convertedType = IntegerType::get(&ctx, 8);
   auto quantizedType = getTestQuantizedType(convertedType, &ctx);
   TestUniformQuantizedValueConverter converter(quantizedType);
   auto realValue = getTestElementsAttr<DenseElementsAttr, Attribute>(
       &ctx, {1, 2}, getTestFloatAttr(1.0, &ctx));
 
   Type returnedType;
   auto returnedValue =
       quantizeAttrUniform(realValue, quantizedType, converter, returnedType);
 
   // Check Elements attribute shape and kind are not changed.
   auto tensorType = returnedType.cast<TensorType>();
   auto expectedTensorType = realValue.getType().cast<TensorType>();
   EXPECT_EQ(tensorType.getShape(), expectedTensorType.getShape());
   EXPECT_EQ(tensorType.getElementType(), convertedType);
   EXPECT_TRUE(returnedValue.isa<SplatElementsAttr>());
 
   // Check Elements attribute element value is expected.
   auto firstValue = returnedValue.cast<ElementsAttr>().getValue({0, 0});
   EXPECT_EQ(firstValue.cast<IntegerAttr>().getInt(), 5);
 }
 
 TEST(QuantizationUtilsTest, convertRankedSparseAttrUniform) {
   MLIRContext ctx;
   ctx.getOrLoadDialect<QuantizationDialect>();
-  IntegerType convertedType = IntegerType::get(8, &ctx);
+  IntegerType convertedType = IntegerType::get(&ctx, 8);
   auto quantizedType = getTestQuantizedType(convertedType, &ctx);
   TestUniformQuantizedValueConverter converter(quantizedType);
   auto realValue = getTestSparseElementsAttr(&ctx, {1, 2});
 
   Type returnedType;
   auto returnedValue =
       quantizeAttrUniform(realValue, quantizedType, converter, returnedType);
 

mlir/unittests/IR/AttributeTest.cpp

static void testSplat(Type eltType, const EltTy &splatElt) {
 
   for (auto newValue : detectedSplat.template getValues<EltTy>())
     EXPECT_TRUE(newValue == splatElt);
 }
 
 namespace {
 TEST(DenseSplatTest, BoolSplat) {
   MLIRContext context;
-  IntegerType boolTy = IntegerType::get(1, &context);
+  IntegerType boolTy = IntegerType::get(&context, 1);
   RankedTensorType shape = RankedTensorType::get({2, 2}, boolTy);
 
   // Check that splat is automatically detected for boolean values.
   /// True.
   DenseElementsAttr trueSplat = DenseElementsAttr::get(shape, true);
   EXPECT_TRUE(trueSplat.isSplat());
   /// False.
   DenseElementsAttr falseSplat = DenseElementsAttr::get(shape, false);
   EXPECT_TRUE(falseSplat.isSplat());
   EXPECT_NE(falseSplat, trueSplat);
 
   /// Detect and handle splat within 8 elements (bool values are bit-packed).
   /// True.
   auto detectedSplat = DenseElementsAttr::get(shape, {true, true, true, true});
   EXPECT_EQ(detectedSplat, trueSplat);
   /// False.
   detectedSplat = DenseElementsAttr::get(shape, {false, false, false, false});
   EXPECT_EQ(detectedSplat, falseSplat);
 }
 
 TEST(DenseSplatTest, LargeBoolSplat) {
   constexpr int64_t boolCount = 56;
 
   MLIRContext context;
-  IntegerType boolTy = IntegerType::get(1, &context);
+  IntegerType boolTy = IntegerType::get(&context, 1);
   RankedTensorType shape = RankedTensorType::get({boolCount}, boolTy);
 
   // Check that splat is automatically detected for boolean values.
   /// True.
   DenseElementsAttr trueSplat = DenseElementsAttr::get(shape, true);
   DenseElementsAttr falseSplat = DenseElementsAttr::get(shape, false);
   EXPECT_TRUE(trueSplat.isSplat());
   EXPECT_TRUE(falseSplat.isSplat());
 
   /// Detect that the large boolean arrays are properly splatted.
   /// True.
   SmallVector<bool, 64> trueValues(boolCount, true);
   auto detectedSplat = DenseElementsAttr::get(shape, trueValues);
   EXPECT_EQ(detectedSplat, trueSplat);
   /// False.
   SmallVector<bool, 64> falseValues(boolCount, false);
   detectedSplat = DenseElementsAttr::get(shape, falseValues);
   EXPECT_EQ(detectedSplat, falseSplat);
 }
 
 TEST(DenseSplatTest, BoolNonSplat) {
   MLIRContext context;
-  IntegerType boolTy = IntegerType::get(1, &context);
+  IntegerType boolTy = IntegerType::get(&context, 1);
   RankedTensorType shape = RankedTensorType::get({6}, boolTy);
 
   // Check that we properly handle non-splat values.
   DenseElementsAttr nonSplat =
       DenseElementsAttr::get(shape, {false, false, true, false, false, true});
   EXPECT_FALSE(nonSplat.isSplat());
 }
 
 TEST(DenseSplatTest, OddIntSplat) {
   // Test detecting a splat with an odd(non 8-bit) integer bitwidth.
   MLIRContext context;
   constexpr size_t intWidth = 19;
-  IntegerType intTy = IntegerType::get(intWidth, &context);
+  IntegerType intTy = IntegerType::get(&context, intWidth);
   APInt value(intWidth, 10);
 
   testSplat(intTy, value);
 }
 
 TEST(DenseSplatTest, Int32Splat) {
   MLIRContext context;
-  IntegerType intTy = IntegerType::get(32, &context);
+  IntegerType intTy = IntegerType::get(&context, 32);
   int value = 64;
 
   testSplat(intTy, value);
 }
 
 TEST(DenseSplatTest, IntAttrSplat) {
   MLIRContext context;
-  IntegerType intTy = IntegerType::get(85, &context);
+  IntegerType intTy = IntegerType::get(&context, 85);
   Attribute value = IntegerAttr::get(intTy, 109);
 
   testSplat(intTy, value);
 }
 
 TEST(DenseSplatTest, F32Splat) {
   MLIRContext context;
   FloatType floatTy = FloatType::getF32(&context);
TEST(DenseSplatTest, BF16Splat) {
   Attribute value = FloatAttr::get(floatTy, 10.0);
 
   testSplat(floatTy, value);
 }
 
 TEST(DenseSplatTest, StringSplat) {
   MLIRContext context;
   Type stringType =
-      OpaqueType::get(Identifier::get("test", &context), "string", &context);
+      OpaqueType::get(&context, Identifier::get("test", &context), "string");
   StringRef value = "test-string";
   testSplat(stringType, value);
 }
 
 TEST(DenseSplatTest, StringAttrSplat) {
   MLIRContext context;
   Type stringType =
-      OpaqueType::get(Identifier::get("test", &context), "string", &context);
+      OpaqueType::get(&context, Identifier::get("test", &context), "string");
   Attribute stringAttr = StringAttr::get("test-string", stringType);
   testSplat(stringType, stringAttr);
 }
 
 TEST(DenseComplexTest, ComplexFloatSplat) {
   MLIRContext context;
   ComplexType complexType = ComplexType::get(FloatType::getF32(&context));
   std::complex<float> value(10.0, 15.0);
   testSplat(complexType, value);
 }
 
 TEST(DenseComplexTest, ComplexIntSplat) {
   MLIRContext context;
-  ComplexType complexType = ComplexType::get(IntegerType::get(64, &context));
+  ComplexType complexType = ComplexType::get(IntegerType::get(&context, 64));
   std::complex<int64_t> value(10, 15);
   testSplat(complexType, value);
 }
 
 TEST(DenseComplexTest, ComplexAPFloatSplat) {
   MLIRContext context;
   ComplexType complexType = ComplexType::get(FloatType::getF32(&context));
   std::complex<APFloat> value(APFloat(10.0f), APFloat(15.0f));
   testSplat(complexType, value);
 }
 
 TEST(DenseComplexTest, ComplexAPIntSplat) {
   MLIRContext context;
-  ComplexType complexType = ComplexType::get(IntegerType::get(64, &context));
+  ComplexType complexType = ComplexType::get(IntegerType::get(&context, 64));
   std::complex<APInt> value(APInt(64, 10), APInt(64, 15));
   testSplat(complexType, value);
 }
 
 } // end namespace

mlir/unittests/TableGen/StructsGenTest.cpp

 
 /// Pull in generated enum utility declarations and definitions.
 #include "StructAttrGenTest.h.inc"
 #include "StructAttrGenTest.cpp.inc"
 
 /// Helper that returns an example test::TestStruct for testing its
 /// implementation.
 static test::TestStruct getTestStruct(mlir::MLIRContext *context) {
-  auto integerType = mlir::IntegerType::get(32, context);
+  auto integerType = mlir::IntegerType::get(context, 32);
   auto integerAttr = mlir::IntegerAttr::get(integerType, 127);
 
   auto floatType = mlir::FloatType::getF32(context);
   auto floatAttr = mlir::FloatAttr::get(floatType, 0.25);
 
   auto elementsType = mlir::RankedTensorType::get({2, 3}, integerType);
   auto elementsAttr =
       mlir::DenseIntElementsAttr::get(elementsType, {1, 2, 3, 4, 5, 6});
TEST(StructsGenTest, ClassofBadTypeFalse) {
   auto expectedValues = structAttr.getValue();
   ASSERT_EQ(expectedValues.size(), 3u);
 
   // Create a copy of all but the last NamedAttributes.
   llvm::SmallVector<mlir::NamedAttribute, 4> newValues(
       expectedValues.begin(), expectedValues.end() - 1);
 
   // Add a copy of the last attribute with the wrong type.
-  auto i64Type = mlir::IntegerType::get(64, &context);
+  auto i64Type = mlir::IntegerType::get(&context, 64);
   auto elementsType = mlir::RankedTensorType::get({3}, i64Type);
   auto elementsAttr =
       mlir::DenseIntElementsAttr::get(elementsType, ArrayRef<int64_t>{1, 2, 3});
   mlir::Identifier id = expectedValues.back().first;
   auto wrongAttr = mlir::NamedAttribute(id, elementsAttr);
   newValues.push_back(wrongAttr);
 
   auto badDictionary = mlir::DictionaryAttr::get(newValues, &context);