[mlir][ods] Improve integer signedness modelling

[antiagainst]

Summary

A previous commit added support for integer signedness in C++
IntegerType. This change introduces ODS definitions for
integer types and integer (element) attributes w.r.t. signedness.

This commit also updates various existing definitions' descriptions
to mention signless where suitable to make it more clear.

Positive and non-negative integer attributes are removed to avoid
the explosion of subclasses. Instead, one should use more atmoic
constraints together with Confined to model that. For example,
Confined<..., [IntPositive]>.

[rriddle]

Thanks Lei!

mlir/include/mlir/Dialect/LLVMIR/LLVMOps.td

569

IMO: we should cleanup all of these definitions to not use Arguments. It is much much cleaner.

mlir/include/mlir/IR/OpBase.td

381

nit: Move the signed before the unsigned.

859

nit: Move the signed before the unsigned.

[mravishankar]

Just a minor comment on the SPIR-V side.

mlir/include/mlir/Dialect/SPIRV/SPIRVBase.td

66

Do we want to used unsigned attribute here, i.e UI32Attr.

[antiagainst]

Reorder

[antiagainst]

mlir/include/mlir/Dialect/LLVMIR/LLVMOps.td

569

I agree. This one is a bit extreme given we have many fields already. But I'll leave that to @ftynse to decide.

mlir/include/mlir/Dialect/SPIRV/SPIRVBase.td

66

Core EnumAttr and EnumAttrCase is still based on signless integers; this is to be consistent there given we are just simplifying the verifications for the known case comparison.

mlir/include/mlir/Dialect/LLVMIR/LLVMOps.td

def LLVM_AddressOfOp
 
   let assemblyFormat = "$global_name attr-dict `:` type($res)";
   let verifier = "return ::verify(*this);";
 }
 
 def LLVM_GlobalOp
     : LLVM_ZeroResultOp<"mlir.global",
                         [IsolatedFromAbove,
-                         SingleBlockImplicitTerminator<"ReturnOp">, Symbol]>,
-      Arguments<(ins TypeAttr:$type, UnitAttr:$constant, StrAttr:$sym_name,
-                 Linkage:$linkage,
-                 OptionalAttr<AnyAttr>:$value,
-                 DefaultValuedAttr<NonNegativeI32Attr, "0">:$addr_space)> {
+                         SingleBlockImplicitTerminator<"ReturnOp">, Symbol]> {
+  let arguments = (ins
+    TypeAttr:$type,
+    UnitAttr:$constant,
+    StrAttr:$sym_name,
+    DefaultValuedAttr<Confined<I32Attr, [IntNonNegative]>, "0">:$addr_space
+  );
   let summary = "LLVM dialect global.";
   let description = [{
     Can contain an optional initializer region or attribute for simple
     initializers.
 
     Examples:
       // Initialized using an attribute.
       llvm.mlir.global @a("abc") : !llvm<"[3 x i8]">

mlir/include/mlir/Dialect/SPIRV/SPIRVBase.td

class SPV_IsKnownEnumCaseFor<string name> :
     CPred<"::mlir::spirv::symbolize" # name # "("
           "$_self.cast<IntegerAttr>().getValue().getZExtValue()).hasValue()">;
 
 // Wrapper over base BitEnumAttr to set common fields.
 class SPV_BitEnumAttr<string name, string description,
                       list<BitEnumAttrCase> cases> :
     BitEnumAttr<name, description, cases> {
   let predicate = And<[
-    IntegerAttrBase<I32, "">.predicate,
+    I32Attr.predicate,
     SPV_IsKnownEnumCaseFor<name>,
   ]>;
   let cppNamespace = "::mlir::spirv";
 }
 
 // Wrapper over base I32EnumAttr to set common fields.
 class SPV_I32EnumAttr<string name, string description,
                       list<I32EnumAttrCase> cases> :
     I32EnumAttr<name, description, cases> {
   let predicate = And<[
-    IntegerAttrBase<I32, "">.predicate,
+    I32Attr.predicate,
     SPV_IsKnownEnumCaseFor<name>,
   ]>;
   let cppNamespace = "::mlir::spirv";
 }
 
 // Wrapper over base StrEnumAttr to set common fields.
 class SPV_StrEnumAttr<string name, string description,
                       list<StrEnumAttrCase> cases> :

 def SPV_IsRTArrayType : CPred<"$_self.isa<::mlir::spirv::RuntimeArrayType>()">;
 def SPV_IsStructType : CPred<"$_self.isa<::mlir::spirv::StructType>()">;
 
 // See https://www.khronos.org/registry/spir-v/specs/unified1/SPIRV.html#_types
 // for the definition of the following types and type categories.
 
 def SPV_Void : TypeAlias<NoneType, "void type">;
 def SPV_Bool : I<1>;
-def SPV_Integer : IntOfWidths<[8, 16, 32, 64]>;
+def SPV_Integer : AnyIntOfWidths<[8, 16, 32, 64]>;
 def SPV_Float : FloatOfWidths<[16, 32, 64]>;
 def SPV_Float16or32 : FloatOfWidths<[16, 32]>;
 def SPV_Vector : VectorOfLengthAndType<[2, 3, 4],
                                        [SPV_Bool, SPV_Integer, SPV_Float]>;
 // Component type check is done in the type parser for the following SPIR-V
 // dialect-specific types so we use "Any" here.
 def SPV_AnyPtr : Type<SPV_IsPtrType, "any SPIR-V pointer type">;
 def SPV_AnyArray : Type<SPV_IsArrayType, "any SPIR-V array type">;

mlir/include/mlir/Dialect/StandardOps/IR/Ops.td

def AssumeAlignmentOp : Std_Op<"assume_alignment"> {
   let description = [{
     The assume alignment operation takes a memref and a integer of alignment
     value, and internally annotates the buffer with the given alignment. If
     the buffer isn't aligned to the given alignment, the behavior is undefined.
 
     This operation doesn't affect the semantics of a correct program. It's for
     optimization only, and the optimization is best-effort.
   }];
-  let arguments = (ins AnyMemRef:$memref, PositiveI32Attr:$alignment);
+  let arguments = (ins AnyMemRef:$memref,
+                       Confined<I32Attr, [IntPositive]>:$alignment);
   let results = (outs);
 
   let assemblyFormat = "$memref `,` $alignment attr-dict `:` type($memref)";
 }
 
 #endif // STANDARD_OPS

mlir/include/mlir/IR/OpBase.td

 class AnyTypeOf<list<Type> allowedTypes, string description = ""> : Type<
     // Satisfy any of the allowed type's condition
     Or<!foreach(allowedtype, allowedTypes, allowedtype.predicate)>,
     !if(!eq(description, ""),
         StrJoin<!foreach(t, allowedTypes, t.description), " or ">.result,
         description)>;
 
 // Integer types.
-// Any integer type irrespective of its width.
-def AnySignlessInteger : Type<
-  CPred<"$_self.isSignlessInteger()">, "integer">;
 
-// Index type.
-def Index : Type<CPred<"$_self.isa<IndexType>()">, "index">,
-            BuildableType<"$_builder.getIndexType()">;
+// Any integer type irrespective of its width and signedness semantics.
+def AnyInteger : Type<CPred<"$_self.isInteger()">, "integer">;
+
+// Any integer type (regardless of signedness semantics) of a specific width.
+class AnyI<int width>
+    : Type<CPred<"$_self.isInteger(" # width # ")">, width # "-bit integer"> {
+  int bitwidth = width;
+}
 
-// Integer type of a specific width.
+class AnyIntOfWidths<list<int> widths> :
+    AnyTypeOf<!foreach(w, widths, AnyI<w>),
+              StrJoinInt<widths, "/">.result # "-bit integer">;
+
+def AnyI1  : AnyI<1>;
+def AnyI8  : AnyI<8>;
+def AnyI16 : AnyI<16>;
+def AnyI32 : AnyI<32>;
+def AnyI64 : AnyI<64>;
+
+// Any signless integer type irrespective of its width.
+def AnySignlessInteger : Type<
+  CPred<"$_self.isSignlessInteger()">, "signless integer">;
+
+// Signless integer type of a specific width.
 class I<int width>
     : Type<CPred<"$_self.isSignlessInteger(" # width # ")">,
-                  width # "-bit integer">,
+                  width # "-bit signless integer">,
       BuildableType<"$_builder.getIntegerType(" # width # ")"> {
   int bitwidth = width;
 }
 
-class IntOfWidths<list<int> widths> :
+class SignlessIntOfWidths<list<int> widths> :
     AnyTypeOf<!foreach(w, widths, I<w>),
-              StrJoinInt<widths, "/">.result # "-bit integer">;
+              StrJoinInt<widths, "/">.result # "-bit signless integer">;
 
 def I1  : I<1>;
 def I8  : I<8>;
 def I16 : I<16>;
 def I32 : I<32>;
 def I64 : I<64>;
 
-// Unsigned integer types.
 // Any unsigned integer type irrespective of its width.
 def AnyUnsignedInteger : Type<
   CPred<"$_self.isUnsignedInteger()">, "unsigned integer">;
 
 // Unsigned integer type of a specific width.
 class UI<int width>
     : Type<CPred<"$_self.isUnsignedInteger(" # width # ")">,
                   width # "-bit unsigned integer">,
-      BuildableType<"$_builder.getIntegerType(" # width #
-                    ", /*isSigned=*/false)"> {
+      BuildableType<
+        "$_builder.getIntegerType(" # width # ", /*isSigned=*/false)"> {
   int bitwidth = width;
 }
 
 class UnsignedIntOfWidths<list<int> widths> :
     AnyTypeOf<!foreach(w, widths, UI<w>),
               StrJoinInt<widths, "/">.result # "-bit unsigned integer">;
 
 def UI1  : UI<1>;
 def UI8  : UI<8>;
 def UI16 : UI<16>;
 def UI32 : UI<32>;
 def UI64 : UI<64>;
 
+// Any signed integer type irrespective of its width.
+def AnySignedInteger : Type<
+  CPred<"$_self.isSignedInteger()">, "signed integer">;
+
+// Signed integer type of a specific width.
+class SI<int width>
+    : Type<CPred<"$_self.isSignedInteger(" # width # ")">,
+                  width # "-bit signed integer">,
+      BuildableType<
+        "$_builder.getIntegerType(" # width # ", /*isSigned=*/true)"> {
+  int bitwidth = width;
+}
+
+class SignedIntOfWidths<list<int> widths> :
+    AnyTypeOf<!foreach(w, widths, SI<w>),
+              StrJoinInt<widths, "/">.result # "-bit signed integer">;
+
+def SI1  : SI<1>;
+def SI8  : SI<8>;
+def SI16 : SI<16>;
+def SI32 : SI<32>;
+def SI64 : SI<64>;
+
+// Index type.
+def Index : Type<CPred<"$_self.isa<IndexType>()">, "index">,
+            BuildableType<"$_builder.getIndexType()">;
+
 // Floating point types.
 
 // Any float type irrespective of its width.
 def AnyFloat : Type<CPred<"$_self.isa<FloatType>()">, "floating-point">;
 
 // Float type of a specific width.
 class F<int width>
     : Type<CPred<"$_self.isF" # width # "()">,

 //===----------------------------------------------------------------------===//
 
 // Type constraint for bool-like types: bools, vectors of bools, tensors of
 // bools.
 def BoolLike : TypeConstraint<Or<[I1.predicate, VectorOf<[I1]>.predicate,
                                   TensorOf<[I1]>.predicate]>,
     "bool-like">;
 
-// Type constraint for integer-like types: integers, indices, vectors of
-// integers, tensors of integers.
+// Type constraint for signless-integer-like types: signless integers, indices,
+// vectors of signless integers, tensors of signless integers.
 def SignlessIntegerLike : TypeConstraint<Or<[
         AnySignlessInteger.predicate, Index.predicate,
         VectorOf<[AnySignlessInteger]>.predicate,
         TensorOf<[AnySignlessInteger]>.predicate]>,
-    "integer-like">;
+    "signless-integer-like">;
 
 // Type constraint for float-like types: floats, vectors or tensors thereof.
 def FloatLike : TypeConstraint<Or<[AnyFloat.predicate,
         VectorOf<[AnyFloat]>.predicate, TensorOf<[AnyFloat]>.predicate]>,
     "floating-point-like">;
 
-// Type constraint for integer-like or float-like types.
+// Type constraint for signless-integer-like or float-like types.
 def SignlessIntegerOrFloatLike : TypeConstraint<Or<[
     SignlessIntegerLike.predicate, FloatLike.predicate]>,
-    "integer-like or floating-point-like">;
+    "signless-integer-like or floating-point-like">;
 
 
 //===----------------------------------------------------------------------===//
 // Attribute definitions
 //===----------------------------------------------------------------------===//
 
 //===----------------------------------------------------------------------===//
 // Base attribute definition

 }
 
 def BoolAttr : Attr<CPred<"$_self.isa<BoolAttr>()">, "bool attribute"> {
   let storageType = [{ BoolAttr }];
   let returnType = [{ bool }];
   let constBuilderCall = "$_builder.getBoolAttr($0)";
 }
 
-// Base class for integer attributes of fixed width.
-class IntegerAttrBase<I attrValType, string descr> :
+// Base class for any integer (regardless of signedness semantics) attributes
+// of fixed width.
+class AnyIntegerAttrBase<AnyI attrValType, string descr> :
     TypedAttrBase<
       attrValType, "IntegerAttr",
       And<[CPred<"$_self.isa<IntegerAttr>()">,
            CPred<"$_self.cast<IntegerAttr>().getType()."
-                 "isSignlessInteger(" # attrValType.bitwidth # ")">]>,
+                 "isInteger(" # attrValType.bitwidth # ")">]>,
       descr> {
   let returnType = [{ APInt }];
+  let constBuilderCall = ?;
 }
 
+def AnyI1Attr  : AnyIntegerAttrBase<AnyI1,  "1-bit integer attribute">;
+def AnyI8Attr  : AnyIntegerAttrBase<AnyI8,  "8-bit integer attribute">;
+def AnyI16Attr : AnyIntegerAttrBase<AnyI16, "16-bit integer attribute">;
+def AnyI32Attr : AnyIntegerAttrBase<AnyI32, "32-bit integer attribute">;
+def AnyI64Attr : AnyIntegerAttrBase<AnyI64, "64-bit integer attribute">;
+
 def APIntAttr : Attr<CPred<"$_self.isa<IntegerAttr>()">,
                      "arbitrary integer attribute"> {
   let storageType = [{ IntegerAttr }];
   let returnType = [{ APInt }];
 }
 
-def I1Attr  : IntegerAttrBase<I1,  "1-bit integer attribute">;
-def I8Attr  : IntegerAttrBase<I8,  "8-bit integer attribute">;
-def I16Attr : IntegerAttrBase<I16, "16-bit integer attribute">;
-def I32Attr : IntegerAttrBase<I32, "32-bit integer attribute">;
-def I64Attr : IntegerAttrBase<I64, "64-bit integer attribute">;
+// Base class for signless integer attributes of fixed width.
+class SignlessIntegerAttrBase<I attrValType, string descr> :
+    TypedAttrBase<
+      attrValType, "IntegerAttr",
+      And<[CPred<"$_self.isa<IntegerAttr>()">,
+           CPred<"$_self.cast<IntegerAttr>().getType()."
+                 "isSignlessInteger(" # attrValType.bitwidth # ")">]>,
+      descr> {
+  let returnType = [{ APInt }];
+}
+
+def I1Attr  : SignlessIntegerAttrBase<I1,  "1-bit signless integer attribute">;
+def I8Attr  : SignlessIntegerAttrBase<I8,  "8-bit signless integer attribute">;
+def I16Attr : SignlessIntegerAttrBase<I16, "16-bit signless integer attribute">;
+def I32Attr : SignlessIntegerAttrBase<I32, "32-bit signless integer attribute">;
+def I64Attr : SignlessIntegerAttrBase<I64, "64-bit signless integer attribute">;
 
-class NonNegativeIntAttrBase<I attrValType, string descr> :
+// Base class for unsigned integer attributes of fixed width.
+class UnsignedIntegerAttrBase<UI attrValType, string descr> :
     TypedAttrBase<
       attrValType, "IntegerAttr",
-      And<[IntegerAttrBase<attrValType, "">.predicate,
-           CPred<"!$_self.cast<IntegerAttr>().getValue().isNegative()">]>,
+      And<[CPred<"$_self.isa<IntegerAttr>()">,
+           CPred<"$_self.cast<IntegerAttr>().getType()."
+                 "isUnsignedInteger(" # attrValType.bitwidth # ")">]>,
       descr> {
   let returnType = [{ APInt }];
 }
 
-def NonNegativeI32Attr : NonNegativeIntAttrBase<
-    I32, "non-negative 32-bit integer attribute">;
-def NonNegativeI64Attr : NonNegativeIntAttrBase<
-    I64, "non-negative 64-bit integer attribute">;
+def UI1Attr  : UnsignedIntegerAttrBase<
+    UI1,  "1-bit unsigned integer attribute">;
+def UI8Attr  : UnsignedIntegerAttrBase<
+    UI8,  "8-bit unsigned integer attribute">;
+def UI16Attr : UnsignedIntegerAttrBase<
+    UI16, "16-bit unsigned integer attribute">;
+def UI32Attr : UnsignedIntegerAttrBase<
+    UI32, "32-bit unsigned integer attribute">;
+def UI64Attr : UnsignedIntegerAttrBase<
+    UI64, "64-bit unsigned integer attribute">;
 
-class PositiveIntAttrBase<I attrValType, string descr> :
+// Base class for signed integer attributes of fixed width.
+class SignedIntegerAttrBase<SI attrValType, string descr> :
     TypedAttrBase<
       attrValType, "IntegerAttr",
-      And<[IntegerAttrBase<attrValType, "">.predicate,
-           CPred<"$_self.cast<IntegerAttr>().getValue()"
-                 ".isStrictlyPositive()">]>,
+      And<[CPred<"$_self.isa<IntegerAttr>()">,
+           CPred<"$_self.cast<IntegerAttr>().getType()."
+                 "isSignedInteger(" # attrValType.bitwidth # ")">]>,
       descr> {
   let returnType = [{ APInt }];
 }
 
-def PositiveI32Attr : PositiveIntAttrBase<
-    I32, "positive 32-bit integer attribute">;
-def PositiveI64Attr : PositiveIntAttrBase<
-    I64, "positive 64-bit integer attribute">;
+def SI1Attr  : SignedIntegerAttrBase<
+    SI1,  "1-bit signed integer attribute">;
+def SI8Attr  : SignedIntegerAttrBase<
+    SI8,  "8-bit signed integer attribute">;
+def SI16Attr : SignedIntegerAttrBase<
+    SI16, "16-bit signed integer attribute">;
+def SI32Attr : SignedIntegerAttrBase<
+    SI32, "32-bit signed integer attribute">;
+def SI64Attr : SignedIntegerAttrBase<
+    SI64, "64-bit signed integer attribute">;
 
 // Base class for float attributes of fixed width.
 class FloatAttrBase<F attrValType, string descr> :
     TypedAttrBase<attrValType, "FloatAttr",
               And<[CPred<"$_self.isa<FloatAttr>()">,
                      CPred<"$_self.cast<FloatAttr>().getType().isF" #
                            attrValType.bitwidth # "()">]>,
               descr> {
class StrEnumAttrCase<string sym, int val = -1> :
     StringBasedAttr<
       CPred<"$_self.cast<StringAttr>().getValue() == \"" # sym # "\"">,
       "case " # sym>;
 
 // An enum attribute case stored with IntegerAttr, which has an integer value,
 // its representation as a string and a C++ symbol name which may be different.
 class IntEnumAttrCaseBase<I intType, string sym, string strVal, int intVal> :
     EnumAttrCaseInfo<sym, intVal, strVal>,
-    IntegerAttrBase<intType, "case " # strVal> {
+    SignlessIntegerAttrBase<intType, "case " # strVal> {
   let predicate =
     CPred<"$_self.cast<IntegerAttr>().getInt() == " # intVal>;
 }
 
 // Cases of integer enum attributes with a specific type. By default, the string
 // representation is the same as the C++ symbol name.
 class I32EnumAttrCase<string sym, int val, string str = sym>
     : IntEnumAttrCaseBase<I32, sym, str, val>;
 class I64EnumAttrCase<string sym, int val, string str = sym>
     : IntEnumAttrCaseBase<I64, sym, str, val>;
 
 // A bit enum case stored with 32-bit IntegerAttr. `val` here is *not* the
 // ordinal number of the bit that is set. It is the 32-bit integer with only
 // one bit set.
 class BitEnumAttrCase<string sym, int val> :
     EnumAttrCaseInfo<sym, val, sym>,
-    IntegerAttrBase<I32, "case " # sym> {
+    SignlessIntegerAttrBase<I32, "case " # sym> {
   let predicate = CPred<
     "$_self.cast<IntegerAttr>().getValue().getZExtValue() & " # val # "u">;
 }
 
 // Additional information for an enum attribute.
 class EnumAttrInfo<string name, list<EnumAttrCaseInfo> cases> {
   // The C++ enum class name
   string className = name;

 // An enum attribute backed by IntegerAttr.
 //
 // Op attributes of this kind are stored as IntegerAttr. Extra verification will
 // be generated on the integer though: only the values of the allowed cases are
 // permitted as the integer value.
 class IntEnumAttr<I intType, string name, string description,
                   list<IntEnumAttrCaseBase> cases> :
     EnumAttrInfo<name, cases>,
-    IntegerAttrBase<intType,
+    SignlessIntegerAttrBase<intType,
       !if(!empty(description), "allowed " # intType.description # " cases: " #
           StrJoinInt<!foreach(case, cases, case.value)>.result, description)> {
   let predicate = And<[
-    IntegerAttrBase<intType, "">.predicate,
+    SignlessIntegerAttrBase<intType, "">.predicate,
     Or<!foreach(case, cases, case.predicate)>]>;
 }
 
 class I32EnumAttr<string name, string description,
                   list<I32EnumAttrCase> cases> :
     IntEnumAttr<I32, name, description, cases> {
   let returnType = cppNamespace # "::" # name;
   let underlyingType = "uint32_t";

 // A bit enum stored with 32-bit IntegerAttr.
 //
 // Op attributes of this kind are stored as IntegerAttr. Extra verification will
 // be generated on the integer to make sure only allowed bit are set. Besides,
 // helper methods are generated to parse a string separated with a specified
 // delimiter to a symbol and vice versa.
 class BitEnumAttr<string name, string description,
                   list<BitEnumAttrCase> cases> :
-    EnumAttrInfo<name, cases>, IntegerAttrBase<I32, description> {
+    EnumAttrInfo<name, cases>, SignlessIntegerAttrBase<I32, description> {
   let predicate = And<[
-    IntegerAttrBase<I32, "">.predicate,
+    I32Attr.predicate,
     // Make sure we don't have unknown bit set.
     CPred<"!($_self.cast<IntegerAttr>().getValue().getZExtValue() & (~(" #
           StrJoin<!foreach(case, cases, case.value # "u"), "|">.result #
           ")))">
   ]>;
 
   let returnType = cppNamespace # "::" # name;
   let underlyingType = "uint32_t";

 class ElementsAttrBase<Pred condition, string description> :
     Attr<condition, description> {
   let storageType = [{ ElementsAttr }];
   let returnType = [{ ElementsAttr }];
   let convertFromStorage = "$_self";
 }
 
 def ElementsAttr : ElementsAttrBase<CPred<"$_self.isa<ElementsAttr>()">,
                                     "constant vector/tensor attribute">;
 
-class IntElementsAttr<int width> : ElementsAttrBase<
-  CPred<"$_self.isa<DenseIntElementsAttr>() &&"
-      "$_self.cast<DenseIntElementsAttr>().getType()."
-      "getElementType().isSignlessInteger(" # width # ")">,
-  width # "-bit integer elements attribute"> {
-
+class IntElementsAttrBase<Pred condition, string description> :
+    ElementsAttrBase<And<[CPred<"$_self.isa<DenseIntElementsAttr>()">,
+                          condition]>,
+                     description> {
   let storageType = [{ DenseIntElementsAttr }];
   let returnType = [{ DenseIntElementsAttr }];
 
+  let convertFromStorage = "$_self";
+}
+
+class AnyIntElementsAttr<int width> : IntElementsAttrBase<
+  CPred<"$_self.cast<DenseIntElementsAttr>().getType()."
+        "getElementType().isInteger(" # width # ")">,
+  width # "-bit integer elements attribute">;
+
+def AnyI32ElementsAttr : AnyIntElementsAttr<32>;
+def AnyI64ElementsAttr : AnyIntElementsAttr<64>;
+
+class SignlessIntElementsAttr<int width> : IntElementsAttrBase<
+  CPred<"$_self.cast<DenseIntElementsAttr>().getType()."
+        "getElementType().isSignlessInteger(" # width # ")">,
+  width # "-bit signless integer elements attribute"> {
+
   // Note that this is only constructing scalar elements attribute.
   let constBuilderCall = "DenseElementsAttr::get("
     "RankedTensorType::get({}, $_builder.getIntegerType(" # width # ")), "
     "llvm::makeArrayRef($0)).cast<DenseIntElementsAttr>()";
-  let convertFromStorage = "$_self";
 }
 
-def I32ElementsAttr : IntElementsAttr<32>;
-def I64ElementsAttr : IntElementsAttr<64>;
+def I32ElementsAttr : SignlessIntElementsAttr<32>;
+def I64ElementsAttr : SignlessIntElementsAttr<64>;
 
-// A `width`-bit integer elements attribute. The attribute should be ranked and
-// has a shape as specified in `dims`.
-class RankedIntElementsAttr<int width, list<int> dims> : IntElementsAttr<width> {
+// A `width`-bit signless integer elements attribute. The attribute should be
+// ranked and has a shape as specified in `dims`.
+class RankedSignlessIntElementsAttr<int width, list<int> dims> :
+    SignlessIntElementsAttr<width> {
   // Check that this has the specified shape.
   let predicate = And<[
-    IntElementsAttr<width>.predicate,
+    SignlessIntElementsAttr<width>.predicate,
     CPred<"$_self.cast<DenseIntElementsAttr>().getType().getShape() == "
         "ArrayRef<int64_t>({" # StrJoinInt<dims>.result # "})">]>;
 
-  let description = width # "-bit int elements attribute of shape [" #
+  let description = width # "-bit signless int elements attribute of shape [" #
                     StrJoinInt<dims>.result # "]";
 
   let constBuilderCall = "DenseIntElementsAttr::get("
     "RankedTensorType::get({" # StrJoinInt<dims>.result #
     "}, $_builder.getIntegerType(" # width # ")), makeArrayRef($0))";
 }
 
-class RankedI32ElementsAttr<list<int> dims> : RankedIntElementsAttr<32, dims>;
-class RankedI64ElementsAttr<list<int> dims> : RankedIntElementsAttr<64, dims>;
+class RankedI32ElementsAttr<list<int> dims> :
+    RankedSignlessIntElementsAttr<32, dims>;
+class RankedI64ElementsAttr<list<int> dims> :
+    RankedSignlessIntElementsAttr<64, dims>;
 
 class FloatElementsAttr<int width> : ElementsAttrBase<
   CPred<"$_self.isa<DenseFPElementsAttr>() &&"
       "$_self.cast<DenseElementsAttr>().getType()."
       "getElementType().isF" # width # "()">,
   width # "-bit float elements attribute"> {
 
   let storageType = [{ DenseElementsAttr }];

 class IntMinValue<int n> : AttrConstraint<
     CPred<"$_self.cast<IntegerAttr>().getInt() >= " # n>,
     "whose minimum value is " # n>;
 
 class IntMaxValue<int n> : AttrConstraint<
     CPred<"$_self.cast<IntegerAttr>().getInt() <= " # n>,
     "whose maximum value is " # n>;
 
+def IntNonNegative : AttrConstraint<
+    CPred<"!$_self.cast<IntegerAttr>().getValue().isNegative()">,
+    "whose value is non-negative">;
+
+def IntPositive : AttrConstraint<
+    CPred<"$_self.cast<IntegerAttr>().getValue().isStrictlyPositive()">,
+    "whose value is positive">;
+
 class ArrayMinCount<int n> : AttrConstraint<
     CPred<"$_self.cast<ArrayAttr>().size() >= " # n>,
     "with at least " # n # " elements">;
 
 class ArrayCount<int n> : AttrConstraint<
     CPred<"$_self.cast<ArrayAttr>().size() == " #n>,
     "with exactly " # n # " elements">;
 

mlir/test/Dialect/LLVMIR/global.mlir

 
 // -----
 
 // expected-error @+1 {{expects type to be a valid element type for an LLVM pointer}}
 llvm.mlir.global internal constant @constant(37.0) : !llvm<"label">
 
 // -----
 
-// expected-error @+1 {{'addr_space' failed to satisfy constraint: non-negative 32-bit integer}}
+// expected-error @+1 {{'addr_space' failed to satisfy constraint: 32-bit signless integer attribute whose value is non-negative}}
 "llvm.mlir.global"() {sym_name = "foo", type = !llvm.i64, value = 42 : i64, addr_space = -1 : i32, linkage = 0} : () -> ()
 
 // -----
 
-// expected-error @+1 {{'addr_space' failed to satisfy constraint: non-negative 32-bit integer}}
+// expected-error @+1 {{'addr_space' failed to satisfy constraint: 32-bit signless integer attribute whose value is non-negative}}
 "llvm.mlir.global"() {sym_name = "foo", type = !llvm.i64, value = 42 : i64, addr_space = 1.0 : f32, linkage = 0} : () -> ()
 
 // -----
 
 func @foo() {
   // expected-error @+1 {{must appear at the module level}}
   llvm.mlir.global internal @bar(42) : !llvm.i32
 }

mlir/test/Dialect/Loops/invalid.mlir

"loop.for"(%arg0, %arg0, %arg0) (
     }
   ) : (index, index, index) -> ()
   return
 }
 
 // -----
 
 func @loop_if_not_i1(%arg0: index) {
-  // expected-error@+1 {{operand #0 must be 1-bit integer}}
+  // expected-error@+1 {{operand #0 must be 1-bit signless integer}}
   "loop.if"(%arg0) : (index) -> ()
   return
 }
 
 // -----
 
 func @loop_if_more_than_2_regions(%arg0: i1) {
   // expected-error@+1 {{op has incorrect number of regions: expected 2}}

mlir/test/Dialect/SPIRV/ops.mlir

func @logicalUnary(%arg0 : i1)
   %0 = spv.LogicalNot : i1
   return
 }
 
 // -----
 
 func @logicalUnary(%arg0 : i32)
 {
-  // expected-error @+1 {{'spv.LogicalNot' op operand #0 must be 1-bit integer or vector of 1-bit integer values of length 2/3/4, but got 'i32'}}
+  // expected-error @+1 {{operand #0 must be 1-bit signless integer or vector of 1-bit signless integer values of length 2/3/4, but got 'i32'}}
   %0 = spv.LogicalNot %arg0 : i32
   return
 }
 
 // -----
 
 //===----------------------------------------------------------------------===//
 // spv.MemoryBarrier

mlir/test/IR/attribute.mlir

 // RUN: mlir-opt %s -split-input-file -verify-diagnostics | FileCheck %s
 
 //===----------------------------------------------------------------------===//
+// Test integer attributes
+//===----------------------------------------------------------------------===//
+
+func @int_attrs_pass() {
+  "test.int_attrs"() {
+    // CHECK: any_i32_attr = 5 : ui32
+    any_i32_attr = 5 : ui32,
+    // CHECK-SAME: si32_attr = 7 : si32
+    si32_attr = 7 : si32,
+    // CHECK-SAME: ui32_attr = 6 : ui32
+    ui32_attr = 6 : ui32
+  } : () -> ()
+
+  "test.int_attrs"() {
+    // CHECK: any_i32_attr = 5 : si32
+    any_i32_attr = 5 : si32,
+    si32_attr = 7 : si32,
+    ui32_attr = 6 : ui32
+  } : () -> ()
+
+  "test.int_attrs"() {
+    // CHECK: any_i32_attr = 5 : i32
+    any_i32_attr = 5 : i32,
+    si32_attr = 7 : si32,
+    ui32_attr = 6 : ui32
+  } : () -> ()
+
+  return
+}
+
+// -----
+
+func @wrong_int_attrs_signedness_fail() {
+  // expected-error @+1 {{'si32_attr' failed to satisfy constraint: 32-bit signed integer attribute}}
+  "test.int_attrs"() {
+    any_i32_attr = 5 : i32,
+    si32_attr = 7 : ui32,
+    ui32_attr = 6 : ui32
+  } : () -> ()
+  return
+}
+
+// -----
+
+func @wrong_int_attrs_signedness_fail() {
+  // expected-error @+1 {{'ui32_attr' failed to satisfy constraint: 32-bit unsigned integer attribute}}
+  "test.int_attrs"() {
+    any_i32_attr = 5 : i32,
+    si32_attr = 7 : si32,
+    ui32_attr = 6 : si32
+  } : () -> ()
+  return
+}
+
+// -----
+
+func @wrong_int_attrs_type_fail() {
+  // expected-error @+1 {{'any_i32_attr' failed to satisfy constraint: 32-bit integer attribute}}
+  "test.int_attrs"() {
+    any_i32_attr = 5.0 : f32,
+    si32_attr = 7 : si32,
+    ui32_attr = 6 : ui32
+  } : () -> ()
+  return
+}
+
+// -----
+
+//===----------------------------------------------------------------------===//
 // Test Non-negative Int Attr
 //===----------------------------------------------------------------------===//
 
 func @non_negative_int_attr_pass() {
   // CHECK: test.non_negative_int_attr
   "test.non_negative_int_attr"() {i32attr = 5 : i32, i64attr = 10 : i64} : () -> ()
   // CHECK: test.non_negative_int_attr
   "test.non_negative_int_attr"() {i32attr = 0 : i32, i64attr = 0 : i64} : () -> ()
   return
 }
 
 // -----
 
 func @negative_int_attr_fail() {
-  // expected-error @+1 {{'i32attr' failed to satisfy constraint: non-negative 32-bit integer attribute}}
+  // expected-error @+1 {{'i32attr' failed to satisfy constraint: 32-bit signless integer attribute whose value is non-negative}}
   "test.non_negative_int_attr"() {i32attr = -5 : i32, i64attr = 10 : i64} : () -> ()
   return
 }
 
 // -----
 
 func @negative_int_attr_fail() {
-  // expected-error @+1 {{'i64attr' failed to satisfy constraint: non-negative 64-bit integer attribute}}
+  // expected-error @+1 {{'i64attr' failed to satisfy constraint: 64-bit signless integer attribute whose value is non-negative}}
   "test.non_negative_int_attr"() {i32attr = 5 : i32, i64attr = -10 : i64} : () -> ()
   return
 }
 
 // -----
 
 //===----------------------------------------------------------------------===//
 // Test Positive Int Attr
 //===----------------------------------------------------------------------===//
 
 func @positive_int_attr_pass() {
   // CHECK: test.positive_int_attr
   "test.positive_int_attr"() {i32attr = 5 : i32, i64attr = 10 : i64} : () -> ()
   return
 }
 
 // -----
 
 func @positive_int_attr_fail() {
-  // expected-error @+1 {{'i32attr' failed to satisfy constraint: positive 32-bit integer attribute}}
+  // expected-error @+1 {{'i32attr' failed to satisfy constraint: 32-bit signless integer attribute whose value is positive}}
   "test.positive_int_attr"() {i32attr = 0 : i32, i64attr = 5: i64} : () -> ()
   return
 }
 
 // -----
 
 func @positive_int_attr_fail() {
-  // expected-error @+1 {{'i64attr' failed to satisfy constraint: positive 64-bit integer attribute}}
+  // expected-error @+1 {{'i64attr' failed to satisfy constraint: 64-bit signless integer attribute whose value is positive}}
   "test.positive_int_attr"() {i32attr = 5 : i32, i64attr = 0: i64} : () -> ()
   return
 }
 
 // -----
 
 func @positive_int_attr_fail() {
-  // expected-error @+1 {{'i32attr' failed to satisfy constraint: positive 32-bit integer attribute}}
+  // expected-error @+1 {{'i32attr' failed to satisfy constraint: 32-bit signless integer attribute whose value is positive}}
   "test.positive_int_attr"() {i32attr = -10 : i32, i64attr = 5 : i64} : () -> ()
   return
 }
 
 // -----
 
 func @positive_int_attr_fail() {
-  // expected-error @+1 {{'i64attr' failed to satisfy constraint: positive 64-bit integer attribute}}
+  // expected-error @+1 {{'i64attr' failed to satisfy constraint: 64-bit signless integer attribute whose value is positive}}
   "test.positive_int_attr"() {i32attr = 5 : i32, i64attr = -10 : i64} : () -> ()
   return
 }
 
 // -----
 
 //===----------------------------------------------------------------------===//
 // Test TypeArrayAttr
func @allowed_cases_pass() {
   // CHECK: test.i32_enum_attr
   %1 = "test.i32_enum_attr"() {attr = 10: i32} : () -> i32
   return
 }
 
 // -----
 
 func @disallowed_case7_fail() {
-  // expected-error @+1 {{allowed 32-bit integer cases: 5, 10}}
+  // expected-error @+1 {{allowed 32-bit signless integer cases: 5, 10}}
   %0 = "test.i32_enum_attr"() {attr = 7: i32} : () -> i32
   return
 }
 
 // -----
 
 func @disallowed_case7_fail() {
-  // expected-error @+1 {{allowed 32-bit integer cases: 5, 10}}
+  // expected-error @+1 {{allowed 32-bit signless integer cases: 5, 10}}
   %0 = "test.i32_enum_attr"() {attr = 5: i64} : () -> i32
   return
 }
 
 // -----
 
 //===----------------------------------------------------------------------===//
 // Test I64EnumAttr
 //===----------------------------------------------------------------------===//
 
 // CHECK-LABEL: func @allowed_cases_pass
 func @allowed_cases_pass() {
   // CHECK: test.i64_enum_attr
   %0 = "test.i64_enum_attr"() {attr = 5: i64} : () -> i32
   // CHECK: test.i64_enum_attr
   %1 = "test.i64_enum_attr"() {attr = 10: i64} : () -> i32
   return
 }
 
 // -----
 
 func @disallowed_case7_fail() {
-  // expected-error @+1 {{allowed 64-bit integer cases: 5, 10}}
+  // expected-error @+1 {{allowed 64-bit signless integer cases: 5, 10}}
   %0 = "test.i64_enum_attr"() {attr = 7: i64} : () -> i32
   return
 }
 
 // -----
 
 func @disallowed_case7_fail() {
-  // expected-error @+1 {{allowed 64-bit integer cases: 5, 10}}
+  // expected-error @+1 {{allowed 64-bit signless integer cases: 5, 10}}
   %0 = "test.i64_enum_attr"() {attr = 5: i32} : () -> i32
   return
 }
 
 // -----
 
 //===----------------------------------------------------------------------===//
 // Test FloatElementsAttr

 "test.symbol_ref_attr"() {symbol = @foo} : () -> ()
 
 // -----
 
 //===----------------------------------------------------------------------===//
 // Test IntElementsAttr
 //===----------------------------------------------------------------------===//
 
-func @correct_type_pass() {
+func @correct_int_elements_attr_pass() {
   "test.int_elements_attr"() {
+    // CHECK: any_i32_attr = dense<5> : tensor<1x2x3x4xui32>,
+    any_i32_attr = dense<5> : tensor<1x2x3x4xui32>,
+    i32_attr = dense<5> : tensor<6xi32>
+  } : () -> ()
+
+  "test.int_elements_attr"() {
+    // CHECK: any_i32_attr = dense<5> : tensor<1x2x3x4xsi32>,
+    any_i32_attr = dense<5> : tensor<1x2x3x4xsi32>,
+    i32_attr = dense<5> : tensor<6xi32>
+  } : () -> ()
+
+  "test.int_elements_attr"() {
+    // CHECK: any_i32_attr = dense<5> : tensor<1x2x3x4xi32>,
+    any_i32_attr = dense<5> : tensor<1x2x3x4xi32>,
+    i32_attr = dense<5> : tensor<6xi32>
+  } : () -> ()
+
+  return
+}
+
+// -----
+
+func @wrong_int_elements_attr_type_fail() {
+  // expected-error @+1 {{'any_i32_attr' failed to satisfy constraint: 32-bit integer elements attribute}}
+  "test.int_elements_attr"() {
+    any_i32_attr = dense<5.0> : tensor<1x2x3x4xf32>,
+    i32_attr = dense<5> : tensor<6xi32>
+  } : () -> ()
+  return
+}
+
+// -----
+
+func @wrong_int_elements_attr_signedness_fail() {
+  // expected-error @+1 {{'i32_attr' failed to satisfy constraint: 32-bit signless integer elements attribute}}
+  "test.int_elements_attr"() {
+    any_i32_attr = dense<5> : tensor<1x2x3x4xi32>,
+    i32_attr = dense<5> : tensor<6xsi32>
+  } : () -> ()
+  return
+}
+
+// -----
+
+//===----------------------------------------------------------------------===//
+// Test Ranked IntElementsAttr
+//===----------------------------------------------------------------------===//
+
+func @correct_type_pass() {
+  "test.ranked_int_elements_attr"() {
     // CHECK: matrix_i64_attr = dense<6> : tensor<4x8xi64>
     // CHECK: vector_i32_attr = dense<5> : tensor<2xi32>
     matrix_i64_attr = dense<6> : tensor<4x8xi64>,
     vector_i32_attr = dense<5> : tensor<2xi32>
   } : () -> ()
   return
 }
 
 // -----
 
 func @wrong_element_type_fail() {
-  // expected-error @+1 {{failed to satisfy constraint: 32-bit int elements attribute of shape [2]}}
-  "test.int_elements_attr"() {
+  // expected-error @+1 {{failed to satisfy constraint: 32-bit signless int elements attribute of shape [2]}}
+  "test.ranked_int_elements_attr"() {
     matrix_i64_attr = dense<6> : tensor<4x8xi64>,
     vector_i32_attr = dense<5> : tensor<2xi64>
   } : () -> ()
   return
 }
 
 // -----
 
 func @wrong_shape_fail() {
-  // expected-error @+1 {{failed to satisfy constraint: 64-bit int elements attribute of shape [4, 8]}}
-  "test.int_elements_attr"() {
+  // expected-error @+1 {{failed to satisfy constraint: 64-bit signless int elements attribute of shape [4, 8]}}
+  "test.ranked_int_elements_attr"() {
     matrix_i64_attr = dense<6> : tensor<4xi64>,
     vector_i32_attr = dense<5> : tensor<2xi32>
   } : () -> ()
   return
 }
 
 // -----
 
 func @wrong_shape_fail() {
-  // expected-error @+1 {{failed to satisfy constraint: 32-bit int elements attribute of shape [2]}}
-  "test.int_elements_attr"() {
+  // expected-error @+1 {{failed to satisfy constraint: 32-bit signless int elements attribute of shape [2]}}
+  "test.ranked_int_elements_attr"() {
     matrix_i64_attr = dense<6> : tensor<4x8xi64>,
     vector_i32_attr = dense<5> : tensor<i32>
   } : () -> ()
   return
 }
 

mlir/test/IR/invalid-ops.mlir

 ^bb0(%a : f32):
   %sf = addf{%a, %a} : f32  // expected-error {{expected attribute name}}
 }
 
 // -----
 
 func @func_with_ops(f32) {
 ^bb0(%a : f32):
-  // expected-error@+1 {{'std.addi' op operand #0 must be integer-like}}
+  // expected-error@+1 {{'std.addi' op operand #0 must be signless-integer-like}}
   %sf = addi %a, %a : f32
 }
 
 // -----
 
 func @func_with_ops(i32) {
 ^bb0(%a : i32):
   %sf = addf %a, %a : i32  // expected-error {{'std.addf' op operand #0 must be floating-point-like}}
 }
 
 // -----
 
 func @func_with_ops(i32) {
 ^bb0(%a : i32):
-  // expected-error@+1 {{failed to satisfy constraint: allowed 64-bit integer cases: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9}}
+  // expected-error@+1 {{failed to satisfy constraint: allowed 64-bit signless integer cases: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9}}
   %r = "std.cmpi"(%a, %a) {predicate = 42} : (i32, i32) -> i1
 }
 
 // -----
 
 // Comparison are defined for arguments of the same type.
 func @func_with_ops(i32, i64) {
 ^bb0(%a : i32, %b : i64): // expected-note {{prior use here}}
   %r = cmpi "eq", %a, %b : i32 // expected-error {{use of value '%b' expects different type than prior uses}}
 }
 
 // -----
 
 // Comparisons must have the "predicate" attribute.
 func @func_with_ops(i32, i32) {
 ^bb0(%a : i32, %b : i32):
   %r = cmpi %a, %b : i32 // expected-error {{expected non-function type}}
 }
 
 // -----
 
 // Integer comparisons are not recognized for float types.
 func @func_with_ops(f32, f32) {
 ^bb0(%a : f32, %b : f32):
-  %r = cmpi "eq", %a, %b : f32 // expected-error {{'lhs' must be integer-like, but got 'f32'}}
+  %r = cmpi "eq", %a, %b : f32 // expected-error {{'lhs' must be signless-integer-like, but got 'f32'}}
 }
 
 // -----
 
 // Result type must be boolean like.
 func @func_with_ops(i32, i32) {
 ^bb0(%a : i32, %b : i32):
   %r = "std.cmpi"(%a, %b) {predicate = 0} : (i32, i32) -> i32 // expected-error {{op result #0 must be bool-like}}

 ^bb0(%cond : i1, %t : tensor<42xi32>, %f : tensor<?xi32>):
   // expected-error@+1 {{ op requires the same shape for all operands and results}}
   %r = "std.select"(%cond, %t, %f) : (i1, tensor<42xi32>, tensor<?xi32>) -> tensor<42xi32>
 }
 
 // -----
 
 func @invalid_select_shape(%cond : i1, %idx : () -> ()) {
-  // expected-error@+1 {{'result' must be integer-like or floating-point-like, but got '() -> ()'}}
+  // expected-error@+1 {{'result' must be signless-integer-like or floating-point-like, but got '() -> ()'}}
   %sel = select %cond, %idx, %idx : () -> ()
 
 // -----
 
 func @invalid_cmp_shape(%idx : () -> ()) {
-  // expected-error@+1 {{'lhs' must be integer-like, but got '() -> ()'}}
+  // expected-error@+1 {{'lhs' must be signless-integer-like, but got '() -> ()'}}
   %cmp = cmpi "eq", %idx, %idx : () -> ()
 
 // -----
 
 func @dma_no_src_memref(%m : f32, %tag : f32, %c0 : index) {
   // expected-error@+1 {{expected source to be of memref type}}
   dma_start %m[%c0], %m[%c0], %c0, %tag[%c0] : f32, f32, f32
 }
%1 = view %0[][%arg0, %arg1]
     : memref<2048xi8> to memref<?x?xf32, affine_map<(d0, d1)[s0] -> (d0, d1, s0)>>
   return
 }
 
 // -----
 
 func @invalid_view(%arg0 : index, %arg1 : index, %arg2 : index) {
   %0 = alloc() : memref<2048xf32>
-  // expected-error@+1 {{must be 1D memref of 8-bit integer values}}
+  // expected-error@+1 {{must be 1D memref of 8-bit signless integer values}}
   %1 = view %0[][%arg0, %arg1]
     : memref<2048xf32> to memref<?x?xf32, affine_map<(d0, d1)[s0] -> (d0 * 4 + d1 + s0)>>
   return
 }
 
 // -----
 
 func @invalid_view(%arg0 : index, %arg1 : index, %arg2 : index) {
func @invalid_prefetch_cache_type(%i : index) {
   prefetch %0[%i], read, locality<0>, false  : memref<10xf32>
   return
 }
 
 // -----
 
 func @invalid_prefetch_locality_hint(%i : index) {
   %0 = alloc() : memref<10xf32>
-  // expected-error@+1 {{32-bit integer attribute whose minimum value is 0 whose maximum value is 3}}
+  // expected-error@+1 {{32-bit signless integer attribute whose minimum value is 0 whose maximum value is 3}}
   prefetch %0[%i], read, locality<5>, data  : memref<10xf32>
   return
 }
 
 // -----
 
 // incompatible memory space
 func @invalid_memref_cast() {
func @assume_alignment(%0: memref<4x4xf16>) {
   std.assume_alignment %0, 12 : memref<4x4xf16>
   return
 }
 
 // -----
 
 // 0 alignment value.
 func @assume_alignment(%0: memref<4x4xf16>) {
-  // expected-error@+1 {{'std.assume_alignment' op attribute 'alignment' failed to satisfy constraint: positive 32-bit integer attribute}}
+  // expected-error@+1 {{'std.assume_alignment' op attribute 'alignment' failed to satisfy constraint: 32-bit signless integer attribute whose value is positive}}
   std.assume_alignment %0, 0 : memref<4x4xf16>
   return
 }

mlir/test/lib/TestDialect/TestOps.td

 
 class TEST_Op<string mnemonic, list<OpTrait> traits = []> :
     Op<TEST_Dialect, mnemonic, traits>;
 
 //===----------------------------------------------------------------------===//
 // Test Types
 //===----------------------------------------------------------------------===//
 
+def IntTypesOp : TEST_Op<"int_types"> {
+  let results = (outs
+    AnyI16:$any_i16,
+    SI32:$si32,
+    UI64:$ui64
+  );
+}
+
 def ComplexF64 : Complex<F64>;
 def ComplexOp : TEST_Op<"complex_f64"> {
   let results = (outs ComplexF64);
 }
 
 def ComplexTensorOp : TEST_Op<"complex_f64_tensor"> {
   let results = (outs TensorOf<[ComplexF64]>);
 }

 }
 
 //===----------------------------------------------------------------------===//
 // Test Attributes
 //===----------------------------------------------------------------------===//
 
 def NonNegIntAttrOp : TEST_Op<"non_negative_int_attr"> {
   let arguments = (ins
-      NonNegativeI32Attr:$i32attr,
-      NonNegativeI64Attr:$i64attr
+      Confined<I32Attr, [IntNonNegative]>:$i32attr,
+      Confined<I64Attr, [IntNonNegative]>:$i64attr
   );
 }
 
 def PositiveIntAttrOp : TEST_Op<"positive_int_attr"> {
   let arguments = (ins
-      PositiveI32Attr:$i32attr,
-      PositiveI64Attr:$i64attr
+      Confined<I32Attr, [IntPositive]>:$i32attr,
+      Confined<I64Attr, [IntPositive]>:$i64attr
   );
 }
 
 def TypeArrayAttrOp : TEST_Op<"type_array_attr"> {
   let arguments = (ins TypeArrayAttr:$attr);
 }
 def TypeStringAttrWithTypeOp : TEST_Op<"string_attr_with_type"> {
   let arguments = (ins StrAttr:$attr);

 def SomeI64Enum: I64EnumAttr<
   "SomeI64Enum", "", [I64Case5, I64Case10]>;
 
 def I64EnumAttrOp : TEST_Op<"i64_enum_attr"> {
   let arguments = (ins SomeI64Enum:$attr);
   let results = (outs I32:$val);
 }
 
+
+def IntAttrOp : TEST_Op<"int_attrs"> {
+  let arguments = (ins
+    AnyI32Attr:$any_i32_attr,
+    UI32Attr:$ui32_attr,
+    SI32Attr:$si32_attr
+  );
+}
+
 def FloatElementsAttrOp : TEST_Op<"float_elements_attr"> {
   let arguments = (ins
       RankedF32ElementsAttr<[2]>:$scalar_f32_attr,
       RankedF64ElementsAttr<[4, 8]>:$tensor_f64_attr
   );
 }
 
 // A pattern that updates dense<[3.0, 4.0]> to dense<[5.0, 6.0]>.
 // This tests both matching and generating float elements attributes.
 def UpdateFloatElementsAttr : Pat<
   (FloatElementsAttrOp
     ConstantAttr<RankedF32ElementsAttr<[2]>, "{3.0f, 4.0f}">:$f32attr,
     $f64attr),
   (FloatElementsAttrOp
     ConstantAttr<RankedF32ElementsAttr<[2]>, "{5.0f, 6.0f}">:$f32attr,
     $f64attr)>;
 
 def IntElementsAttrOp : TEST_Op<"int_elements_attr"> {
   let arguments = (ins
+      AnyI32ElementsAttr:$any_i32_attr,
+      I32ElementsAttr:$i32_attr
+  );
+}
+
+def RankedIntElementsAttrOp : TEST_Op<"ranked_int_elements_attr"> {
+  let arguments = (ins
       RankedI32ElementsAttr<[2]>:$vector_i32_attr,
       RankedI64ElementsAttr<[4, 8]>:$matrix_i64_attr
   );
 }
 
 //===----------------------------------------------------------------------===//
 // Test Attribute Constraints
 //===----------------------------------------------------------------------===//

mlir/test/mlir-tblgen/predicate.td

 // CHECK: if (!(((first)) && ((second))))
 
 def OpF : NS_Op<"op_for_int_min_val", []> {
   let arguments = (ins Confined<I32Attr, [IntMinValue<10>]>:$attr);
 }
 
 // CHECK-LABEL: OpF::verify()
 // CHECK:       (tblgen_attr.cast<IntegerAttr>().getInt() >= 10)
-// CHECK-SAME:    return emitOpError("attribute 'attr' failed to satisfy constraint: 32-bit integer attribute whose minimum value is 10");
+// CHECK-SAME:    return emitOpError("attribute 'attr' failed to satisfy constraint: 32-bit signless integer attribute whose minimum value is 10");
 
 def OpFX : NS_Op<"op_for_int_max_val", []> {
   let arguments = (ins Confined<I32Attr, [IntMaxValue<10>]>:$attr);
 }
 
 // CHECK-LABEL: OpFX::verify()
 // CHECK:       (tblgen_attr.cast<IntegerAttr>().getInt() <= 10)
-// CHECK-SAME:    return emitOpError("attribute 'attr' failed to satisfy constraint: 32-bit integer attribute whose maximum value is 10");
+// CHECK-SAME:    return emitOpError("attribute 'attr' failed to satisfy constraint: 32-bit signless integer attribute whose maximum value is 10");
 
 def OpG : NS_Op<"op_for_arr_min_count", []> {
   let arguments = (ins Confined<ArrayAttr, [ArrayMinCount<8>]>:$attr);
 }
 
 // CHECK-LABEL: OpG::verify()
 // CHECK:       (tblgen_attr.cast<ArrayAttr>().size() >= 8)
 // CHECK-SAME:    return emitOpError("attribute 'attr' failed to satisfy constraint: array attribute with at least 8 elements");

mlir/test/mlir-tblgen/types.mlir

 // RUN: mlir-opt %s -split-input-file -verify-diagnostics | FileCheck %s
 
+func @correct_int_types_success() {
+  "test.int_types"() : () -> (i16, si32, ui64)
+  "test.int_types"() : () -> (si16, si32, ui64)
+  "test.int_types"() : () -> (ui16, si32, ui64)
+  return
+}
+
+// -----
+
+func @wrong_int_type_signedness_failure() {
+  // expected-error @+1 {{result #1 must be 32-bit signed integer, but got 'ui32'}}
+  "test.int_types"() : () -> (ui16, ui32, ui64)
+  return
+}
+
+// -----
+
+func @wrong_int_type_signedness_failure() {
+  // expected-error @+1 {{result #2 must be 64-bit unsigned integer, but got 'si64'}}
+  "test.int_types"() : () -> (ui16, si32, si64)
+  return
+}
+
+// -----
+
+func @wrong_int_type_failure() {
+  // expected-error @+1 {{result #0 must be 16-bit integer, but got 'f16'}}
+  "test.int_types"() : () -> (f16, si32, ui64)
+  return
+}
+
 // -----
 
 // CHECK-LABEL: @complex_f64_success
 func @complex_f64_success() {
   "test.complex_f64"() : () -> (complex<f64>)
   return
 }
 

 func @tuple_empty_success() {
   "test.tuple_32_bit"() : () -> (tuple<>)
   return
 }
 
 // -----
 
 func @tuple_wrong_type_scalar() {
-  // expected-error@+1 {{must be tuple with any combination of 32-bit integer or 32-bit float values}}
+  // expected-error@+1 {{must be tuple with any combination of 32-bit signless integer or 32-bit float values}}
   "test.tuple_32_bit"() : () -> (tuple<i64>)
   return
 }
 
 // -----
 
 func @tuple_wrong_type_tensor() {
-  // expected-error@+1 {{must be tuple with any combination of 32-bit integer or 32-bit float values}}
+  // expected-error@+1 {{must be tuple with any combination of 32-bit signless integer or 32-bit float values}}
   "test.tuple_32_bit"() : () -> (tuple<tensor<i32>>)
   return
 }
 
 // -----
 
 // CHECK-LABEL: @nested_tuple_empty_success
 func @nested_tuple_empty_success() {

 func @nested_tuple_multi_level_mixed_success() {
   "test.nested_tuple_32_bit"() : () -> (tuple<i32, tuple<f32, tuple<i32>>>)
   return
 }
 
 // -----
 
 func @nested_tuple_multi_level_wrong_type() {
-  // expected-error@+1 {{must be nested tuple with any combination of 32-bit integer or 32-bit float values}}
+  // expected-error@+1 {{must be nested tuple with any combination of 32-bit signless integer or 32-bit float values}}
   "test.nested_tuple_32_bit"() : () -> (tuple<i32, tuple<i32, tuple<i64>>>)
   return
 }
 
 // -----
 
 // CHECK-LABEL: func @rank_less_than_2_I8_F32_memref_success
 func @rank_less_than_2_I8_F32_memref_success() {
   "test.rank_less_than_2_I8_F32_memref"() : () -> (memref<i8>)
   "test.rank_less_than_2_I8_F32_memref"() : () -> (memref<3xi8>)
   "test.rank_less_than_2_I8_F32_memref"() : () -> (memref<f32>)
   "test.rank_less_than_2_I8_F32_memref"() : () -> (memref<1xf32>)
   return
 }
 
 // -----
 
 func @rank_less_than_2_I8_F32_memref_bad_type() {
-  // expected-error@+1 {{must be 0D/1D memref of 8-bit integer or 32-bit float values}}
+  // expected-error@+1 {{must be 0D/1D memref of 8-bit signless integer or 32-bit float values}}
   "test.rank_less_than_2_I8_F32_memref"() : () -> (memref<i16>)
   return
 }
 
 // -----
 
 func @rank_less_than_2_I8_F32_memref_bad_rank() {
-  // expected-error@+1 {{must be 0D/1D memref of 8-bit integer or 32-bit float values}}
+  // expected-error@+1 {{must be 0D/1D memref of 8-bit signless integer or 32-bit float values}}
   "test.rank_less_than_2_I8_F32_memref"() : () -> (memref<1x2xi8>)
   return
 }
 
 // -----
 
 func @nd_tensor_of_success(%arg0: tensor<f32>, %arg1: tensor<10xf32>, %arg2: tensor<20x30xi16>, %arg3: tensor<40x50x60xi16>, %arg4: tensor<70x80x90x100xi16>) {
   "test.nd_tensor_of"(%arg0, %arg1, %arg2, %arg3, %arg4) : (tensor<f32>, tensor<10xf32>, tensor<20x30xi16>, tensor<40x50x60xi16>, tensor<70x80x90x100xi16>) -> ()
   return
 }
 
 // -----
 
 func @nd_tensor_of_success_wrong_type_0d(%arg0: tensor<f32>, %arg1: tensor<10xf32>, %arg2: tensor<20x30xi16>, %arg3: tensor<40x50x60xi16>, %arg4: tensor<70x80x90x100xi32>) {
   // expected-error @+1 {{'test.nd_tensor_of' op operand #0 must be 0D tensor of 32-bit float values}}
   "test.nd_tensor_of"(%arg1, %arg1, %arg2, %arg3, %arg4) : (tensor<10xf32>, tensor<10xf32>, tensor<20x30xi16>, tensor<40x50x60xi16>, tensor<70x80x90x100xi32>) -> ()
   return
 }
 
 // -----
 
 func @nd_tensor_of_success_wrong_type_4d(%arg0: tensor<f32>, %arg1: tensor<10xf32>, %arg2: tensor<20x30xi16>, %arg3: tensor<40x50x60xi16>, %arg4: tensor<70x80x90x100xi32>) {
-  // expected-error @+1 {{'test.nd_tensor_of' op operand #4 must be 4D tensor of 16-bit integer values}}
+  // expected-error @+1 {{'test.nd_tensor_of' op operand #4 must be 4D tensor of 16-bit signless integer values}}
   "test.nd_tensor_of"(%arg0, %arg1, %arg2, %arg3, %arg3) : (tensor<f32>, tensor<10xf32>, tensor<20x30xi16>, tensor<40x50x60xi16>, tensor<40x50x60xi16>) -> ()
   return
 }
 
 // -----
 
 func @ranked_tensor_success(%arg0: tensor<i8>, %arg1: tensor<1xi32>, %arg2: tensor<?x?xf32>) {
   "test.ranked_tensor_op"(%arg0) : (tensor<i8>) -> ()
func @multi_tensor_rank_of_success(%arg0: tensor<i8>, %arg1: tensor<i32>, %arg2: tensor<f32>, %arg3: tensor<1xi8>, %arg4: tensor<1xi32>, %arg5: tensor<1xf32>) {
   "test.multi_tensor_rank_of"(%arg4) : (tensor<1xi32>) -> ()
   "test.multi_tensor_rank_of"(%arg5) : (tensor<1xf32>) -> ()
   return
 }
 
 // -----
 
 func @multi_tensor_rank_of_wrong_unranked_type(%arg0: tensor<2x2xi8>) {
-  // expected-error @+1 {{'test.multi_tensor_rank_of' op operand #0 must be 0D/1D tensor of 8-bit integer or 32-bit integer or 32-bit float values}}
+  // expected-error @+1 {{'test.multi_tensor_rank_of' op operand #0 must be 0D/1D tensor of 8-bit signless integer or 32-bit signless integer or 32-bit float values}}
   "test.multi_tensor_rank_of"(%arg0) : (tensor<2x2xi8>) -> ()
   return
 }
 
 // -----
 
 func @multi_tensor_rank_of_wrong_element_type(%arg0: tensor<2xi16>) {
-  // expected-error @+1 {{'test.multi_tensor_rank_of' op operand #0 must be 0D/1D tensor of 8-bit integer or 32-bit integer or 32-bit float values}}
+  // expected-error @+1 {{'test.multi_tensor_rank_of' op operand #0 must be 0D/1D tensor of 8-bit signless integer or 32-bit signless integer or 32-bit float values}}
   "test.multi_tensor_rank_of"(%arg0) : (tensor<2xi16>) -> ()
   return
 }
 
 // -----
 
 // CHECK-LABEL: @fixed_element_types
 func @fixed_element_types(%ti32: tensor<* x i32>, %tf32: tensor<* x f32>, %mi32 : memref<2x3xi32>, %vf32 : vector<2xf32>) {
   "test.arg_and_res_have_fixed_element_types"(%ti32, %tf32) : (tensor<* x i32>, tensor<* x f32>) -> tensor<* x i16>
   "test.arg_and_res_have_fixed_element_types"(%mi32, %vf32) : (memref<2x3xi32>, vector<2xf32>) -> memref<1x2xi16>
   return
 }
 
 // -----
 
 func @fixed_element_types(%arg0: tensor<* x i32>, %arg1: tensor<* x f32>) {
-  // expected-error@+1 {{'res' is 16-bit integer}}
+  // expected-error@+1 {{'res' is 16-bit signless integer}}
   "test.arg_and_res_have_fixed_element_types"(%arg0, %arg1) : (tensor<* x i32>, tensor<* x f32>) -> tensor<* x i32>
   return
 }
 
 // -----
 
 func @fixed_element_types(%arg0: tensor<* x i32>, %arg1: tensor<* x f32>) {
   // expected-error@+1 {{fixed type combination}}

 func @does_not_have_static_memref(%arg0: memref<?xi32>) {
   // expected-error@+1 {{'test.takes_static_memref' op operand #0 must be statically shaped memref of any type values}}
   "test.takes_static_memref"(%arg0) : (memref<?xi32>) -> ()
 }
 
 // -----
 
 func @elements_attr_not_i32_f32() {
-  // expected-error@+1 {{32-bit integer elements attribute}}
+  // expected-error@+1 {{32-bit signless integer elements attribute}}
   "test.i32ElementsAttr"() {attr = dense<[1.0, 20.0]>:tensor<2xf32>} : () -> ()
   return
 }
 
 // -----
 
 func @elements_attr_not_i32_i64() {
-  // expected-error@+1 {{32-bit integer elements attribute}}
+  // expected-error@+1 {{32-bit signless integer elements attribute}}
   "test.i32ElementsAttr"() {attr = dense<[1, 20]>:tensor<2xi64>} : () -> ()
   return
 }
 
 
 // -----
 
 func @elements_attr_i32(%arg0: tensor<1x2xi32>) {
   "test.i32ElementsAttr"() {attr = dense<[1, 2]>:tensor<2xi32>} : () -> ()
   return
 }