[mlir][IR] Refactor the `getChecked` and `verifyConstructionInvariants` methods on Attributes/Types

[rriddle]

Summary

verifyConstructionInvariants is intended to allow for verifying the invariants of an attribute/type on construction, and getChecked is intended to enable more graceful error handling aside from an assert. There are a few problems with the current implementation of these methods:

• verifyConstructionInvariants requires an mlir::Location for emitting errors, which is prohibitively costly in the situations that would most likely use them, e.g. the parser.

This creates an unfortunate code duplication between the verifier code and the parser code, given that the parser operates on llvm::SMLoc and it is an undesirable overhead to pre-emptively convert from that to an mlir::Location.

• getChecked effectively requires duplicating the definition of the get method, creating a quite clunky workflow due to the subtle different in its signature.

This revision aims to talk the above problems by refactoring the implementation to use a callback for error emission. Using a callback allows for deferring the costly part of error emission until it is actually necessary.

Due to the necessary signature change in each instance of these methods, this revision also takes this opportunity to cleanup the definition of these methods by:

• restructuring the signature of getChecked such that it can be generated from the same code block as the get method.
• renaming verifyConstructionInvariants to verify to match the naming scheme of the rest of the compiler.

[mehdi_amini]

No change needed in flang?

[rriddle]

In D97100#2575967, @mehdi_amini wrote:

No change needed in flang?

Thanks, added flang change on commit.

flang/include/flang/Optimizer/Dialect/FIRType.h

 #include "llvm/ADT/SmallVector.h"
 
 #define GET_TYPEDEF_CLASSES
 #include "flang/Optimizer/Dialect/FIROpsTypes.h.inc"
 
 namespace llvm {
 class raw_ostream;
 class StringRef;
-template <typename>
-class ArrayRef;
+template <typename> class ArrayRef;
 class hash_code;
 } // namespace llvm
 
 namespace mlir {
 class DialectAsmParser;
 class DialectAsmPrinter;
 class ComplexType;
 class FloatType;

 class HeapType : public mlir::Type::TypeBase<HeapType, mlir::Type,
                                              detail::HeapTypeStorage> {
 public:
   using Base::Base;
   static HeapType get(mlir::Type elementType);
 
   mlir::Type getEleTy() const;
 
-  static mlir::LogicalResult verifyConstructionInvariants(mlir::Location,
-                                                          mlir::Type eleTy);
+  static mlir::LogicalResult
+  verify(llvm::function_ref<mlir::InFlightDiagnostic()> emitError,
 };
 
 /// The type of a LEN parameter name. Implementations may defer the layout of a
 /// Fortran derived type until runtime. This implies that the runtime must be
 /// able to determine the offset of LEN type parameters related to an entity.
 class LenType
     : public mlir::Type::TypeBase<LenType, mlir::Type, detail::LenTypeStorage> {
 public:
   using Base::Base;
   static LenType get(mlir::MLIRContext *ctxt);
 };
 
 /// The type of entities with the POINTER attribute.  These pointers are
 /// explicitly distinguished to disallow the composition of multiple levels of
 /// indirection. For example, an ALLOCATABLE POINTER is invalid.
 class PointerType : public mlir::Type::TypeBase<PointerType, mlir::Type,
                                                 detail::PointerTypeStorage> {
 public:
   using Base::Base;
   static PointerType get(mlir::Type elementType);
 
   mlir::Type getEleTy() const;
 
-  static mlir::LogicalResult verifyConstructionInvariants(mlir::Location,
-                                                          mlir::Type eleTy);
+  static mlir::LogicalResult
+  verify(llvm::function_ref<mlir::InFlightDiagnostic()> emitError,
 };
 
 /// The type of a reference to an entity in memory.
 class ReferenceType
     : public mlir::Type::TypeBase<ReferenceType, mlir::Type,
                                   detail::ReferenceTypeStorage> {
 public:
   using Base::Base;
   static ReferenceType get(mlir::Type elementType);
 
   mlir::Type getEleTy() const;
 
-  static mlir::LogicalResult verifyConstructionInvariants(mlir::Location,
-                                                          mlir::Type eleTy);
+  static mlir::LogicalResult
+  verify(llvm::function_ref<mlir::InFlightDiagnostic()> emitError,
 };
 
 /// A sequence type is a multi-dimensional array of values. The sequence type
 /// may have an unknown number of dimensions or the extent of dimensions may be
 /// unknown. A sequence type models a Fortran array entity, giving it a type in
 /// FIR. A sequence type is assumed to be stored in a column-major order, which
 /// differs from LLVM IR and other dialects of MLIR.
 class SequenceType : public mlir::Type::TypeBase<SequenceType, mlir::Type,
public:
   /// (`array<*xT>`), or rows with shape and ending with column(s) of
   /// unknown extent (`array<C...xCx?...x?xT>`).
   bool hasConstantInterior() const;
 
   /// The value `-1` represents an unknown extent for a dimension
   static constexpr Extent getUnknownExtent() { return -1; }
 
   static mlir::LogicalResult
-  verifyConstructionInvariants(mlir::Location loc, const Shape &shape,
-                               mlir::Type eleTy, mlir::AffineMapAttr map);
+  verify(llvm::function_ref<mlir::InFlightDiagnostic()> emitError,
+         const Shape &shape, mlir::Type eleTy, mlir::AffineMapAttr map);
 };
 
 bool operator==(const SequenceType::Shape &, const SequenceType::Shape &);
 llvm::hash_code hash_value(const SequenceType::Extent &);
 llvm::hash_code hash_value(const SequenceType::Shape &);
 
 /// The type of a type descriptor object. The runtime may generate type
 /// descriptor objects to determine the type of an entity at runtime, etc.
 class TypeDescType : public mlir::Type::TypeBase<TypeDescType, mlir::Type,
                                                  detail::TypeDescTypeStorage> {
 public:
   using Base::Base;
   static TypeDescType get(mlir::Type ofType);
   mlir::Type getOfTy() const;
 
-  static mlir::LogicalResult verifyConstructionInvariants(mlir::Location,
-                                                          mlir::Type ofType);
+  static mlir::LogicalResult
+  verify(llvm::function_ref<mlir::InFlightDiagnostic()> emitError,
 };
 
 // Derived types
 
 /// Model of Fortran's derived type, TYPE. The name of the TYPE includes any
 /// KIND type parameters. The record includes runtime slots for LEN type
 /// parameters and for data components.
 class RecordType : public mlir::Type::TypeBase<RecordType, mlir::Type,
public:
   unsigned getNumLenParams() { return getLenParamList().size(); }
 
   static RecordType get(mlir::MLIRContext *ctxt, llvm::StringRef name);
   void finalize(llvm::ArrayRef<TypePair> lenPList,
                 llvm::ArrayRef<TypePair> typeList);
 
   detail::RecordTypeStorage const *uniqueKey() const;
 
-  static mlir::LogicalResult verifyConstructionInvariants(mlir::Location,
-                                                          llvm::StringRef name);
+  static mlir::LogicalResult
+  verify(llvm::function_ref<mlir::InFlightDiagnostic()> emitError,
 };
 
 /// Is `t` a FIR Real or MLIR Float type?
 inline bool isa_real(mlir::Type t) {
   return t.isa<fir::RealType>() || t.isa<mlir::FloatType>();
 }
 
 /// Is `t` an integral type?

 public:
   using Base::Base;
 
   static fir::VectorType get(uint64_t len, mlir::Type eleTy);
   mlir::Type getEleTy() const;
   uint64_t getLen() const;
 
   static mlir::LogicalResult
-  verifyConstructionInvariants(mlir::Location, uint64_t len, mlir::Type eleTy);
+  verify(llvm::function_ref<mlir::InFlightDiagnostic()> emitError, uint64_t len,
+         mlir::Type eleTy);
   static bool isValidElementType(mlir::Type t) {
     return isa_real(t) || isa_integer(t);
   }
 };
 
 mlir::Type parseFirType(FIROpsDialect *, mlir::DialectAsmParser &parser);
 
 void printFirType(FIROpsDialect *, mlir::Type ty, mlir::DialectAsmPrinter &p);

flang/include/flang/Optimizer/Dialect/FIRTypes.td

def fir_BoxProcType : FIR_Type<"BoxProc", "boxproc"> {
 
   let printer = [{
     $_printer << "boxproc<";
     $_printer.printType(getEleTy());
     $_printer << '>';
   }];
 
   let genAccessors = 1;
-  let genVerifyInvariantsDecl = 1;
+  let genVerifyDecl = 1;
 }
 
 def fir_BoxType : FIR_Type<"Box", "box"> {
   let summary = "The type of a Fortran descriptor";
 
   let description = [{
     Descriptors are tuples of information that describe an entity being passed
     from a calling context. This information might include (but is not limited
     to) whether the entity is an array, its size, or what type it has.
   }];
 
   let parameters = (ins "mlir::Type":$eleTy, "mlir::AffineMapAttr":$map);
 
   let extraClassDeclaration = [{
     mlir::Type getElementType() const { return getEleTy(); }
     mlir::AffineMapAttr getLayoutMap() const { return getMap(); }
     static BoxType get(mlir::Type eleTy, mlir::AffineMapAttr map = {}) {
       return get(eleTy.getContext(), eleTy, map);
     }
   }];
 
   let genAccessors = 1;
-  let genVerifyInvariantsDecl = 1;
+  let genVerifyDecl = 1;
 }
 
 def fir_CharacterType : FIR_Type<"Character", "char"> {
   let summary = "FIR character type";
 
   let description = [{
     Model of the Fortran CHARACTER intrinsic type, including the KIND type
     parameter. The model optionally includes a LEN type parameter. A

flang/lib/Optimizer/Dialect/FIRType.cpp

 private:
   VectorTypeStorage() = delete;
   explicit VectorTypeStorage(uint64_t len, mlir::Type eleTy)
       : len{len}, eleTy{eleTy} {}
 };
 
 } // namespace detail
 
-template <typename A, typename B>
-bool inbounds(A v, B lb, B ub) {
+template <typename A, typename B> bool inbounds(A v, B lb, B ub) {
   return v >= lb && v < ub;
 }
 
 bool isa_fir_type(mlir::Type t) {
   return llvm::isa<FIROpsDialect>(t.getDialect());
 }
 
 bool isa_std_type(mlir::Type t) {

 
 RealType fir::RealType::get(mlir::MLIRContext *ctxt, KindTy kind) {
   return Base::get(ctxt, kind);
 }
 
 KindTy fir::RealType::getFKind() const { return getImpl()->getFKind(); }
 
 mlir::LogicalResult
-fir::BoxType::verifyConstructionInvariants(mlir::Location, mlir::Type eleTy,
-                                           mlir::AffineMapAttr map) {
+fir::BoxType::verify(llvm::function_ref<mlir::InFlightDiagnostic()>,
+                     mlir::Type eleTy, mlir::AffineMapAttr map) {
   // TODO
   return mlir::success();
 }
 
 // Reference<T>
 
 ReferenceType fir::ReferenceType::get(mlir::Type elementType) {
   return Base::get(elementType.getContext(), elementType);
 }
 
 mlir::Type fir::ReferenceType::getEleTy() const {
   return getImpl()->getElementType();
 }
 
-mlir::LogicalResult
-fir::ReferenceType::verifyConstructionInvariants(mlir::Location loc,
-                                                 mlir::Type eleTy) {
+mlir::LogicalResult fir::ReferenceType::verify(
+    llvm::function_ref<mlir::InFlightDiagnostic()> emitError,
   if (eleTy.isa<ShapeType>() || eleTy.isa<ShapeShiftType>() ||
       eleTy.isa<SliceType>() || eleTy.isa<FieldType>() ||
       eleTy.isa<LenType>() || eleTy.isa<ReferenceType>() ||
       eleTy.isa<TypeDescType>())
-    return mlir::emitError(loc, "cannot build a reference to type: ")
-           << eleTy << '\n';
+    return emitError() << "cannot build a reference to type: " << eleTy << '\n';
   return mlir::success();
 }
 
 // Pointer<T>
 
 PointerType fir::PointerType::get(mlir::Type elementType) {
   assert(singleIndirectionLevel(elementType) && "invalid element type");
   return Base::get(elementType.getContext(), elementType);
 }
 
 mlir::Type fir::PointerType::getEleTy() const {
   return getImpl()->getElementType();
 }
 
 static bool canBePointerOrHeapElementType(mlir::Type eleTy) {
   return eleTy.isa<BoxType>() || eleTy.isa<BoxCharType>() ||
          eleTy.isa<BoxProcType>() || eleTy.isa<ShapeType>() ||
          eleTy.isa<ShapeShiftType>() || eleTy.isa<SliceType>() ||
          eleTy.isa<FieldType>() || eleTy.isa<LenType>() ||
          eleTy.isa<HeapType>() || eleTy.isa<PointerType>() ||
          eleTy.isa<ReferenceType>() || eleTy.isa<TypeDescType>();
 }
 
-mlir::LogicalResult
-fir::PointerType::verifyConstructionInvariants(mlir::Location loc,
-                                               mlir::Type eleTy) {
+mlir::LogicalResult fir::PointerType::verify(
+    llvm::function_ref<mlir::InFlightDiagnostic()> emitError,
   if (canBePointerOrHeapElementType(eleTy))
-    return mlir::emitError(loc, "cannot build a pointer to type: ")
-           << eleTy << '\n';
+    return emitError() << "cannot build a pointer to type: " << eleTy << '\n';
   return mlir::success();
 }
 
 // Heap<T>
 
 HeapType fir::HeapType::get(mlir::Type elementType) {
   assert(singleIndirectionLevel(elementType) && "invalid element type");
   return Base::get(elementType.getContext(), elementType);
 }
 
 mlir::Type fir::HeapType::getEleTy() const {
   return getImpl()->getElementType();
 }
 
 mlir::LogicalResult
-fir::HeapType::verifyConstructionInvariants(mlir::Location loc,
-                                            mlir::Type eleTy) {
+fir::HeapType::verify(llvm::function_ref<mlir::InFlightDiagnostic()> emitError,
   if (canBePointerOrHeapElementType(eleTy))
-    return mlir::emitError(loc, "cannot build a heap pointer to type: ")
-           << eleTy << '\n';
+    return emitError() << "cannot build a heap pointer to type: " << eleTy
+                       << '\n';
   return mlir::success();
 }
 
 // Sequence<T>
 
 SequenceType fir::SequenceType::get(const Shape &shape, mlir::Type elementType,
                                     mlir::AffineMapAttr map) {
   auto *ctxt = elementType.getContext();
if (rows == dim)
     return true;
   auto shape = getShape();
   for (unsigned i{rows}, size{dim}; i < size; ++i)
     if (shape[i] != getUnknownExtent())
       return false;
   return true;
 }
 
-mlir::LogicalResult fir::SequenceType::verifyConstructionInvariants(
-    mlir::Location loc, const SequenceType::Shape &shape, mlir::Type eleTy,
+mlir::LogicalResult fir::SequenceType::verify(
+    llvm::function_ref<mlir::InFlightDiagnostic()> emitError,
+    const SequenceType::Shape &shape, mlir::Type eleTy,
     mlir::AffineMapAttr map) {
   // DIMENSION attribute can only be applied to an intrinsic or record type
   if (eleTy.isa<BoxType>() || eleTy.isa<BoxCharType>() ||
       eleTy.isa<BoxProcType>() || eleTy.isa<ShapeType>() ||
       eleTy.isa<ShapeShiftType>() || eleTy.isa<SliceType>() ||
       eleTy.isa<FieldType>() || eleTy.isa<LenType>() || eleTy.isa<HeapType>() ||
       eleTy.isa<PointerType>() || eleTy.isa<ReferenceType>() ||
       eleTy.isa<TypeDescType>() || eleTy.isa<fir::VectorType>() ||
       eleTy.isa<SequenceType>())
-    return mlir::emitError(loc, "cannot build an array of this element type: ")
+    return emitError() << "cannot build an array of this element type: "
                        << eleTy << '\n';
   return mlir::success();
 }
 
 // compare if two shapes are equivalent
 bool fir::operator==(const SequenceType::Shape &sh_1,
                      const SequenceType::Shape &sh_2) {
   if (sh_1.size() != sh_2.size())
     return false;

 RecordType::TypeList fir::RecordType::getLenParamList() {
   return getImpl()->getLenParamList();
 }
 
 detail::RecordTypeStorage const *fir::RecordType::uniqueKey() const {
   return getImpl();
 }
 
-mlir::LogicalResult
-fir::RecordType::verifyConstructionInvariants(mlir::Location loc,
-                                              llvm::StringRef name) {
+mlir::LogicalResult fir::RecordType::verify(
+    llvm::function_ref<mlir::InFlightDiagnostic()> emitError,
   if (name.size() == 0)
-    return mlir::emitError(loc, "record types must have a name");
+    return emitError() << "record types must have a name";
   return mlir::success();
 }
 
 mlir::Type fir::RecordType::getType(llvm::StringRef ident) {
   for (auto f : getTypeList())
     if (ident == f.first)
       return f.second;
   return {};
 }
 
 //===----------------------------------------------------------------------===//
 // Type descriptor type
 //===----------------------------------------------------------------------===//
 
 TypeDescType fir::TypeDescType::get(mlir::Type ofType) {
   assert(!ofType.isa<ReferenceType>());
   return Base::get(ofType.getContext(), ofType);
 }
 
 mlir::Type fir::TypeDescType::getOfTy() const { return getImpl()->getOfType(); }
 
-mlir::LogicalResult
-fir::TypeDescType::verifyConstructionInvariants(mlir::Location loc,
-                                                mlir::Type eleTy) {
+mlir::LogicalResult fir::TypeDescType::verify(
+    llvm::function_ref<mlir::InFlightDiagnostic()> emitError,
   if (eleTy.isa<BoxType>() || eleTy.isa<BoxCharType>() ||
       eleTy.isa<BoxProcType>() || eleTy.isa<ShapeType>() ||
       eleTy.isa<ShapeShiftType>() || eleTy.isa<SliceType>() ||
       eleTy.isa<FieldType>() || eleTy.isa<LenType>() ||
       eleTy.isa<ReferenceType>() || eleTy.isa<TypeDescType>())
-    return mlir::emitError(loc, "cannot build a type descriptor of type: ")
-           << eleTy << '\n';
+    return emitError() << "cannot build a type descriptor of type: " << eleTy
+                       << '\n';
   return mlir::success();
 }
 
 //===----------------------------------------------------------------------===//
 // Vector type
 //===----------------------------------------------------------------------===//
 
 fir::VectorType fir::VectorType::get(uint64_t len, mlir::Type eleTy) {
   return Base::get(eleTy.getContext(), len, eleTy);
 }
 
 mlir::Type fir::VectorType::getEleTy() const { return getImpl()->getEleTy(); }
 
 uint64_t fir::VectorType::getLen() const { return getImpl()->getLen(); }
 
-mlir::LogicalResult
-fir::VectorType::verifyConstructionInvariants(mlir::Location loc, uint64_t len,
-                                              mlir::Type eleTy) {
+mlir::LogicalResult fir::VectorType::verify(
+    llvm::function_ref<mlir::InFlightDiagnostic()> emitError, uint64_t len,
   if (!(fir::isa_real(eleTy) || fir::isa_integer(eleTy)))
-    return mlir::emitError(loc, "cannot build a vector of type ")
-           << eleTy << '\n';
+    return emitError() << "cannot build a vector of type " << eleTy << '\n';
   return mlir::success();
 }
 
 namespace {
 
 void printBounds(llvm::raw_ostream &os, const SequenceType::Shape &bounds) {
   os << '<';
   for (auto &b : bounds) {
mlir::Type BoxProcType::parse(mlir::MLIRContext *context,
   if (parser.parseLess() || parser.parseType(ty) || parser.parseGreater()) {
     parser.emitError(parser.getCurrentLocation(), "type expected");
     return Type();
   }
   return get(context, ty);
 }
 
 mlir::LogicalResult
-BoxProcType::verifyConstructionInvariants(mlir::Location loc,
-                                          mlir::Type eleTy) {
+BoxProcType::verify(llvm::function_ref<mlir::InFlightDiagnostic()> emitError,
   if (eleTy.isa<mlir::FunctionType>())
     return mlir::success();
   if (auto refTy = eleTy.dyn_cast<ReferenceType>())
     if (refTy.isa<mlir::FunctionType>())
       return mlir::success();
-  return mlir::emitError(loc, "invalid type for boxproc") << eleTy << '\n';
+  return emitError() << "invalid type for boxproc" << eleTy << '\n';
 }
 
 //===----------------------------------------------------------------------===//
 // BoxType
 //===----------------------------------------------------------------------===//
 
 // `box` `<` type (',' affine-map)? `>`
 mlir::Type fir::BoxType::parse(mlir::MLIRContext *context,

mlir/docs/OpDefinitions.md

 ### Other fields
 
 -   If the `genStorageClass` field is set to 1 (the default) a storage class is
     generated with member variables corresponding to each of the specified
     `parameters`.
 -   If the `genAccessors` field is 1 (the default) accessor methods will be
     generated on the Type class (e.g. `int getWidth() const` in the example
     above).
--   If the `genVerifyInvariantsDecl` field is set, a declaration for a method
-    `static LogicalResult verifyConstructionInvariants(Location, parameters...)`
-    is added to the class as well as a `getChecked(Location, parameters...)`
-    method which gets the result of `verifyConstructionInvariants` before
-    calling `get`.
+-   If the `genVerifyDecl` field is set, a declaration for a method `static
+    LogicalResult verify(emitErrorFn, parameters...)` is added to the class as
+    well as a `getChecked(emitErrorFn, parameters...)` method which checks the
+    result of `verify` before calling `get`.
 -   The `storageClass` field can be used to set the name of the storage class.
 -   The `storageNamespace` field is used to set the namespace where the storage
     class should sit. Defaults to "detail".
 -   The `extraClassDeclaration` field is used to include extra code in the class
     declaration.
 
 ### Type builder methods
 

 
 The following builders are generated:
 
 ```c++
 // Type builders are named `get`, and return a new instance of a type for a
 // given set of parameters.
 static MyType get(MLIRContext *context, int intParam);
 
-// If `genVerifyInvariantsDecl` is set to 1, the following method is also
-// generated.
-static MyType getChecked(Location loc, int intParam);
+// If `genVerifyDecl` is set to 1, the following method is also generated.
+static MyType getChecked(function_ref<InFlightDiagnostic()> emitError,
+                         MLIRContext *context, int intParam);
 ```
 
 If these autogenerated methods are not desired, such as when they conflict with
 a custom builder method, a type can set `skipDefaultBuilders` to 1 to signal
 that they should not be generated.
 
 #### Custom type builder methods
 

mlir/docs/Tutorials/DefiningAttributesAndTypes.md

public:
   /// gracefully handle failed construction, getChecked should be used instead.
   static ComplexType get(unsigned param, Type type) {
     // Call into a helper 'get' method in 'TypeBase' to get a uniqued instance
     // of this type. All parameters to the storage class are passed after the
     // context.
     return Base::get(type.getContext(), param, type);
   }
 
-  /// This method is used to get an instance of the 'ComplexType', defined at
-  /// the given location. If any of the construction invariants are invalid,
-  /// errors are emitted with the provided location and a null type is returned.
+  /// This method is used to get an instance of the 'ComplexType'. If any of the
+  /// construction invariants are invalid, errors are emitted with the provided
+  /// `emitError` function and a null type is returned.
   /// Note: This method is completely optional.
-  static ComplexType getChecked(unsigned param, Type type, Location location) {
+  static ComplexType getChecked(function_ref<InFlightDiagnostic()> emitError,
+                                unsigned param, Type type) {
     // Call into a helper 'getChecked' method in 'TypeBase' to get a uniqued
     // instance of this type. All parameters to the storage class are passed
-    // after the location.
-    return Base::getChecked(location, param, type);
+    // after the context.
+    return Base::getChecked(emitError, type.getContext(), param, type);
   }
 
   /// This method is used to verify the construction invariants passed into the
   /// 'get' and 'getChecked' methods. Note: This method is completely optional.
-  static LogicalResult verifyConstructionInvariants(
-      Location loc, unsigned param, Type type) {
+  static LogicalResult verify(function_ref<InFlightDiagnostic()> emitError,
+                              unsigned param, Type type) {
     // Our type only allows non-zero parameters.
     if (param == 0)
-      return emitError(loc) << "non-zero parameter passed to 'ComplexType'";
+      return emitError() << "non-zero parameter passed to 'ComplexType'";
     // Our type also expects an integer type.
     if (!type.isa<IntegerType>())
-      return emitError(loc) << "non integer-type passed to 'ComplexType'";
+      return emitError() << "non integer-type passed to 'ComplexType'";
     return success();
   }
 
   /// Return the parameter value.
   unsigned getParameter() {
     // 'getImpl' returns a pointer to our internal storage instance.
     return getImpl()->nonZeroParam;
   }

mlir/include/mlir-c/BuiltinAttributes.h

 /// Creates a floating point attribute in the given context with the given
 /// double value and double-precision FP semantics.
 MLIR_CAPI_EXPORTED MlirAttribute mlirFloatAttrDoubleGet(MlirContext ctx,
                                                         MlirType type,
                                                         double value);
 
 /// Same as "mlirFloatAttrDoubleGet", but if the type is not valid for a
 /// construction of a FloatAttr, returns a null MlirAttribute.
-MLIR_CAPI_EXPORTED MlirAttribute
-mlirFloatAttrDoubleGetChecked(MlirType type, double value, MlirLocation loc);
+MLIR_CAPI_EXPORTED MlirAttribute mlirFloatAttrDoubleGetChecked(MlirLocation loc,
+                                                               MlirType type,
+                                                               double value);
 
 /// Returns the value stored in the given floating point attribute, interpreting
 /// the value as double.
 MLIR_CAPI_EXPORTED double mlirFloatAttrGetValueDouble(MlirAttribute attr);
 
 //===----------------------------------------------------------------------===//
 // Integer attribute.
 //===----------------------------------------------------------------------===//

mlir/include/mlir-c/BuiltinTypes.h

 /// with the given element type in the same context as the element type. The
 /// type is owned by the context.
 MLIR_CAPI_EXPORTED MlirType mlirVectorTypeGet(intptr_t rank,
                                               const int64_t *shape,
                                               MlirType elementType);
 
 /// Same as "mlirVectorTypeGet" but returns a nullptr wrapping MlirType on
 /// illegal arguments, emitting appropriate diagnostics.
-MLIR_CAPI_EXPORTED MlirType mlirVectorTypeGetChecked(intptr_t rank,
+MLIR_CAPI_EXPORTED MlirType mlirVectorTypeGetChecked(MlirLocation loc,
+                                                     intptr_t rank,
                                                      const int64_t *shape,
-                                                     MlirType elementType,
-                                                     MlirLocation loc);
+                                                     MlirType elementType);
 
 //===----------------------------------------------------------------------===//
 // Ranked / Unranked Tensor type.
 //===----------------------------------------------------------------------===//
 
 /// Checks whether the given type is a Tensor type.
 MLIR_CAPI_EXPORTED bool mlirTypeIsATensor(MlirType type);
 
 /// Checks whether the given type is a ranked tensor type.
 MLIR_CAPI_EXPORTED bool mlirTypeIsARankedTensor(MlirType type);
 
 /// Checks whether the given type is an unranked tensor type.
 MLIR_CAPI_EXPORTED bool mlirTypeIsAUnrankedTensor(MlirType type);
 
 /// Creates a tensor type of a fixed rank with the given shape and element type
 /// in the same context as the element type. The type is owned by the context.
 MLIR_CAPI_EXPORTED MlirType mlirRankedTensorTypeGet(intptr_t rank,
                                                     const int64_t *shape,
                                                     MlirType elementType);
 
 /// Same as "mlirRankedTensorTypeGet" but returns a nullptr wrapping MlirType on
 /// illegal arguments, emitting appropriate diagnostics.
-MLIR_CAPI_EXPORTED MlirType mlirRankedTensorTypeGetChecked(intptr_t rank,
-                                                           const int64_t *shape,
-                                                           MlirType elementType,
-                                                           MlirLocation loc);
+MLIR_CAPI_EXPORTED MlirType
+mlirRankedTensorTypeGetChecked(MlirLocation loc, intptr_t rank,
+                               const int64_t *shape, MlirType elementType);
 
 /// Creates an unranked tensor type with the given element type in the same
 /// context as the element type. The type is owned by the context.
 MLIR_CAPI_EXPORTED MlirType mlirUnrankedTensorTypeGet(MlirType elementType);
 
 /// Same as "mlirUnrankedTensorTypeGet" but returns a nullptr wrapping MlirType
 /// on illegal arguments, emitting appropriate diagnostics.
 MLIR_CAPI_EXPORTED MlirType
-mlirUnrankedTensorTypeGetChecked(MlirType elementType, MlirLocation loc);
+mlirUnrankedTensorTypeGetChecked(MlirLocation loc, MlirType elementType);
 
 //===----------------------------------------------------------------------===//
 // Ranked / Unranked MemRef type.
 //===----------------------------------------------------------------------===//
 
 /// Checks whether the given type is a MemRef type.
 MLIR_CAPI_EXPORTED bool mlirTypeIsAMemRef(MlirType type);
 
 /// Checks whether the given type is an UnrankedMemRef type.
 MLIR_CAPI_EXPORTED bool mlirTypeIsAUnrankedMemRef(MlirType type);
 
 /// Creates a MemRef type with the given rank and shape, a potentially empty
 /// list of affine layout maps, the given memory space and element type, in the
 /// same context as element type. The type is owned by the context.
 MLIR_CAPI_EXPORTED MlirType mlirMemRefTypeGet(
     MlirType elementType, intptr_t rank, const int64_t *shape, intptr_t numMaps,
     MlirAffineMap const *affineMaps, unsigned memorySpace);
 
 /// Same as "mlirMemRefTypeGet" but returns a nullptr-wrapping MlirType o
 /// illegal arguments, emitting appropriate diagnostics.
 MLIR_CAPI_EXPORTED MlirType mlirMemRefTypeGetChecked(
-    MlirType elementType, intptr_t rank, const int64_t *shape, intptr_t numMaps,
-    MlirAffineMap const *affineMaps, unsigned memorySpace, MlirLocation loc);
+    MlirLocation loc, MlirType elementType, intptr_t rank, const int64_t *shape,
+    intptr_t numMaps, MlirAffineMap const *affineMaps, unsigned memorySpace);
 
 /// Creates a MemRef type with the given rank, shape, memory space and element
 /// type in the same context as the element type. The type has no affine maps,
 /// i.e. represents a default row-major contiguous memref. The type is owned by
 /// the context.
 MLIR_CAPI_EXPORTED MlirType mlirMemRefTypeContiguousGet(MlirType elementType,
                                                         intptr_t rank,
                                                         const int64_t *shape,
                                                         unsigned memorySpace);
 
 /// Same as "mlirMemRefTypeContiguousGet" but returns a nullptr wrapping
 /// MlirType on illegal arguments, emitting appropriate diagnostics.
 MLIR_CAPI_EXPORTED MlirType mlirMemRefTypeContiguousGetChecked(
-    MlirType elementType, intptr_t rank, const int64_t *shape,
-    unsigned memorySpace, MlirLocation loc);
+    MlirLocation loc, MlirType elementType, intptr_t rank, const int64_t *shape,
+    unsigned memorySpace);
 
 /// Creates an Unranked MemRef type with the given element type and in the given
 /// memory space. The type is owned by the context of element type.
 MLIR_CAPI_EXPORTED MlirType mlirUnrankedMemRefTypeGet(MlirType elementType,
                                                       unsigned memorySpace);
 
 /// Same as "mlirUnrankedMemRefTypeGet" but returns a nullptr wrapping
 /// MlirType on illegal arguments, emitting appropriate diagnostics.
 MLIR_CAPI_EXPORTED MlirType mlirUnrankedMemRefTypeGetChecked(
-    MlirType elementType, unsigned memorySpace, MlirLocation loc);
+    MlirLocation loc, MlirType elementType, unsigned memorySpace);
 
 /// Returns the number of affine layout maps in the given MemRef type.
 MLIR_CAPI_EXPORTED intptr_t mlirMemRefTypeGetNumAffineMaps(MlirType type);
 
 /// Returns the pos-th affine map of the given MemRef type.
 MLIR_CAPI_EXPORTED MlirAffineMap mlirMemRefTypeGetAffineMap(MlirType type,
                                                             intptr_t pos);
 

mlir/include/mlir/Dialect/Async/IR/AsyncTypes.td

let description = [{
     `async.value` represents a value returned by asynchronous operations,
     which may or may not be available currently, but will be available at some
     point in the future.
   }];
 
   let parameters = (ins "Type":$valueType);
   let builders = [
     TypeBuilderWithInferredContext<(ins "Type":$valueType), [{
-      return Base::get(valueType.getContext(), valueType);
-    }], [{
-      return Base::getChecked($_loc, valueType);
+      return $_get(valueType.getContext(), valueType);
     }]>
   ];
   let skipDefaultBuilders = 1;
 }
 
 def Async_GroupType : Async_Type<"Group", "group"> {
   let summary = "async group type";
   let description = [{

mlir/include/mlir/Dialect/LLVMIR/LLVMTypes.h

 /// LLVM dialect array type. It is an aggregate type representing consecutive
 /// elements in memory, parameterized by the number of elements and the element
 /// type.
 class LLVMArrayType : public Type::TypeBase<LLVMArrayType, Type,
                                             detail::LLVMTypeAndSizeStorage> {
 public:
   /// Inherit base constructors.
   using Base::Base;
+  using Base::getChecked;
 
   /// Checks if the given type can be used inside an array type.
   static bool isValidElementType(Type type);
 
   /// Gets or creates an instance of LLVM dialect array type containing
   /// `numElements` of `elementType`, in the same context as `elementType`.
   static LLVMArrayType get(Type elementType, unsigned numElements);
-  static LLVMArrayType getChecked(Location loc, Type elementType,
-                                  unsigned numElements);
+  static LLVMArrayType getChecked(function_ref<InFlightDiagnostic()> emitError,
+                                  Type elementType, unsigned numElements);
 
   /// Returns the element type of the array.
   Type getElementType();
 
   /// Returns the number of elements in the array type.
   unsigned getNumElements();
 
   /// Verifies that the type about to be constructed is well-formed.
-  static LogicalResult verifyConstructionInvariants(Location loc,
-                                                    Type elementType,
-                                                    unsigned numElements);
+  static LogicalResult verify(function_ref<InFlightDiagnostic()> emitError,
+                              Type elementType, unsigned numElements);
 };
 
 //===----------------------------------------------------------------------===//
 // LLVMFunctionType.
 //===----------------------------------------------------------------------===//
 
 /// LLVM dialect function type. It consists of a single return type (unlike MLIR
 /// which can have multiple), a list of parameter types and can optionally be
 /// variadic.
 class LLVMFunctionType
     : public Type::TypeBase<LLVMFunctionType, Type,
                             detail::LLVMFunctionTypeStorage> {
 public:
   /// Inherit base constructors.
   using Base::Base;
+  using Base::getChecked;
 
   /// Checks if the given type can be used an argument in a function type.
   static bool isValidArgumentType(Type type);
 
   /// Checks if the given type can be used as a result in a function type.
   static bool isValidResultType(Type type);
 
   /// Returns whether the function is variadic.
   bool isVarArg();
 
   /// Gets or creates an instance of LLVM dialect function in the same context
   /// as the `result` type.
   static LLVMFunctionType get(Type result, ArrayRef<Type> arguments,
                               bool isVarArg = false);
-  static LLVMFunctionType getChecked(Location loc, Type result,
-                                     ArrayRef<Type> arguments,
-                                     bool isVarArg = false);
+  static LLVMFunctionType
+  getChecked(function_ref<InFlightDiagnostic()> emitError, Type result,
+             ArrayRef<Type> arguments, bool isVarArg = false);
 
   /// Returns the result type of the function.
   Type getReturnType();
 
   /// Returns the number of arguments to the function.
   unsigned getNumParams();
 
   /// Returns `i`-th argument of the function. Asserts on out-of-bounds.
   Type getParamType(unsigned i);
 
   /// Returns a list of argument types of the function.
   ArrayRef<Type> getParams();
   ArrayRef<Type> params() { return getParams(); }
 
   /// Verifies that the type about to be constructed is well-formed.
-  static LogicalResult verifyConstructionInvariants(Location loc, Type result,
-                                                    ArrayRef<Type> arguments,
-                                                    bool);
+  static LogicalResult verify(function_ref<InFlightDiagnostic()> emitError,
+                              Type result, ArrayRef<Type> arguments, bool);
 };
 
 //===----------------------------------------------------------------------===//
 // LLVMPointerType.
 //===----------------------------------------------------------------------===//
 
 /// LLVM dialect pointer type. This type typically represents a reference to an
 /// object in memory. It is parameterized by the element type and the address
 /// space.
 class LLVMPointerType : public Type::TypeBase<LLVMPointerType, Type,
                                               detail::LLVMPointerTypeStorage> {
 public:
   /// Inherit base constructors.
   using Base::Base;
+  using Base::getChecked;
 
   /// Checks if the given type can have a pointer type pointing to it.
   static bool isValidElementType(Type type);
 
   /// Gets or creates an instance of LLVM dialect pointer type pointing to an
   /// object of `pointee` type in the given address space. The pointer type is
   /// created in the same context as `pointee`.
   static LLVMPointerType get(Type pointee, unsigned addressSpace = 0);
-  static LLVMPointerType getChecked(Location loc, Type pointee,
-                                    unsigned addressSpace = 0);
+  static LLVMPointerType
+  getChecked(function_ref<InFlightDiagnostic()> emitError, Type pointee,
 
   /// Returns the pointed-to type.
   Type getElementType();
 
   /// Returns the address space of the pointer.
   unsigned getAddressSpace();
 
   /// Verifies that the type about to be constructed is well-formed.
-  static LogicalResult verifyConstructionInvariants(Location loc, Type pointee,
-                                                    unsigned);
+  static LogicalResult verify(function_ref<InFlightDiagnostic()> emitError,
+                              Type pointee, unsigned);
 };
 
 //===----------------------------------------------------------------------===//
 // LLVMStructType.
 //===----------------------------------------------------------------------===//
 
 /// LLVM dialect structure type representing a collection of different-typed
 /// elements manipulated together. Structured can optionally be packed, meaning
public:
   static bool isValidElementType(Type type);
 
   /// Gets or creates an identified struct with the given name in the provided
   /// context. Note that unlike llvm::StructType::create, this function will
   /// _NOT_ rename a struct in case a struct with the same name already exists
   /// in the context. Instead, it will just return the existing struct,
   /// similarly to the rest of MLIR type ::get methods.
   static LLVMStructType getIdentified(MLIRContext *context, StringRef name);
-  static LLVMStructType getIdentifiedChecked(Location loc, StringRef name);
+  static LLVMStructType
+  getIdentifiedChecked(function_ref<InFlightDiagnostic()> emitError,
+                       MLIRContext *context, StringRef name);
 
   /// Gets a new identified struct with the given body. The body _cannot_ be
   /// changed later. If a struct with the given name already exists, renames
   /// the struct by appending a `.` followed by a number to the name. Renaming
   /// happens even if the existing struct has the same body.
   static LLVMStructType getNewIdentified(MLIRContext *context, StringRef name,
                                          ArrayRef<Type> elements,
                                          bool isPacked = false);
 
   /// Gets or creates a literal struct with the given body in the provided
   /// context.
   static LLVMStructType getLiteral(MLIRContext *context, ArrayRef<Type> types,
                                    bool isPacked = false);
-  static LLVMStructType getLiteralChecked(Location loc, ArrayRef<Type> types,
-                                          bool isPacked = false);
+  static LLVMStructType
+  getLiteralChecked(function_ref<InFlightDiagnostic()> emitError,
+                    MLIRContext *context, ArrayRef<Type> types,
 
   /// Gets or creates an intentionally-opaque identified struct. Such a struct
   /// cannot have its body set. To create an opaque struct with a mutable body,
   /// use `getIdentified`. Note that unlike llvm::StructType::create, this
   /// function will _NOT_ rename a struct in case a struct with the same name
   /// already exists in the context. Instead, it will just return the existing
   /// struct, similarly to the rest of MLIR type ::get methods.
   static LLVMStructType getOpaque(StringRef name, MLIRContext *context);
-  static LLVMStructType getOpaqueChecked(Location loc, StringRef name);
+  static LLVMStructType
+  getOpaqueChecked(function_ref<InFlightDiagnostic()> emitError,
+                   MLIRContext *context, StringRef name);
 
   /// Set the body of an identified struct. Returns failure if the body could
   /// not be set, e.g. if the struct already has a body or if it was marked as
   /// intentionally opaque. This might happen in a multi-threaded context when a
   /// different thread modified the struct after it was created. Most callers
   /// are likely to assert this always succeeds, but it is possible to implement
   /// a local renaming scheme based on the result of this call.
   LogicalResult setBody(ArrayRef<Type> types, bool isPacked);
public:
 
   /// Returns the name of an identified struct.
   StringRef getName();
 
   /// Returns the list of element types contained in a non-opaque struct.
   ArrayRef<Type> getBody();
 
   /// Verifies that the type about to be constructed is well-formed.
-  static LogicalResult verifyConstructionInvariants(Location, StringRef, bool);
-  static LogicalResult verifyConstructionInvariants(Location loc,
-                                                    ArrayRef<Type> types, bool);
+  static LogicalResult verify(function_ref<InFlightDiagnostic()> emitError,
+                              StringRef, bool);
+  static LogicalResult verify(function_ref<InFlightDiagnostic()> emitError,
 };
 
 //===----------------------------------------------------------------------===//
 // LLVMVectorType.
 //===----------------------------------------------------------------------===//
 
 /// LLVM dialect vector type, represents a sequence of elements that can be
 /// processed as one, typically in SIMD context. This is a base class for fixed
public:
 
   /// Returns the element type of the vector.
   Type getElementType();
 
   /// Returns the number of elements in the vector.
   llvm::ElementCount getElementCount();
 
   /// Verifies that the type about to be constructed is well-formed.
-  static LogicalResult verifyConstructionInvariants(Location loc,
-                                                    Type elementType,
-                                                    unsigned numElements);
+  static LogicalResult verify(function_ref<InFlightDiagnostic()> emitError,
+                              Type elementType, unsigned numElements);
 };
 
 //===----------------------------------------------------------------------===//
 // LLVMFixedVectorType.
 //===----------------------------------------------------------------------===//
 
 /// LLVM dialect fixed vector type, represents a sequence of elements of known
 /// length that can be processed as one.
 class LLVMFixedVectorType
     : public Type::TypeBase<LLVMFixedVectorType, Type,
                             detail::LLVMTypeAndSizeStorage> {
 public:
   /// Inherit base constructor.
   using Base::Base;
+  using Base::getChecked;
 
   /// Gets or creates a fixed vector type containing `numElements` of
   /// `elementType` in the same context as `elementType`.
   static LLVMFixedVectorType get(Type elementType, unsigned numElements);
-  static LLVMFixedVectorType getChecked(Location loc, Type elementType,
-                                        unsigned numElements);
+  static LLVMFixedVectorType
+  getChecked(function_ref<InFlightDiagnostic()> emitError, Type elementType,
 
   /// Checks if the given type can be used in a vector type. This type supports
   /// only a subset of LLVM dialect types that don't have a built-in
   /// counter-part, e.g., pointers.
   static bool isValidElementType(Type type);
 
   /// Returns the element type of the vector.
   Type getElementType();
 
   /// Returns the number of elements in the fixed vector.
   unsigned getNumElements();
 
   /// Verifies that the type about to be constructed is well-formed.
-  static LogicalResult verifyConstructionInvariants(Location loc,
-                                                    Type elementType,
-                                                    unsigned numElements);
+  static LogicalResult verify(function_ref<InFlightDiagnostic()> emitError,
+                              Type elementType, unsigned numElements);
 };
 
 //===----------------------------------------------------------------------===//
 // LLVMScalableVectorType.
 //===----------------------------------------------------------------------===//
 
 /// LLVM dialect scalable vector type, represents a sequence of elements of
 /// unknown length that is known to be divisible by some constant. These
 /// elements can be processed as one in SIMD context.
 class LLVMScalableVectorType
     : public Type::TypeBase<LLVMScalableVectorType, Type,
                             detail::LLVMTypeAndSizeStorage> {
 public:
   /// Inherit base constructor.
   using Base::Base;
+  using Base::getChecked;
 
   /// Gets or creates a scalable vector type containing a non-zero multiple of
   /// `minNumElements` of `elementType` in the same context as `elementType`.
   static LLVMScalableVectorType get(Type elementType, unsigned minNumElements);
-  static LLVMScalableVectorType getChecked(Location loc, Type elementType,
-                                           unsigned minNumElements);
+  static LLVMScalableVectorType
+  getChecked(function_ref<InFlightDiagnostic()> emitError, Type elementType,
 
   /// Checks if the given type can be used in a vector type.
   static bool isValidElementType(Type type);
 
   /// Returns the element type of the vector.
   Type getElementType();
 
   /// Returns the scaling factor of the number of elements in the vector. The
   /// vector contains at least the resulting number of elements, or any non-zero
   /// multiple of this number.
   unsigned getMinNumElements();
 
   /// Verifies that the type about to be constructed is well-formed.
-  static LogicalResult verifyConstructionInvariants(Location loc,
-                                                    Type elementType,
-                                                    unsigned minNumElements);
+  static LogicalResult verify(function_ref<InFlightDiagnostic()> emitError,
+                              Type elementType, unsigned minNumElements);
 };
 
 //===----------------------------------------------------------------------===//
 // Printing and parsing.
 //===----------------------------------------------------------------------===//
 
 namespace detail {
 /// Parses an LLVM dialect type.

mlir/include/mlir/Dialect/Quant/QuantTypes.h

 class QuantizedType : public Type {
 public:
   using ImplType = detail::QuantizedTypeStorage;
   using Type::Type;
 
   /// The maximum number of bits supported for storage types.
   static constexpr unsigned MaxStorageBits = 32;
 
-  static LogicalResult
-  verifyConstructionInvariants(Location loc, unsigned flags, Type storageType,
-                               Type expressedType, int64_t storageTypeMin,
-                               int64_t storageTypeMax);
+  static LogicalResult verify(function_ref<InFlightDiagnostic()> emitError,
+                              unsigned flags, Type storageType,
 
   /// Support method to enable LLVM-style type casting.
   static bool classof(Type type);
 
   /// Gets the minimum possible stored by a storageType. storageTypeMin must
   /// be greater than or equal to this value.
   static int64_t getDefaultMinimumForInteger(bool isSigned,
                                              unsigned integralWidth) {

 ///   quant.any<i8<-16,15>>
 ///
 /// Note that for the any type, the expressed type is optional.
 class AnyQuantizedType
     : public Type::TypeBase<AnyQuantizedType, QuantizedType,
                             detail::AnyQuantizedTypeStorage> {
 public:
   using Base::Base;
+  using Base::getChecked;
 
   /// Gets an instance of the type with all parameters specified but not
   /// checked.
   static AnyQuantizedType get(unsigned flags, Type storageType,
                               Type expressedType, int64_t storageTypeMin,
                               int64_t storageTypeMax);
 
   /// Gets an instance of the type with all specified parameters checked.
   /// Returns a nullptr convertible type on failure.
-  static AnyQuantizedType getChecked(unsigned flags, Type storageType,
-                                     Type expressedType, int64_t storageTypeMin,
-                                     int64_t storageTypeMax, Location location);
+  static AnyQuantizedType
+  getChecked(function_ref<InFlightDiagnostic()> emitError, unsigned flags,
+             Type storageType, Type expressedType, int64_t storageTypeMin,
+             int64_t storageTypeMax);
 
   /// Verifies construction invariants and issues errors/warnings.
-  static LogicalResult
-  verifyConstructionInvariants(Location loc, unsigned flags, Type storageType,
-                               Type expressedType, int64_t storageTypeMin,
-                               int64_t storageTypeMax);
+  static LogicalResult verify(function_ref<InFlightDiagnostic()> emitError,
+                              unsigned flags, Type storageType,
 };
 
 /// Represents a family of uniform, quantized types.
 ///
 /// Each instance of this type expresses a mapping between real values (most
 /// often expressed in floating point f32) and quantized values (either fixed
 /// point or affine).
 ///

 ///   ExpressedType: 'f16', 'f32', 'bf16', 'f64'
 ///   Scale: A legal double value
 ///   ZeroPoint: An integer value
 class UniformQuantizedType
     : public Type::TypeBase<UniformQuantizedType, QuantizedType,
                             detail::UniformQuantizedTypeStorage> {
 public:
   using Base::Base;
+  using Base::getChecked;
 
   /// Gets an instance of the type with all parameters specified but not
   /// checked.
   static UniformQuantizedType get(unsigned flags, Type storageType,
                                   Type expressedType, double scale,
                                   int64_t zeroPoint, int64_t storageTypeMin,
                                   int64_t storageTypeMax);
 
   /// Gets an instance of the type with all specified parameters checked.
   /// Returns a nullptr convertible type on failure.
   static UniformQuantizedType
-  getChecked(unsigned flags, Type storageType, Type expressedType, double scale,
-             int64_t zeroPoint, int64_t storageTypeMin, int64_t storageTypeMax,
-             Location location);
+  getChecked(function_ref<InFlightDiagnostic()> emitError, unsigned flags,
+             Type storageType, Type expressedType, double scale,
+             int64_t zeroPoint, int64_t storageTypeMin, int64_t storageTypeMax);
 
   /// Verifies construction invariants and issues errors/warnings.
-  static LogicalResult
-  verifyConstructionInvariants(Location loc, unsigned flags, Type storageType,
-                               Type expressedType, double scale,
-                               int64_t zeroPoint, int64_t storageTypeMin,
-                               int64_t storageTypeMax);
+  static LogicalResult verify(function_ref<InFlightDiagnostic()> emitError,
+                              unsigned flags, Type storageType,
 
   /// Gets the scale term. The scale designates the difference between the real
   /// values corresponding to consecutive quantized values differing by 1.
   double getScale() const;
 
   /// Gets the storage value corresponding to the real value 0 in the affine
   /// equation.
   int64_t getZeroPoint() const;

 ///   QuantParams: (Scale ':' ZeroPoint)+
 ///   Scale: A legal double value
 ///   ZeroPoint: An integer value
 class UniformQuantizedPerAxisType
     : public Type::TypeBase<UniformQuantizedPerAxisType, QuantizedType,
                             detail::UniformQuantizedPerAxisTypeStorage> {
 public:
   using Base::Base;
+  using Base::getChecked;
 
   /// Gets an instance of the type with all parameters specified but not
   /// checked.
   static UniformQuantizedPerAxisType
   get(unsigned flags, Type storageType, Type expressedType,
       ArrayRef<double> scales, ArrayRef<int64_t> zeroPoints,
       int32_t quantizedDimension, int64_t storageTypeMin,
       int64_t storageTypeMax);
 
   /// Gets an instance of the type with all specified parameters checked.
   /// Returns a nullptr convertible type on failure.
   static UniformQuantizedPerAxisType
-  getChecked(unsigned flags, Type storageType, Type expressedType,
-             ArrayRef<double> scales, ArrayRef<int64_t> zeroPoints,
-             int32_t quantizedDimension, int64_t storageTypeMin,
-             int64_t storageTypeMax, Location location);
+  getChecked(function_ref<InFlightDiagnostic()> emitError, unsigned flags,
+             Type storageType, Type expressedType, ArrayRef<double> scales,
+             ArrayRef<int64_t> zeroPoints, int32_t quantizedDimension,
+             int64_t storageTypeMin, int64_t storageTypeMax);
 
   /// Verifies construction invariants and issues errors/warnings.
-  static LogicalResult
-  verifyConstructionInvariants(Location loc, unsigned flags, Type storageType,
-                               Type expressedType, ArrayRef<double> scales,
-                               ArrayRef<int64_t> zeroPoints,
-                               int32_t quantizedDimension,
-                               int64_t storageTypeMin, int64_t storageTypeMax);
+  static LogicalResult verify(function_ref<InFlightDiagnostic()> emitError,
+                              unsigned flags, Type storageType,
 
   /// Gets the quantization scales. The scales designate the difference between
   /// the real values corresponding to consecutive quantized values differing
   /// by 1. The ith scale corresponds to the ith slice in the
   /// quantized_dimension.
   ArrayRef<double> getScales() const;
 
   /// Gets the storage values corresponding to the real value 0 in the affine

 ///
 /// Typical syntax:
 ///   quant.calibrated<f32<-0.922,0.981>>
 class CalibratedQuantizedType
     : public Type::TypeBase<CalibratedQuantizedType, QuantizedType,
                             detail::CalibratedQuantizedTypeStorage> {
 public:
   using Base::Base;
+  using Base::getChecked;
 
   /// Gets an instance of the type with all parameters specified but not
   /// checked.
   static CalibratedQuantizedType get(Type expressedType, double min,
                                      double max);
 
   /// Gets an instance of the type with all specified parameters checked.
   /// Returns a nullptr convertible type on failure.
-  static CalibratedQuantizedType getChecked(Type expressedType, double min,
-                                            double max, Location location);
+  static CalibratedQuantizedType
+  getChecked(function_ref<InFlightDiagnostic()> emitError, Type expressedType,
+             double min, double max);
 
   /// Verifies construction invariants and issues errors/warnings.
-  static LogicalResult verifyConstructionInvariants(Location loc,
-                                                    Type expressedType,
-                                                    double min, double max);
+  static LogicalResult verify(function_ref<InFlightDiagnostic()> emitError,
+                              Type expressedType, double min, double max);
   double getMin() const;
   double getMax() const;
 };
 
 } // namespace quant
 } // namespace mlir
 
 #endif // MLIR_DIALECT_QUANT_QUANT_TYPES_H_

mlir/include/mlir/Dialect/SPIRV/IR/SPIRVAttributes.h

public:
   uint32_t getDescriptorSet();
 
   /// Returns binding.
   uint32_t getBinding();
 
   /// Returns `spirv::StorageClass`.
   Optional<StorageClass> getStorageClass();
 
-  static LogicalResult verifyConstructionInvariants(Location loc,
-                                                    IntegerAttr descriptorSet,
-                                                    IntegerAttr binding,
-                                                    IntegerAttr storageClass);
+  static LogicalResult verify(function_ref<InFlightDiagnostic()> emitError,
+                              IntegerAttr descriptorSet, IntegerAttr binding,
 };
 
 /// An attribute that specifies the SPIR-V (version, capabilities, extensions)
 /// triple.
 class VerCapExtAttr
     : public Attribute::AttrBase<VerCapExtAttr, Attribute,
                                  detail::VerCapExtAttributeStorage> {
 public:
public:
   };
   using cap_range = llvm::iterator_range<cap_iterator>;
 
   /// Returns the capabilities.
   cap_range getCapabilities();
   /// Returns the capabilities as an integer array attribute.
   ArrayAttr getCapabilitiesAttr();
 
-  static LogicalResult verifyConstructionInvariants(Location loc,
-                                                    IntegerAttr version,
-                                                    ArrayAttr capabilities,
-                                                    ArrayAttr extensions);
+  static LogicalResult verify(function_ref<InFlightDiagnostic()> emitError,
+                              IntegerAttr version, ArrayAttr capabilities,
 };
 
 /// An attribute that specifies the target version, allowed extensions and
 /// capabilities, and resource limits. These information describes a SPIR-V
 /// target environment.
 class TargetEnvAttr
     : public Attribute::AttrBase<TargetEnvAttr, Attribute,
                                  detail::TargetEnvAttributeStorage> {
public:
   DeviceType getDeviceType() const;
 
   /// Returns the device ID.
   uint32_t getDeviceID() const;
 
   /// Returns the target resource limits.
   ResourceLimitsAttr getResourceLimits() const;
 
-  static LogicalResult
-  verifyConstructionInvariants(Location loc, VerCapExtAttr triple,
-                               Vendor vendorID, DeviceType deviceType,
-                               uint32_t deviceID, DictionaryAttr limits);
+  static LogicalResult verify(function_ref<InFlightDiagnostic()> emitError,
+                              VerCapExtAttr triple, Vendor vendorID,
+                              DeviceType deviceType, uint32_t deviceID,
+                              DictionaryAttr limits);
 };
 } // namespace spirv
 } // namespace mlir
 
 #endif // MLIR_DIALECT_SPIRV_IR_SPIRVATTRIBUTES_H

mlir/include/mlir/Dialect/SPIRV/IR/SPIRVTypes.h

 class SampledImageType
     : public Type::TypeBase<SampledImageType, SPIRVType,
                             detail::SampledImageTypeStorage> {
 public:
   using Base::Base;
 
   static SampledImageType get(Type imageType);
 
-  static SampledImageType getChecked(Type imageType, Location location);
+  static SampledImageType
+  getChecked(function_ref<InFlightDiagnostic()> emitError, Type imageType);
 
-  static LogicalResult verifyConstructionInvariants(Location Loc,
-                                                    Type imageType);
+  static LogicalResult verify(function_ref<InFlightDiagnostic()> emitError,
 
   Type getImageType() const;
 
   void getExtensions(SPIRVType::ExtensionArrayRefVector &extensions,
                      Optional<spirv::StorageClass> storage = llvm::None);
   void getCapabilities(SPIRVType::CapabilityArrayRefVector &capabilities,
                        Optional<spirv::StorageClass> storage = llvm::None);
 };

 // SPIR-V matrix type
 class MatrixType : public Type::TypeBase<MatrixType, CompositeType,
                                          detail::MatrixTypeStorage> {
 public:
   using Base::Base;
 
   static MatrixType get(Type columnType, uint32_t columnCount);
 
-  static MatrixType getChecked(Type columnType, uint32_t columnCount,
-                               Location location);
+  static MatrixType getChecked(function_ref<InFlightDiagnostic()> emitError,
+                               Type columnType, uint32_t columnCount);
 
-  static LogicalResult verifyConstructionInvariants(Location loc,
-                                                    Type columnType,
-                                                    uint32_t columnCount);
+  static LogicalResult verify(function_ref<InFlightDiagnostic()> emitError,
+                              Type columnType, uint32_t columnCount);
 
   /// Returns true if the matrix elements are vectors of float elements.
   static bool isValidColumnType(Type columnType);
 
   Type getColumnType() const;
 
   /// Returns the number of rows.
   unsigned getNumRows() const;

mlir/include/mlir/IR/BuiltinAttributes.h

 //===----------------------------------------------------------------------===//
 // FloatAttr
 //===----------------------------------------------------------------------===//
 
 class FloatAttr : public Attribute::AttrBase<FloatAttr, Attribute,
                                              detail::FloatAttributeStorage> {
 public:
   using Base::Base;
+  using Base::getChecked;
   using ValueType = APFloat;
 
   /// Return a float attribute for the specified value in the specified type.
   /// These methods should only be used for simple constant values, e.g 1.0/2.0,
   /// that are known-valid both as host double and the 'type' format.
   static FloatAttr get(Type type, double value);
-  static FloatAttr getChecked(Type type, double value, Location loc);
+  static FloatAttr getChecked(function_ref<InFlightDiagnostic()> emitError,
+                              Type type, double value);
 
   /// Return a float attribute for the specified value in the specified type.
   static FloatAttr get(Type type, const APFloat &value);
-  static FloatAttr getChecked(Type type, const APFloat &value, Location loc);
+  static FloatAttr getChecked(function_ref<InFlightDiagnostic()> emitError,
+                              Type type, const APFloat &value);
 
   APFloat getValue() const;
 
   /// This function is used to convert the value to a double, even if it loses
   /// precision.
   double getValueAsDouble() const;
   static double getValueAsDouble(APFloat val);
 
   /// Verify the construction invariants for a double value.
-  static LogicalResult verifyConstructionInvariants(Location loc, Type type,
-                                                    double value);
-  static LogicalResult verifyConstructionInvariants(Location loc, Type type,
-                                                    const APFloat &value);
+  static LogicalResult verify(function_ref<InFlightDiagnostic()> emitError,
+                              Type type, double value);
+  static LogicalResult verify(function_ref<InFlightDiagnostic()> emitError,
+                              Type type, const APFloat &value);
 };
 
 //===----------------------------------------------------------------------===//
 // IntegerAttr
 //===----------------------------------------------------------------------===//
 
 class IntegerAttr
     : public Attribute::AttrBase<IntegerAttr, Attribute,
public:
   int64_t getInt() const;
   /// Return the integer value as a signed 64-bit int. The attribute must be
   /// a signed integer.
   int64_t getSInt() const;
   /// Return the integer value as a unsigned 64-bit int. The attribute must be
   /// an unsigned integer.
   uint64_t getUInt() const;
 
-  static LogicalResult verifyConstructionInvariants(Location loc, Type type,
-                                                    int64_t value);
-  static LogicalResult verifyConstructionInvariants(Location loc, Type type,
-                                                    const APInt &value);
+  static LogicalResult verify(function_ref<InFlightDiagnostic()> emitError,
+                              Type type, int64_t value);
+  static LogicalResult verify(function_ref<InFlightDiagnostic()> emitError,
+                              Type type, const APInt &value);
 };
 
 //===----------------------------------------------------------------------===//
 // BoolAttr
 
 /// Special case of IntegerAttr to represent boolean integers, i.e., signless i1
 /// integers.
 class BoolAttr : public Attribute {

 
 /// Opaque attributes represent attributes of non-registered dialects. These are
 /// attribute represented in their raw string form, and can only usefully be
 /// tested for attribute equality.
 class OpaqueAttr : public Attribute::AttrBase<OpaqueAttr, Attribute,
                                               detail::OpaqueAttributeStorage> {
 public:
   using Base::Base;
+  using Base::getChecked;
 
   /// Get or create a new OpaqueAttr with the provided dialect and string data.
   static OpaqueAttr get(MLIRContext *context, Identifier dialect,
                         StringRef attrData, Type type);
 
   /// Get or create a new OpaqueAttr with the provided dialect and string data.
   /// If the given identifier is not a valid namespace for a dialect, then a
   /// null attribute is returned.
-  static OpaqueAttr getChecked(Identifier dialect, StringRef attrData,
-                               Type type, Location location);
+  static OpaqueAttr getChecked(function_ref<InFlightDiagnostic()> emitError,
+                               Identifier dialect, StringRef attrData,
+                               Type type);
 
   /// Returns the dialect namespace of the opaque attribute.
   Identifier getDialectNamespace() const;
 
   /// Returns the raw attribute data of the opaque attribute.
   StringRef getAttrData() const;
 
   /// Verify the construction of an opaque attribute.
-  static LogicalResult verifyConstructionInvariants(Location loc,
-                                                    Identifier dialect,
-                                                    StringRef attrData,
-                                                    Type type);
+  static LogicalResult verify(function_ref<InFlightDiagnostic()> emitError,
+                              Identifier dialect, StringRef attrData,
 };
 
 //===----------------------------------------------------------------------===//
 // StringAttr
 //===----------------------------------------------------------------------===//
 
 class StringAttr : public Attribute::AttrBase<StringAttr, Attribute,
                                               detail::StringAttributeStorage> {
public:
   static UnitAttr get(MLIRContext *context);
 };
 
 //===----------------------------------------------------------------------===//
 // Elements Attributes
 //===----------------------------------------------------------------------===//
 
 namespace detail {
-template <typename T>
-class ElementsAttrIterator;
-template <typename T>
-class ElementsAttrRange;
+template <typename T> class ElementsAttrIterator;
+template <typename T> class ElementsAttrRange;
 } // namespace detail
 
 /// A base attribute that represents a reference to a static shaped tensor or
 /// vector constant.
 class ElementsAttr : public Attribute {
 public:
   using Attribute::Attribute;
-  template <typename T>
-  using iterator = detail::ElementsAttrIterator<T>;
-  template <typename T>
-  using iterator_range = detail::ElementsAttrRange<T>;
+  template <typename T> using iterator = detail::ElementsAttrIterator<T>;
+  template <typename T> using iterator_range = detail::ElementsAttrRange<T>;
 
   /// Return the type of this ElementsAttr, guaranteed to be a vector or tensor
   /// with static shape.
   ShapedType getType() const;
 
   /// Return the value at the given index. The index is expected to refer to a
   /// valid element.
   Attribute getValue(ArrayRef<uint64_t> index) const;
 
   /// Return the value of type 'T' at the given index, where 'T' corresponds to
   /// an Attribute type.
-  template <typename T>
-  T getValue(ArrayRef<uint64_t> index) const {
+  template <typename T> T getValue(ArrayRef<uint64_t> index) const {
     return getValue(index).template cast<T>();
   }
 
   /// Return the elements of this attribute as a value of type 'T'. Note:
   /// Aborts if the subclass is OpaqueElementsAttrs, these attrs do not support
   /// iteration.
-  template <typename T>
-  iterator_range<T> getValues() const;
+  template <typename T> iterator_range<T> getValues() const;
 
   /// Return if the given 'index' refers to a valid element in this attribute.
   bool isValidIndex(ArrayRef<uint64_t> index) const;
 
   /// Returns the number of elements held by this attribute.
   int64_t getNumElements() const;
 
   /// Returns the number of elements held by this attribute.
ptrdiff_t getDataIndex() const {
     return isSplat ? 0 : this->index;
   }
 
   /// Return the data base pointer.
   const char *getData() const { return this->base.getPointer(); }
 };
 
 /// Type trait detector that checks if a given type T is a complex type.
-template <typename T>
-struct is_complex_t : public std::false_type {};
+template <typename T> struct is_complex_t : public std::false_type {};
 template <typename T>
 struct is_complex_t<std::complex<T>> : public std::true_type {};
 } // namespace detail
 
 /// An attribute that represents a reference to a dense vector or tensor object.
 ///
 class DenseElementsAttr : public ElementsAttr {
 public:
   using ElementsAttr::ElementsAttr;
 
   /// Type trait used to check if the given type T is a potentially valid C++
   /// floating point type that can be used to access the underlying element
   /// types of a DenseElementsAttr.
   // TODO: Use std::disjunction when C++17 is supported.
-  template <typename T>
-  struct is_valid_cpp_fp_type {
+  template <typename T> struct is_valid_cpp_fp_type {
     /// The type is a valid floating point type if it is a builtin floating
     /// point type, or is a potentially user defined floating point type. The
     /// latter allows for supporting users that have custom types defined for
     /// bfloat16/half/etc.
     static constexpr bool value = llvm::is_one_of<T, float, double>::value ||
                                   (std::numeric_limits<T>::is_specialized &&
                                    !std::numeric_limits<T>::is_integer);
   };
getSplatValue() const {
     return getSplatValue().template cast<T>();
   }
 
   /// Return the value at the given index. The 'index' is expected to refer to a
   /// valid element.
   Attribute getValue(ArrayRef<uint64_t> index) const {
     return getValue<Attribute>(index);
   }
-  template <typename T>
-  T getValue(ArrayRef<uint64_t> index) const {
+  template <typename T> T getValue(ArrayRef<uint64_t> index) const {
     // Skip to the element corresponding to the flattened index.
     return *std::next(getValues<T>().begin(), getFlattenedIndex(index));
   }
 
   /// Return the held element values as a range of integer or floating-point
   /// values.
   template <typename T, typename = typename std::enable_if<
                             (!std::is_same<T, bool>::value &&
static SparseElementsAttr get(ShapedType type, DenseElementsAttr indices,
                                 DenseElementsAttr values);
 
   DenseIntElementsAttr getIndices() const;
 
   DenseElementsAttr getValues() const;
 
   /// Return the values of this attribute in the form of the given type 'T'. 'T'
   /// may be any of Attribute, APInt, APFloat, c++ integer/float types, etc.
-  template <typename T>
-  llvm::iterator_range<iterator<T>> getValues() const {
+  template <typename T> llvm::iterator_range<iterator<T>> getValues() const {
     auto zeroValue = getZeroValue<T>();
     auto valueIt = getValues().getValues<T>().begin();
     const std::vector<ptrdiff_t> flatSparseIndices(getFlattenedSparseIndices());
     // TODO: Move-capture flatSparseIndices when c++14 is available.
     std::function<T(ptrdiff_t)> mapFn = [=](ptrdiff_t index) {
       // Try to map the current index to one of the sparse indices.
       for (unsigned i = 0, e = flatSparseIndices.size(); i != e; ++i)
         if (flatSparseIndices[i] == index)
RetT process(Args &...args) const {
     if (attr.isa<DenseElementsAttr>())
       return ProcessFn<DenseIteratorT>()(args...);
     if (attr.isa<SparseElementsAttr>())
       return ProcessFn<SparseIteratorT>()(args...);
     llvm_unreachable("unexpected attribute kind");
   }
 
   /// Utility functors used to generically implement the iterators methods.
-  template <typename ItT>
-  struct PlusAssign {
+  template <typename ItT> struct PlusAssign {
     void operator()(ItT &it, ptrdiff_t offset) { it += offset; }
   };
-  template <typename ItT>
-  struct Minus {
+  template <typename ItT> struct Minus {
     ptrdiff_t operator()(const ItT &lhs, const ItT &rhs) { return lhs - rhs; }
   };
-  template <typename ItT>
-  struct MinusAssign {
+  template <typename ItT> struct MinusAssign {
     void operator()(ItT &it, ptrdiff_t offset) { it -= offset; }
   };
-  template <typename ItT>
-  struct Dereference {
+  template <typename ItT> struct Dereference {
     T operator()(ItT &it) { return *it; }
   };
-  template <typename ItT>
-  struct ConstructIter {
+  template <typename ItT> struct ConstructIter {
     void operator()(ItT &dest, const ItT &it) { ::new (&dest) ItT(it); }
   };
-  template <typename ItT>
-  struct DestructIter {
+  template <typename ItT> struct DestructIter {
     void operator()(ItT &it) { it.~ItT(); }
   };
 
 public:
   ElementsAttrIterator(const ElementsAttrIterator<T> &rhs) : attr(rhs.attr) {
     process<void, ConstructIter>(it, rhs.it);
   }
   ~ElementsAttrIterator() { process<void, DestructIter>(it); }

mlir/include/mlir/IR/BuiltinTypes.h

 //===----------------------------------------------------------------------===//
 
 /// Vector types represent multi-dimensional SIMD vectors, and have a fixed
 /// known constant shape with one or more dimension.
 class VectorType
     : public Type::TypeBase<VectorType, ShapedType, detail::VectorTypeStorage> {
 public:
   using Base::Base;
+  using Base::getChecked;
 
   /// 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(Location location, ArrayRef<int64_t> shape,
-                               Type elementType);
+  /// Get or create a new VectorType of the provided shape and element type. If
+  /// the VectorType defined by the arguments would be ill-formed, an error is
+  /// emitted to `emitError` and a null type is returned.
+  static VectorType getChecked(function_ref<InFlightDiagnostic()> emitError,
+                               ArrayRef<int64_t> shape, Type elementType);
 
   /// Verify the construction of a vector type.
-  static LogicalResult verifyConstructionInvariants(Location loc,
-                                                    ArrayRef<int64_t> shape,
-                                                    Type elementType);
+  static LogicalResult verify(function_ref<InFlightDiagnostic()> emitError,
+                              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.
   static bool isValidElementType(Type t) {
     return t.isa<IntegerType, FloatType>();
   }
 
   ArrayRef<int64_t> getShape() const;

 /// Ranked tensor types represent multi-dimensional arrays that have a shape
 /// with a fixed number of dimensions. Each shape element can be a non-negative
 /// integer or unknown (represented by -1).
 class RankedTensorType
     : public Type::TypeBase<RankedTensorType, TensorType,
                             detail::RankedTensorTypeStorage> {
 public:
   using Base::Base;
+  using Base::getChecked;
 
   /// 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(Location location, ArrayRef<int64_t> shape,
-                                     Type elementType);
+  /// type. If the RankedTensorType defined by the arguments would be
+  /// ill-formed, an error is emitted to `emitError` and a null type is
+  /// returned.
+  static RankedTensorType
+  getChecked(function_ref<InFlightDiagnostic()> emitError,
+             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);
+  static LogicalResult verify(function_ref<InFlightDiagnostic()> emitError,
+                              ArrayRef<int64_t> shape, Type elementType);
 
   ArrayRef<int64_t> getShape() const;
 };
 
 //===----------------------------------------------------------------------===//
 // UnrankedTensorType
 
 /// Unranked tensor types represent multi-dimensional arrays that have an
 /// unknown shape.
 class UnrankedTensorType
     : public Type::TypeBase<UnrankedTensorType, TensorType,
                             detail::UnrankedTensorTypeStorage> {
 public:
   using Base::Base;
+  using Base::getChecked;
 
   /// 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(Location location, Type elementType);
+  /// type. If the RankedTensorType defined by the arguments would be
+  /// ill-formed, an error is emitted to `emitError` and a null type is
+  /// returned.
+  static UnrankedTensorType
+  getChecked(function_ref<InFlightDiagnostic()> emitError, Type elementType);
 
   /// Verify the construction of a unranked tensor type.
-  static LogicalResult verifyConstructionInvariants(Location loc,
-                                                    Type elementType);
+  static LogicalResult verify(function_ref<InFlightDiagnostic()> emitError,
 
   ArrayRef<int64_t> getShape() const { return llvm::None; }
 };
 
 //===----------------------------------------------------------------------===//
 // BaseMemRefType
 //===----------------------------------------------------------------------===//
 
public:
   private:
     ArrayRef<int64_t> shape;
     Type elementType;
     ArrayRef<AffineMap> affineMaps;
     unsigned memorySpace;
   };
 
   using Base::Base;
+  using Base::getChecked;
 
   /// Get or create a new MemRefType based on shape, element type, affine
   /// map composition, and memory space.  Assumes the arguments define a
   /// well-formed MemRef type.  Use getChecked to gracefully handle MemRefType
   /// construction failures.
   static MemRefType get(ArrayRef<int64_t> shape, Type elementType,
                         ArrayRef<AffineMap> affineMapComposition = {},
                         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(Location location, ArrayRef<int64_t> shape,
-                               Type elementType,
+  /// map composition, and memory space. If the MemRefType defined by the
+  /// arguments would be ill-formed, an error is emitted to `emitError` and a
+  /// null type is returned.
+  static MemRefType getChecked(function_ref<InFlightDiagnostic()> emitError,
+                               ArrayRef<int64_t> shape, Type elementType,
                                ArrayRef<AffineMap> affineMapComposition,
                                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.
   // Unfortunately, uses of `-1` have crept deep into the codebase now and are
   // hard to track.
   static int64_t getDynamicStrideOrOffset() {
     return ShapedType::kDynamicStrideOrOffset;
   }
 
 private:
   /// 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.
+  /// type would be ill-formed, return nullptr.
   static MemRefType getImpl(ArrayRef<int64_t> shape, Type elementType,
                             ArrayRef<AffineMap> affineMapComposition,
-                            unsigned memorySpace, Optional<Location> location);
+                            unsigned memorySpace,
+                            function_ref<InFlightDiagnostic()> emitError);
   using Base::getImpl;
 };
 
 //===----------------------------------------------------------------------===//
 // UnrankedMemRefType
 
 /// Unranked MemRef type represent multi-dimensional MemRefs that
 /// have an unknown rank.
 class UnrankedMemRefType
     : public Type::TypeBase<UnrankedMemRefType, BaseMemRefType,
                             detail::UnrankedMemRefTypeStorage> {
 public:
   using Base::Base;
+  using Base::getChecked;
 
   /// 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(Location location, Type elementType,
-                                       unsigned memorySpace);
+  /// type and memory space. If the UnrankedMemRefType defined by the arguments
+  /// would be ill-formed, an error is emitted to `emitError` and a null type is
+  /// returned.
+  static UnrankedMemRefType
+  getChecked(function_ref<InFlightDiagnostic()> emitError, Type elementType,
 
   /// Verify the construction of a unranked memref type.
-  static LogicalResult verifyConstructionInvariants(Location loc,
-                                                    Type elementType,
-                                                    unsigned memorySpace);
+  static LogicalResult verify(function_ref<InFlightDiagnostic()> emitError,
+                              Type elementType, unsigned memorySpace);
 
   ArrayRef<int64_t> getShape() const { return llvm::None; }
 };
 } // end namespace mlir
 
 //===----------------------------------------------------------------------===//
 // Tablegen Type Declarations
 //===----------------------------------------------------------------------===//

mlir/include/mlir/IR/BuiltinTypes.td

let description = [{
     ```mlir
     complex<f32>
     complex<i32>
     ```
   }];
   let parameters = (ins "Type":$elementType);
   let builders = [
     TypeBuilderWithInferredContext<(ins "Type":$elementType), [{
-      return Base::get(elementType.getContext(), elementType);
-    }], [{
-      return Base::getChecked($_loc, elementType);
+      return $_get(elementType.getContext(), elementType);
     }]>
   ];
   let skipDefaultBuilders = 1;
-  let genVerifyInvariantsDecl = 1;
+  let genVerifyDecl = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // FloatType
 //===----------------------------------------------------------------------===//
 
 // Base class for Builtin dialect float types.
 class Builtin_FloatType<string name> : TypeDef<Builtin_Dialect, name,
let description = [{
 
     The function type can be thought of as a function signature. It consists of
     a list of formal parameter types and a list of formal result types.
     ```
   }];
   let parameters = (ins "ArrayRef<Type>":$inputs, "ArrayRef<Type>":$results);
   let builders = [
     TypeBuilder<(ins CArg<"TypeRange">:$inputs, CArg<"TypeRange">:$results), [{
-      return Base::get($_ctxt, inputs, results);
+      return $_get($_ctxt, inputs, results);
     }]>
   ];
   let skipDefaultBuilders = 1;
   let genStorageClass = 0;
   let extraClassDeclaration = [{
     /// Input types.
     unsigned getNumInputs() const;
     Type getInput(unsigned i) const { return getInputs()[i]; }
let builders = [
     TypeBuilder<(ins "unsigned":$width,
                      CArg<"SignednessSemantics", "Signless">:$signedness)>
   ];
 
   // IntegerType uses a special storage class that compacts parameters to save
   // memory.
   let genStorageClass = 0;
   let skipDefaultBuilders = 1;
-  let genVerifyInvariantsDecl = 1;
+  let genVerifyDecl = 1;
   let extraClassDeclaration = [{
     /// Signedness semantics.
     enum SignednessSemantics : uint32_t {
       Signless, /// No signedness semantics
       Signed,   /// Signed integer
       Unsigned, /// Unsigned integer
     };
 
let description = [{
     opaque<"llvm", "struct<(i32, float)>">
     opaque<"pdl", "value">
     ```
   }];
   let parameters = (ins
     "Identifier":$dialectNamespace,
     StringRefParameter<"">:$typeData
   );
-  let genVerifyInvariantsDecl = 1;
+  let genVerifyDecl = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // TupleType
 //===----------------------------------------------------------------------===//
 
 def Builtin_Tuple : Builtin_Type<"Tuple"> {
   let summary = "Fixed-sized collection of other types";
let description = [{
 
     // Many elements.
     tuple<i32, f32, tensor<i1>, i5>
     ```
   }];
   let parameters = (ins "ArrayRef<Type>":$types);
   let builders = [
     TypeBuilder<(ins "TypeRange":$elementTypes), [{
-      return Base::get($_ctxt, elementTypes);
+      return $_get($_ctxt, elementTypes);
     }]>,
     TypeBuilder<(ins), [{
-      return Base::get($_ctxt, TypeRange());
+      return $_get($_ctxt, TypeRange());
     }]>
   ];
   let skipDefaultBuilders = 1;
   let genStorageClass = 0;
   let extraClassDeclaration = [{
     /// 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

mlir/include/mlir/IR/OpBase.td

 // ```
 // TypeBuilder<(ins "int":$integerArg, CArg<"float", "3.0f">:$floatArg)>
 // ```
 //
 // has an integer parameter and a float parameter with a default value.
 //
 // If an empty string is passed in for `body`, then *only* the builder
 // declaration will be generated; this provides a way to define complicated
-// builders entirely in C++.
+// builders entirely in C++. If a `body` string is provided, the `Base::get`
+// method should be invoked using `$_get`, e.g.:
+//
+// ```
+// TypeBuilder<(ins "int":$integerArg, CArg<"float", "3.0f">:$floatArg), [{
+//   return $_get($_ctxt, integerArg, floatArg);
+// }]>
+// ```
+//
+// This is necessary because the `body` is also used to generate `getChecked`
+// methods, which have a different underlying `Base::get*` call.
 //
-// `checkedBody` is similar to `body`, but is the code block used when
-// generating a `getChecked` method.
-class TypeBuilder<dag parameters, code bodyCode = "",
-                  code checkedBodyCode = ""> {
+class TypeBuilder<dag parameters, code bodyCode = ""> {
   dag dagParams = parameters;
   code body = bodyCode;
-  code checkedBody = checkedBodyCode;
 
   // The context parameter can be inferred from one of the other parameters and
   // is not implicitly added to the parameter list.
   bit hasInferredContextParam = 0;
 }
 
 // A class of TypeBuilder that is able to infer the MLIRContext parameter from
 // one of the other builder parameters. Instances of this builder do not have
 // `MLIRContext *` implicitly added to the parameter list.
-class TypeBuilderWithInferredContext<dag parameters, code bodyCode = "",
-                                     code checkedBodyCode = "">
+class TypeBuilderWithInferredContext<dag parameters, code bodyCode = "">
   : TypeBuilder<parameters, bodyCode> {
-  code checkedBody = checkedBodyCode;
   let hasInferredContextParam = 1;
 }
 
 // Define a new type, named `name`, belonging to `dialect` that inherits from
 // the given C++ base class.
 class TypeDef<Dialect dialect, string name,
               string baseCppClass = "::mlir::Type">
     : DialectType<dialect, CPred<"">, /*descr*/"", name # "Type"> {
class TypeDef<Dialect dialect, string name,
   code printer = ?;
   code parser = ?;
 
   // If set, generate accessors for each Type parameter.
   bit genAccessors = 1;
   // Avoid generating default get/getChecked functions. Custom get methods must
   // be provided.
   bit skipDefaultBuilders = 0;
-  // Generate the verifyConstructionInvariants declaration and getChecked
-  // method.
-  bit genVerifyInvariantsDecl = 0;
+  // Generate the verify and getChecked methods.
+  bit genVerifyDecl = 0;
   // Extra code to include in the class declaration.
   code extraClassDeclaration = [{}];
 
   // The predicate for when this type is used as a type constraint.
   let predicate = CPred<"$_self.isa<" # dialect.cppNamespace #
                                  "::" # cppClassName # ">()">;
   // A constant builder provided when the type has no parameters.
   let builderCall = !if(!empty(parameters),

mlir/include/mlir/IR/StorageUniquerSupport.h

 
 #ifndef MLIR_IR_STORAGEUNIQUERSUPPORT_H
 #define MLIR_IR_STORAGEUNIQUERSUPPORT_H
 
 #include "mlir/Support/InterfaceSupport.h"
 #include "mlir/Support/LogicalResult.h"
 #include "mlir/Support/StorageUniquer.h"
 #include "mlir/Support/TypeID.h"
+#include "llvm/ADT/FunctionExtras.h"
 
 namespace mlir {
-class AttributeStorage;
+class InFlightDiagnostic;
+class Location;
 class MLIRContext;
 
 namespace detail {
-/// Utility method to generate a raw default location for use when checking the
-/// construction invariants of a storage object. This is defined out-of-line to
-/// avoid the need to include Location.h.
-const AttributeStorage *generateUnknownStorageLocation(MLIRContext *ctx);
+/// Utility method to generate a callback that can be used to generate a
+/// diagnostic when checking the construction invariants of a storage object.
+/// This is defined out-of-line to avoid the need to include Location.h.
+llvm::unique_function<InFlightDiagnostic()>
+getDefaultDiagnosticEmitFn(MLIRContext *ctx);
+llvm::unique_function<InFlightDiagnostic()>
+getDefaultDiagnosticEmitFn(const Location &loc);
 
 //===----------------------------------------------------------------------===//
 // StorageUserTraitBase
 //===----------------------------------------------------------------------===//
 
 /// Helper class for implementing traits for storage classes. Clients are not
 /// expected to interact with this directly, so its members are all protected.
 template <typename ConcreteType, template <typename> class TraitType>
public:
   }
 
   /// Get or create a new ConcreteT instance within the ctx. This
   /// function is guaranteed to return a non null object and will assert if
   /// the arguments provided are invalid.
   template <typename... Args>
   static ConcreteT get(MLIRContext *ctx, Args... args) {
     // Ensure that the invariants are correct for construction.
-    assert(succeeded(ConcreteT::verifyConstructionInvariants(
-        generateUnknownStorageLocation(ctx), args...)));
+    assert(
+        succeeded(ConcreteT::verify(getDefaultDiagnosticEmitFn(ctx), args...)));
     return UniquerT::template get<ConcreteT>(ctx, args...);
   }
 
   /// Get or create a new ConcreteT instance within the ctx, defined at
   /// the given, potentially unknown, location. If the arguments provided are
-  /// invalid then emit errors and return a null object.
-  template <typename LocationT, typename... Args>
-  static ConcreteT getChecked(LocationT loc, Args... args) {
+  /// invalid, errors are emitted using the provided location and a null object
+  /// is returned.
+  template <typename... Args>
+  static ConcreteT getChecked(const Location &loc, Args... args) {
+    return ConcreteT::getChecked(getDefaultDiagnosticEmitFn(loc), args...);
+  }
+
+  /// Get or create a new ConcreteT instance within the ctx. If the arguments
+  /// provided are invalid, errors are emitted using the provided `emitError`
+  /// and a null object is returned.
+  template <typename... Args>
+  static ConcreteT getChecked(function_ref<InFlightDiagnostic()> emitErrorFn,
+                              MLIRContext *ctx, Args... args) {
     // If the construction invariants fail then we return a null attribute.
-    if (failed(ConcreteT::verifyConstructionInvariants(loc, args...)))
+    if (failed(ConcreteT::verify(emitErrorFn, args...)))
       return ConcreteT();
-    return UniquerT::template get<ConcreteT>(loc.getContext(), args...);
+    return UniquerT::template get<ConcreteT>(ctx, args...);
   }
 
   /// Get an instance of the concrete type from a void pointer.
   static ConcreteT getFromOpaquePointer(const void *ptr) {
     return ptr ? BaseT::getFromOpaquePointer(ptr).template cast<ConcreteT>()
                : nullptr;
   }
 
 protected:
   /// Mutate the current storage instance. This will not change the unique key.
   /// The arguments are forwarded to 'ConcreteT::mutate'.
   template <typename... Args> LogicalResult mutate(Args &&...args) {
     return UniquerT::template mutate<ConcreteT>(this->getContext(), getImpl(),
                                                 std::forward<Args>(args)...);
   }
 
   /// Default implementation that just returns success.
-  template <typename... Args>
-  static LogicalResult verifyConstructionInvariants(Args... args) {
+  template <typename... Args> static LogicalResult verify(Args... args) {
     return success();
   }
 
   /// Utility for easy access to the storage instance.
   ImplType *getImpl() const { return static_cast<ImplType *>(this->impl); }
 };
 } // namespace detail
 } // namespace mlir
 
 #endif

mlir/include/mlir/IR/Types.h

 /// immutable key.  The mutable component of the type can be modified after the
 /// type is created, but cannot affect the identity of the type.
 ///
 /// Types are constructed and uniqued via the 'detail::TypeUniquer' class.
 ///
 /// Derived type classes are expected to implement several required
 /// implementation hooks:
 ///  * Optional:
-///    - static LogicalResult verifyConstructionInvariants(Location loc,
-///                                                        Args... args)
+///    - static LogicalResult verify(
+///                                function_ref<InFlightDiagnostic()> emitError,
+///                                Args... args)
 ///      * This method is invoked when calling the 'TypeBase::get/getChecked'
 ///        methods to ensure that the arguments passed in are valid to construct
 ///        a type instance with.
 ///      * This method is expected to return failure if a type cannot be
 ///        constructed with 'args', success otherwise.
 ///      * 'args' must correspond with the arguments passed into the
 ///        'TypeBase::get' call.
 ///
public:
 
   bool operator==(Type other) const { return impl == other.impl; }
   bool operator!=(Type other) const { return !(*this == other); }
   explicit operator bool() const { return impl; }
 
   bool operator!() const { return impl == nullptr; }
 
   template <typename U> bool isa() const;
-  template <typename First, typename Second, typename... Rest>
-  bool isa() const;
+  template <typename First, typename Second, typename... Rest> bool isa() const;
   template <typename U> U dyn_cast() const;
   template <typename U> U dyn_cast_or_null() const;
   template <typename U> U cast() const;
 
   // Support type casting Type to itself.
   static bool classof(Type) { return true; }
 
   /// Return a unique identifier for the concrete type. This is used to support

mlir/include/mlir/TableGen/TypeDef.h

 // TypeBuilder
 //===----------------------------------------------------------------------===//
 
 /// Wrapper class that represents a Tablegen TypeBuilder.
 class TypeBuilder : public Builder {
 public:
   using Builder::Builder;
 
-  /// Return an optional code body used for the `getChecked` variant of this
-  /// builder.
-  Optional<StringRef> getCheckedBody() const;
-
   /// Returns true if this builder is able to infer the MLIRContext parameter.
   bool hasInferredContextParameter() const;
 };
 
 //===----------------------------------------------------------------------===//
 // TypeDef
 //===----------------------------------------------------------------------===//
 
public:
   // Returns the code to use as the types parser method. If not specified,
   // return a non-value. Otherwise, return the contents of that code block.
   Optional<StringRef> getParserCode() const;
 
   // Returns true if the accessors based on the types parameters should be
   // generated.
   bool genAccessors() const;
 
-  // Return true if we need to generate the verifyConstructionInvariants
-  // declaration and getChecked method.
-  bool genVerifyInvariantsDecl() const;
+  // Return true if we need to generate the verify declaration and getChecked
+  // method.
+  bool genVerifyDecl() const;
 
   // Returns the dialects extra class declaration code.
   Optional<StringRef> getExtraDecls() const;
 
   // Get the code location (for error printing).
   ArrayRef<llvm::SMLoc> getLoc() const;
 
   // Returns true if the default get/getChecked methods should be skipped during

mlir/lib/Bindings/Python/IRModules.cpp

 //------------------------------------------------------------------------------
 // PyValue and subclases.
 //------------------------------------------------------------------------------
 
 namespace {
 /// CRTP base class for Python MLIR values that subclass Value and should be
 /// castable from it. The value hierarchy is one level deep and is not supposed
 /// to accommodate other levels unless core MLIR changes.
-template <typename DerivedTy>
-class PyConcreteValue : public PyValue {
+template <typename DerivedTy> class PyConcreteValue : public PyValue {
 public:
   // Derived classes must define statics for:
   //   IsAFunctionTy isaFunction
   //   const char *pyClassName
   // and redefine bindDerived.
   using ClassTy = py::class_<DerivedTy, PyValue>;
   using IsAFunctionTy = bool (*)(MlirValue);
 
public:
   static constexpr IsAFunctionTy isaFunction = mlirAttributeIsAFloat;
   static constexpr const char *pyClassName = "FloatAttr";
   using PyConcreteAttribute::PyConcreteAttribute;
 
   static void bindDerived(ClassTy &c) {
     c.def_static(
         "get",
         [](PyType &type, double value, DefaultingPyLocation loc) {
-          MlirAttribute attr = mlirFloatAttrDoubleGetChecked(type, value, loc);
+          MlirAttribute attr = mlirFloatAttrDoubleGetChecked(loc, type, value);
           // TODO: Rework error reporting once diagnostic engine is exposed
           // in C API.
           if (mlirAttributeIsNull(attr)) {
             throw SetPyError(PyExc_ValueError,
                              Twine("invalid '") +
                                  py::repr(py::cast(type)).cast<std::string>() +
                                  "' and expected floating point type.");
           }
public:
   static constexpr const char *pyClassName = "VectorType";
   using PyConcreteType::PyConcreteType;
 
   static void bindDerived(ClassTy &c) {
     c.def_static(
         "get",
         [](std::vector<int64_t> shape, PyType &elementType,
            DefaultingPyLocation loc) {
-          MlirType t = mlirVectorTypeGetChecked(shape.size(), shape.data(),
-                                                elementType, loc);
+          MlirType t = mlirVectorTypeGetChecked(loc, shape.size(), shape.data(),
+                                                elementType);
           // TODO: Rework error reporting once diagnostic engine is exposed
           // in C API.
           if (mlirTypeIsNull(t)) {
             throw SetPyError(
                 PyExc_ValueError,
                 Twine("invalid '") +
                     py::repr(py::cast(elementType)).cast<std::string>() +
                     "' and expected floating point or integer type.");
public:
   using PyConcreteType::PyConcreteType;
 
   static void bindDerived(ClassTy &c) {
     c.def_static(
         "get",
         [](std::vector<int64_t> shape, PyType &elementType,
            DefaultingPyLocation loc) {
           MlirType t = mlirRankedTensorTypeGetChecked(
-              shape.size(), shape.data(), elementType, loc);
+              loc, shape.size(), shape.data(), elementType);
           // TODO: Rework error reporting once diagnostic engine is exposed
           // in C API.
           if (mlirTypeIsNull(t)) {
             throw SetPyError(
                 PyExc_ValueError,
                 Twine("invalid '") +
                     py::repr(py::cast(elementType)).cast<std::string>() +
                     "' and expected floating point, integer, vector or "
public:
   static constexpr IsAFunctionTy isaFunction = mlirTypeIsAUnrankedTensor;
   static constexpr const char *pyClassName = "UnrankedTensorType";
   using PyConcreteType::PyConcreteType;
 
   static void bindDerived(ClassTy &c) {
     c.def_static(
         "get",
         [](PyType &elementType, DefaultingPyLocation loc) {
-          MlirType t = mlirUnrankedTensorTypeGetChecked(elementType, loc);
+          MlirType t = mlirUnrankedTensorTypeGetChecked(loc, elementType);
           // TODO: Rework error reporting once diagnostic engine is exposed
           // in C API.
           if (mlirTypeIsNull(t)) {
             throw SetPyError(
                 PyExc_ValueError,
                 Twine("invalid '") +
                     py::repr(py::cast(elementType)).cast<std::string>() +
                     "' and expected floating point, integer, vector or "
c.def_static(
          [](std::vector<int64_t> shape, PyType &elementType,
             std::vector<PyAffineMap> layout, unsigned memorySpace,
             DefaultingPyLocation loc) {
            SmallVector<MlirAffineMap> maps;
            maps.reserve(layout.size());
            for (PyAffineMap &map : layout)
              maps.push_back(map);
 
-           MlirType t = mlirMemRefTypeGetChecked(elementType, shape.size(),
+           MlirType t = mlirMemRefTypeGetChecked(loc, elementType, shape.size(),
                                                  shape.data(), maps.size(),
-                                                 maps.data(), memorySpace, loc);
+                                                 maps.data(), memorySpace);
            // TODO: Rework error reporting once diagnostic engine is exposed
            // in C API.
            if (mlirTypeIsNull(t)) {
              throw SetPyError(
                  PyExc_ValueError,
                  Twine("invalid '") +
                      py::repr(py::cast(elementType)).cast<std::string>() +
                      "' and expected floating point, integer, vector or "
public:
   using PyConcreteType::PyConcreteType;
 
   static void bindDerived(ClassTy &c) {
     c.def_static(
          "get",
          [](PyType &elementType, unsigned memorySpace,
             DefaultingPyLocation loc) {
            MlirType t =
-               mlirUnrankedMemRefTypeGetChecked(elementType, memorySpace, loc);
+               mlirUnrankedMemRefTypeGetChecked(loc, elementType, memorySpace);
            // TODO: Rework error reporting once diagnostic engine is exposed
            // in C API.
            if (mlirTypeIsNull(t)) {
              throw SetPyError(
                  PyExc_ValueError,
                  Twine("invalid '") +
                      py::repr(py::cast(elementType)).cast<std::string>() +
                      "' and expected floating point, integer, vector or "

mlir/lib/CAPI/IR/BuiltinAttributes.cpp

bool mlirAttributeIsAFloat(MlirAttribute attr) {
   return unwrap(attr).isa<FloatAttr>();
 }
 
 MlirAttribute mlirFloatAttrDoubleGet(MlirContext ctx, MlirType type,
                                      double value) {
   return wrap(FloatAttr::get(unwrap(type), value));
 }
 
-MlirAttribute mlirFloatAttrDoubleGetChecked(MlirType type, double value,
-                                            MlirLocation loc) {
-  return wrap(FloatAttr::getChecked(unwrap(type), value, unwrap(loc)));
+MlirAttribute mlirFloatAttrDoubleGetChecked(MlirLocation loc, MlirType type,
+                                            double value) {
+  return wrap(FloatAttr::getChecked(unwrap(loc), unwrap(type), value));
 }
 
 double mlirFloatAttrGetValueDouble(MlirAttribute attr) {
   return unwrap(attr).cast<FloatAttr>().getValueAsDouble();
 }
 
 //===----------------------------------------------------------------------===//
 // Integer attribute.

mlir/lib/CAPI/IR/BuiltinTypes.cpp

 
 MlirType mlirVectorTypeGet(intptr_t rank, const int64_t *shape,
                            MlirType elementType) {
   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) {
+MlirType mlirVectorTypeGetChecked(MlirLocation loc, intptr_t rank,
+                                  const int64_t *shape, MlirType elementType) {
   return wrap(VectorType::getChecked(
       unwrap(loc), llvm::makeArrayRef(shape, static_cast<size_t>(rank)),
       unwrap(elementType)));
 }
 
 //===----------------------------------------------------------------------===//
 // Ranked / Unranked tensor type.
 //===----------------------------------------------------------------------===//

 
 MlirType mlirRankedTensorTypeGet(intptr_t rank, const int64_t *shape,
                                  MlirType elementType) {
   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) {
+MlirType mlirRankedTensorTypeGetChecked(MlirLocation loc, intptr_t rank,
+                                        const int64_t *shape,
+                                        MlirType elementType) {
   return wrap(RankedTensorType::getChecked(
       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) {
+MlirType mlirUnrankedTensorTypeGetChecked(MlirLocation loc,
+                                          MlirType elementType) {
   return wrap(UnrankedTensorType::getChecked(unwrap(loc), unwrap(elementType)));
 }
 
 //===----------------------------------------------------------------------===//
 // Ranked / Unranked MemRef type.
 //===----------------------------------------------------------------------===//
 
 bool mlirTypeIsAMemRef(MlirType type) { return unwrap(type).isa<MemRefType>(); }
 
 MlirType mlirMemRefTypeGet(MlirType elementType, intptr_t rank,
                            const int64_t *shape, intptr_t numMaps,
                            MlirAffineMap const *affineMaps,
                            unsigned memorySpace) {
   SmallVector<AffineMap, 1> maps;
   (void)unwrapList(numMaps, affineMaps, maps);
   return wrap(
       MemRefType::get(llvm::makeArrayRef(shape, static_cast<size_t>(rank)),
                       unwrap(elementType), maps, memorySpace));
 }
 
-MlirType mlirMemRefTypeGetChecked(MlirType elementType, intptr_t rank,
-                                  const int64_t *shape, intptr_t numMaps,
+MlirType mlirMemRefTypeGetChecked(MlirLocation loc, MlirType elementType,
+                                  intptr_t rank, const int64_t *shape,
+                                  intptr_t numMaps,
                                   MlirAffineMap const *affineMaps,
-                                  unsigned memorySpace, MlirLocation loc) {
+                                  unsigned memorySpace) {
   SmallVector<AffineMap, 1> maps;
   (void)unwrapList(numMaps, affineMaps, maps);
   return wrap(MemRefType::getChecked(
       unwrap(loc), llvm::makeArrayRef(shape, static_cast<size_t>(rank)),
       unwrap(elementType), maps, memorySpace));
 }
 
 MlirType mlirMemRefTypeContiguousGet(MlirType elementType, intptr_t rank,
                                      const int64_t *shape,
                                      unsigned memorySpace) {
   return wrap(
       MemRefType::get(llvm::makeArrayRef(shape, static_cast<size_t>(rank)),
                       unwrap(elementType), llvm::None, memorySpace));
 }
 
-MlirType mlirMemRefTypeContiguousGetChecked(MlirType elementType, intptr_t rank,
+MlirType mlirMemRefTypeContiguousGetChecked(MlirLocation loc,
+                                            MlirType elementType, intptr_t rank,
                                             const int64_t *shape,
-                                            unsigned memorySpace,
-                                            MlirLocation loc) {
+                                            unsigned memorySpace) {
   return wrap(MemRefType::getChecked(
       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());

 bool mlirTypeIsAUnrankedMemRef(MlirType type) {
   return unwrap(type).isa<UnrankedMemRefType>();
 }
 
 MlirType mlirUnrankedMemRefTypeGet(MlirType elementType, unsigned memorySpace) {
   return wrap(UnrankedMemRefType::get(unwrap(elementType), memorySpace));
 }
 
-MlirType mlirUnrankedMemRefTypeGetChecked(MlirType elementType,
-                                          unsigned memorySpace,
-                                          MlirLocation loc) {
+MlirType mlirUnrankedMemRefTypeGetChecked(MlirLocation loc,
+                                          MlirType elementType,
+                                          unsigned memorySpace) {
   return wrap(UnrankedMemRefType::getChecked(unwrap(loc), unwrap(elementType),
                                              memorySpace));
 }
 
 unsigned mlirUnrankedMemrefGetMemorySpace(MlirType type) {
   return unwrap(type).cast<UnrankedMemRefType>().getMemorySpace();
 }
 

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

static LLVMFunctionType parseFunctionType(DialectAsmParser &parser) {
   Type returnType;
   if (parser.parseLess() || dispatchParse(parser, returnType) ||
       parser.parseLParen())
     return LLVMFunctionType();
 
   // Function type without arguments.
   if (succeeded(parser.parseOptionalRParen())) {
     if (succeeded(parser.parseGreater()))
-      return LLVMFunctionType::getChecked(loc, returnType, {},
+      return LLVMFunctionType::getChecked(loc, returnType, llvm::None,
                                           /*isVarArg=*/false);
     return LLVMFunctionType();
   }
 
   // Parse arguments.
   SmallVector<Type, 8> argTypes;
   do {
     if (succeeded(parser.parseOptionalEllipsis())) {
static LLVMStructType parseStructType(DialectAsmParser &parser) {
   // stack already contains a struct with the same identifier, bail out after
   // the name.
   StringRef name;
   bool isIdentified = succeeded(parser.parseOptionalString(&name));
   if (isIdentified) {
     if (knownStructNames.count(name)) {
       if (failed(parser.parseGreater()))
         return LLVMStructType();
-      return LLVMStructType::getIdentifiedChecked(loc, name);
+      return LLVMStructType::getIdentifiedChecked(
+          [loc] { return emitError(loc); }, loc.getContext(), name);
     }
     if (failed(parser.parseComma()))
       return LLVMStructType();
   }
 
   // Handle intentionally opaque structs.
   llvm::SMLoc kwLoc = parser.getCurrentLocation();
   if (succeeded(parser.parseOptionalKeyword("opaque"))) {
     if (!isIdentified)
       return parser.emitError(kwLoc, "only identified structs can be opaque"),
              LLVMStructType();
     if (failed(parser.parseGreater()))
       return LLVMStructType();
-    auto type = LLVMStructType::getOpaqueChecked(loc, name);
+    auto type = LLVMStructType::getOpaqueChecked(
+        [loc] { return emitError(loc); }, loc.getContext(), name);
     if (!type.isOpaque()) {
       parser.emitError(kwLoc, "redeclaring defined struct as opaque");
       return LLVMStructType();
     }
     return type;
   }
 
   // Check for packedness.
   bool isPacked = succeeded(parser.parseOptionalKeyword("packed"));
   if (failed(parser.parseLParen()))
     return LLVMStructType();
 
   // Fast pass for structs with zero subtypes.
   if (succeeded(parser.parseOptionalRParen())) {
     if (failed(parser.parseGreater()))
       return LLVMStructType();
     if (!isIdentified)
-      return LLVMStructType::getLiteralChecked(loc, {}, isPacked);
-    auto type = LLVMStructType::getIdentifiedChecked(loc, name);
+      return LLVMStructType::getLiteralChecked([loc] { return emitError(loc); },
+                                               loc.getContext(), {}, isPacked);
+    auto type = LLVMStructType::getIdentifiedChecked(
+        [loc] { return emitError(loc); }, loc.getContext(), name);
     return trySetStructBody(type, {}, isPacked, parser, kwLoc);
   }
 
   // Parse subtypes. For identified structs, put the identifier of the struct on
   // the stack to support self-references in the recursive calls.
   SmallVector<Type, 4> subtypes;
   llvm::SMLoc subtypesLoc = parser.getCurrentLocation();
   do {
     if (isIdentified)
       knownStructNames.insert(name);
     Type type;
     if (dispatchParse(parser, type))
       return LLVMStructType();
     subtypes.push_back(type);
     if (isIdentified)
       knownStructNames.pop_back();
   } while (succeeded(parser.parseOptionalComma()));
 
   if (parser.parseRParen() || parser.parseGreater())
     return LLVMStructType();
 
   // Construct the struct with body.
   if (!isIdentified)
-    return LLVMStructType::getLiteralChecked(loc, subtypes, isPacked);
-  auto type = LLVMStructType::getIdentifiedChecked(loc, name);
+    return LLVMStructType::getLiteralChecked(
+        [loc] { return emitError(loc); }, loc.getContext(), subtypes, isPacked);
+  auto type = LLVMStructType::getIdentifiedChecked(
+      [loc] { return emitError(loc); }, loc.getContext(), name);
   return trySetStructBody(type, subtypes, isPacked, parser, subtypesLoc);
 }
 
 /// Parses a type appearing inside another LLVM dialect-compatible type. This
 /// will try to parse any type in full form (including types with the `!llvm`
 /// prefix), and on failure fall back to parsing the short-hand version of the
 /// LLVM dialect types without the `!llvm` prefix.
 static Type dispatchParse(DialectAsmParser &parser, bool allowAny = true) {

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

return !type.isa<LLVMVoidType, LLVMLabelType, LLVMMetadataType,
                    LLVMFunctionType, LLVMTokenType, LLVMScalableVectorType>();
 }
 
 LLVMArrayType LLVMArrayType::get(Type elementType, unsigned numElements) {
   assert(elementType && "expected non-null subtype");
   return Base::get(elementType.getContext(), elementType, numElements);
 }
 
-LLVMArrayType LLVMArrayType::getChecked(Location loc, Type elementType,
-                                        unsigned numElements) {
+LLVMArrayType
+LLVMArrayType::getChecked(function_ref<InFlightDiagnostic()> emitError,
+                          Type elementType, unsigned numElements) {
   assert(elementType && "expected non-null subtype");
-  return Base::getChecked(loc, elementType, numElements);
+  return Base::getChecked(emitError, elementType.getContext(), elementType,
+                          numElements);
 }
 
 Type LLVMArrayType::getElementType() { return getImpl()->elementType; }
 
 unsigned LLVMArrayType::getNumElements() { return getImpl()->numElements; }
 
 LogicalResult
-LLVMArrayType::verifyConstructionInvariants(Location loc, Type elementType,
-                                            unsigned numElements) {
+LLVMArrayType::verify(function_ref<InFlightDiagnostic()> emitError,
+                      Type elementType, unsigned numElements) {
   if (!isValidElementType(elementType))
-    return emitError(loc, "invalid array element type: ") << elementType;
+    return emitError() << "invalid array element type: " << elementType;
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // Function type.
 //===----------------------------------------------------------------------===//
 
 bool LLVMFunctionType::isValidArgumentType(Type type) {
   return !type.isa<LLVMVoidType, LLVMFunctionType>();
 }
 
 bool LLVMFunctionType::isValidResultType(Type type) {
   return !type.isa<LLVMFunctionType, LLVMMetadataType, LLVMLabelType>();
 }
 
 LLVMFunctionType LLVMFunctionType::get(Type result, ArrayRef<Type> arguments,
                                        bool isVarArg) {
   assert(result && "expected non-null result");
   return Base::get(result.getContext(), result, arguments, isVarArg);
 }
 
-LLVMFunctionType LLVMFunctionType::getChecked(Location loc, Type result,
-                                              ArrayRef<Type> arguments,
-                                              bool isVarArg) {
+LLVMFunctionType
+LLVMFunctionType::getChecked(function_ref<InFlightDiagnostic()> emitError,
+                             Type result, ArrayRef<Type> arguments,
   assert(result && "expected non-null result");
-  return Base::getChecked(loc, result, arguments, isVarArg);
+  return Base::getChecked(emitError, result.getContext(), result, arguments,
+                          isVarArg);
 }
 
 Type LLVMFunctionType::getReturnType() { return getImpl()->getReturnType(); }
 
 unsigned LLVMFunctionType::getNumParams() {
   return getImpl()->getArgumentTypes().size();
 }
 
 Type LLVMFunctionType::getParamType(unsigned i) {
   return getImpl()->getArgumentTypes()[i];
 }
 
 bool LLVMFunctionType::isVarArg() { return getImpl()->isVariadic(); }
 
 ArrayRef<Type> LLVMFunctionType::getParams() {
   return getImpl()->getArgumentTypes();
 }
 
 LogicalResult
-LLVMFunctionType::verifyConstructionInvariants(Location loc, Type result,
-                                               ArrayRef<Type> arguments, bool) {
+LLVMFunctionType::verify(function_ref<InFlightDiagnostic()> emitError,
+                         Type result, ArrayRef<Type> arguments, bool) {
   if (!isValidResultType(result))
-    return emitError(loc, "invalid function result type: ") << result;
+    return emitError() << "invalid function result type: " << result;
 
   for (Type arg : arguments)
     if (!isValidArgumentType(arg))
-      return emitError(loc, "invalid function argument type: ") << arg;
+      return emitError() << "invalid function argument type: " << arg;
 
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // Pointer type.
 //===----------------------------------------------------------------------===//
 
 bool LLVMPointerType::isValidElementType(Type type) {
   return !type.isa<LLVMVoidType, LLVMTokenType, LLVMMetadataType,
                    LLVMLabelType>();
 }
 
 LLVMPointerType LLVMPointerType::get(Type pointee, unsigned addressSpace) {
   assert(pointee && "expected non-null subtype");
   return Base::get(pointee.getContext(), pointee, addressSpace);
 }
 
-LLVMPointerType LLVMPointerType::getChecked(Location loc, Type pointee,
-                                            unsigned addressSpace) {
-  return Base::getChecked(loc, pointee, addressSpace);
+LLVMPointerType
+LLVMPointerType::getChecked(function_ref<InFlightDiagnostic()> emitError,
+                            Type pointee, unsigned addressSpace) {
+  return Base::getChecked(emitError, pointee.getContext(), pointee,
+                          addressSpace);
 }
 
 Type LLVMPointerType::getElementType() { return getImpl()->pointeeType; }
 
 unsigned LLVMPointerType::getAddressSpace() { return getImpl()->addressSpace; }
 
-LogicalResult LLVMPointerType::verifyConstructionInvariants(Location loc,
-                                                            Type pointee,
-                                                            unsigned) {
+LogicalResult
+LLVMPointerType::verify(function_ref<InFlightDiagnostic()> emitError,
+                        Type pointee, unsigned) {
   if (!isValidElementType(pointee))
-    return emitError(loc, "invalid pointer element type: ") << pointee;
+    return emitError() << "invalid pointer element type: " << pointee;
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // Struct type.
 //===----------------------------------------------------------------------===//
 
 bool LLVMStructType::isValidElementType(Type type) {
   return !type.isa<LLVMVoidType, LLVMLabelType, LLVMMetadataType,
                    LLVMFunctionType, LLVMTokenType, LLVMScalableVectorType>();
 }
 
 LLVMStructType LLVMStructType::getIdentified(MLIRContext *context,
                                              StringRef name) {
   return Base::get(context, name, /*opaque=*/false);
 }
 
-LLVMStructType LLVMStructType::getIdentifiedChecked(Location loc,
-                                                    StringRef name) {
-  return Base::getChecked(loc, name, /*opaque=*/false);
+LLVMStructType LLVMStructType::getIdentifiedChecked(
+    function_ref<InFlightDiagnostic()> emitError, MLIRContext *context,
+  return Base::getChecked(emitError, context, name, /*opaque=*/false);
 }
 
 LLVMStructType LLVMStructType::getNewIdentified(MLIRContext *context,
                                                 StringRef name,
                                                 ArrayRef<Type> elements,
                                                 bool isPacked) {
   std::string stringName = name.str();
   unsigned counter = 0;
   do {
     auto type = LLVMStructType::getIdentified(context, stringName);
     if (type.isInitialized() || failed(type.setBody(elements, isPacked))) {
       counter += 1;
       stringName = (Twine(name) + "." + std::to_string(counter)).str();
       continue;
     }
     return type;
   } while (true);
 }
 
 LLVMStructType LLVMStructType::getLiteral(MLIRContext *context,
                                           ArrayRef<Type> types, bool isPacked) {
   return Base::get(context, types, isPacked);
 }
 
-LLVMStructType LLVMStructType::getLiteralChecked(Location loc,
-                                                 ArrayRef<Type> types,
-                                                 bool isPacked) {
-  return Base::getChecked(loc, types, isPacked);
+LLVMStructType
+LLVMStructType::getLiteralChecked(function_ref<InFlightDiagnostic()> emitError,
+                                  MLIRContext *context, ArrayRef<Type> types,
+  return Base::getChecked(emitError, context, types, isPacked);
 }
 
 LLVMStructType LLVMStructType::getOpaque(StringRef name, MLIRContext *context) {
   return Base::get(context, name, /*opaque=*/true);
 }
 
-LLVMStructType LLVMStructType::getOpaqueChecked(Location loc, StringRef name) {
-  return Base::getChecked(loc, name, /*opaque=*/true);
+LLVMStructType
+LLVMStructType::getOpaqueChecked(function_ref<InFlightDiagnostic()> emitError,
+                                 MLIRContext *context, StringRef name) {
+  return Base::getChecked(emitError, context, name, /*opaque=*/true);
 }
 
 LogicalResult LLVMStructType::setBody(ArrayRef<Type> types, bool isPacked) {
   assert(isIdentified() && "can only set bodies of identified structs");
   assert(llvm::all_of(types, LLVMStructType::isValidElementType) &&
          "expected valid body types");
   return Base::mutate(types, isPacked);
 }
 
 bool LLVMStructType::isPacked() { return getImpl()->isPacked(); }
 bool LLVMStructType::isIdentified() { return getImpl()->isIdentified(); }
 bool LLVMStructType::isOpaque() {
   return getImpl()->isIdentified() &&
          (getImpl()->isOpaque() || !getImpl()->isInitialized());
 }
 bool LLVMStructType::isInitialized() { return getImpl()->isInitialized(); }
 StringRef LLVMStructType::getName() { return getImpl()->getIdentifier(); }
 ArrayRef<Type> LLVMStructType::getBody() {
   return isIdentified() ? getImpl()->getIdentifiedStructBody()
                         : getImpl()->getTypeList();
 }
 
-LogicalResult LLVMStructType::verifyConstructionInvariants(Location, StringRef,
-                                                           bool) {
+LogicalResult LLVMStructType::verify(function_ref<InFlightDiagnostic()>,
+                                     StringRef, bool) {
   return success();
 }
 
-LogicalResult LLVMStructType::verifyConstructionInvariants(Location loc,
-                                                           ArrayRef<Type> types,
-                                                           bool) {
+LogicalResult
+LLVMStructType::verify(function_ref<InFlightDiagnostic()> emitError,
+                       ArrayRef<Type> types, bool) {
   for (Type t : types)
     if (!isValidElementType(t))
-      return emitError(loc, "invalid LLVM structure element type: ") << t;
+      return emitError() << "invalid LLVM structure element type: " << t;
 
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // Vector types.
 //===----------------------------------------------------------------------===//
 
 /// Verifies that the type about to be constructed is well-formed.
 template <typename VecTy>
-static LogicalResult verifyVectorConstructionInvariants(Location loc,
-                                                        Type elementType,
-                                                        unsigned numElements) {
+static LogicalResult
+verifyVectorConstructionInvariants(function_ref<InFlightDiagnostic()> emitError,
+                                   Type elementType, unsigned numElements) {
   if (numElements == 0)
-    return emitError(loc, "the number of vector elements must be positive");
+    return emitError() << "the number of vector elements must be positive";
 
   if (!VecTy::isValidElementType(elementType))
-    return emitError(loc, "invalid vector element type");
+    return emitError() << "invalid vector element type";
 
   return success();
 }
 
 LLVMFixedVectorType LLVMFixedVectorType::get(Type elementType,
                                              unsigned numElements) {
   assert(elementType && "expected non-null subtype");
   return Base::get(elementType.getContext(), elementType, numElements);
 }
 
-LLVMFixedVectorType LLVMFixedVectorType::getChecked(Location loc,
-                                                    Type elementType,
-                                                    unsigned numElements) {
+LLVMFixedVectorType
+LLVMFixedVectorType::getChecked(function_ref<InFlightDiagnostic()> emitError,
+                                Type elementType, unsigned numElements) {
   assert(elementType && "expected non-null subtype");
-  return Base::getChecked(loc, elementType, numElements);
+  return Base::getChecked(emitError, elementType.getContext(), elementType,
+                          numElements);
 }
 
 Type LLVMFixedVectorType::getElementType() {
   return static_cast<detail::LLVMTypeAndSizeStorage *>(impl)->elementType;
 }
 
 unsigned LLVMFixedVectorType::getNumElements() {
   return getImpl()->numElements;
 }
 
 bool LLVMFixedVectorType::isValidElementType(Type type) {
   return type.isa<LLVMPointerType, LLVMPPCFP128Type>();
 }
 
-LogicalResult LLVMFixedVectorType::verifyConstructionInvariants(
-    Location loc, Type elementType, unsigned numElements) {
+LogicalResult
+LLVMFixedVectorType::verify(function_ref<InFlightDiagnostic()> emitError,
+                            Type elementType, unsigned numElements) {
   return verifyVectorConstructionInvariants<LLVMFixedVectorType>(
-      loc, elementType, numElements);
+      emitError, elementType, numElements);
 }
 
 //===----------------------------------------------------------------------===//
 // LLVMScalableVectorType.
 //===----------------------------------------------------------------------===//
 
 LLVMScalableVectorType LLVMScalableVectorType::get(Type elementType,
                                                    unsigned minNumElements) {
   assert(elementType && "expected non-null subtype");
   return Base::get(elementType.getContext(), elementType, minNumElements);
 }
 
 LLVMScalableVectorType
-LLVMScalableVectorType::getChecked(Location loc, Type elementType,
-                                   unsigned minNumElements) {
+LLVMScalableVectorType::getChecked(function_ref<InFlightDiagnostic()> emitError,
+                                   Type elementType, unsigned minNumElements) {
   assert(elementType && "expected non-null subtype");
-  return Base::getChecked(loc, elementType, minNumElements);
+  return Base::getChecked(emitError, elementType.getContext(), elementType,
+                          minNumElements);
 }
 
 Type LLVMScalableVectorType::getElementType() {
   return static_cast<detail::LLVMTypeAndSizeStorage *>(impl)->elementType;
 }
 
 unsigned LLVMScalableVectorType::getMinNumElements() {
   return getImpl()->numElements;
 }
 
 bool LLVMScalableVectorType::isValidElementType(Type type) {
   if (auto intType = type.dyn_cast<IntegerType>())
     return intType.isSignless();
 
   return isCompatibleFloatingPointType(type) || type.isa<LLVMPointerType>();
 }
 
-LogicalResult LLVMScalableVectorType::verifyConstructionInvariants(
-    Location loc, Type elementType, unsigned numElements) {
+LogicalResult
+LLVMScalableVectorType::verify(function_ref<InFlightDiagnostic()> emitError,
+                               Type elementType, unsigned numElements) {
   return verifyVectorConstructionInvariants<LLVMScalableVectorType>(
-      loc, elementType, numElements);
+      emitError, elementType, numElements);
 }
 
 //===----------------------------------------------------------------------===//
 // Utility functions.
 //===----------------------------------------------------------------------===//
 
 bool mlir::LLVM::isCompatibleType(Type type) {
   // Only signless integers are compatible.

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

 unsigned QuantizedType::getFlags() const {
   return static_cast<ImplType *>(impl)->flags;
 }
 
 bool QuantizedType::classof(Type type) {
   return llvm::isa<QuantizationDialect>(type.getDialect());
 }
 
-LogicalResult QuantizedType::verifyConstructionInvariants(
-    Location loc, unsigned flags, Type storageType, Type expressedType,
+LogicalResult
+QuantizedType::verify(function_ref<InFlightDiagnostic()> emitError,
+                      unsigned flags, Type storageType, Type expressedType,
                       int64_t storageTypeMin, int64_t storageTypeMax) {
   // Verify that the storage type is integral.
   // This restriction may be lifted at some point in favor of using bf16
   // or f16 as exact representations on hardware where that is advantageous.
   auto intStorageType = storageType.dyn_cast<IntegerType>();
   if (!intStorageType)
-    return emitError(loc, "storage type must be integral");
+    return emitError() << "storage type must be integral";
   unsigned integralWidth = intStorageType.getWidth();
 
   // Verify storage width.
   if (integralWidth == 0 || integralWidth > MaxStorageBits)
-    return emitError(loc, "illegal storage type size: ") << integralWidth;
+    return emitError() << "illegal storage type size: " << integralWidth;
 
   // Verify storageTypeMin and storageTypeMax.
   bool isSigned =
       (flags & QuantizationFlags::Signed) == QuantizationFlags::Signed;
   int64_t defaultIntegerMin =
       getDefaultMinimumForInteger(isSigned, integralWidth);
   int64_t defaultIntegerMax =
       getDefaultMaximumForInteger(isSigned, integralWidth);
   if (storageTypeMax - storageTypeMin <= 0 ||
       storageTypeMin < defaultIntegerMin ||
       storageTypeMax > defaultIntegerMax) {
-    return emitError(loc, "illegal storage min and storage max: (")
+    return emitError() << "illegal storage min and storage max: ("
                        << storageTypeMin << ":" << storageTypeMax << ")";
   }
   return success();
 }
 
 Type QuantizedType::getStorageType() const {
   return static_cast<ImplType *>(impl)->storageType;
 }
 

 AnyQuantizedType AnyQuantizedType::get(unsigned flags, Type storageType,
                                        Type expressedType,
                                        int64_t storageTypeMin,
                                        int64_t storageTypeMax) {
   return Base::get(storageType.getContext(), flags, storageType, expressedType,
                    storageTypeMin, storageTypeMax);
 }
 
-AnyQuantizedType AnyQuantizedType::getChecked(unsigned flags, Type storageType,
-                                              Type expressedType,
-                                              int64_t storageTypeMin,
-                                              int64_t storageTypeMax,
-                                              Location location) {
-  return Base::getChecked(location, flags, storageType, expressedType,
-                          storageTypeMin, storageTypeMax);
+AnyQuantizedType
+AnyQuantizedType::getChecked(function_ref<InFlightDiagnostic()> emitError,
+                             unsigned flags, Type storageType,
+                             Type expressedType, int64_t storageTypeMin,
+                             int64_t storageTypeMax) {
+  return Base::getChecked(emitError, storageType.getContext(), flags,
+                          storageType, expressedType, storageTypeMin,
+                          storageTypeMax);
 }
 
-LogicalResult AnyQuantizedType::verifyConstructionInvariants(
-    Location loc, unsigned flags, Type storageType, Type expressedType,
+LogicalResult
+AnyQuantizedType::verify(function_ref<InFlightDiagnostic()> emitError,
+                         unsigned flags, Type storageType, Type expressedType,
                          int64_t storageTypeMin, int64_t storageTypeMax) {
-  if (failed(QuantizedType::verifyConstructionInvariants(
-          loc, flags, storageType, expressedType, storageTypeMin,
-          storageTypeMax))) {
+  if (failed(QuantizedType::verify(emitError, flags, storageType, expressedType,
+                                   storageTypeMin, storageTypeMax))) {
     return failure();
   }
 
   // Verify that the expressed type is floating point.
   // If this restriction is ever eliminated, the parser/printer must be
   // extended.
   if (expressedType && !expressedType.isa<FloatType>())
-    return emitError(loc, "expressed type must be floating point");
+    return emitError() << "expressed type must be floating point";
 
   return success();
 }
 
 UniformQuantizedType UniformQuantizedType::get(unsigned flags, Type storageType,
                                                Type expressedType, double scale,
                                                int64_t zeroPoint,
                                                int64_t storageTypeMin,
                                                int64_t storageTypeMax) {
   return Base::get(storageType.getContext(), flags, storageType, expressedType,
                    scale, zeroPoint, storageTypeMin, storageTypeMax);
 }
 
-UniformQuantizedType
-UniformQuantizedType::getChecked(unsigned flags, Type storageType,
-                                 Type expressedType, double scale,
-                                 int64_t zeroPoint, int64_t storageTypeMin,
-                                 int64_t storageTypeMax, Location location) {
-  return Base::getChecked(location, flags, storageType, expressedType, scale,
-                          zeroPoint, storageTypeMin, storageTypeMax);
+UniformQuantizedType UniformQuantizedType::getChecked(
+    function_ref<InFlightDiagnostic()> emitError, unsigned flags,
+    Type storageType, Type expressedType, double scale, int64_t zeroPoint,
+    int64_t storageTypeMin, int64_t storageTypeMax) {
+  return Base::getChecked(emitError, storageType.getContext(), flags,
+                          storageType, expressedType, scale, zeroPoint,
+                          storageTypeMin, storageTypeMax);
 }
 
-LogicalResult UniformQuantizedType::verifyConstructionInvariants(
-    Location loc, unsigned flags, Type storageType, Type expressedType,
-    double scale, int64_t zeroPoint, int64_t storageTypeMin,
-    int64_t storageTypeMax) {
-  if (failed(QuantizedType::verifyConstructionInvariants(
-          loc, flags, storageType, expressedType, storageTypeMin,
-          storageTypeMax))) {
+LogicalResult UniformQuantizedType::verify(
+    function_ref<InFlightDiagnostic()> emitError, unsigned flags,
+    Type storageType, Type expressedType, double scale, int64_t zeroPoint,
+    int64_t storageTypeMin, int64_t storageTypeMax) {
+  if (failed(QuantizedType::verify(emitError, flags, storageType, expressedType,
+                                   storageTypeMin, storageTypeMax))) {
     return failure();
   }
 
   // Uniform quantization requires fully expressed parameters, including
   // expressed type.
   if (!expressedType)
-    return emitError(loc, "uniform quantization requires expressed type");
+    return emitError() << "uniform quantization requires expressed type";
 
   // Verify that the expressed type is floating point.
   // If this restriction is ever eliminated, the parser/printer must be
   // extended.
   if (!expressedType.isa<FloatType>())
-    return emitError(loc, "expressed type must be floating point");
+    return emitError() << "expressed type must be floating point";
 
   // Verify scale.
   if (scale <= 0.0 || std::isinf(scale) || std::isnan(scale))
-    return emitError(loc, "illegal scale: ") << scale;
+    return emitError() << "illegal scale: " << scale;
 
   return success();
 }
 
 double UniformQuantizedType::getScale() const { return getImpl()->scale; }
 
 int64_t UniformQuantizedType::getZeroPoint() const {
   return getImpl()->zeroPoint;
 }
 
 UniformQuantizedPerAxisType UniformQuantizedPerAxisType::get(
     unsigned flags, Type storageType, Type expressedType,
     ArrayRef<double> scales, ArrayRef<int64_t> zeroPoints,
     int32_t quantizedDimension, int64_t storageTypeMin,
     int64_t storageTypeMax) {
   return Base::get(storageType.getContext(), flags, storageType, expressedType,
                    scales, zeroPoints, quantizedDimension, storageTypeMin,
                    storageTypeMax);
 }
 
 UniformQuantizedPerAxisType UniformQuantizedPerAxisType::getChecked(
-    unsigned flags, Type storageType, Type expressedType,
-    ArrayRef<double> scales, ArrayRef<int64_t> zeroPoints,
-    int32_t quantizedDimension, int64_t storageTypeMin, int64_t storageTypeMax,
-    Location location) {
-  return Base::getChecked(location, flags, storageType, expressedType, scales,
-                          zeroPoints, quantizedDimension, storageTypeMin,
-                          storageTypeMax);
+    function_ref<InFlightDiagnostic()> emitError, unsigned flags,
+    Type storageType, Type expressedType, ArrayRef<double> scales,
+    ArrayRef<int64_t> zeroPoints, int32_t quantizedDimension,
+    int64_t storageTypeMin, int64_t storageTypeMax) {
+  return Base::getChecked(emitError, storageType.getContext(), flags,
+                          storageType, expressedType, scales, zeroPoints,
+                          quantizedDimension, storageTypeMin, storageTypeMax);
 }
 
-LogicalResult UniformQuantizedPerAxisType::verifyConstructionInvariants(
-    Location loc, unsigned flags, Type storageType, Type expressedType,
-    ArrayRef<double> scales, ArrayRef<int64_t> zeroPoints,
-    int32_t quantizedDimension, int64_t storageTypeMin,
-    int64_t storageTypeMax) {
-  if (failed(QuantizedType::verifyConstructionInvariants(
-          loc, flags, storageType, expressedType, storageTypeMin,
-          storageTypeMax))) {
+LogicalResult UniformQuantizedPerAxisType::verify(
+    function_ref<InFlightDiagnostic()> emitError, unsigned flags,
+    Type storageType, Type expressedType, ArrayRef<double> scales,
+    ArrayRef<int64_t> zeroPoints, int32_t quantizedDimension,
+    int64_t storageTypeMin, int64_t storageTypeMax) {
+  if (failed(QuantizedType::verify(emitError, flags, storageType, expressedType,
+                                   storageTypeMin, storageTypeMax))) {
     return failure();
   }
 
   // Uniform quantization requires fully expressed parameters, including
   // expressed type.
   if (!expressedType)
-    return emitError(loc, "uniform quantization requires expressed type");
+    return emitError() << "uniform quantization requires expressed type";
 
   // Verify that the expressed type is floating point.
   // If this restriction is ever eliminated, the parser/printer must be
   // extended.
   if (!expressedType.isa<FloatType>())
-    return emitError(loc, "expressed type must be floating point");
+    return emitError() << "expressed type must be floating point";
 
   // Ensure that the number of scales and zeroPoints match.
   if (scales.size() != zeroPoints.size())
-    return emitError(loc, "illegal number of scales and zeroPoints: ")
+    return emitError() << "illegal number of scales and zeroPoints: "
                        << scales.size() << ", " << zeroPoints.size();
 
   // Verify scale.
   for (double scale : scales) {
     if (scale <= 0.0 || std::isinf(scale) || std::isnan(scale))
-      return emitError(loc, "illegal scale: ") << scale;
+      return emitError() << "illegal scale: " << scale;
   }
 
   return success();
 }
 
 ArrayRef<double> UniformQuantizedPerAxisType::getScales() const {
   return getImpl()->getScales();
 }
 
 ArrayRef<int64_t> UniformQuantizedPerAxisType::getZeroPoints() const {
   return getImpl()->getZeroPoints();
 }
 
 int32_t UniformQuantizedPerAxisType::getQuantizedDimension() const {
   return getImpl()->quantizedDimension;
 }
 
 CalibratedQuantizedType CalibratedQuantizedType::get(Type expressedType,
                                                      double min, double max) {
   return Base::get(expressedType.getContext(), expressedType, min, max);
 }
 
-CalibratedQuantizedType CalibratedQuantizedType::getChecked(Type expressedType,
-                                                            double min,
-                                                            double max,
-                                                            Location location) {
-  return Base::getChecked(location, expressedType, min, max);
+CalibratedQuantizedType CalibratedQuantizedType::getChecked(
+    function_ref<InFlightDiagnostic()> emitError, Type expressedType,
+    double min, double max) {
+  return Base::getChecked(emitError, expressedType.getContext(), expressedType,
+                          min, max);
 }
 
-LogicalResult CalibratedQuantizedType::verifyConstructionInvariants(
-    Location loc, Type expressedType, double min, double max) {
+LogicalResult
+CalibratedQuantizedType::verify(function_ref<InFlightDiagnostic()> emitError,
+                                Type expressedType, double min, double max) {
   // Verify that the expressed type is floating point.
   // If this restriction is ever eliminated, the parser/printer must be
   // extended.
   if (!expressedType.isa<FloatType>())
-    return emitError(loc, "expressed type must be floating point");
+    return emitError() << "expressed type must be floating point";
   if (max <= min)
-    return emitError(loc, "illegal min and max: (") << min << ":" << max << ")";
+    return emitError() << "illegal min and max: (" << min << ":" << max << ")";
 
   return success();
 }
 
 double CalibratedQuantizedType::getMin() const { return getImpl()->min; }
 
 double CalibratedQuantizedType::getMax() const { return getImpl()->max; }

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

if (parser.parseType(expressedType)) {
       return nullptr;
     }
   }
 
   if (parser.parseGreater()) {
     return nullptr;
   }
 
-  return AnyQuantizedType::getChecked(typeFlags, storageType, expressedType,
-                                      storageTypeMin, storageTypeMax, loc);
+  return AnyQuantizedType::getChecked(loc, typeFlags, storageType,
+                                      expressedType, storageTypeMin,
+                                      storageTypeMax);
 }
 
 static ParseResult parseQuantParams(DialectAsmParser &parser, double &scale,
                                     int64_t &zeroPoint) {
   // scale[:zeroPoint]?
   // scale.
   if (parser.parseFloat(scale))
     return failure();
return (parser.emitError(scaleZPLoc,
                              "quantizedDimension wasn't specified"),
             nullptr);
   }
 
   if (isPerAxis) {
     ArrayRef<double> scalesRef(scales.begin(), scales.end());
     ArrayRef<int64_t> zeroPointsRef(zeroPoints.begin(), zeroPoints.end());
     return UniformQuantizedPerAxisType::getChecked(
-        typeFlags, storageType, expressedType, scalesRef, zeroPointsRef,
-        quantizedDimension, storageTypeMin, storageTypeMax, loc);
+        loc, typeFlags, storageType, expressedType, scalesRef, zeroPointsRef,
+        quantizedDimension, storageTypeMin, storageTypeMax);
   }
 
-  return UniformQuantizedType::getChecked(typeFlags, storageType, expressedType,
-                                          scales.front(), zeroPoints.front(),
-                                          storageTypeMin, storageTypeMax, loc);
+  return UniformQuantizedType::getChecked(
+      loc, typeFlags, storageType, expressedType, scales.front(),
+      zeroPoints.front(), storageTypeMin, storageTypeMax);
 }
 
 /// Parses an CalibratedQuantizedType.
 ///
 ///   calibrated ::= `calibrated<` expressed-spec `>`
 ///   expressed-spec ::= expressed-type `<` calibrated-range `>`
 ///   expressed-type ::= `f` integer-literal
 ///   calibrated-range ::= float-literal `:` float-literal
static Type parseCalibratedType(DialectAsmParser &parser, Location loc) {
   if (!expressedType) {
     return nullptr;
   }
 
   if (parser.parseGreater()) {
     return nullptr;
   }
 
-  return CalibratedQuantizedType::getChecked(expressedType, min, max, loc);
+  return CalibratedQuantizedType::getChecked(loc, expressedType, min, max);
 }
 
 /// Parse a type registered to this dialect.
 Type QuantizationDialect::parseType(DialectAsmParser &parser) const {
   Location loc = parser.getEncodedSourceLoc(parser.getNameLoc());
 
   // All types start with an identifier that we switch on.
   StringRef typeNameSpelling;

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

if (getDefaultStorageParams(numBits, narrowRange, isSigned, ctx, storageType,
     return (emitError(loc, "unsupported FakeQuant number of bits: ") << numBits,
             nullptr);
   }
 
   // Special case where min/max is close enough. The tensor contents are all
   // 0.0s, so the scale is set to 1.0 and the tensor can be quantized to zero
   // points and dequantized to 0.0.
   if (std::fabs(rmax - rmin) < std::numeric_limits<double>::epsilon()) {
-    return UniformQuantizedType::getChecked(flags, storageType, expressedType,
-                                            1.0, qmin, qmin, qmax, loc);
+    return UniformQuantizedType::getChecked(
+        loc, flags, storageType, expressedType, 1.0, qmin, qmin, qmax);
   }
 
   double scale;
   int64_t nudgedZeroPoint;
   getNudgedScaleAndZeroPoint(qmin, qmax, rmin, rmax, scale, nudgedZeroPoint);
 
-  return UniformQuantizedType::getChecked(flags, storageType, expressedType,
-                                          scale, nudgedZeroPoint, qmin, qmax,
-                                          loc);
+  return UniformQuantizedType::getChecked(loc, flags, storageType,
+                                          expressedType, scale, nudgedZeroPoint,
+                                          qmin, qmax);
 }
 
 UniformQuantizedPerAxisType mlir::quant::fakeQuantAttrsToType(
     Location loc, unsigned numBits, int32_t quantizedDimension,
     ArrayRef<double> rmins, ArrayRef<double> rmaxs, bool narrowRange,
     Type expressedType, bool isSigned) {
   size_t axis_size = rmins.size();
   if (axis_size != rmaxs.size()) {
for (size_t axis = 0; axis != axis_size; ++axis) {
     int64_t nudgedZeroPoint;
     getNudgedScaleAndZeroPoint(qmin, qmax, rmin, rmax, scale, nudgedZeroPoint);
     scales.push_back(scale);
     zeroPoints.push_back(nudgedZeroPoint);
   }
 
   unsigned flags = isSigned ? QuantizationFlags::Signed : 0;
   return UniformQuantizedPerAxisType::getChecked(
-      flags, storageType, expressedType, scales, zeroPoints, quantizedDimension,
-      qmin, qmax, loc);
+      loc, flags, storageType, expressedType, scales, zeroPoints,
+      quantizedDimension, qmin, qmax);
 }

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

 
 Optional<spirv::StorageClass> spirv::InterfaceVarABIAttr::getStorageClass() {
   if (getImpl()->storageClass)
     return static_cast<spirv::StorageClass>(
         getImpl()->storageClass.cast<IntegerAttr>().getValue().getZExtValue());
   return llvm::None;
 }
 
-LogicalResult spirv::InterfaceVarABIAttr::verifyConstructionInvariants(
-    Location loc, IntegerAttr descriptorSet, IntegerAttr binding,
-    IntegerAttr storageClass) {
+LogicalResult spirv::InterfaceVarABIAttr::verify(
+    function_ref<InFlightDiagnostic()> emitError, IntegerAttr descriptorSet,
+    IntegerAttr binding, IntegerAttr storageClass) {
   if (!descriptorSet.getType().isSignlessInteger(32))
-    return emitError(loc, "expected 32-bit integer for descriptor set");
+    return emitError() << "expected 32-bit integer for descriptor set";
 
   if (!binding.getType().isSignlessInteger(32))
-    return emitError(loc, "expected 32-bit integer for binding");
+    return emitError() << "expected 32-bit integer for binding";
 
   if (storageClass) {
     if (auto storageClassAttr = storageClass.cast<IntegerAttr>()) {
       auto storageClassValue =
           spirv::symbolizeStorageClass(storageClassAttr.getInt());
       if (!storageClassValue)
-        return emitError(loc, "unknown storage class");
+        return emitError() << "unknown storage class";
     } else {
-      return emitError(loc, "expected valid storage class");
+      return emitError() << "expected valid storage class";
     }
   }
 
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // VerCapExtAttr
spirv::VerCapExtAttr::cap_range spirv::VerCapExtAttr::getCapabilities() {
   auto range = getCapabilitiesAttr().getValue();
   return {cap_iterator(range.begin()), cap_iterator(range.end())};
 }
 
 ArrayAttr spirv::VerCapExtAttr::getCapabilitiesAttr() {
   return getImpl()->capabilities.cast<ArrayAttr>();
 }
 
-LogicalResult spirv::VerCapExtAttr::verifyConstructionInvariants(
-    Location loc, IntegerAttr version, ArrayAttr capabilities,
+LogicalResult
+spirv::VerCapExtAttr::verify(function_ref<InFlightDiagnostic()> emitError,
+                             IntegerAttr version, ArrayAttr capabilities,
                              ArrayAttr extensions) {
   if (!version.getType().isSignlessInteger(32))
-    return emitError(loc, "expected 32-bit integer for version");
+    return emitError() << "expected 32-bit integer for version";
 
   if (!llvm::all_of(capabilities.getValue(), [](Attribute attr) {
         if (auto intAttr = attr.dyn_cast<IntegerAttr>())
           if (spirv::symbolizeCapability(intAttr.getValue().getZExtValue()))
             return true;
         return false;
       }))
-    return emitError(loc, "unknown capability in capability list");
+    return emitError() << "unknown capability in capability list";
 
   if (!llvm::all_of(extensions.getValue(), [](Attribute attr) {
         if (auto strAttr = attr.dyn_cast<StringAttr>())
           if (spirv::symbolizeExtension(strAttr.getValue()))
             return true;
         return false;
       }))
-    return emitError(loc, "unknown extension in extension list");
+    return emitError() << "unknown extension in extension list";
 
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // TargetEnvAttr
 //===----------------------------------------------------------------------===//
 

 uint32_t spirv::TargetEnvAttr::getDeviceID() const {
   return getImpl()->deviceID;
 }
 
 spirv::ResourceLimitsAttr spirv::TargetEnvAttr::getResourceLimits() const {
   return getImpl()->limits.cast<spirv::ResourceLimitsAttr>();
 }
 
-LogicalResult spirv::TargetEnvAttr::verifyConstructionInvariants(
-    Location loc, spirv::VerCapExtAttr /*triple*/, spirv::Vendor /*vendorID*/,
-    spirv::DeviceType /*deviceType*/, uint32_t /*deviceID*/,
-    DictionaryAttr limits) {
+LogicalResult
+spirv::TargetEnvAttr::verify(function_ref<InFlightDiagnostic()> emitError,
+                             spirv::VerCapExtAttr /*triple*/,
+                             spirv::Vendor /*vendorID*/,
+                             spirv::DeviceType /*deviceType*/,
+                             uint32_t /*deviceID*/, DictionaryAttr limits) {
   if (!limits.isa<spirv::ResourceLimitsAttr>())
-    return emitError(loc, "expected spirv::ResourceLimitsAttr for limits");
+    return emitError() << "expected spirv::ResourceLimitsAttr for limits";
 
   return success();
 }

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

void CooperativeMatrixNVType::getCapabilities(
   ArrayRef<Capability> ref(caps, llvm::array_lengthof(caps));
   capabilities.push_back(ref);
 }
 
 //===----------------------------------------------------------------------===//
 // ImageType
 //===----------------------------------------------------------------------===//
 
-template <typename T>
-static constexpr unsigned getNumBits() {
-  return 0;
-}
-template <>
-constexpr unsigned getNumBits<Dim>() {
+template <typename T> static constexpr unsigned getNumBits() { return 0; }
+template <> constexpr unsigned getNumBits<Dim>() {
   static_assert((1 << 3) > getMaxEnumValForDim(),
                 "Not enough bits to encode Dim value");
   return 3;
 }
-template <>
-constexpr unsigned getNumBits<ImageDepthInfo>() {
+template <> constexpr unsigned getNumBits<ImageDepthInfo>() {
   static_assert((1 << 2) > getMaxEnumValForImageDepthInfo(),
                 "Not enough bits to encode ImageDepthInfo value");
   return 2;
 }
-template <>
-constexpr unsigned getNumBits<ImageArrayedInfo>() {
+template <> constexpr unsigned getNumBits<ImageArrayedInfo>() {
   static_assert((1 << 1) > getMaxEnumValForImageArrayedInfo(),
                 "Not enough bits to encode ImageArrayedInfo value");
   return 1;
 }
-template <>
-constexpr unsigned getNumBits<ImageSamplingInfo>() {
+template <> constexpr unsigned getNumBits<ImageSamplingInfo>() {
   static_assert((1 << 1) > getMaxEnumValForImageSamplingInfo(),
                 "Not enough bits to encode ImageSamplingInfo value");
   return 1;
 }
-template <>
-constexpr unsigned getNumBits<ImageSamplerUseInfo>() {
+template <> constexpr unsigned getNumBits<ImageSamplerUseInfo>() {
   static_assert((1 << 2) > getMaxEnumValForImageSamplerUseInfo(),
                 "Not enough bits to encode ImageSamplerUseInfo value");
   return 2;
 }
-template <>
-constexpr unsigned getNumBits<ImageFormat>() {
+template <> constexpr unsigned getNumBits<ImageFormat>() {
   static_assert((1 << 6) > getMaxEnumValForImageFormat(),
                 "Not enough bits to encode ImageFormat value");
   return 6;
 }
 
 struct spirv::detail::ImageTypeStorage : public TypeStorage {
 public:
   using KeyTy = std::tuple<Type, Dim, ImageDepthInfo, ImageArrayedInfo,
struct spirv::detail::SampledImageTypeStorage : public TypeStorage {
 
   Type imageType;
 };
 
 SampledImageType SampledImageType::get(Type imageType) {
   return Base::get(imageType.getContext(), imageType);
 }
 
-SampledImageType SampledImageType::getChecked(Type imageType,
-                                              Location location) {
-  return Base::getChecked(location, imageType);
+SampledImageType
+SampledImageType::getChecked(function_ref<InFlightDiagnostic()> emitError,
+                             Type imageType) {
+  return Base::getChecked(emitError, imageType.getContext(), imageType);
 }
 
 Type SampledImageType::getImageType() const { return getImpl()->imageType; }
 
-LogicalResult SampledImageType::verifyConstructionInvariants(Location loc,
-                                                             Type imageType) {
+LogicalResult
+SampledImageType::verify(function_ref<InFlightDiagnostic()> emitError,
   if (!imageType.isa<ImageType>())
-    return emitError(loc, "expected image type");
+    return emitError() << "expected image type";
 
   return success();
 }
 
 void SampledImageType::getExtensions(
     SPIRVType::ExtensionArrayRefVector &extensions,
     Optional<StorageClass> storage) {
   getImageType().cast<ImageType>().getExtensions(extensions, storage);
struct spirv::detail::MatrixTypeStorage : public TypeStorage {
   Type columnType;
   const uint32_t columnCount;
 };
 
 MatrixType MatrixType::get(Type columnType, uint32_t columnCount) {
   return Base::get(columnType.getContext(), columnType, columnCount);
 }
 
-MatrixType MatrixType::getChecked(Type columnType, uint32_t columnCount,
-                                  Location location) {
-  return Base::getChecked(location, columnType, columnCount);
+MatrixType MatrixType::getChecked(function_ref<InFlightDiagnostic()> emitError,
+                                  Type columnType, uint32_t columnCount) {
+  return Base::getChecked(emitError, columnType.getContext(), columnType,
+                          columnCount);
 }
 
-LogicalResult MatrixType::verifyConstructionInvariants(Location loc,
-                                                       Type columnType,
-                                                       uint32_t columnCount) {
+LogicalResult MatrixType::verify(function_ref<InFlightDiagnostic()> emitError,
+                                 Type columnType, uint32_t columnCount) {
   if (columnCount < 2 || columnCount > 4)
-    return emitError(loc, "matrix can have 2, 3, or 4 columns only");
+    return emitError() << "matrix can have 2, 3, or 4 columns only";
 
   if (!isValidColumnType(columnType))
-    return emitError(loc, "matrix columns must be vectors of floats");
+    return emitError() << "matrix columns must be vectors of floats";
 
   /// The underlying vectors (columns) must be of size 2, 3, or 4
   ArrayRef<int64_t> columnShape = columnType.cast<VectorType>().getShape();
   if (columnShape.size() != 1)
-    return emitError(loc, "matrix columns must be 1D vectors");
+    return emitError() << "matrix columns must be 1D vectors";
 
   if (columnShape[0] < 2 || columnShape[0] > 4)
-    return emitError(loc, "matrix columns must be of size 2, 3, or 4");
+    return emitError() << "matrix columns must be of size 2, 3, or 4";
 
   return success();
 }
 
 /// Returns true if the matrix elements are vectors of float elements
 bool MatrixType::isValidColumnType(Type columnType) {
   if (auto vectorType = columnType.dyn_cast<VectorType>()) {
     if (vectorType.getElementType().isa<FloatType>())

mlir/lib/IR/BuiltinAttributes.cpp

 //===----------------------------------------------------------------------===//
 // FloatAttr
 //===----------------------------------------------------------------------===//
 
 FloatAttr FloatAttr::get(Type type, double value) {
   return Base::get(type.getContext(), type, value);
 }
 
-FloatAttr FloatAttr::getChecked(Type type, double value, Location loc) {
-  return Base::getChecked(loc, type, value);
+FloatAttr FloatAttr::getChecked(function_ref<InFlightDiagnostic()> emitError,
+                                Type type, double value) {
+  return Base::getChecked(emitError, type.getContext(), type, value);
 }
 
 FloatAttr FloatAttr::get(Type type, const APFloat &value) {
   return Base::get(type.getContext(), type, value);
 }
 
-FloatAttr FloatAttr::getChecked(Type type, const APFloat &value, Location loc) {
-  return Base::getChecked(loc, type, value);
+FloatAttr FloatAttr::getChecked(function_ref<InFlightDiagnostic()> emitError,
+                                Type type, const APFloat &value) {
+  return Base::getChecked(emitError, type.getContext(), type, value);
 }
 
 APFloat FloatAttr::getValue() const { return getImpl()->getValue(); }
 
 double FloatAttr::getValueAsDouble() const {
   return getValueAsDouble(getValue());
 }
 double FloatAttr::getValueAsDouble(APFloat value) {
   if (&value.getSemantics() != &APFloat::IEEEdouble()) {
     bool losesInfo = false;
     value.convert(APFloat::IEEEdouble(), APFloat::rmNearestTiesToEven,
                   &losesInfo);
   }
   return value.convertToDouble();
 }
 
 /// Verify construction invariants.
-static LogicalResult verifyFloatTypeInvariants(Location loc, Type type) {
+static LogicalResult
+verifyFloatTypeInvariants(function_ref<InFlightDiagnostic()> emitError,
+                          Type type) {
   if (!type.isa<FloatType>())
-    return emitError(loc, "expected floating point type");
+    return emitError() << "expected floating point type";
   return success();
 }
 
-LogicalResult FloatAttr::verifyConstructionInvariants(Location loc, Type type,
-                                                      double value) {
-  return verifyFloatTypeInvariants(loc, type);
+LogicalResult FloatAttr::verify(function_ref<InFlightDiagnostic()> emitError,
+                                Type type, double value) {
+  return verifyFloatTypeInvariants(emitError, type);
 }
 
-LogicalResult FloatAttr::verifyConstructionInvariants(Location loc, Type type,
-                                                      const APFloat &value) {
+LogicalResult FloatAttr::verify(function_ref<InFlightDiagnostic()> emitError,
+                                Type type, const APFloat &value) {
   // Verify that the type is correct.
-  if (failed(verifyFloatTypeInvariants(loc, type)))
+  if (failed(verifyFloatTypeInvariants(emitError, type)))
     return failure();
 
   // Verify that the type semantics match that of the value.
   if (&type.cast<FloatType>().getFloatSemantics() != &value.getSemantics()) {
-    return emitError(
-        loc, "FloatAttr type doesn't match the type implied by its value");
+    return emitError()
+           << "FloatAttr type doesn't match the type implied by its value";
   }
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // SymbolRefAttr
 //===----------------------------------------------------------------------===//
 

 }
 
 uint64_t IntegerAttr::getUInt() const {
   assert(getImpl()->getType().isUnsignedInteger() &&
          "must be unsigned integer");
   return getValue().getZExtValue();
 }
 
-static LogicalResult verifyIntegerTypeInvariants(Location loc, Type type) {
+static LogicalResult
+verifyIntegerTypeInvariants(function_ref<InFlightDiagnostic()> emitError,
+                            Type type) {
   if (type.isa<IntegerType, IndexType>())
     return success();
-  return emitError(loc, "expected integer or index type");
+  return emitError() << "expected integer or index type";
 }
 
-LogicalResult IntegerAttr::verifyConstructionInvariants(Location loc, Type type,
-                                                        int64_t value) {
-  return verifyIntegerTypeInvariants(loc, type);
+LogicalResult IntegerAttr::verify(function_ref<InFlightDiagnostic()> emitError,
+                                  Type type, int64_t value) {
+  return verifyIntegerTypeInvariants(emitError, type);
 }
 
-LogicalResult IntegerAttr::verifyConstructionInvariants(Location loc, Type type,
-                                                        const APInt &value) {
-  if (failed(verifyIntegerTypeInvariants(loc, type)))
+LogicalResult IntegerAttr::verify(function_ref<InFlightDiagnostic()> emitError,
+                                  Type type, const APInt &value) {
+  if (failed(verifyIntegerTypeInvariants(emitError, type)))
     return failure();
   if (auto integerType = type.dyn_cast<IntegerType>())
     if (integerType.getWidth() != value.getBitWidth())
-      return emitError(loc, "integer type bit width (")
-             << integerType.getWidth() << ") doesn't match value bit width ("
+      return emitError() << "integer type bit width (" << integerType.getWidth()
+                         << ") doesn't match value bit width ("
                          << value.getBitWidth() << ")";
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // BoolAttr
 
 bool BoolAttr::getValue() const {
   auto *storage = reinterpret_cast<IntegerAttributeStorage *>(impl);

 // OpaqueAttr
 //===----------------------------------------------------------------------===//
 
 OpaqueAttr OpaqueAttr::get(MLIRContext *context, Identifier dialect,
                            StringRef attrData, Type type) {
   return Base::get(context, dialect, attrData, type);
 }
 
-OpaqueAttr OpaqueAttr::getChecked(Identifier dialect, StringRef attrData,
-                                  Type type, Location location) {
-  return Base::getChecked(location, dialect, attrData, type);
+OpaqueAttr OpaqueAttr::getChecked(function_ref<InFlightDiagnostic()> emitError,
+                                  Identifier dialect, StringRef attrData,
+                                  Type type) {
+  return Base::getChecked(emitError, dialect.getContext(), dialect, attrData,
+                          type);
 }
 
 /// Returns the dialect namespace of the opaque attribute.
 Identifier OpaqueAttr::getDialectNamespace() const {
   return getImpl()->dialectNamespace;
 }
 
 /// Returns the raw attribute data of the opaque attribute.
 StringRef OpaqueAttr::getAttrData() const { return getImpl()->attrData; }
 
 /// Verify the construction of an opaque attribute.
-LogicalResult OpaqueAttr::verifyConstructionInvariants(Location loc,
-                                                       Identifier dialect,
-                                                       StringRef attrData,
-                                                       Type type) {
+LogicalResult OpaqueAttr::verify(function_ref<InFlightDiagnostic()> emitError,
+                                 Identifier dialect, StringRef attrData,
   if (!Dialect::isValidNamespace(dialect.strref()))
-    return emitError(loc, "invalid dialect namespace '") << dialect << "'";
+    return emitError() << "invalid dialect namespace '" << dialect << "'";
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // StringAttr
 //===----------------------------------------------------------------------===//
 
 StringAttr StringAttr::get(MLIRContext *context, StringRef bytes) {

mlir/lib/IR/BuiltinTypes.cpp

 #define GET_TYPEDEF_CLASSES
 #include "mlir/IR/BuiltinTypes.cpp.inc"
 
 //===----------------------------------------------------------------------===//
 /// ComplexType
 //===----------------------------------------------------------------------===//
 
 /// Verify the construction of an integer type.
-LogicalResult ComplexType::verifyConstructionInvariants(Location loc,
-                                                        Type elementType) {
+LogicalResult ComplexType::verify(function_ref<InFlightDiagnostic()> emitError,
   if (!elementType.isIntOrFloat())
-    return emitError(loc, "invalid element type for complex");
+    return emitError() << "invalid element type for complex";
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // Integer Type
 //===----------------------------------------------------------------------===//
 
 // static constexpr must have a definition (until in C++17 and inline variable).
 constexpr unsigned IntegerType::kMaxWidth;
 
 /// Verify the construction of an integer type.
-LogicalResult
-IntegerType::verifyConstructionInvariants(Location loc, unsigned width,
-                                          SignednessSemantics signedness) {
+LogicalResult IntegerType::verify(function_ref<InFlightDiagnostic()> emitError,
+                                  unsigned width,
   if (width > IntegerType::kMaxWidth) {
-    return emitError(loc) << "integer bitwidth is limited to "
-                          << IntegerType::kMaxWidth << " bits";
+    return emitError() << "integer bitwidth is limited to "
   }
   return success();
 }
 
 unsigned IntegerType::getWidth() const { return getImpl()->width; }
 
 IntegerType::SignednessSemantics IntegerType::getSignedness() const {
   return getImpl()->signedness;
FunctionType::getWithoutArgsAndResults(ArrayRef<unsigned> argIndices,
   return get(getContext(), newInputTypes, newResultTypes);
 }
 
 //===----------------------------------------------------------------------===//
 // OpaqueType
 //===----------------------------------------------------------------------===//
 
 /// Verify the construction of an opaque type.
-LogicalResult OpaqueType::verifyConstructionInvariants(Location loc,
-                                                       Identifier dialect,
-                                                       StringRef typeData) {
+LogicalResult OpaqueType::verify(function_ref<InFlightDiagnostic()> emitError,
+                                 Identifier dialect, StringRef typeData) {
   if (!Dialect::isValidNamespace(dialect.strref()))
-    return emitError(loc, "invalid dialect namespace '") << dialect << "'";
+    return emitError() << "invalid dialect namespace '" << dialect << "'";
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // ShapedType
 //===----------------------------------------------------------------------===//
 constexpr int64_t ShapedType::kDynamicSize;
 constexpr int64_t ShapedType::kDynamicStrideOrOffset;

 //===----------------------------------------------------------------------===//
 // VectorType
 //===----------------------------------------------------------------------===//
 
 VectorType VectorType::get(ArrayRef<int64_t> shape, Type elementType) {
   return Base::get(elementType.getContext(), shape, elementType);
 }
 
-VectorType VectorType::getChecked(Location location, ArrayRef<int64_t> shape,
-                                  Type elementType) {
-  return Base::getChecked(location, shape, elementType);
+VectorType VectorType::getChecked(function_ref<InFlightDiagnostic()> emitError,
+                                  ArrayRef<int64_t> shape, Type elementType) {
+  return Base::getChecked(emitError, elementType.getContext(), shape,
+                          elementType);
 }
 
-LogicalResult VectorType::verifyConstructionInvariants(Location loc,
-                                                       ArrayRef<int64_t> shape,
-                                                       Type elementType) {
+LogicalResult VectorType::verify(function_ref<InFlightDiagnostic()> emitError,
+                                 ArrayRef<int64_t> shape, Type elementType) {
   if (shape.empty())
-    return emitError(loc, "vector types must have at least one dimension");
+    return emitError() << "vector types must have at least one dimension";
 
   if (!isValidElementType(elementType))
-    return emitError(loc, "vector elements must be int or float type");
+    return emitError() << "vector elements must be int or float type";
 
   if (any_of(shape, [](int64_t i) { return i <= 0; }))
-    return emitError(loc, "vector types must have positive constant sizes");
+    return emitError() << "vector types must have positive constant sizes";
 
   return success();
 }
 
 ArrayRef<int64_t> VectorType::getShape() const { return getImpl()->getShape(); }
 
 VectorType VectorType::scaleElementBitwidth(unsigned scale) {
   if (!scale)
     return VectorType();
   if (auto et = getElementType().dyn_cast<IntegerType>())
     if (auto scaledEt = et.scaleElementBitwidth(scale))
       return VectorType::get(getShape(), scaledEt);
   if (auto et = getElementType().dyn_cast<FloatType>())
     if (auto scaledEt = et.scaleElementBitwidth(scale))
       return VectorType::get(getShape(), scaledEt);
   return VectorType();
 }
 
 //===----------------------------------------------------------------------===//
 // TensorType
 //===----------------------------------------------------------------------===//
 
-// Check if "elementType" can be an element type of a tensor. Emit errors if
-// location is not nullptr.  Returns failure if check failed.
-static LogicalResult checkTensorElementType(Location location,
-                                            Type elementType) {
+// Check if "elementType" can be an element type of a tensor.
+static LogicalResult
+checkTensorElementType(function_ref<InFlightDiagnostic()> emitError,
   if (!TensorType::isValidElementType(elementType))
-    return emitError(location, "invalid tensor element type: ") << elementType;
+    return emitError() << "invalid tensor element type: " << elementType;
   return success();
 }
 
 /// Return true if the specified element type is ok in a tensor.
 bool TensorType::isValidElementType(Type type) {
   // Note: Non standard/builtin types are allowed to exist within tensor
   // types. Dialects are expected to verify that tensor types have a valid
   // element type within that dialect.
   return type.isa<ComplexType, FloatType, IntegerType, OpaqueType, VectorType,
                   IndexType>() ||
          !type.getDialect().getNamespace().empty();
 }
 
 //===----------------------------------------------------------------------===//
 // RankedTensorType
 //===----------------------------------------------------------------------===//
 
 RankedTensorType RankedTensorType::get(ArrayRef<int64_t> shape,
                                        Type elementType) {
   return Base::get(elementType.getContext(), shape, elementType);
 }
 
-RankedTensorType RankedTensorType::getChecked(Location location,
-                                              ArrayRef<int64_t> shape,
-                                              Type elementType) {
-  return Base::getChecked(location, shape, elementType);
+RankedTensorType
+RankedTensorType::getChecked(function_ref<InFlightDiagnostic()> emitError,
+                             ArrayRef<int64_t> shape, Type elementType) {
+  return Base::getChecked(emitError, elementType.getContext(), shape,
+                          elementType);
 }
 
-LogicalResult RankedTensorType::verifyConstructionInvariants(
-    Location loc, ArrayRef<int64_t> shape, Type elementType) {
+LogicalResult
+RankedTensorType::verify(function_ref<InFlightDiagnostic()> emitError,
+                         ArrayRef<int64_t> shape, Type elementType) {
   for (int64_t s : shape) {
     if (s < -1)
-      return emitError(loc, "invalid tensor dimension size");
+      return emitError() << "invalid tensor dimension size";
   }
-  return checkTensorElementType(loc, elementType);
+  return checkTensorElementType(emitError, 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(Location location,
-                                                  Type elementType) {
-  return Base::getChecked(location, elementType);
+UnrankedTensorType
+UnrankedTensorType::getChecked(function_ref<InFlightDiagnostic()> emitError,
+  return Base::getChecked(emitError, elementType.getContext(), elementType);
 }
 
 LogicalResult
-UnrankedTensorType::verifyConstructionInvariants(Location loc,
-                                                 Type elementType) {
-  return checkTensorElementType(loc, elementType);
+UnrankedTensorType::verify(function_ref<InFlightDiagnostic()> emitError,
+  return checkTensorElementType(emitError, elementType);
 }
 
 //===----------------------------------------------------------------------===//
 // BaseMemRefType
 //===----------------------------------------------------------------------===//
 
 unsigned BaseMemRefType::getMemorySpace() const {
   return static_cast<ImplType *>(impl)->memorySpace;
 }
 
 //===----------------------------------------------------------------------===//
 // MemRefType
 //===----------------------------------------------------------------------===//
 
 /// Get or create a new MemRefType based on shape, element type, affine
 /// map composition, and memory space.  Assumes the arguments define a
 /// well-formed MemRef type.  Use getChecked to gracefully handle MemRefType
 /// construction failures.
 MemRefType MemRefType::get(ArrayRef<int64_t> shape, Type elementType,
                            ArrayRef<AffineMap> affineMapComposition,
                            unsigned memorySpace) {
-  auto result = getImpl(shape, elementType, affineMapComposition, memorySpace,
-                        /*location=*/llvm::None);
+  auto result =
+      getImpl(shape, elementType, affineMapComposition, memorySpace, [=] {
+        return emitError(UnknownLoc::get(elementType.getContext()));
+      });
   assert(result && "Failed to construct instance of MemRefType.");
   return result;
 }
 
 /// 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(Location location, ArrayRef<int64_t> shape,
-                                  Type elementType,
+MemRefType MemRefType::getChecked(function_ref<InFlightDiagnostic()> emitError,
+                                  ArrayRef<int64_t> shape, Type elementType,
                                   ArrayRef<AffineMap> affineMapComposition,
                                   unsigned memorySpace) {
   return getImpl(shape, elementType, affineMapComposition, memorySpace,
-                 location);
+                 emitError);
 }
 
 /// 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.
 MemRefType MemRefType::getImpl(ArrayRef<int64_t> shape, Type elementType,
                                ArrayRef<AffineMap> affineMapComposition,
                                unsigned memorySpace,
-                               Optional<Location> location) {
+                               function_ref<InFlightDiagnostic()> emitError) {
   auto *context = elementType.getContext();
 
   if (!BaseMemRefType::isValidElementType(elementType))
-    return (void)emitOptionalError(location, "invalid memref element type"),
-           MemRefType();
+    return (emitError() << "invalid memref element type", MemRefType());
 
   for (int64_t s : shape) {
     // Negative sizes are not allowed except for `-1` that means dynamic size.
     if (s < -1)
-      return (void)emitOptionalError(location, "invalid memref size"),
-             MemRefType();
+      return (emitError() << "invalid memref size", MemRefType());
   }
 
   // Check that the structure of the composition is valid, i.e. that each
   // subsequent affine map has as many inputs as the previous map has results.
   // Take the dimensionality of the MemRef for the first map.
   auto dim = shape.size();
   unsigned i = 0;
   for (const auto &affineMap : affineMapComposition) {
     if (affineMap.getNumDims() != dim) {
-      if (location)
-        emitError(*location)
-            << "memref affine map dimension mismatch between "
+      emitError() << "memref affine map dimension mismatch between "
                   << (i == 0 ? Twine("memref rank") : "affine map " + Twine(i))
                   << " and affine map" << i + 1 << ": " << dim
                   << " != " << affineMap.getNumDims();
       return nullptr;
     }
 
     dim = affineMap.getNumResults();
     ++i;
   }
 
   // Drop identity maps from the composition.

 // UnrankedMemRefType
 //===----------------------------------------------------------------------===//
 
 UnrankedMemRefType UnrankedMemRefType::get(Type elementType,
                                            unsigned memorySpace) {
   return Base::get(elementType.getContext(), elementType, memorySpace);
 }
 
-UnrankedMemRefType UnrankedMemRefType::getChecked(Location location,
-                                                  Type elementType,
-                                                  unsigned memorySpace) {
-  return Base::getChecked(location, elementType, memorySpace);
+UnrankedMemRefType
+UnrankedMemRefType::getChecked(function_ref<InFlightDiagnostic()> emitError,
+                               Type elementType, unsigned memorySpace) {
+  return Base::getChecked(emitError, elementType.getContext(), elementType,
+                          memorySpace);
 }
 
 LogicalResult
-UnrankedMemRefType::verifyConstructionInvariants(Location loc, Type elementType,
-                                                 unsigned memorySpace) {
+UnrankedMemRefType::verify(function_ref<InFlightDiagnostic()> emitError,
+                           Type elementType, unsigned memorySpace) {
   if (!BaseMemRefType::isValidElementType(elementType))
-    return emitError(loc, "invalid memref element type");
+    return emitError() << "invalid memref element type";
   return success();
 }
 
 // Fallback cases for terminal dim/sym/cst that are not part of a binary op (
 // i.e. single term). Accumulate the AffineExpr into the existing one.
 static void extractStridesFromTerm(AffineExpr e,
                                    AffineExpr multiplicativeFactor,
                                    MutableArrayRef<AffineExpr> strides,

mlir/lib/IR/MLIRContext.cpp

 
 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(Location location, unsigned width,
-                                    SignednessSemantics signedness) {
-  if (auto cached =
-          getCachedIntegerType(width, signedness, location->getContext()))
+IntegerType
+IntegerType::getChecked(function_ref<InFlightDiagnostic()> emitError,
+                        MLIRContext *context, unsigned width,
+  if (auto cached = getCachedIntegerType(width, signedness, context))
     return cached;
-  return Base::getChecked(location, width, signedness);
+  return Base::getChecked(emitError, context, width, signedness);
 }
 
 /// Get an instance of the NoneType.
 NoneType NoneType::get(MLIRContext *context) {
   if (NoneType cachedInst = context->getImpl().noneType)
     return cachedInst;
   // Note: May happen when initializing the singleton attributes of the builtin
   // dialect.
IntegerSet IntegerSet::get(unsigned dimCount, unsigned symbolCount,
   ScopedWriterLock affineLock(impl.affineMutex, impl.threadingIsEnabled);
   return constructorFn();
 }
 
 //===----------------------------------------------------------------------===//
 // StorageUniquerSupport
 //===----------------------------------------------------------------------===//
 
-/// Utility method to generate a default location for use when checking the
-/// construction invariants of a storage object. This is defined out-of-line to
-/// avoid the need to include Location.h.
-const AttributeStorage *
-mlir::detail::generateUnknownStorageLocation(MLIRContext *ctx) {
-  return reinterpret_cast<const AttributeStorage *>(
-      ctx->getImpl().unknownLocAttr.getAsOpaquePointer());
+/// Utility method to generate a callback that can be used to generate a
+/// diagnostic when checking the construction invariants of a storage object.
+/// This is defined out-of-line to avoid the need to include Location.h.
+llvm::unique_function<InFlightDiagnostic()>
+mlir::detail::getDefaultDiagnosticEmitFn(MLIRContext *ctx) {
+  return [ctx] { return emitError(UnknownLoc::get(ctx)); };
+}
+llvm::unique_function<InFlightDiagnostic()>
+mlir::detail::getDefaultDiagnosticEmitFn(const Location &loc) {
+  return [=] { return emitError(loc); };
 }

mlir/lib/Parser/DialectSymbolParser.cpp

Attribute attr = parseExtendedSymbol<Attribute>(
               symbolData, state.context, state.symbols, [&](Parser &parser) {
                 CustomDialectAsmParser customParser(symbolData, parser);
                 return dialect->parseAttribute(customParser, attrType);
               });
         }
 
         // Otherwise, form a new opaque attribute.
         return OpaqueAttr::getChecked(
+            getEncodedSourceLocation(loc),
             Identifier::get(dialectName, state.context), symbolData,
-            attrType ? attrType : NoneType::get(state.context),
-            getEncodedSourceLocation(loc));
+            attrType ? attrType : NoneType::get(state.context));
       });
 
   // Ensure that the attribute has the same type as requested.
   if (attr && type && attr.getType() != type) {
     emitError("attribute type different than expected: expected ")
         << type << ", but got " << attr.getType();
     return nullptr;
   }
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(
-            getEncodedSourceLocation(loc),
+            getEncodedSourceLocation(loc), state.context,
             Identifier::get(dialectName, state.context), symbolData);
       });
 }
 
 //===----------------------------------------------------------------------===//
 // mlir::parseAttribute/parseType
 //===----------------------------------------------------------------------===//
 

mlir/lib/TableGen/TypeDef.cpp

 
 using namespace mlir;
 using namespace mlir::tblgen;
 
 //===----------------------------------------------------------------------===//
 // TypeBuilder
 //===----------------------------------------------------------------------===//
 
-/// Return an optional code body used for the `getChecked` variant of this
-/// builder.
-Optional<StringRef> TypeBuilder::getCheckedBody() const {
-  Optional<StringRef> body = def->getValueAsOptionalString("checkedBody");
-  return body && !body->empty() ? body : llvm::None;
-}
-
 /// Returns true if this builder is able to infer the MLIRContext parameter.
 bool TypeBuilder::hasInferredContextParameter() const {
   return def->getValueAsBit("hasInferredContextParam");
 }
 
 //===----------------------------------------------------------------------===//
 // TypeDef
 //===----------------------------------------------------------------------===//
llvm::Optional<StringRef> TypeDef::getPrinterCode() const {
   return def->getValueAsOptionalString("printer");
 }
 llvm::Optional<StringRef> TypeDef::getParserCode() const {
   return def->getValueAsOptionalString("parser");
 }
 bool TypeDef::genAccessors() const {
   return def->getValueAsBit("genAccessors");
 }
-bool TypeDef::genVerifyInvariantsDecl() const {
-  return def->getValueAsBit("genVerifyInvariantsDecl");
+bool TypeDef::genVerifyDecl() const {
+  return def->getValueAsBit("genVerifyDecl");
 }
 llvm::Optional<StringRef> TypeDef::getExtraDecls() const {
   auto value = def->getValueAsString("extraClassDeclaration");
   return value.empty() ? llvm::Optional<StringRef>() : value;
 }
 llvm::ArrayRef<llvm::SMLoc> TypeDef::getLoc() const { return def->getLoc(); }
 
 bool TypeDef::skipDefaultBuilders() const {

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

def CompoundTypeA : Test_Type<"CompoundA"> {
   let extraClassDeclaration = [{
     struct SomeCppStruct {};
   }];
 }
 
 // An example of how one could implement a standard integer.
 def IntegerType : Test_Type<"TestInteger"> {
   let mnemonic = "int";
-  let genVerifyInvariantsDecl = 1;
+  let genVerifyDecl = 1;
   let parameters = (
     ins
     "unsigned":$width,
     // SignednessSemantics is defined below.
     "::mlir::test::TestIntegerType::SignednessSemantics":$signedness
   );
 
   // We define the printer inline.
   let printer = [{
     $_printer << "int<";
     printSignedness($_printer, getImpl()->signedness);
     $_printer << ", " << getImpl()->width << ">";
   }];
 
   // Define custom builder methods.
   let builders = [
     TypeBuilder<(ins "unsigned":$width,
                      CArg<"SignednessSemantics", "Signless">:$signedness), [{
-      return Base::get($_ctxt, width, signedness);
-    }], [{
-      return Base::getChecked($_loc, width, signedness);
+      return $_get($_ctxt, width, signedness);
     }]>
   ];
   let skipDefaultBuilders = 1;
 
   // The parser is defined here also.
   let parser = [{
     if (parser.parseLess()) return Type();
     SignednessSemantics signedness;
     if (parseSignedness($_parser, signedness)) return mlir::Type();
     if ($_parser.parseComma()) return Type();
     int width;
     if ($_parser.parseInteger(width)) return Type();
     if ($_parser.parseGreater()) return Type();
     Location loc = $_parser.getEncodedSourceLoc($_parser.getNameLoc());
-    return getChecked(loc, width, signedness);
+    return getChecked(loc, loc.getContext(), width, signedness);
   }];
 
   // Any extra code one wants in the type's class declaration.
   let extraClassDeclaration = [{
     /// Signedness semantics.
     enum SignednessSemantics {
       Signless, /// No signedness semantics
       Signed,   /// Signed integer

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

 }
 
 // FieldInfo is used as part of a parameter, so a hash will be computed.
 static llvm::hash_code mlir::test::hash_value(const FieldInfo &fi) { // NOLINT
   return llvm::hash_combine(fi.name, fi.type);
 }
 
 // Example type validity checker.
-LogicalResult TestIntegerType::verifyConstructionInvariants(
-    Location loc, unsigned width, TestIntegerType::SignednessSemantics ss) {
+LogicalResult
+TestIntegerType::verify(function_ref<InFlightDiagnostic()> emitError,
+                        unsigned width,
+                        TestIntegerType::SignednessSemantics ss) {
   if (width > 8)
     return failure();
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // Tablegen Generated Definitions
 //===----------------------------------------------------------------------===//

mlir/test/mlir-tblgen/typedefs.td

let parameters = (
       ins
       "int":$widthOfSomething,
       "::mlir::test::SimpleTypeA": $exampleTdType,
       "SomeCppStruct": $exampleCppType,
       ArrayRefParameter<"int", "Matrix dimensions">:$dims,
       RTLValueType:$inner
   );
 
-  let genVerifyInvariantsDecl = 1;
+  let genVerifyDecl = 1;
 
 // DECL-LABEL: class CompoundAType : public ::mlir::Type
-// DECL: static CompoundAType getChecked(::mlir::Location loc, int widthOfSomething, ::mlir::test::SimpleTypeA exampleTdType, SomeCppStruct exampleCppType, ::llvm::ArrayRef<int> dims, ::mlir::Type inner);
-// DECL: static ::mlir::LogicalResult verifyConstructionInvariants(::mlir::Location loc, int widthOfSomething, ::mlir::test::SimpleTypeA exampleTdType, SomeCppStruct exampleCppType, ::llvm::ArrayRef<int> dims, ::mlir::Type inner);
+// DECL: static CompoundAType getChecked(llvm::function_ref<::mlir::InFlightDiagnostic()> emitError, ::mlir::MLIRContext *context, int widthOfSomething, ::mlir::test::SimpleTypeA exampleTdType, SomeCppStruct exampleCppType, ::llvm::ArrayRef<int> dims, ::mlir::Type inner);
+// DECL: static ::mlir::LogicalResult verify(::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError, int widthOfSomething, ::mlir::test::SimpleTypeA exampleTdType, SomeCppStruct exampleCppType, ::llvm::ArrayRef<int> dims, ::mlir::Type inner);
 // DECL: static ::llvm::StringRef getMnemonic() { return "cmpnd_a"; }
 // DECL: static ::mlir::Type parse(::mlir::MLIRContext *context,
 // DECL-NEXT: ::mlir::DialectAsmParser &parser);
 // DECL: void print(::mlir::DialectAsmPrinter &printer) const;
 // DECL: int getWidthOfSomething() const;
 // DECL: ::mlir::test::SimpleTypeA getExampleTdType() const;
 // DECL: SomeCppStruct getExampleCppType() const;
 }
def D_SingleParameterType : TestType<"SingleParameter"> {
   );
 // DECL-LABEL: struct SingleParameterTypeStorage;
 // DECL-LABEL: class SingleParameterType
 // DECL-NEXT:                   detail::SingleParameterTypeStorage
 }
 
 def E_IntegerType : TestType<"Integer"> {
     let mnemonic = "int";
-    let genVerifyInvariantsDecl = 1;
+    let genVerifyDecl = 1;
     let parameters = (
         ins
         "SignednessSemantics":$signedness,
         TypeParameter<"unsigned", "Bitwidth of integer">:$width
     );
 
 // DECL-LABEL: IntegerType : public ::mlir::Type
 

mlir/tools/mlir-tblgen/TypeDefGen.cpp

 
 /// The snippet for print/parse.
 static const char *const typeDefParsePrint = R"(
     static ::mlir::Type parse(::mlir::MLIRContext *context,
                               ::mlir::DialectAsmParser &parser);
     void print(::mlir::DialectAsmPrinter &printer) const;
 )";
 
-/// The code block for the verifyConstructionInvariants and getChecked.
+/// The code block for the verify method declaration.
 ///
-/// {0}: The name of the typeDef class.
-/// {1}: List of parameters, parameters style.
+/// {0}: List of parameters, parameters style.
 static const char *const typeDefDeclVerifyStr = R"(
-    static ::mlir::LogicalResult verifyConstructionInvariants(::mlir::Location loc{1});
+    using Base::getChecked;
+    static ::mlir::LogicalResult verify(::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError{0});
 )";
 
 /// Emit the builders for the given type.
 static void emitTypeBuilderDecls(const TypeDef &typeDef, raw_ostream &os,
                                  TypeParamCommaFormatter &paramTypes) {
   StringRef typeClass = typeDef.getCppClassName();
-  bool genCheckedMethods = typeDef.genVerifyInvariantsDecl();
+  bool genCheckedMethods = typeDef.genVerifyDecl();
   if (!typeDef.skipDefaultBuilders()) {
     os << llvm::formatv(
         "    static {0} get(::mlir::MLIRContext *context{1});\n", typeClass,
         paramTypes);
     if (genCheckedMethods) {
-      os << llvm::formatv(
-          "    static {0} getChecked(::mlir::Location loc{1});\n", typeClass,
-          paramTypes);
+      os << llvm::formatv("    static {0} "
+                          "getChecked(llvm::function_ref<::mlir::"
+                          "InFlightDiagnostic()> emitError, "
+                          "::mlir::MLIRContext *context{1});\n",
+                          typeClass, paramTypes);
     }
   }
 
   // Generate the builders specified by the user.
   for (const TypeBuilder &builder : typeDef.getBuilders()) {
     std::string paramStr;
     llvm::raw_string_ostream paramOS(paramStr);
     llvm::interleaveComma(
if (!builder.hasInferredContextParameter()) {
       os << "::mlir::MLIRContext *context";
       if (!paramStr.empty())
         os << ", ";
     }
     os << paramStr << ");\n";
 
     // Generate the `getChecked` variant of the builder.
     if (genCheckedMethods) {
-      os << "    static " << typeClass << " getChecked(::mlir::Location loc";
+      os << "    static " << typeClass
+         << " getChecked(llvm::function_ref<mlir::InFlightDiagnostic()> "
+            "emitError";
+      if (!builder.hasInferredContextParameter())
+        os << ", ::mlir::MLIRContext *context";
       if (!paramStr.empty())
-        os << ", " << paramStr;
-      os << ");\n";
+        os << ", ";
+      os << paramStr << ");\n";
     }
   }
 }
 
 /// Generate the declaration for the given typeDef class.
 static void emitTypeDefDecl(const TypeDef &typeDef, raw_ostream &os) {
   SmallVector<TypeParameter, 4> params;
   typeDef.getParameters(params);
if (Optional<StringRef> extraDecl = typeDef.getExtraDecls())
     os << *extraDecl << "\n";
 
   TypeParamCommaFormatter emitTypeNamePairsAfterComma(
       TypeParamCommaFormatter::EmitFormat::TypeNamePairs, params);
   if (!params.empty()) {
     emitTypeBuilderDecls(typeDef, os, emitTypeNamePairsAfterComma);
 
     // Emit the verify invariants declaration.
-    if (typeDef.genVerifyInvariantsDecl())
-      os << llvm::formatv(typeDefDeclVerifyStr, typeDef.getCppClassName(),
-                          emitTypeNamePairsAfterComma);
+    if (typeDef.genVerifyDecl())
+      os << llvm::formatv(typeDefDeclVerifyStr, emitTypeNamePairsAfterComma);
   }
 
   // Emit the mnenomic, if specified.
   if (auto mnenomic = typeDef.getMnemonic()) {
     os << "    static ::llvm::StringRef getMnemonic() { return \"" << mnenomic
        << "\"; }\n";
 
     // If mnemonic specified, emit print/parse declarations.
if (*parserCode == "") {
                           ": parser (if specified) must have non-empty code");
     }
     auto fmtCtxt =
         FmtContext().addSubst("_parser", "parser").addSubst("_ctxt", "context");
     os << tgfmt(*parserCode, &fmtCtxt) << "\n}\n";
   }
 }
 
+/// Replace all instances of 'from' to 'to' in `str` and return the new string.
+static std::string replaceInStr(std::string str, StringRef from, StringRef to) {
+  size_t pos = 0;
+  while ((pos = str.find(from.data(), pos, from.size())) != std::string::npos)
+    str.replace(pos, from.size(), to.data(), to.size());
+  return str;
+}
+
 /// Emit the builders for the given type.
 static void emitTypeBuilderDefs(const TypeDef &typeDef, raw_ostream &os,
                                 ArrayRef<TypeParameter> typeDefParams) {
-  bool genCheckedMethods = typeDef.genVerifyInvariantsDecl();
+  bool genCheckedMethods = typeDef.genVerifyDecl();
   StringRef typeClass = typeDef.getCppClassName();
   if (!typeDef.skipDefaultBuilders()) {
     os << llvm::formatv(
         "{0} {0}::get(::mlir::MLIRContext *context{1}) {{\n"
         "  return Base::get(context{2});\n}\n",
         typeClass,
         TypeParamCommaFormatter(
             TypeParamCommaFormatter::EmitFormat::TypeNamePairs, typeDefParams),
         TypeParamCommaFormatter(TypeParamCommaFormatter::EmitFormat::JustParams,
                                 typeDefParams));
     if (genCheckedMethods) {
       os << llvm::formatv(
-          "{0} {0}::getChecked(::mlir::Location loc{1}) {{\n"
-          "  return Base::getChecked(loc{2});\n}\n",
+          "{0} {0}::getChecked("
+          "llvm::function_ref<::mlir::InFlightDiagnostic()> emitError, "
+          "::mlir::MLIRContext *context{1}) {{\n"
+          "  return Base::getChecked(emitError, context{2});\n}\n",
           typeClass,
           TypeParamCommaFormatter(
               TypeParamCommaFormatter::EmitFormat::TypeNamePairs,
               typeDefParams),
           TypeParamCommaFormatter(
               TypeParamCommaFormatter::EmitFormat::JustParams, typeDefParams));
     }
   }
 
+  auto builderFmtCtx =
+      FmtContext().addSubst("_ctxt", "context").addSubst("_get", "Base::get");
+  auto inferredCtxBuilderFmtCtx = FmtContext().addSubst("_get", "Base::get");
+  auto checkedBuilderFmtCtx = FmtContext().addSubst("_ctxt", "context");
+
   // Generate the builders specified by the user.
-  auto builderFmtCtx = FmtContext().addSubst("_ctxt", "context");
-  auto checkedBuilderFmtCtx = FmtContext()
-                                  .addSubst("_loc", "loc")
-                                  .addSubst("_ctxt", "loc.getContext()");
   for (const TypeBuilder &builder : typeDef.getBuilders()) {
     Optional<StringRef> body = builder.getBody();
-    Optional<StringRef> checkedBody =
-        genCheckedMethods ? builder.getCheckedBody() : llvm::None;
-    if (!body && !checkedBody)
+    if (!body)
       continue;
     std::string paramStr;
     llvm::raw_string_ostream paramOS(paramStr);
     llvm::interleaveComma(builder.getParameters(), paramOS,
                           [&](const TypeBuilder::Parameter &param) {
                             // Note: TypeBuilder parameters are guaranteed to
                             // have names.
                             paramOS << param.getCppType() << " "
                                     << *param.getName();
                           });
     paramOS.flush();
 
     // Emit the `get` variant of the builder.
-    if (body) {
-      os << llvm::formatv("{0} {0}::get(", typeClass);
-      if (!builder.hasInferredContextParameter()) {
-        os << "::mlir::MLIRContext *context";
-        if (!paramStr.empty())
-          os << ", ";
-        os << llvm::formatv("{0}) {{\n  {1};\n}\n", paramStr,
-                            tgfmt(*body, &builderFmtCtx).str());
-      } else {
-        os << llvm::formatv("{0}) {{\n  {1};\n}\n", paramStr, *body);
-      }
+      os << llvm::formatv("{0}) {{\n  {1};\n}\n", paramStr,
+                          tgfmt(*body, &inferredCtxBuilderFmtCtx).str());
     }
 
     // Emit the `getChecked` variant of the builder.
-    if (checkedBody) {
-      os << llvm::formatv("{0} {0}::getChecked(::mlir::Location loc",
+    if (genCheckedMethods) {
+      os << llvm::formatv("{0} "
+                          "{0}::getChecked(llvm::function_ref<::mlir::"
+                          "InFlightDiagnostic()> emitErrorFn",
                           typeClass);
+      std::string checkedBody =
+          replaceInStr(body->str(), "$_get(", "Base::getChecked(emitErrorFn, ");
+      if (!builder.hasInferredContextParameter()) {
+        os << ", ::mlir::MLIRContext *context";
+        checkedBody = tgfmt(checkedBody, &checkedBuilderFmtCtx).str();
+      }
       if (!paramStr.empty())
-        os << ", " << paramStr;
-      os << llvm::formatv(") {{\n  {0};\n}\n",
-                          tgfmt(*checkedBody, &checkedBuilderFmtCtx));
+        os << ", ";
+      os << llvm::formatv("{0}) {{\n  {1};\n}\n", paramStr, checkedBody);
     }
   }
 }
 
 /// Print all the typedef-specific definition code.
 static void emitTypeDefDef(const TypeDef &typeDef, raw_ostream &os) {
   NamespaceEmitter ns(os, typeDef.getDialect());