[mlir][CAPI] Convert the rest of the API int -> bool.

[stellaraccident]

Summary

• Follows on https://reviews.llvm.org/D92193
• I had a mid-air collision with some additional occurrences and then noticed that there were a lot more. Think I got them all.

[GeorgeLyon]

LGTM. Thanks for doing this!

mlir/include/mlir-c/AffineExpr.h

MLIR_CAPI_EXPORTED void mlirAffineExprPrint(MlirAffineExpr affineExpr,
                                             MlirStringCallback callback,
                                             void *userData);
 
 /// Prints the affine expression to the standard error stream.
 MLIR_CAPI_EXPORTED void mlirAffineExprDump(MlirAffineExpr affineExpr);
 
 /** Checks whether the given affine expression is made out of only symbols and
  * constants. */
-MLIR_CAPI_EXPORTED int
+MLIR_CAPI_EXPORTED bool
 mlirAffineExprIsSymbolicOrConstant(MlirAffineExpr affineExpr);
 
 /** Checks whether the given affine expression is a pure affine expression, i.e.
  * mul, floordiv, ceildic, and mod is only allowed w.r.t constants. */
-MLIR_CAPI_EXPORTED int mlirAffineExprIsPureAffine(MlirAffineExpr affineExpr);
+MLIR_CAPI_EXPORTED bool mlirAffineExprIsPureAffine(MlirAffineExpr affineExpr);
 
 /** Returns the greatest known integral divisor of this affine expression. The
  * result is always positive. */
 MLIR_CAPI_EXPORTED int64_t
 mlirAffineExprGetLargestKnownDivisor(MlirAffineExpr affineExpr);
 
 /// Checks whether the given affine expression is a multiple of 'factor'.
-MLIR_CAPI_EXPORTED int mlirAffineExprIsMultipleOf(MlirAffineExpr affineExpr,
+MLIR_CAPI_EXPORTED bool mlirAffineExprIsMultipleOf(MlirAffineExpr affineExpr,
                                                    int64_t factor);
 
 /** Checks whether the given affine expression involves AffineDimExpr
  * 'position'. */
-MLIR_CAPI_EXPORTED int mlirAffineExprIsFunctionOfDim(MlirAffineExpr affineExpr,
+MLIR_CAPI_EXPORTED bool mlirAffineExprIsFunctionOfDim(MlirAffineExpr affineExpr,
                                                       intptr_t position);
 
 //===----------------------------------------------------------------------===//
 // Affine Dimension Expression.
 //===----------------------------------------------------------------------===//
 
 /// Creates an affine dimension expression with 'position' in the context.
 MLIR_CAPI_EXPORTED MlirAffineExpr mlirAffineDimExprGet(MlirContext ctx,
                                                        intptr_t position);

 MLIR_CAPI_EXPORTED int64_t
 mlirAffineConstantExprGetValue(MlirAffineExpr affineExpr);
 
 //===----------------------------------------------------------------------===//
 // Affine Add Expression.
 //===----------------------------------------------------------------------===//
 
 /// Checks whether the given affine expression is an add expression.
-MLIR_CAPI_EXPORTED int mlirAffineExprIsAAdd(MlirAffineExpr affineExpr);
+MLIR_CAPI_EXPORTED bool mlirAffineExprIsAAdd(MlirAffineExpr affineExpr);
 
 /// Creates an affine add expression with 'lhs' and 'rhs'.
 MLIR_CAPI_EXPORTED MlirAffineExpr mlirAffineAddExprGet(MlirAffineExpr lhs,
                                                        MlirAffineExpr rhs);
 
 //===----------------------------------------------------------------------===//
 // Affine Mul Expression.
 //===----------------------------------------------------------------------===//
 
 /// Checks whether the given affine expression is an mul expression.
-MLIR_CAPI_EXPORTED int mlirAffineExprIsAMul(MlirAffineExpr affineExpr);
+MLIR_CAPI_EXPORTED bool mlirAffineExprIsAMul(MlirAffineExpr affineExpr);
 
 /// Creates an affine mul expression with 'lhs' and 'rhs'.
 MLIR_CAPI_EXPORTED MlirAffineExpr mlirAffineMulExprGet(MlirAffineExpr lhs,
                                                        MlirAffineExpr rhs);
 
 //===----------------------------------------------------------------------===//
 // Affine Mod Expression.
 //===----------------------------------------------------------------------===//
 
 /// Checks whether the given affine expression is an mod expression.
-MLIR_CAPI_EXPORTED int mlirAffineExprIsAMod(MlirAffineExpr affineExpr);
+MLIR_CAPI_EXPORTED bool mlirAffineExprIsAMod(MlirAffineExpr affineExpr);
 
 /// Creates an affine mod expression with 'lhs' and 'rhs'.
 MLIR_CAPI_EXPORTED MlirAffineExpr mlirAffineModExprGet(MlirAffineExpr lhs,
                                                        MlirAffineExpr rhs);
 
 //===----------------------------------------------------------------------===//
 // Affine FloorDiv Expression.
 //===----------------------------------------------------------------------===//
 
 /// Checks whether the given affine expression is an floordiv expression.
-MLIR_CAPI_EXPORTED int mlirAffineExprIsAFloorDiv(MlirAffineExpr affineExpr);
+MLIR_CAPI_EXPORTED bool mlirAffineExprIsAFloorDiv(MlirAffineExpr affineExpr);
 
 /// Creates an affine floordiv expression with 'lhs' and 'rhs'.
 MLIR_CAPI_EXPORTED MlirAffineExpr mlirAffineFloorDivExprGet(MlirAffineExpr lhs,
                                                             MlirAffineExpr rhs);
 
 //===----------------------------------------------------------------------===//
 // Affine CeilDiv Expression.
 //===----------------------------------------------------------------------===//
 
 /// Checks whether the given affine expression is an ceildiv expression.
-MLIR_CAPI_EXPORTED int mlirAffineExprIsACeilDiv(MlirAffineExpr affineExpr);
+MLIR_CAPI_EXPORTED bool mlirAffineExprIsACeilDiv(MlirAffineExpr affineExpr);
 
 /// Creates an affine ceildiv expression with 'lhs' and 'rhs'.
 MLIR_CAPI_EXPORTED MlirAffineExpr mlirAffineCeilDivExprGet(MlirAffineExpr lhs,
                                                            MlirAffineExpr rhs);
 
 //===----------------------------------------------------------------------===//
 // Affine Binary Operation Expression.
 //===----------------------------------------------------------------------===//

mlir/include/mlir-c/AffineMap.h

 DEFINE_C_API_STRUCT(MlirAffineMap, const void);
 
 #undef DEFINE_C_API_STRUCT
 
 /// Gets the context that the given affine map was created with
 MLIR_CAPI_EXPORTED MlirContext mlirAffineMapGetContext(MlirAffineMap affineMap);
 
 /// Checks whether an affine map is null.
-static inline int mlirAffineMapIsNull(MlirAffineMap affineMap) {
+static inline bool mlirAffineMapIsNull(MlirAffineMap affineMap) {
   return !affineMap.ptr;
 }
 
 /// Checks if two affine maps are equal.
-MLIR_CAPI_EXPORTED int mlirAffineMapEqual(MlirAffineMap a1, MlirAffineMap a2);
+MLIR_CAPI_EXPORTED bool mlirAffineMapEqual(MlirAffineMap a1, MlirAffineMap a2);
 
 /** Prints an affine map by sending chunks of the string representation and
  * forwarding `userData to `callback`. Note that the callback may be called
  * several times with consecutive chunks of the string. */
 MLIR_CAPI_EXPORTED void mlirAffineMapPrint(MlirAffineMap affineMap,
                                            MlirStringCallback callback,
                                            void *userData);
 

  * be repeated (i.e. `[1,2,0]` is a valid permutation. `[2,0]` or `[1,1,2]` is
  * an invalid invalid permutation.) The affine map is owned by the context. */
 MLIR_CAPI_EXPORTED MlirAffineMap mlirAffineMapPermutationGet(
     MlirContext ctx, intptr_t size, unsigned *permutation);
 
 /** Checks whether the given affine map is an identity affine map. The function
  * asserts that the number of dimensions is greater or equal to the number of
  * results. */
-MLIR_CAPI_EXPORTED int mlirAffineMapIsIdentity(MlirAffineMap affineMap);
+MLIR_CAPI_EXPORTED bool mlirAffineMapIsIdentity(MlirAffineMap affineMap);
 
 /// Checks whether the given affine map is a minor identity affine map.
-MLIR_CAPI_EXPORTED int mlirAffineMapIsMinorIdentity(MlirAffineMap affineMap);
+MLIR_CAPI_EXPORTED bool mlirAffineMapIsMinorIdentity(MlirAffineMap affineMap);
 
 /// Checks whether the given affine map is an empty affine map.
-MLIR_CAPI_EXPORTED int mlirAffineMapIsEmpty(MlirAffineMap affineMap);
+MLIR_CAPI_EXPORTED bool mlirAffineMapIsEmpty(MlirAffineMap affineMap);
 
 /** Checks whether the given affine map is a single result constant affine
  * map. */
-MLIR_CAPI_EXPORTED int mlirAffineMapIsSingleConstant(MlirAffineMap affineMap);
+MLIR_CAPI_EXPORTED bool mlirAffineMapIsSingleConstant(MlirAffineMap affineMap);
 
 /** Returns the constant result of the given affine map. The function asserts
  * that the map has a single constant result. */
 MLIR_CAPI_EXPORTED int64_t
 mlirAffineMapGetSingleConstantResult(MlirAffineMap affineMap);
 
 /// Returns the number of dimensions of the given affine map.
 MLIR_CAPI_EXPORTED intptr_t mlirAffineMapGetNumDims(MlirAffineMap affineMap);
 
 /// Returns the number of symbols of the given affine map.
 MLIR_CAPI_EXPORTED intptr_t mlirAffineMapGetNumSymbols(MlirAffineMap affineMap);
 
 /// Returns the number of results of the given affine map.
 MLIR_CAPI_EXPORTED intptr_t mlirAffineMapGetNumResults(MlirAffineMap affineMap);
 
 /** Returns the number of inputs (dimensions + symbols) of the given affine
  * map. */
 MLIR_CAPI_EXPORTED intptr_t mlirAffineMapGetNumInputs(MlirAffineMap affineMap);
 
 /** Checks whether the given affine map represents a subset of a symbol-less
  * permutation map. */
-MLIR_CAPI_EXPORTED int
+MLIR_CAPI_EXPORTED bool
 mlirAffineMapIsProjectedPermutation(MlirAffineMap affineMap);
 
 /** Checks whether the given affine map represents a symbol-less permutation
  * map. */
-MLIR_CAPI_EXPORTED int mlirAffineMapIsPermutation(MlirAffineMap affineMap);
+MLIR_CAPI_EXPORTED bool mlirAffineMapIsPermutation(MlirAffineMap affineMap);
 
 /// Returns the affine map consisting of the `resultPos` subset.
 MLIR_CAPI_EXPORTED MlirAffineMap mlirAffineMapGetSubMap(MlirAffineMap affineMap,
                                                         intptr_t size,
                                                         intptr_t *resultPos);
 
 /** Returns the affine map consisting of the most major `numResults` results.
  * Returns the null AffineMap if the `numResults` is equal to zero.

mlir/include/mlir-c/IR.h

static inline bool mlirContextIsNull(MlirContext context) {
   return !context.ptr;
 }
 
 /// Takes an MLIR context owned by the caller and destroys it.
 MLIR_CAPI_EXPORTED void mlirContextDestroy(MlirContext context);
 
 /// Sets whether unregistered dialects are allowed in this context.
 MLIR_CAPI_EXPORTED void
-mlirContextSetAllowUnregisteredDialects(MlirContext context, int allow);
+mlirContextSetAllowUnregisteredDialects(MlirContext context, bool allow);
 
 /// Returns whether the context allows unregistered dialects.
-MLIR_CAPI_EXPORTED int
+MLIR_CAPI_EXPORTED bool
 mlirContextGetAllowUnregisteredDialects(MlirContext context);
 
 /** Returns the number of dialects registered with the given context. A
  * registered dialect will be loaded if needed by the parser. */
 MLIR_CAPI_EXPORTED intptr_t
 mlirContextGetNumRegisteredDialects(MlirContext context);
 
 /** Returns the number of dialects loaded by the context.

 
 /// Creates a location with unknown position owned by the given context.
 MLIR_CAPI_EXPORTED MlirLocation mlirLocationUnknownGet(MlirContext context);
 
 /// Gets the context that a location was created with.
 MLIR_CAPI_EXPORTED MlirContext mlirLocationGetContext(MlirLocation location);
 
 /// Checks if the location is null.
-static inline int mlirLocationIsNull(MlirLocation location) {
+static inline bool mlirLocationIsNull(MlirLocation location) {
   return !location.ptr;
 }
 
 /// Checks if two locations are equal.
-MLIR_CAPI_EXPORTED int mlirLocationEqual(MlirLocation l1, MlirLocation l2);
+MLIR_CAPI_EXPORTED bool mlirLocationEqual(MlirLocation l1, MlirLocation l2);
 
 /** Prints a location by sending chunks of the string representation and
  * forwarding `userData to `callback`. Note that the callback may be called
  * several times with consecutive chunks of the string. */
 MLIR_CAPI_EXPORTED void mlirLocationPrint(MlirLocation location,
                                           MlirStringCallback callback,
                                           void *userData);
 

 MLIR_CAPI_EXPORTED void
 mlirOpPrintingFlagsElideLargeElementsAttrs(MlirOpPrintingFlags flags,
                                            intptr_t largeElementLimit);
 
 /** Enable printing of debug information. If 'prettyForm' is set to true,
  * debug information is printed in a more readable 'pretty' form. Note: The
  * IR generated with 'prettyForm' is not parsable. */
 MLIR_CAPI_EXPORTED void
-mlirOpPrintingFlagsEnableDebugInfo(MlirOpPrintingFlags flags, int prettyForm);
+mlirOpPrintingFlagsEnableDebugInfo(MlirOpPrintingFlags flags, bool prettyForm);
 
 /// Always print operations in the generic form.
 MLIR_CAPI_EXPORTED void
 mlirOpPrintingFlagsPrintGenericOpForm(MlirOpPrintingFlags flags);
 
 /** Use local scope when printing the operation. This allows for using the
  * printer in a more localized and thread-safe setting, but may not
  * necessarily be identical to what the IR will look like when dumping

 mlirOperationGetAttributeByName(MlirOperation op, MlirStringRef name);
 
 /** Sets an attribute by name, replacing the existing if it exists or
  * adding a new one otherwise. */
 MLIR_CAPI_EXPORTED void mlirOperationSetAttributeByName(MlirOperation op,
                                                         MlirStringRef name,
                                                         MlirAttribute attr);
 
-/** Removes an attribute by name. Returns 0 if the attribute was not found
- * and !0 if removed. */
-MLIR_CAPI_EXPORTED int mlirOperationRemoveAttributeByName(MlirOperation op,
+/** Removes an attribute by name. Returns false if the attribute was not found
+ * and true if removed. */
+MLIR_CAPI_EXPORTED bool mlirOperationRemoveAttributeByName(MlirOperation op,
                                                            MlirStringRef name);
 
 /** Prints an operation by sending chunks of the string representation and
  * forwarding `userData to `callback`. Note that the callback may be called
  * several times with consecutive chunks of the string. */
 MLIR_CAPI_EXPORTED void mlirOperationPrint(MlirOperation op,
                                            MlirStringCallback callback,
                                            void *userData);
 

 
 /// Returns whether the value is null.
 static inline bool mlirValueIsNull(MlirValue value) { return !value.ptr; }
 
 /// Returns 1 if two values are equal, 0 otherwise.
 bool mlirValueEqual(MlirValue value1, MlirValue value2);
 
 /// Returns 1 if the value is a block argument, 0 otherwise.
-MLIR_CAPI_EXPORTED int mlirValueIsABlockArgument(MlirValue value);
+MLIR_CAPI_EXPORTED bool mlirValueIsABlockArgument(MlirValue value);
 
 /// Returns 1 if the value is an operation result, 0 otherwise.
-MLIR_CAPI_EXPORTED int mlirValueIsAOpResult(MlirValue value);
+MLIR_CAPI_EXPORTED bool mlirValueIsAOpResult(MlirValue value);
 
 /** Returns the block in which this value is defined as an argument. Asserts if
  * the value is not a block argument. */
 MLIR_CAPI_EXPORTED MlirBlock mlirBlockArgumentGetOwner(MlirValue value);
 
 /// Returns the position of the value in the argument list of its block.
 MLIR_CAPI_EXPORTED intptr_t mlirBlockArgumentGetArgNumber(MlirValue value);
 

mlir/include/mlir-c/Pass.h

 
 /// Create a new top-level PassManager.
 MLIR_CAPI_EXPORTED MlirPassManager mlirPassManagerCreate(MlirContext ctx);
 
 /// Destroy the provided PassManager.
 MLIR_CAPI_EXPORTED void mlirPassManagerDestroy(MlirPassManager passManager);
 
 /// Checks if a PassManager is null.
-static inline int mlirPassManagerIsNull(MlirPassManager passManager) {
+static inline bool mlirPassManagerIsNull(MlirPassManager passManager) {
   return !passManager.ptr;
 }
 
 /// Cast a top-level PassManager to a generic OpPassManager.
 MLIR_CAPI_EXPORTED MlirOpPassManager
 mlirPassManagerGetAsOpPassManager(MlirPassManager passManager);
 
 /// Run the provided `passManager` on the given `module`.

mlir/include/mlir-c/StandardAttributes.h

 extern "C" {
 #endif
 
 //===----------------------------------------------------------------------===//
 // Affine map attribute.
 //===----------------------------------------------------------------------===//
 
 /// Checks whether the given attribute is an affine map attribute.
-MLIR_CAPI_EXPORTED int mlirAttributeIsAAffineMap(MlirAttribute attr);
+MLIR_CAPI_EXPORTED bool mlirAttributeIsAAffineMap(MlirAttribute attr);
 
 /** Creates an affine map attribute wrapping the given map. The attribute
  * belongs to the same context as the affine map. */
 MLIR_CAPI_EXPORTED MlirAttribute mlirAffineMapAttrGet(MlirAffineMap map);
 
 /// Returns the affine map wrapped in the given affine map attribute.
 MLIR_CAPI_EXPORTED MlirAffineMap mlirAffineMapAttrGetValue(MlirAttribute attr);
 
 //===----------------------------------------------------------------------===//
 // Array attribute.
 //===----------------------------------------------------------------------===//
 
 /// Checks whether the given attribute is an array attribute.
-MLIR_CAPI_EXPORTED int mlirAttributeIsAArray(MlirAttribute attr);
+MLIR_CAPI_EXPORTED bool mlirAttributeIsAArray(MlirAttribute attr);
 
 /** Creates an array element containing the given list of elements in the given
  * context. */
 MLIR_CAPI_EXPORTED MlirAttribute mlirArrayAttrGet(MlirContext ctx,
                                                   intptr_t numElements,
                                                   MlirAttribute const *elements);
 
 /// Returns the number of elements stored in the given array attribute.
 MLIR_CAPI_EXPORTED intptr_t mlirArrayAttrGetNumElements(MlirAttribute attr);
 
 /// Returns pos-th element stored in the given array attribute.
 MLIR_CAPI_EXPORTED MlirAttribute mlirArrayAttrGetElement(MlirAttribute attr,
                                                          intptr_t pos);
 
 //===----------------------------------------------------------------------===//
 // Dictionary attribute.
 //===----------------------------------------------------------------------===//
 
 /// Checks whether the given attribute is a dictionary attribute.
-MLIR_CAPI_EXPORTED int mlirAttributeIsADictionary(MlirAttribute attr);
+MLIR_CAPI_EXPORTED bool mlirAttributeIsADictionary(MlirAttribute attr);
 
 /** Creates a dictionary attribute containing the given list of elements in the
  * provided context. */
 MLIR_CAPI_EXPORTED MlirAttribute mlirDictionaryAttrGet(
     MlirContext ctx, intptr_t numElements, MlirNamedAttribute const *elements);
 
 /// Returns the number of attributes contained in a dictionary attribute.
 MLIR_CAPI_EXPORTED intptr_t

 //===----------------------------------------------------------------------===//
 // Floating point attribute.
 //===----------------------------------------------------------------------===//
 
 /* TODO: add support for APFloat and APInt to LLVM IR C API, then expose the
  * relevant functions here. */
 
 /// Checks whether the given attribute is a floating point attribute.
-MLIR_CAPI_EXPORTED int mlirAttributeIsAFloat(MlirAttribute attr);
+MLIR_CAPI_EXPORTED bool mlirAttributeIsAFloat(MlirAttribute attr);
 
 /** 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);
 
 /** Returns the value stored in the given floating point attribute, interpreting
  * the value as double. */
 MLIR_CAPI_EXPORTED double mlirFloatAttrGetValueDouble(MlirAttribute attr);
 
 //===----------------------------------------------------------------------===//
 // Integer attribute.
 //===----------------------------------------------------------------------===//
 
 /* TODO: add support for APFloat and APInt to LLVM IR C API, then expose the
  * relevant functions here. */
 
 /// Checks whether the given attribute is an integer attribute.
-MLIR_CAPI_EXPORTED int mlirAttributeIsAInteger(MlirAttribute attr);
+MLIR_CAPI_EXPORTED bool mlirAttributeIsAInteger(MlirAttribute attr);
 
 /** Creates an integer attribute of the given type with the given integer
  * value. */
 MLIR_CAPI_EXPORTED MlirAttribute mlirIntegerAttrGet(MlirType type,
                                                     int64_t value);
 
 /** Returns the value stored in the given integer attribute, assuming the value
  * fits into a 64-bit integer. */
 MLIR_CAPI_EXPORTED int64_t mlirIntegerAttrGetValueInt(MlirAttribute attr);
 
 //===----------------------------------------------------------------------===//
 // Bool attribute.
 //===----------------------------------------------------------------------===//
 
 /// Checks whether the given attribute is a bool attribute.
-MLIR_CAPI_EXPORTED int mlirAttributeIsABool(MlirAttribute attr);
+MLIR_CAPI_EXPORTED bool mlirAttributeIsABool(MlirAttribute attr);
 
 /// Creates a bool attribute in the given context with the given value.
 MLIR_CAPI_EXPORTED MlirAttribute mlirBoolAttrGet(MlirContext ctx, int value);
 
 /// Returns the value stored in the given bool attribute.
-MLIR_CAPI_EXPORTED int mlirBoolAttrGetValue(MlirAttribute attr);
+MLIR_CAPI_EXPORTED bool mlirBoolAttrGetValue(MlirAttribute attr);
 
 //===----------------------------------------------------------------------===//
 // Integer set attribute.
 //===----------------------------------------------------------------------===//
 
 /// Checks whether the given attribute is an integer set attribute.
-MLIR_CAPI_EXPORTED int mlirAttributeIsAIntegerSet(MlirAttribute attr);
+MLIR_CAPI_EXPORTED bool mlirAttributeIsAIntegerSet(MlirAttribute attr);
 
 //===----------------------------------------------------------------------===//
 // Opaque attribute.
 //===----------------------------------------------------------------------===//
 
 /// Checks whether the given attribute is an opaque attribute.
-MLIR_CAPI_EXPORTED int mlirAttributeIsAOpaque(MlirAttribute attr);
+MLIR_CAPI_EXPORTED bool mlirAttributeIsAOpaque(MlirAttribute attr);
 
 /** Creates an opaque attribute in the given context associated with the dialect
  * identified by its namespace. The attribute contains opaque byte data of the
  * specified length (data need not be null-terminated). */
 MLIR_CAPI_EXPORTED MlirAttribute mlirOpaqueAttrGet(MlirContext ctx,
                                                    const char *dialectNamespace,
                                                    intptr_t dataLength,
                                                    const char *data,
                                                    MlirType type);
 
 /** Returns the namespace of the dialect with which the given opaque attribute
  * is associated. The namespace string is owned by the context. */
 MLIR_CAPI_EXPORTED const char *
 mlirOpaqueAttrGetDialectNamespace(MlirAttribute attr);
 
 /** Returns the raw data as a string reference. The data remains live as long as
  * the context in which the attribute lives. */
 MLIR_CAPI_EXPORTED MlirStringRef mlirOpaqueAttrGetData(MlirAttribute attr);
 
 //===----------------------------------------------------------------------===//
 // String attribute.
 //===----------------------------------------------------------------------===//
 
 /// Checks whether the given attribute is a string attribute.
-MLIR_CAPI_EXPORTED int mlirAttributeIsAString(MlirAttribute attr);
+MLIR_CAPI_EXPORTED bool mlirAttributeIsAString(MlirAttribute attr);
 
 /** Creates a string attribute in the given context containing the given string.
  * The string need not be null-terminated and its length must be specified. */
 MLIR_CAPI_EXPORTED MlirAttribute mlirStringAttrGet(MlirContext ctx,
                                                    intptr_t length,
                                                    const char *data);
 
 /** Creates a string attribute in the given context containing the given string.
  * The string need not be null-terminated and its length must be specified.
  * Additionally, the attribute has the given type. */
 MLIR_CAPI_EXPORTED MlirAttribute mlirStringAttrTypedGet(MlirType type,
                                                         intptr_t length,
                                                         const char *data);
 
 /** Returns the attribute values as a string reference. The data remains live as
  * long as the context in which the attribute lives. */
 MLIR_CAPI_EXPORTED MlirStringRef mlirStringAttrGetValue(MlirAttribute attr);
 
 //===----------------------------------------------------------------------===//
 // SymbolRef attribute.
 //===----------------------------------------------------------------------===//
 
 /// Checks whether the given attribute is a symbol reference attribute.
-MLIR_CAPI_EXPORTED int mlirAttributeIsASymbolRef(MlirAttribute attr);
+MLIR_CAPI_EXPORTED bool mlirAttributeIsASymbolRef(MlirAttribute attr);
 
 /** Creates a symbol reference attribute in the given context referencing a
  * symbol identified by the given string inside a list of nested references.
  * Each of the references in the list must not be nested. The string need not be
  * null-terminated and its length must be specified. */
 MLIR_CAPI_EXPORTED MlirAttribute
 mlirSymbolRefAttrGet(MlirContext ctx, intptr_t length, const char *symbol,
                      intptr_t numReferences, MlirAttribute const *references);

 MLIR_CAPI_EXPORTED MlirAttribute
 mlirSymbolRefAttrGetNestedReference(MlirAttribute attr, intptr_t pos);
 
 //===----------------------------------------------------------------------===//
 // Flat SymbolRef attribute.
 //===----------------------------------------------------------------------===//
 
 /// Checks whether the given attribute is a flat symbol reference attribute.
-MLIR_CAPI_EXPORTED int mlirAttributeIsAFlatSymbolRef(MlirAttribute attr);
+MLIR_CAPI_EXPORTED bool mlirAttributeIsAFlatSymbolRef(MlirAttribute attr);
 
 /** Creates a flat symbol reference attribute in the given context referencing a
  * symbol identified by the given string. The string need not be null-terminated
  * and its length must be specified. */
 MLIR_CAPI_EXPORTED MlirAttribute mlirFlatSymbolRefAttrGet(MlirContext ctx,
                                                           intptr_t length,
                                                           const char *symbol);
 
 /** Returns the referenced symbol as a string reference. The data remains live
  * as long as the context in which the attribute lives. */
 MLIR_CAPI_EXPORTED MlirStringRef
 mlirFlatSymbolRefAttrGetValue(MlirAttribute attr);
 
 //===----------------------------------------------------------------------===//
 // Type attribute.
 //===----------------------------------------------------------------------===//
 
 /// Checks whether the given attribute is a type attribute.
-MLIR_CAPI_EXPORTED int mlirAttributeIsAType(MlirAttribute attr);
+MLIR_CAPI_EXPORTED bool mlirAttributeIsAType(MlirAttribute attr);
 
 /** Creates a type attribute wrapping the given type in the same context as the
  * type. */
 MLIR_CAPI_EXPORTED MlirAttribute mlirTypeAttrGet(MlirType type);
 
 /// Returns the type stored in the given type attribute.
 MLIR_CAPI_EXPORTED MlirType mlirTypeAttrGetValue(MlirAttribute attr);
 
 //===----------------------------------------------------------------------===//
 // Unit attribute.
 //===----------------------------------------------------------------------===//
 
 /// Checks whether the given attribute is a unit attribute.
-MLIR_CAPI_EXPORTED int mlirAttributeIsAUnit(MlirAttribute attr);
+MLIR_CAPI_EXPORTED bool mlirAttributeIsAUnit(MlirAttribute attr);
 
 /// Creates a unit attribute in the given context.
 MLIR_CAPI_EXPORTED MlirAttribute mlirUnitAttrGet(MlirContext ctx);
 
 //===----------------------------------------------------------------------===//
 // Elements attributes.
 //===----------------------------------------------------------------------===//
 
 /// Checks whether the given attribute is an elements attribute.
-MLIR_CAPI_EXPORTED int mlirAttributeIsAElements(MlirAttribute attr);
+MLIR_CAPI_EXPORTED bool mlirAttributeIsAElements(MlirAttribute attr);
 
 /// Returns the element at the given rank-dimensional index.
 MLIR_CAPI_EXPORTED MlirAttribute mlirElementsAttrGetValue(MlirAttribute attr,
                                                           intptr_t rank,
                                                           uint64_t *idxs);
 
 /** Checks whether the given rank-dimensional index is valid in the given
  * elements attribute. */
-MLIR_CAPI_EXPORTED int
+MLIR_CAPI_EXPORTED bool
 mlirElementsAttrIsValidIndex(MlirAttribute attr, intptr_t rank, uint64_t *idxs);
 
 /** Gets the total number of elements in the given elements attribute. In order
  * to iterate over the attribute, obtain its type, which must be a statically
  * shaped type and use its sizes to build a multi-dimensional index. */
 MLIR_CAPI_EXPORTED int64_t mlirElementsAttrGetNumElements(MlirAttribute attr);
 
 //===----------------------------------------------------------------------===//
 // Dense elements attribute.
 //===----------------------------------------------------------------------===//
 
 // TODO: decide on the interface and add support for complex elements.
 /* TODO: add support for APFloat and APInt to LLVM IR C API, then expose the
  * relevant functions here. */
 
 /// Checks whether the given attribute is a dense elements attribute.
-MLIR_CAPI_EXPORTED int mlirAttributeIsADenseElements(MlirAttribute attr);
-MLIR_CAPI_EXPORTED int mlirAttributeIsADenseIntElements(MlirAttribute attr);
-MLIR_CAPI_EXPORTED int mlirAttributeIsADenseFPElements(MlirAttribute attr);
+MLIR_CAPI_EXPORTED bool mlirAttributeIsADenseElements(MlirAttribute attr);
+MLIR_CAPI_EXPORTED bool mlirAttributeIsADenseIntElements(MlirAttribute attr);
+MLIR_CAPI_EXPORTED bool mlirAttributeIsADenseFPElements(MlirAttribute attr);
 
 /** Creates a dense elements attribute with the given Shaped type and elements
  * in the same context as the type. */
 MLIR_CAPI_EXPORTED MlirAttribute mlirDenseElementsAttrGet(
     MlirType shapedType, intptr_t numElements, MlirAttribute const *elements);
 
 /** Creates a dense elements attribute with the given Shaped type containing a
  * single replicated element (splat). */
 MLIR_CAPI_EXPORTED MlirAttribute
 mlirDenseElementsAttrSplatGet(MlirType shapedType, MlirAttribute element);
 MLIR_CAPI_EXPORTED MlirAttribute
-mlirDenseElementsAttrBoolSplatGet(MlirType shapedType, int element);
+mlirDenseElementsAttrBoolSplatGet(MlirType shapedType, bool element);
 MLIR_CAPI_EXPORTED MlirAttribute
 mlirDenseElementsAttrUInt32SplatGet(MlirType shapedType, uint32_t element);
 MLIR_CAPI_EXPORTED MlirAttribute
 mlirDenseElementsAttrInt32SplatGet(MlirType shapedType, int32_t element);
 MLIR_CAPI_EXPORTED MlirAttribute
 mlirDenseElementsAttrUInt64SplatGet(MlirType shapedType, uint64_t element);
 MLIR_CAPI_EXPORTED MlirAttribute
 mlirDenseElementsAttrInt64SplatGet(MlirType shapedType, int64_t element);

 /** Creates a dense elements attribute that has the same data as the given dense
  * elements attribute and a different shaped type. The new type must have the
  * same total number of elements. */
 MLIR_CAPI_EXPORTED MlirAttribute
 mlirDenseElementsAttrReshapeGet(MlirAttribute attr, MlirType shapedType);
 
 /** Checks whether the given dense elements attribute contains a single
  * replicated value (splat). */
-MLIR_CAPI_EXPORTED int mlirDenseElementsAttrIsSplat(MlirAttribute attr);
+MLIR_CAPI_EXPORTED bool mlirDenseElementsAttrIsSplat(MlirAttribute attr);
 
 /** Returns the single replicated value (splat) of a specific type contained by
  * the given dense elements attribute. */
 MLIR_CAPI_EXPORTED MlirAttribute
 mlirDenseElementsAttrGetSplatValue(MlirAttribute attr);
 MLIR_CAPI_EXPORTED int
 mlirDenseElementsAttrGetBoolSplatValue(MlirAttribute attr);
 MLIR_CAPI_EXPORTED int32_t
 mlirDenseElementsAttrGetInt32SplatValue(MlirAttribute attr);
 MLIR_CAPI_EXPORTED uint32_t
 mlirDenseElementsAttrGetUInt32SplatValue(MlirAttribute attr);
 MLIR_CAPI_EXPORTED int64_t
 mlirDenseElementsAttrGetInt64SplatValue(MlirAttribute attr);
 MLIR_CAPI_EXPORTED uint64_t
 mlirDenseElementsAttrGetUInt64SplatValue(MlirAttribute attr);
 MLIR_CAPI_EXPORTED float
 mlirDenseElementsAttrGetFloatSplatValue(MlirAttribute attr);
 MLIR_CAPI_EXPORTED double
 mlirDenseElementsAttrGetDoubleSplatValue(MlirAttribute attr);
 MLIR_CAPI_EXPORTED MlirStringRef
 mlirDenseElementsAttrGetStringSplatValue(MlirAttribute attr);
 
 /** Returns the pos-th value (flat contiguous indexing) of a specific type
  * contained by the given dense elements attribute. */
-MLIR_CAPI_EXPORTED int mlirDenseElementsAttrGetBoolValue(MlirAttribute attr,
+MLIR_CAPI_EXPORTED bool mlirDenseElementsAttrGetBoolValue(MlirAttribute attr,
                                                           intptr_t pos);
 MLIR_CAPI_EXPORTED int32_t
 mlirDenseElementsAttrGetInt32Value(MlirAttribute attr, intptr_t pos);
 MLIR_CAPI_EXPORTED uint32_t
 mlirDenseElementsAttrGetUInt32Value(MlirAttribute attr, intptr_t pos);
 MLIR_CAPI_EXPORTED int64_t
 mlirDenseElementsAttrGetInt64Value(MlirAttribute attr, intptr_t pos);
 MLIR_CAPI_EXPORTED uint64_t
 mlirDenseElementsAttrGetUInt64Value(MlirAttribute attr, intptr_t pos);

 
 //===----------------------------------------------------------------------===//
 // Opaque elements attribute.
 //===----------------------------------------------------------------------===//
 
 // TODO: expose Dialect to the bindings and implement accessors here.
 
 /// Checks whether the given attribute is an opaque elements attribute.
-MLIR_CAPI_EXPORTED int mlirAttributeIsAOpaqueElements(MlirAttribute attr);
+MLIR_CAPI_EXPORTED bool mlirAttributeIsAOpaqueElements(MlirAttribute attr);
 
 //===----------------------------------------------------------------------===//
 // Sparse elements attribute.
 //===----------------------------------------------------------------------===//
 
 /// Checks whether the given attribute is a sparse elements attribute.
-MLIR_CAPI_EXPORTED int mlirAttributeIsASparseElements(MlirAttribute attr);
+MLIR_CAPI_EXPORTED bool mlirAttributeIsASparseElements(MlirAttribute attr);
 
 /** Creates a sparse elements attribute of the given shape from a list of
  * indices and a list of associated values. Both lists are expected to be dense
  * elements attributes with the same number of elements. The list of indices is
  * expected to contain 64-bit integers. The attribute is created in the same
  * context as the type. */
 MLIR_CAPI_EXPORTED MlirAttribute mlirSparseElementsAttribute(
     MlirType shapedType, MlirAttribute denseIndices, MlirAttribute denseValues);

mlir/include/mlir-c/StandardTypes.h

 extern "C" {
 #endif
 
 //===----------------------------------------------------------------------===//
 // Integer types.
 //===----------------------------------------------------------------------===//
 
 /// Checks whether the given type is an integer type.
-MLIR_CAPI_EXPORTED int mlirTypeIsAInteger(MlirType type);
+MLIR_CAPI_EXPORTED bool mlirTypeIsAInteger(MlirType type);
 
 /** Creates a signless integer type of the given bitwidth in the context. The
  * type is owned by the context. */
 MLIR_CAPI_EXPORTED MlirType mlirIntegerTypeGet(MlirContext ctx,
                                                unsigned bitwidth);
 
 /** Creates a signed integer type of the given bitwidth in the context. The type
  * is owned by the context. */
 MLIR_CAPI_EXPORTED MlirType mlirIntegerTypeSignedGet(MlirContext ctx,
                                                      unsigned bitwidth);
 
 /** Creates an unsigned integer type of the given bitwidth in the context. The
  * type is owned by the context. */
 MLIR_CAPI_EXPORTED MlirType mlirIntegerTypeUnsignedGet(MlirContext ctx,
                                                        unsigned bitwidth);
 
 /// Returns the bitwidth of an integer type.
 MLIR_CAPI_EXPORTED unsigned mlirIntegerTypeGetWidth(MlirType type);
 
 /// Checks whether the given integer type is signless.
-MLIR_CAPI_EXPORTED int mlirIntegerTypeIsSignless(MlirType type);
+MLIR_CAPI_EXPORTED bool mlirIntegerTypeIsSignless(MlirType type);
 
 /// Checks whether the given integer type is signed.
-MLIR_CAPI_EXPORTED int mlirIntegerTypeIsSigned(MlirType type);
+MLIR_CAPI_EXPORTED bool mlirIntegerTypeIsSigned(MlirType type);
 
 /// Checks whether the given integer type is unsigned.
-MLIR_CAPI_EXPORTED int mlirIntegerTypeIsUnsigned(MlirType type);
+MLIR_CAPI_EXPORTED bool mlirIntegerTypeIsUnsigned(MlirType type);
 
 //===----------------------------------------------------------------------===//
 // Index type.
 //===----------------------------------------------------------------------===//
 
 /// Checks whether the given type is an index type.
-MLIR_CAPI_EXPORTED int mlirTypeIsAIndex(MlirType type);
+MLIR_CAPI_EXPORTED bool mlirTypeIsAIndex(MlirType type);
 
 /** Creates an index type in the given context. The type is owned by the
  * context. */
 MLIR_CAPI_EXPORTED MlirType mlirIndexTypeGet(MlirContext ctx);
 
 //===----------------------------------------------------------------------===//
 // Floating-point types.
 //===----------------------------------------------------------------------===//
 
 /// Checks whether the given type is a bf16 type.
-MLIR_CAPI_EXPORTED int mlirTypeIsABF16(MlirType type);
+MLIR_CAPI_EXPORTED bool mlirTypeIsABF16(MlirType type);
 
 /** Creates a bf16 type in the given context. The type is owned by the
  * context. */
 MLIR_CAPI_EXPORTED MlirType mlirBF16TypeGet(MlirContext ctx);
 
 /// Checks whether the given type is an f16 type.
-MLIR_CAPI_EXPORTED int mlirTypeIsAF16(MlirType type);
+MLIR_CAPI_EXPORTED bool mlirTypeIsAF16(MlirType type);
 
 /** Creates an f16 type in the given context. The type is owned by the
  * context. */
 MLIR_CAPI_EXPORTED MlirType mlirF16TypeGet(MlirContext ctx);
 
 /// Checks whether the given type is an f32 type.
-MLIR_CAPI_EXPORTED int mlirTypeIsAF32(MlirType type);
+MLIR_CAPI_EXPORTED bool mlirTypeIsAF32(MlirType type);
 
 /** Creates an f32 type in the given context. The type is owned by the
  * context. */
 MLIR_CAPI_EXPORTED MlirType mlirF32TypeGet(MlirContext ctx);
 
 /// Checks whether the given type is an f64 type.
-MLIR_CAPI_EXPORTED int mlirTypeIsAF64(MlirType type);
+MLIR_CAPI_EXPORTED bool mlirTypeIsAF64(MlirType type);
 
 /** Creates a f64 type in the given context. The type is owned by the
  * context. */
 MLIR_CAPI_EXPORTED MlirType mlirF64TypeGet(MlirContext ctx);
 
 //===----------------------------------------------------------------------===//
 // None type.
 //===----------------------------------------------------------------------===//
 
 /// Checks whether the given type is a None type.
-MLIR_CAPI_EXPORTED int mlirTypeIsANone(MlirType type);
+MLIR_CAPI_EXPORTED bool mlirTypeIsANone(MlirType type);
 
 /** Creates a None type in the given context. The type is owned by the
  * context. */
 MLIR_CAPI_EXPORTED MlirType mlirNoneTypeGet(MlirContext ctx);
 
 //===----------------------------------------------------------------------===//
 // Complex type.
 //===----------------------------------------------------------------------===//
 
 /// Checks whether the given type is a Complex type.
-MLIR_CAPI_EXPORTED int mlirTypeIsAComplex(MlirType type);
+MLIR_CAPI_EXPORTED bool mlirTypeIsAComplex(MlirType type);
 
 /** Creates a complex 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 mlirComplexTypeGet(MlirType elementType);
 
 /// Returns the element type of the given complex type.
 MLIR_CAPI_EXPORTED MlirType mlirComplexTypeGetElementType(MlirType type);
 
 //===----------------------------------------------------------------------===//
 // Shaped type.
 //===----------------------------------------------------------------------===//
 
 /// Checks whether the given type is a Shaped type.
-MLIR_CAPI_EXPORTED int mlirTypeIsAShaped(MlirType type);
+MLIR_CAPI_EXPORTED bool mlirTypeIsAShaped(MlirType type);
 
 /// Returns the element type of the shaped type.
 MLIR_CAPI_EXPORTED MlirType mlirShapedTypeGetElementType(MlirType type);
 
 /// Checks whether the given shaped type is ranked.
-MLIR_CAPI_EXPORTED int mlirShapedTypeHasRank(MlirType type);
+MLIR_CAPI_EXPORTED bool mlirShapedTypeHasRank(MlirType type);
 
 /// Returns the rank of the given ranked shaped type.
 MLIR_CAPI_EXPORTED int64_t mlirShapedTypeGetRank(MlirType type);
 
 /// Checks whether the given shaped type has a static shape.
-MLIR_CAPI_EXPORTED int mlirShapedTypeHasStaticShape(MlirType type);
+MLIR_CAPI_EXPORTED bool mlirShapedTypeHasStaticShape(MlirType type);
 
 /// Checks wither the dim-th dimension of the given shaped type is dynamic.
-MLIR_CAPI_EXPORTED int mlirShapedTypeIsDynamicDim(MlirType type, intptr_t dim);
+MLIR_CAPI_EXPORTED bool mlirShapedTypeIsDynamicDim(MlirType type, intptr_t dim);
 
 /// Returns the dim-th dimension of the given ranked shaped type.
 MLIR_CAPI_EXPORTED int64_t mlirShapedTypeGetDimSize(MlirType type,
                                                     intptr_t dim);
 
 /** Checks whether the given value is used as a placeholder for dynamic sizes
  * in shaped types. */
-MLIR_CAPI_EXPORTED int mlirShapedTypeIsDynamicSize(int64_t size);
+MLIR_CAPI_EXPORTED bool mlirShapedTypeIsDynamicSize(int64_t size);
 
 /** Checks whether the given value is used as a placeholder for dynamic strides
  * and offsets in shaped types. */
-MLIR_CAPI_EXPORTED int mlirShapedTypeIsDynamicStrideOrOffset(int64_t val);
+MLIR_CAPI_EXPORTED bool mlirShapedTypeIsDynamicStrideOrOffset(int64_t val);
 
 //===----------------------------------------------------------------------===//
 // Vector type.
 //===----------------------------------------------------------------------===//
 
 /// Checks whether the given type is a Vector type.
-MLIR_CAPI_EXPORTED int mlirTypeIsAVector(MlirType type);
+MLIR_CAPI_EXPORTED bool mlirTypeIsAVector(MlirType type);
 
 /** Creates a vector type of the shape identified by its rank and dimensions,
  * 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,
                                                      const int64_t *shape,
                                                      MlirType elementType,
                                                      MlirLocation loc);
 
 //===----------------------------------------------------------------------===//
 // Ranked / Unranked Tensor type.
 //===----------------------------------------------------------------------===//
 
 /// Checks whether the given type is a Tensor type.
-MLIR_CAPI_EXPORTED int mlirTypeIsATensor(MlirType type);
+MLIR_CAPI_EXPORTED bool mlirTypeIsATensor(MlirType type);
 
 /// Checks whether the given type is a ranked tensor type.
-MLIR_CAPI_EXPORTED int mlirTypeIsARankedTensor(MlirType type);
+MLIR_CAPI_EXPORTED bool mlirTypeIsARankedTensor(MlirType type);
 
 /// Checks whether the given type is an unranked tensor type.
-MLIR_CAPI_EXPORTED int mlirTypeIsAUnrankedTensor(MlirType 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

 MLIR_CAPI_EXPORTED MlirType
 mlirUnrankedTensorTypeGetChecked(MlirType elementType, MlirLocation loc);
 
 //===----------------------------------------------------------------------===//
 // Ranked / Unranked MemRef type.
 //===----------------------------------------------------------------------===//
 
 /// Checks whether the given type is a MemRef type.
-MLIR_CAPI_EXPORTED int mlirTypeIsAMemRef(MlirType type);
+MLIR_CAPI_EXPORTED bool mlirTypeIsAMemRef(MlirType type);
 
 /// Checks whether the given type is an UnrankedMemRef type.
-MLIR_CAPI_EXPORTED int mlirTypeIsAUnrankedMemRef(MlirType 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,
     MlirAttribute const *affineMaps, unsigned memorySpace);
 

 /// Returns the memory spcae of the given Unranked MemRef type.
 MLIR_CAPI_EXPORTED unsigned mlirUnrankedMemrefGetMemorySpace(MlirType type);
 
 //===----------------------------------------------------------------------===//
 // Tuple type.
 //===----------------------------------------------------------------------===//
 
 /// Checks whether the given type is a tuple type.
-MLIR_CAPI_EXPORTED int mlirTypeIsATuple(MlirType type);
+MLIR_CAPI_EXPORTED bool mlirTypeIsATuple(MlirType type);
 
 /** Creates a tuple type that consists of the given list of elemental types. The
  * type is owned by the context. */
 MLIR_CAPI_EXPORTED MlirType mlirTupleTypeGet(MlirContext ctx,
                                              intptr_t numElements,
                                              MlirType const *elements);
 
 /// Returns the number of types contained in a tuple.
 MLIR_CAPI_EXPORTED intptr_t mlirTupleTypeGetNumTypes(MlirType type);
 
 /// Returns the pos-th type in the tuple type.
 MLIR_CAPI_EXPORTED MlirType mlirTupleTypeGetType(MlirType type, intptr_t pos);
 
 //===----------------------------------------------------------------------===//
 // Function type.
 //===----------------------------------------------------------------------===//
 
 /// Checks whether the given type is a function type.
-MLIR_CAPI_EXPORTED int mlirTypeIsAFunction(MlirType type);
+MLIR_CAPI_EXPORTED bool mlirTypeIsAFunction(MlirType type);
 
 /// Creates a function type, mapping a list of input types to result types.
 MLIR_CAPI_EXPORTED MlirType mlirFunctionTypeGet(MlirContext ctx,
                                                 intptr_t numInputs,
                                                 MlirType const *inputs,
                                                 intptr_t numResults,
                                                 MlirType const *results);
 

mlir/include/mlir-c/Support.h

  * Instances of MlirLogicalResult must only be inspected using the associated
  * functions. */
 struct MlirLogicalResult {
   int8_t value;
 };
 typedef struct MlirLogicalResult MlirLogicalResult;
 
 /// Checks if the given logical result represents a success.
-inline static int mlirLogicalResultIsSuccess(MlirLogicalResult res) {
+inline static bool mlirLogicalResultIsSuccess(MlirLogicalResult res) {
   return res.value != 0;
 }
 
 /// Checks if the given logical result represents a failure.
-inline static int mlirLogicalResultIsFailure(MlirLogicalResult res) {
+inline static bool mlirLogicalResultIsFailure(MlirLogicalResult res) {
   return res.value == 0;
 }
 
 /// Creates a logical result representing a success.
 inline static MlirLogicalResult mlirLogicalResultSuccess() {
   MlirLogicalResult res = {1};
   return res;
 }

mlir/lib/Bindings/Python/IRModules.cpp

 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 = int (*)(MlirValue);
+  using IsAFunctionTy = bool (*)(MlirValue);
 
   PyConcreteValue() = default;
   PyConcreteValue(PyOperationRef operationRef, MlirValue value)
       : PyValue(operationRef, value) {}
   PyConcreteValue(PyValue &orig)
       : PyConcreteValue(orig.getParentOperation(), castFrom(orig)) {}
 
   /// Attempts to cast the original value to the derived type and throws on

 /// python-visible base classes can be modeled by specifying a BaseTy.
 template <typename DerivedTy, typename BaseTy = PyAttribute>
 class PyConcreteAttribute : public BaseTy {
 public:
   // Derived classes must define statics for:
   //   IsAFunctionTy isaFunction
   //   const char *pyClassName
   using ClassTy = py::class_<DerivedTy, BaseTy>;
-  using IsAFunctionTy = int (*)(MlirAttribute);
+  using IsAFunctionTy = bool (*)(MlirAttribute);
 
   PyConcreteAttribute() = default;
   PyConcreteAttribute(PyMlirContextRef contextRef, MlirAttribute attr)
       : BaseTy(std::move(contextRef), attr) {}
   PyConcreteAttribute(PyAttribute &orig)
       : PyConcreteAttribute(orig.getContext(), castFrom(orig)) {}
 
   static MlirAttribute castFrom(PyAttribute &orig) {

 /// base classes can be modeled by specifying a BaseTy.
 template <typename DerivedTy, typename BaseTy = PyType>
 class PyConcreteType : public BaseTy {
 public:
   // Derived classes must define statics for:
   //   IsAFunctionTy isaFunction
   //   const char *pyClassName
   using ClassTy = py::class_<DerivedTy, BaseTy>;
-  using IsAFunctionTy = int (*)(MlirType);
+  using IsAFunctionTy = bool (*)(MlirType);
 
   PyConcreteType() = default;
   PyConcreteType(PyMlirContextRef contextRef, MlirType t)
       : BaseTy(std::move(contextRef), t) {}
   PyConcreteType(PyType &orig)
       : PyConcreteType(orig.getContext(), castFrom(orig)) {}
 
   static MlirType castFrom(PyType &orig) {

mlir/lib/CAPI/IR/AffineExpr.cpp

void mlirAffineExprPrint(MlirAffineExpr affineExpr, MlirStringCallback callback,
   mlir::detail::CallbackOstream stream(callback, userData);
   unwrap(affineExpr).print(stream);
 }
 
 void mlirAffineExprDump(MlirAffineExpr affineExpr) {
   unwrap(affineExpr).dump();
 }
 
-int mlirAffineExprIsSymbolicOrConstant(MlirAffineExpr affineExpr) {
+bool mlirAffineExprIsSymbolicOrConstant(MlirAffineExpr affineExpr) {
   return unwrap(affineExpr).isSymbolicOrConstant();
 }
 
-int mlirAffineExprIsPureAffine(MlirAffineExpr affineExpr) {
+bool mlirAffineExprIsPureAffine(MlirAffineExpr affineExpr) {
   return unwrap(affineExpr).isPureAffine();
 }
 
 int64_t mlirAffineExprGetLargestKnownDivisor(MlirAffineExpr affineExpr) {
   return unwrap(affineExpr).getLargestKnownDivisor();
 }
 
-int mlirAffineExprIsMultipleOf(MlirAffineExpr affineExpr, int64_t factor) {
+bool mlirAffineExprIsMultipleOf(MlirAffineExpr affineExpr, int64_t factor) {
   return unwrap(affineExpr).isMultipleOf(factor);
 }
 
-int mlirAffineExprIsFunctionOfDim(MlirAffineExpr affineExpr,
+bool mlirAffineExprIsFunctionOfDim(MlirAffineExpr affineExpr,
                                    intptr_t position) {
   return unwrap(affineExpr).isFunctionOfDim(position);
 }
 
 //===----------------------------------------------------------------------===//
 // Affine Dimension Expression.
 //===----------------------------------------------------------------------===//
 
 MlirAffineExpr mlirAffineDimExprGet(MlirContext ctx, intptr_t position) {

 int64_t mlirAffineConstantExprGetValue(MlirAffineExpr affineExpr) {
   return unwrap(affineExpr).cast<AffineConstantExpr>().getValue();
 }
 
 //===----------------------------------------------------------------------===//
 // Affine Add Expression.
 //===----------------------------------------------------------------------===//
 
-int mlirAffineExprIsAAdd(MlirAffineExpr affineExpr) {
+bool mlirAffineExprIsAAdd(MlirAffineExpr affineExpr) {
   return unwrap(affineExpr).getKind() == mlir::AffineExprKind::Add;
 }
 
 MlirAffineExpr mlirAffineAddExprGet(MlirAffineExpr lhs, MlirAffineExpr rhs) {
   return wrap(getAffineBinaryOpExpr(mlir::AffineExprKind::Add, unwrap(lhs),
                                     unwrap(rhs)));
 }
 
 //===----------------------------------------------------------------------===//
 // Affine Mul Expression.
 //===----------------------------------------------------------------------===//
 
-int mlirAffineExprIsAMul(MlirAffineExpr affineExpr) {
+bool mlirAffineExprIsAMul(MlirAffineExpr affineExpr) {
   return unwrap(affineExpr).getKind() == mlir::AffineExprKind::Mul;
 }
 
 MlirAffineExpr mlirAffineMulExprGet(MlirAffineExpr lhs, MlirAffineExpr rhs) {
   return wrap(getAffineBinaryOpExpr(mlir::AffineExprKind::Mul, unwrap(lhs),
                                     unwrap(rhs)));
 }
 
 //===----------------------------------------------------------------------===//
 // Affine Mod Expression.
 //===----------------------------------------------------------------------===//
 
-int mlirAffineExprIsAMod(MlirAffineExpr affineExpr) {
+bool mlirAffineExprIsAMod(MlirAffineExpr affineExpr) {
   return unwrap(affineExpr).getKind() == mlir::AffineExprKind::Mod;
 }
 
 MlirAffineExpr mlirAffineModExprGet(MlirAffineExpr lhs, MlirAffineExpr rhs) {
   return wrap(getAffineBinaryOpExpr(mlir::AffineExprKind::Mod, unwrap(lhs),
                                     unwrap(rhs)));
 }
 
 //===----------------------------------------------------------------------===//
 // Affine FloorDiv Expression.
 //===----------------------------------------------------------------------===//
 
-int mlirAffineExprIsAFloorDiv(MlirAffineExpr affineExpr) {
+bool mlirAffineExprIsAFloorDiv(MlirAffineExpr affineExpr) {
   return unwrap(affineExpr).getKind() == mlir::AffineExprKind::FloorDiv;
 }
 
 MlirAffineExpr mlirAffineFloorDivExprGet(MlirAffineExpr lhs,
                                          MlirAffineExpr rhs) {
   return wrap(getAffineBinaryOpExpr(mlir::AffineExprKind::FloorDiv, unwrap(lhs),
                                     unwrap(rhs)));
 }
 
 //===----------------------------------------------------------------------===//
 // Affine CeilDiv Expression.
 //===----------------------------------------------------------------------===//
 
-int mlirAffineExprIsACeilDiv(MlirAffineExpr affineExpr) {
+bool mlirAffineExprIsACeilDiv(MlirAffineExpr affineExpr) {
   return unwrap(affineExpr).getKind() == mlir::AffineExprKind::CeilDiv;
 }
 
 MlirAffineExpr mlirAffineCeilDivExprGet(MlirAffineExpr lhs,
                                         MlirAffineExpr rhs) {
   return wrap(getAffineBinaryOpExpr(mlir::AffineExprKind::CeilDiv, unwrap(lhs),
                                     unwrap(rhs)));
 }

mlir/lib/CAPI/IR/AffineMap.cpp

 // TODO: expose the C API related to `AffineExpr` and mutable affine map.
 
 using namespace mlir;
 
 MlirContext mlirAffineMapGetContext(MlirAffineMap affineMap) {
   return wrap(unwrap(affineMap).getContext());
 }
 
-int mlirAffineMapEqual(MlirAffineMap a1, MlirAffineMap a2) {
+bool mlirAffineMapEqual(MlirAffineMap a1, MlirAffineMap a2) {
   return unwrap(a1) == unwrap(a2);
 }
 
 void mlirAffineMapPrint(MlirAffineMap affineMap, MlirStringCallback callback,
                         void *userData) {
   mlir::detail::CallbackOstream stream(callback, userData);
   unwrap(affineMap).print(stream);
 }

 }
 
 MlirAffineMap mlirAffineMapPermutationGet(MlirContext ctx, intptr_t size,
                                           unsigned *permutation) {
   return wrap(AffineMap::getPermutationMap(
       llvm::makeArrayRef(permutation, static_cast<size_t>(size)), unwrap(ctx)));
 }
 
-int mlirAffineMapIsIdentity(MlirAffineMap affineMap) {
+bool mlirAffineMapIsIdentity(MlirAffineMap affineMap) {
   return unwrap(affineMap).isIdentity();
 }
 
-int mlirAffineMapIsMinorIdentity(MlirAffineMap affineMap) {
+bool mlirAffineMapIsMinorIdentity(MlirAffineMap affineMap) {
   return unwrap(affineMap).isMinorIdentity();
 }
 
-int mlirAffineMapIsEmpty(MlirAffineMap affineMap) {
+bool mlirAffineMapIsEmpty(MlirAffineMap affineMap) {
   return unwrap(affineMap).isEmpty();
 }
 
-int mlirAffineMapIsSingleConstant(MlirAffineMap affineMap) {
+bool mlirAffineMapIsSingleConstant(MlirAffineMap affineMap) {
   return unwrap(affineMap).isSingleConstant();
 }
 
 int64_t mlirAffineMapGetSingleConstantResult(MlirAffineMap affineMap) {
   return unwrap(affineMap).getSingleConstantResult();
 }
 
 intptr_t mlirAffineMapGetNumDims(MlirAffineMap affineMap) {
   return unwrap(affineMap).getNumDims();
 }
 
 intptr_t mlirAffineMapGetNumSymbols(MlirAffineMap affineMap) {
   return unwrap(affineMap).getNumSymbols();
 }
 
 intptr_t mlirAffineMapGetNumResults(MlirAffineMap affineMap) {
   return unwrap(affineMap).getNumResults();
 }
 
 intptr_t mlirAffineMapGetNumInputs(MlirAffineMap affineMap) {
   return unwrap(affineMap).getNumInputs();
 }
 
-int mlirAffineMapIsProjectedPermutation(MlirAffineMap affineMap) {
+bool mlirAffineMapIsProjectedPermutation(MlirAffineMap affineMap) {
   return unwrap(affineMap).isProjectedPermutation();
 }
 
-int mlirAffineMapIsPermutation(MlirAffineMap affineMap) {
+bool mlirAffineMapIsPermutation(MlirAffineMap affineMap) {
   return unwrap(affineMap).isPermutation();
 }
 
 MlirAffineMap mlirAffineMapGetSubMap(MlirAffineMap affineMap, intptr_t size,
                                      intptr_t *resultPos) {
   SmallVector<unsigned, 8> pos;
   pos.reserve(size);
   for (intptr_t i = 0; i < size; ++i)

mlir/lib/CAPI/IR/IR.cpp

 }
 
 bool mlirContextEqual(MlirContext ctx1, MlirContext ctx2) {
   return unwrap(ctx1) == unwrap(ctx2);
 }
 
 void mlirContextDestroy(MlirContext context) { delete unwrap(context); }
 
-void mlirContextSetAllowUnregisteredDialects(MlirContext context, int allow) {
+void mlirContextSetAllowUnregisteredDialects(MlirContext context, bool allow) {
   unwrap(context)->allowUnregisteredDialects(allow);
 }
 
-int mlirContextGetAllowUnregisteredDialects(MlirContext context) {
+bool mlirContextGetAllowUnregisteredDialects(MlirContext context) {
   return unwrap(context)->allowsUnregisteredDialects();
 }
 intptr_t mlirContextGetNumRegisteredDialects(MlirContext context) {
   return static_cast<intptr_t>(unwrap(context)->getAvailableDialects().size());
 }
 
 // TODO: expose a cheaper way than constructing + sorting a vector only to take
 // its size.

 }
 
 void mlirOpPrintingFlagsElideLargeElementsAttrs(MlirOpPrintingFlags flags,
                                                 intptr_t largeElementLimit) {
   unwrap(flags)->elideLargeElementsAttrs(largeElementLimit);
 }
 
 void mlirOpPrintingFlagsEnableDebugInfo(MlirOpPrintingFlags flags,
-                                        int prettyForm) {
+                                        bool prettyForm) {
   unwrap(flags)->enableDebugInfo(/*prettyForm=*/prettyForm);
 }
 
 void mlirOpPrintingFlagsPrintGenericOpForm(MlirOpPrintingFlags flags) {
   unwrap(flags)->printGenericOpForm();
 }
 
 void mlirOpPrintingFlagsUseLocalScope(MlirOpPrintingFlags flags) {
MlirLocation mlirLocationFileLineColGet(MlirContext context,
   return wrap(
       FileLineColLoc::get(unwrap(filename), line, col, unwrap(context)));
 }
 
 MlirLocation mlirLocationUnknownGet(MlirContext context) {
   return wrap(UnknownLoc::get(unwrap(context)));
 }
 
-int mlirLocationEqual(MlirLocation l1, MlirLocation l2) {
+bool mlirLocationEqual(MlirLocation l1, MlirLocation l2) {
   return unwrap(l1) == unwrap(l2);
 }
 
 MlirContext mlirLocationGetContext(MlirLocation location) {
   return wrap(unwrap(location).getContext());
 }
 
 void mlirLocationPrint(MlirLocation location, MlirStringCallback callback,
MlirAttribute mlirOperationGetAttributeByName(MlirOperation op,
   return wrap(unwrap(op)->getAttr(unwrap(name)));
 }
 
 void mlirOperationSetAttributeByName(MlirOperation op, MlirStringRef name,
                                      MlirAttribute attr) {
   unwrap(op)->setAttr(unwrap(name), unwrap(attr));
 }
 
-int mlirOperationRemoveAttributeByName(MlirOperation op, MlirStringRef name) {
+bool mlirOperationRemoveAttributeByName(MlirOperation op, MlirStringRef name) {
   auto removeResult = unwrap(op)->removeAttr(unwrap(name));
   return removeResult == MutableDictionaryAttr::RemoveResult::Removed;
 }
 
 void mlirOperationPrint(MlirOperation op, MlirStringCallback callback,
                         void *userData) {
   detail::CallbackOstream stream(callback, userData);
   unwrap(op)->print(stream);

 //===----------------------------------------------------------------------===//
 // Value API.
 //===----------------------------------------------------------------------===//
 
 bool mlirValueEqual(MlirValue value1, MlirValue value2) {
   return unwrap(value1) == unwrap(value2);
 }
 
-int mlirValueIsABlockArgument(MlirValue value) {
+bool mlirValueIsABlockArgument(MlirValue value) {
   return unwrap(value).isa<BlockArgument>();
 }
 
-int mlirValueIsAOpResult(MlirValue value) {
+bool mlirValueIsAOpResult(MlirValue value) {
   return unwrap(value).isa<OpResult>();
 }
 
 MlirBlock mlirBlockArgumentGetOwner(MlirValue value) {
   return wrap(unwrap(value).cast<BlockArgument>().getOwner());
 }
 
 intptr_t mlirBlockArgumentGetArgNumber(MlirValue value) {

mlir/lib/CAPI/IR/StandardAttributes.cpp

 #include "mlir/IR/StandardTypes.h"
 
 using namespace mlir;
 
 //===----------------------------------------------------------------------===//
 // Affine map attribute.
 //===----------------------------------------------------------------------===//
 
-int mlirAttributeIsAAffineMap(MlirAttribute attr) {
+bool mlirAttributeIsAAffineMap(MlirAttribute attr) {
   return unwrap(attr).isa<AffineMapAttr>();
 }
 
 MlirAttribute mlirAffineMapAttrGet(MlirAffineMap map) {
   return wrap(AffineMapAttr::get(unwrap(map)));
 }
 
 MlirAffineMap mlirAffineMapAttrGetValue(MlirAttribute attr) {
   return wrap(unwrap(attr).cast<AffineMapAttr>().getValue());
 }
 
 //===----------------------------------------------------------------------===//
 // Array attribute.
 //===----------------------------------------------------------------------===//
 
-int mlirAttributeIsAArray(MlirAttribute attr) {
+bool mlirAttributeIsAArray(MlirAttribute attr) {
   return unwrap(attr).isa<ArrayAttr>();
 }
 
 MlirAttribute mlirArrayAttrGet(MlirContext ctx, intptr_t numElements,
                                MlirAttribute const *elements) {
   SmallVector<Attribute, 8> attrs;
   return wrap(ArrayAttr::get(
       unwrapList(static_cast<size_t>(numElements), elements, attrs),
       unwrap(ctx)));
 }
 
 intptr_t mlirArrayAttrGetNumElements(MlirAttribute attr) {
   return static_cast<intptr_t>(unwrap(attr).cast<ArrayAttr>().size());
 }
 
 MlirAttribute mlirArrayAttrGetElement(MlirAttribute attr, intptr_t pos) {
   return wrap(unwrap(attr).cast<ArrayAttr>().getValue()[pos]);
 }
 
 //===----------------------------------------------------------------------===//
 // Dictionary attribute.
 //===----------------------------------------------------------------------===//
 
-int mlirAttributeIsADictionary(MlirAttribute attr) {
+bool mlirAttributeIsADictionary(MlirAttribute attr) {
   return unwrap(attr).isa<DictionaryAttr>();
 }
 
 MlirAttribute mlirDictionaryAttrGet(MlirContext ctx, intptr_t numElements,
                                     MlirNamedAttribute const *elements) {
   SmallVector<NamedAttribute, 8> attributes;
   attributes.reserve(numElements);
   for (intptr_t i = 0; i < numElements; ++i)
MlirAttribute mlirDictionaryAttrGetElementByName(MlirAttribute attr,
                                                  const char *name) {
   return wrap(unwrap(attr).cast<DictionaryAttr>().get(name));
 }
 
 //===----------------------------------------------------------------------===//
 // Floating point attribute.
 //===----------------------------------------------------------------------===//
 
-int mlirAttributeIsAFloat(MlirAttribute attr) {
+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)));
 }
 
 double mlirFloatAttrGetValueDouble(MlirAttribute attr) {
   return unwrap(attr).cast<FloatAttr>().getValueAsDouble();
 }
 
 //===----------------------------------------------------------------------===//
 // Integer attribute.
 //===----------------------------------------------------------------------===//
 
-int mlirAttributeIsAInteger(MlirAttribute attr) {
+bool mlirAttributeIsAInteger(MlirAttribute attr) {
   return unwrap(attr).isa<IntegerAttr>();
 }
 
 MlirAttribute mlirIntegerAttrGet(MlirType type, int64_t value) {
   return wrap(IntegerAttr::get(unwrap(type), value));
 }
 
 int64_t mlirIntegerAttrGetValueInt(MlirAttribute attr) {
   return unwrap(attr).cast<IntegerAttr>().getInt();
 }
 
 //===----------------------------------------------------------------------===//
 // Bool attribute.
 //===----------------------------------------------------------------------===//
 
-int mlirAttributeIsABool(MlirAttribute attr) {
+bool mlirAttributeIsABool(MlirAttribute attr) {
   return unwrap(attr).isa<BoolAttr>();
 }
 
 MlirAttribute mlirBoolAttrGet(MlirContext ctx, int value) {
   return wrap(BoolAttr::get(value, unwrap(ctx)));
 }
 
-int mlirBoolAttrGetValue(MlirAttribute attr) {
+bool mlirBoolAttrGetValue(MlirAttribute attr) {
   return unwrap(attr).cast<BoolAttr>().getValue();
 }
 
 //===----------------------------------------------------------------------===//
 // Integer set attribute.
 //===----------------------------------------------------------------------===//
 
-int mlirAttributeIsAIntegerSet(MlirAttribute attr) {
+bool mlirAttributeIsAIntegerSet(MlirAttribute attr) {
   return unwrap(attr).isa<IntegerSetAttr>();
 }
 
 //===----------------------------------------------------------------------===//
 // Opaque attribute.
 //===----------------------------------------------------------------------===//
 
-int mlirAttributeIsAOpaque(MlirAttribute attr) {
+bool mlirAttributeIsAOpaque(MlirAttribute attr) {
   return unwrap(attr).isa<OpaqueAttr>();
 }
 
 MlirAttribute mlirOpaqueAttrGet(MlirContext ctx, const char *dialectNamespace,
                                 intptr_t dataLength, const char *data,
                                 MlirType type) {
   return wrap(OpaqueAttr::get(Identifier::get(dialectNamespace, unwrap(ctx)),
                               StringRef(data, dataLength), unwrap(type),
                               unwrap(ctx)));
 }
 
 const char *mlirOpaqueAttrGetDialectNamespace(MlirAttribute attr) {
   return unwrap(attr).cast<OpaqueAttr>().getDialectNamespace().c_str();
 }
 
 MlirStringRef mlirOpaqueAttrGetData(MlirAttribute attr) {
   return wrap(unwrap(attr).cast<OpaqueAttr>().getAttrData());
 }
 
 //===----------------------------------------------------------------------===//
 // String attribute.
 //===----------------------------------------------------------------------===//
 
-int mlirAttributeIsAString(MlirAttribute attr) {
+bool mlirAttributeIsAString(MlirAttribute attr) {
   return unwrap(attr).isa<StringAttr>();
 }
 
 MlirAttribute mlirStringAttrGet(MlirContext ctx, intptr_t length,
                                 const char *data) {
   return wrap(StringAttr::get(StringRef(data, length), unwrap(ctx)));
 }
 
 MlirAttribute mlirStringAttrTypedGet(MlirType type, intptr_t length,
                                      const char *data) {
   return wrap(StringAttr::get(StringRef(data, length), unwrap(type)));
 }
 
 MlirStringRef mlirStringAttrGetValue(MlirAttribute attr) {
   return wrap(unwrap(attr).cast<StringAttr>().getValue());
 }
 
 //===----------------------------------------------------------------------===//
 // SymbolRef attribute.
 //===----------------------------------------------------------------------===//
 
-int mlirAttributeIsASymbolRef(MlirAttribute attr) {
+bool mlirAttributeIsASymbolRef(MlirAttribute attr) {
   return unwrap(attr).isa<SymbolRefAttr>();
 }
 
 MlirAttribute mlirSymbolRefAttrGet(MlirContext ctx, intptr_t length,
                                    const char *symbol, intptr_t numReferences,
                                    MlirAttribute const *references) {
   SmallVector<FlatSymbolRefAttr, 4> refs;
   refs.reserve(numReferences);
MlirAttribute mlirSymbolRefAttrGetNestedReference(MlirAttribute attr,
                                                   intptr_t pos) {
   return wrap(unwrap(attr).cast<SymbolRefAttr>().getNestedReferences()[pos]);
 }
 
 //===----------------------------------------------------------------------===//
 // Flat SymbolRef attribute.
 //===----------------------------------------------------------------------===//
 
-int mlirAttributeIsAFlatSymbolRef(MlirAttribute attr) {
+bool mlirAttributeIsAFlatSymbolRef(MlirAttribute attr) {
   return unwrap(attr).isa<FlatSymbolRefAttr>();
 }
 
 MlirAttribute mlirFlatSymbolRefAttrGet(MlirContext ctx, intptr_t length,
                                        const char *symbol) {
   return wrap(FlatSymbolRefAttr::get(StringRef(symbol, length), unwrap(ctx)));
 }
 
 MlirStringRef mlirFlatSymbolRefAttrGetValue(MlirAttribute attr) {
   return wrap(unwrap(attr).cast<FlatSymbolRefAttr>().getValue());
 }
 
 //===----------------------------------------------------------------------===//
 // Type attribute.
 //===----------------------------------------------------------------------===//
 
-int mlirAttributeIsAType(MlirAttribute attr) {
+bool mlirAttributeIsAType(MlirAttribute attr) {
   return unwrap(attr).isa<TypeAttr>();
 }
 
 MlirAttribute mlirTypeAttrGet(MlirType type) {
   return wrap(TypeAttr::get(unwrap(type)));
 }
 
 MlirType mlirTypeAttrGetValue(MlirAttribute attr) {
   return wrap(unwrap(attr).cast<TypeAttr>().getValue());
 }
 
 //===----------------------------------------------------------------------===//
 // Unit attribute.
 //===----------------------------------------------------------------------===//
 
-int mlirAttributeIsAUnit(MlirAttribute attr) {
+bool mlirAttributeIsAUnit(MlirAttribute attr) {
   return unwrap(attr).isa<UnitAttr>();
 }
 
 MlirAttribute mlirUnitAttrGet(MlirContext ctx) {
   return wrap(UnitAttr::get(unwrap(ctx)));
 }
 
 //===----------------------------------------------------------------------===//
 // Elements attributes.
 //===----------------------------------------------------------------------===//
 
-int mlirAttributeIsAElements(MlirAttribute attr) {
+bool mlirAttributeIsAElements(MlirAttribute attr) {
   return unwrap(attr).isa<ElementsAttr>();
 }
 
 MlirAttribute mlirElementsAttrGetValue(MlirAttribute attr, intptr_t rank,
                                        uint64_t *idxs) {
   return wrap(unwrap(attr).cast<ElementsAttr>().getValue(
       llvm::makeArrayRef(idxs, rank)));
 }
 
-int mlirElementsAttrIsValidIndex(MlirAttribute attr, intptr_t rank,
+bool mlirElementsAttrIsValidIndex(MlirAttribute attr, intptr_t rank,
                                   uint64_t *idxs) {
   return unwrap(attr).cast<ElementsAttr>().isValidIndex(
       llvm::makeArrayRef(idxs, rank));
 }
 
 int64_t mlirElementsAttrGetNumElements(MlirAttribute attr) {
   return unwrap(attr).cast<ElementsAttr>().getNumElements();
 }
 
 //===----------------------------------------------------------------------===//
 // Dense elements attribute.
 //===----------------------------------------------------------------------===//
 
 //===----------------------------------------------------------------------===//
 // IsA support.
 
-int mlirAttributeIsADenseElements(MlirAttribute attr) {
+bool mlirAttributeIsADenseElements(MlirAttribute attr) {
   return unwrap(attr).isa<DenseElementsAttr>();
 }
-int mlirAttributeIsADenseIntElements(MlirAttribute attr) {
+bool mlirAttributeIsADenseIntElements(MlirAttribute attr) {
   return unwrap(attr).isa<DenseIntElementsAttr>();
 }
-int mlirAttributeIsADenseFPElements(MlirAttribute attr) {
+bool mlirAttributeIsADenseFPElements(MlirAttribute attr) {
   return unwrap(attr).isa<DenseFPElementsAttr>();
 }
 
 //===----------------------------------------------------------------------===//
 // Constructors.
 
 MlirAttribute mlirDenseElementsAttrGet(MlirType shapedType,
                                        intptr_t numElements,
                                        MlirAttribute const *elements) {
   SmallVector<Attribute, 8> attributes;
   return wrap(
       DenseElementsAttr::get(unwrap(shapedType).cast<ShapedType>(),
                              unwrapList(numElements, elements, attributes)));
 }
 
 MlirAttribute mlirDenseElementsAttrSplatGet(MlirType shapedType,
                                             MlirAttribute element) {
   return wrap(DenseElementsAttr::get(unwrap(shapedType).cast<ShapedType>(),
                                      unwrap(element)));
 }
 MlirAttribute mlirDenseElementsAttrBoolSplatGet(MlirType shapedType,
-                                                int element) {
-  return wrap(DenseElementsAttr::get(unwrap(shapedType).cast<ShapedType>(),
-                                     static_cast<bool>(element)));
+                                                bool element) {
+  return wrap(
+      DenseElementsAttr::get(unwrap(shapedType).cast<ShapedType>(), element));
 }
 MlirAttribute mlirDenseElementsAttrUInt32SplatGet(MlirType shapedType,
                                                   uint32_t element) {
   return wrap(
       DenseElementsAttr::get(unwrap(shapedType).cast<ShapedType>(), element));
 }
 MlirAttribute mlirDenseElementsAttrInt32SplatGet(MlirType shapedType,
                                                  int32_t element) {
MlirAttribute mlirDenseElementsAttrReshapeGet(MlirAttribute attr,
                                               MlirType shapedType) {
   return wrap(unwrap(attr).cast<DenseElementsAttr>().reshape(
       unwrap(shapedType).cast<ShapedType>()));
 }
 
 //===----------------------------------------------------------------------===//
 // Splat accessors.
 
-int mlirDenseElementsAttrIsSplat(MlirAttribute attr) {
+bool mlirDenseElementsAttrIsSplat(MlirAttribute attr) {
   return unwrap(attr).cast<DenseElementsAttr>().isSplat();
 }
 
 MlirAttribute mlirDenseElementsAttrGetSplatValue(MlirAttribute attr) {
   return wrap(unwrap(attr).cast<DenseElementsAttr>().getSplatValue());
 }
 int mlirDenseElementsAttrGetBoolSplatValue(MlirAttribute attr) {
   return unwrap(attr).cast<DenseElementsAttr>().getSplatValue<bool>();

 MlirStringRef mlirDenseElementsAttrGetStringSplatValue(MlirAttribute attr) {
   return wrap(
       unwrap(attr).cast<DenseElementsAttr>().getSplatValue<StringRef>());
 }
 
 //===----------------------------------------------------------------------===//
 // Indexed accessors.
 
-int mlirDenseElementsAttrGetBoolValue(MlirAttribute attr, intptr_t pos) {
+bool mlirDenseElementsAttrGetBoolValue(MlirAttribute attr, intptr_t pos) {
   return *(unwrap(attr).cast<DenseElementsAttr>().getValues<bool>().begin() +
            pos);
 }
 int32_t mlirDenseElementsAttrGetInt32Value(MlirAttribute attr, intptr_t pos) {
   return *(unwrap(attr).cast<DenseElementsAttr>().getValues<int32_t>().begin() +
            pos);
 }
 uint32_t mlirDenseElementsAttrGetUInt32Value(MlirAttribute attr, intptr_t pos) {
const void *mlirDenseElementsAttrGetRawData(MlirAttribute attr) {
   return static_cast<const void *>(
       unwrap(attr).cast<DenseElementsAttr>().getRawData().data());
 }
 
 //===----------------------------------------------------------------------===//
 // Opaque elements attribute.
 //===----------------------------------------------------------------------===//
 
-int mlirAttributeIsAOpaqueElements(MlirAttribute attr) {
+bool mlirAttributeIsAOpaqueElements(MlirAttribute attr) {
   return unwrap(attr).isa<OpaqueElementsAttr>();
 }
 
 //===----------------------------------------------------------------------===//
 // Sparse elements attribute.
 //===----------------------------------------------------------------------===//
 
-int mlirAttributeIsASparseElements(MlirAttribute attr) {
+bool mlirAttributeIsASparseElements(MlirAttribute attr) {
   return unwrap(attr).isa<SparseElementsAttr>();
 }
 
 MlirAttribute mlirSparseElementsAttribute(MlirType shapedType,
                                           MlirAttribute denseIndices,
                                           MlirAttribute denseValues) {
   return wrap(
       SparseElementsAttr::get(unwrap(shapedType).cast<ShapedType>(),

mlir/lib/CAPI/IR/StandardTypes.cpp

 #include "mlir/IR/Types.h"
 
 using namespace mlir;
 
 //===----------------------------------------------------------------------===//
 // Integer types.
 //===----------------------------------------------------------------------===//
 
-int mlirTypeIsAInteger(MlirType type) {
+bool mlirTypeIsAInteger(MlirType type) {
   return unwrap(type).isa<IntegerType>();
 }
 
 MlirType mlirIntegerTypeGet(MlirContext ctx, unsigned bitwidth) {
   return wrap(IntegerType::get(bitwidth, unwrap(ctx)));
 }
 
 MlirType mlirIntegerTypeSignedGet(MlirContext ctx, unsigned bitwidth) {
   return wrap(IntegerType::get(bitwidth, IntegerType::Signed, unwrap(ctx)));
 }
 
 MlirType mlirIntegerTypeUnsignedGet(MlirContext ctx, unsigned bitwidth) {
   return wrap(IntegerType::get(bitwidth, IntegerType::Unsigned, unwrap(ctx)));
 }
 
 unsigned mlirIntegerTypeGetWidth(MlirType type) {
   return unwrap(type).cast<IntegerType>().getWidth();
 }
 
-int mlirIntegerTypeIsSignless(MlirType type) {
+bool mlirIntegerTypeIsSignless(MlirType type) {
   return unwrap(type).cast<IntegerType>().isSignless();
 }
 
-int mlirIntegerTypeIsSigned(MlirType type) {
+bool mlirIntegerTypeIsSigned(MlirType type) {
   return unwrap(type).cast<IntegerType>().isSigned();
 }
 
-int mlirIntegerTypeIsUnsigned(MlirType type) {
+bool mlirIntegerTypeIsUnsigned(MlirType type) {
   return unwrap(type).cast<IntegerType>().isUnsigned();
 }
 
 //===----------------------------------------------------------------------===//
 // Index type.
 //===----------------------------------------------------------------------===//
 
-int mlirTypeIsAIndex(MlirType type) { return unwrap(type).isa<IndexType>(); }
+bool mlirTypeIsAIndex(MlirType type) { return unwrap(type).isa<IndexType>(); }
 
 MlirType mlirIndexTypeGet(MlirContext ctx) {
   return wrap(IndexType::get(unwrap(ctx)));
 }
 
 //===----------------------------------------------------------------------===//
 // Floating-point types.
 //===----------------------------------------------------------------------===//
 
-int mlirTypeIsABF16(MlirType type) { return unwrap(type).isBF16(); }
+bool mlirTypeIsABF16(MlirType type) { return unwrap(type).isBF16(); }
 
 MlirType mlirBF16TypeGet(MlirContext ctx) {
   return wrap(FloatType::getBF16(unwrap(ctx)));
 }
 
-int mlirTypeIsAF16(MlirType type) { return unwrap(type).isF16(); }
+bool mlirTypeIsAF16(MlirType type) { return unwrap(type).isF16(); }
 
 MlirType mlirF16TypeGet(MlirContext ctx) {
   return wrap(FloatType::getF16(unwrap(ctx)));
 }
 
-int mlirTypeIsAF32(MlirType type) { return unwrap(type).isF32(); }
+bool mlirTypeIsAF32(MlirType type) { return unwrap(type).isF32(); }
 
 MlirType mlirF32TypeGet(MlirContext ctx) {
   return wrap(FloatType::getF32(unwrap(ctx)));
 }
 
-int mlirTypeIsAF64(MlirType type) { return unwrap(type).isF64(); }
+bool mlirTypeIsAF64(MlirType type) { return unwrap(type).isF64(); }
 
 MlirType mlirF64TypeGet(MlirContext ctx) {
   return wrap(FloatType::getF64(unwrap(ctx)));
 }
 
 //===----------------------------------------------------------------------===//
 // None type.
 //===----------------------------------------------------------------------===//
 
-int mlirTypeIsANone(MlirType type) { return unwrap(type).isa<NoneType>(); }
+bool mlirTypeIsANone(MlirType type) { return unwrap(type).isa<NoneType>(); }
 
 MlirType mlirNoneTypeGet(MlirContext ctx) {
   return wrap(NoneType::get(unwrap(ctx)));
 }
 
 //===----------------------------------------------------------------------===//
 // Complex type.
 //===----------------------------------------------------------------------===//
 
-int mlirTypeIsAComplex(MlirType type) {
+bool mlirTypeIsAComplex(MlirType type) {
   return unwrap(type).isa<ComplexType>();
 }
 
 MlirType mlirComplexTypeGet(MlirType elementType) {
   return wrap(ComplexType::get(unwrap(elementType)));
 }
 
 MlirType mlirComplexTypeGetElementType(MlirType type) {
   return wrap(unwrap(type).cast<ComplexType>().getElementType());
 }
 
 //===----------------------------------------------------------------------===//
 // Shaped type.
 //===----------------------------------------------------------------------===//
 
-int mlirTypeIsAShaped(MlirType type) { return unwrap(type).isa<ShapedType>(); }
+bool mlirTypeIsAShaped(MlirType type) { return unwrap(type).isa<ShapedType>(); }
 
 MlirType mlirShapedTypeGetElementType(MlirType type) {
   return wrap(unwrap(type).cast<ShapedType>().getElementType());
 }
 
-int mlirShapedTypeHasRank(MlirType type) {
+bool mlirShapedTypeHasRank(MlirType type) {
   return unwrap(type).cast<ShapedType>().hasRank();
 }
 
 int64_t mlirShapedTypeGetRank(MlirType type) {
   return unwrap(type).cast<ShapedType>().getRank();
 }
 
-int mlirShapedTypeHasStaticShape(MlirType type) {
+bool mlirShapedTypeHasStaticShape(MlirType type) {
   return unwrap(type).cast<ShapedType>().hasStaticShape();
 }
 
-int mlirShapedTypeIsDynamicDim(MlirType type, intptr_t dim) {
+bool mlirShapedTypeIsDynamicDim(MlirType type, intptr_t dim) {
   return unwrap(type).cast<ShapedType>().isDynamicDim(
       static_cast<unsigned>(dim));
 }
 
 int64_t mlirShapedTypeGetDimSize(MlirType type, intptr_t dim) {
   return unwrap(type).cast<ShapedType>().getDimSize(static_cast<unsigned>(dim));
 }
 
-int mlirShapedTypeIsDynamicSize(int64_t size) {
+bool mlirShapedTypeIsDynamicSize(int64_t size) {
   return ShapedType::isDynamic(size);
 }
 
-int mlirShapedTypeIsDynamicStrideOrOffset(int64_t val) {
+bool mlirShapedTypeIsDynamicStrideOrOffset(int64_t val) {
   return ShapedType::isDynamicStrideOrOffset(val);
 }
 
 //===----------------------------------------------------------------------===//
 // Vector type.
 //===----------------------------------------------------------------------===//
 
-int mlirTypeIsAVector(MlirType type) { return unwrap(type).isa<VectorType>(); }
+bool mlirTypeIsAVector(MlirType type) { return unwrap(type).isa<VectorType>(); }
 
 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) {
   return wrap(VectorType::getChecked(
       llvm::makeArrayRef(shape, static_cast<size_t>(rank)), unwrap(elementType),
       unwrap(loc)));
 }
 
 //===----------------------------------------------------------------------===//
 // Ranked / Unranked tensor type.
 //===----------------------------------------------------------------------===//
 
-int mlirTypeIsATensor(MlirType type) { return unwrap(type).isa<TensorType>(); }
+bool mlirTypeIsATensor(MlirType type) { return unwrap(type).isa<TensorType>(); }
 
-int mlirTypeIsARankedTensor(MlirType type) {
+bool mlirTypeIsARankedTensor(MlirType type) {
   return unwrap(type).isa<RankedTensorType>();
 }
 
-int mlirTypeIsAUnrankedTensor(MlirType type) {
+bool mlirTypeIsAUnrankedTensor(MlirType type) {
   return unwrap(type).isa<UnrankedTensorType>();
 }
 
 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 mlirUnrankedTensorTypeGetChecked(MlirType elementType,
                                           MlirLocation loc) {
   return wrap(UnrankedTensorType::getChecked(unwrap(elementType), unwrap(loc)));
 }
 
 //===----------------------------------------------------------------------===//
 // Ranked / Unranked MemRef type.
 //===----------------------------------------------------------------------===//
 
-int mlirTypeIsAMemRef(MlirType type) { return unwrap(type).isa<MemRefType>(); }
+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(

 MlirAffineMap mlirMemRefTypeGetAffineMap(MlirType type, intptr_t pos) {
   return wrap(unwrap(type).cast<MemRefType>().getAffineMaps()[pos]);
 }
 
 unsigned mlirMemRefTypeGetMemorySpace(MlirType type) {
   return unwrap(type).cast<MemRefType>().getMemorySpace();
 }
 
-int mlirTypeIsAUnrankedMemRef(MlirType type) {
+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) {
   return wrap(UnrankedMemRefType::getChecked(unwrap(elementType), memorySpace,
                                              unwrap(loc)));
 }
 
 unsigned mlirUnrankedMemrefGetMemorySpace(MlirType type) {
   return unwrap(type).cast<UnrankedMemRefType>().getMemorySpace();
 }
 
 //===----------------------------------------------------------------------===//
 // Tuple type.
 //===----------------------------------------------------------------------===//
 
-int mlirTypeIsATuple(MlirType type) { return unwrap(type).isa<TupleType>(); }
+bool mlirTypeIsATuple(MlirType type) { return unwrap(type).isa<TupleType>(); }
 
 MlirType mlirTupleTypeGet(MlirContext ctx, intptr_t numElements,
                           MlirType const *elements) {
   SmallVector<Type, 4> types;
   ArrayRef<Type> typeRef = unwrapList(numElements, elements, types);
   return wrap(TupleType::get(typeRef, unwrap(ctx)));
 }
 
 intptr_t mlirTupleTypeGetNumTypes(MlirType type) {
   return unwrap(type).cast<TupleType>().size();
 }
 
 MlirType mlirTupleTypeGetType(MlirType type, intptr_t pos) {
   return wrap(unwrap(type).cast<TupleType>().getType(static_cast<size_t>(pos)));
 }
 
 //===----------------------------------------------------------------------===//
 // Function type.
 //===----------------------------------------------------------------------===//
 
-int mlirTypeIsAFunction(MlirType type) {
+bool mlirTypeIsAFunction(MlirType type) {
   return unwrap(type).isa<FunctionType>();
 }
 
 MlirType mlirFunctionTypeGet(MlirContext ctx, intptr_t numInputs,
                              MlirType const *inputs, intptr_t numResults,
                              MlirType const *results) {
   SmallVector<Type, 4> inputsList;
   SmallVector<Type, 4> resultsList;

mlir/test/Bindings/Python/ir_attributes.py

 
 run(testIntegerAttr)
 
 
 # CHECK-LABEL: TEST: testBoolAttr
 def testBoolAttr():
   with Context() as ctx:
     battr = BoolAttr(Attribute.parse("true"))
-    # CHECK: iattr value: 1
+    # CHECK: iattr value: True
     print("iattr value:", battr.value)
 
     # Test factory methods.
     # CHECK: default_get: true
     print("default_get:", BoolAttr.get(True))
 
 run(testBoolAttr)