[MLIR] Add LLVM_NODISCARD to MLIR builders for types and attributes.

[frgossen]

Summary

Building a type or an attribute w/o using the value is almost certainly a bug.

[jpienaar]

Could you add rationale to description?

[frgossen]

Added rationale

[rriddle]

We don't need to touch the declarations in the .h at all?

[pifon2a]

@frgossen is it still needed?

mlir/lib/IR/Builders.cpp

 Location Builder::getFusedLoc(ArrayRef<Location> locs, Attribute metadata) {
   return FusedLoc::get(locs, metadata, context);
 }
 
 //===----------------------------------------------------------------------===//
 // Types.
 //===----------------------------------------------------------------------===//
 
-FloatType Builder::getBF16Type() { return FloatType::getBF16(context); }
+LLVM_NODISCARD FloatType Builder::getBF16Type() {
+  return FloatType::getBF16(context);
+}
 
-FloatType Builder::getF16Type() { return FloatType::getF16(context); }
+LLVM_NODISCARD FloatType Builder::getF16Type() {
+  return FloatType::getF16(context);
+}
 
-FloatType Builder::getF32Type() { return FloatType::getF32(context); }
+LLVM_NODISCARD FloatType Builder::getF32Type() {
+  return FloatType::getF32(context);
+}
 
-FloatType Builder::getF64Type() { return FloatType::getF64(context); }
+LLVM_NODISCARD FloatType Builder::getF64Type() {
+  return FloatType::getF64(context);
+}
 
-FloatType Builder::getF80Type() { return FloatType::getF80(context); }
+LLVM_NODISCARD FloatType Builder::getF80Type() {
+  return FloatType::getF80(context);
+}
 
-FloatType Builder::getF128Type() { return FloatType::getF128(context); }
+LLVM_NODISCARD FloatType Builder::getF128Type() {
+  return FloatType::getF128(context);
+}
 
-IndexType Builder::getIndexType() { return IndexType::get(context); }
+LLVM_NODISCARD IndexType Builder::getIndexType() {
+  return IndexType::get(context);
+}
 
-IntegerType Builder::getI1Type() { return IntegerType::get(context, 1); }
+LLVM_NODISCARD IntegerType Builder::getI1Type() {
+  return IntegerType::get(context, 1);
+}
 
-IntegerType Builder::getI8Type() { return IntegerType::get(context, 8); }
+LLVM_NODISCARD IntegerType Builder::getI8Type() {
+  return IntegerType::get(context, 8);
+}
 
-IntegerType Builder::getI32Type() { return IntegerType::get(context, 32); }
+LLVM_NODISCARD IntegerType Builder::getI32Type() {
+  return IntegerType::get(context, 32);
+}
 
-IntegerType Builder::getI64Type() { return IntegerType::get(context, 64); }
+LLVM_NODISCARD IntegerType Builder::getI64Type() {
+  return IntegerType::get(context, 64);
+}
 
-IntegerType Builder::getIntegerType(unsigned width) {
+LLVM_NODISCARD IntegerType Builder::getIntegerType(unsigned width) {
   return IntegerType::get(context, width);
 }
 
-IntegerType Builder::getIntegerType(unsigned width, bool isSigned) {
+LLVM_NODISCARD IntegerType Builder::getIntegerType(unsigned width,
+                                                   bool isSigned) {
   return IntegerType::get(
       context, width, isSigned ? IntegerType::Signed : IntegerType::Unsigned);
 }
 
-FunctionType Builder::getFunctionType(TypeRange inputs, TypeRange results) {
+LLVM_NODISCARD FunctionType Builder::getFunctionType(TypeRange inputs,
+                                                     TypeRange results) {
   return FunctionType::get(context, inputs, results);
 }
 
-TupleType Builder::getTupleType(TypeRange elementTypes) {
+LLVM_NODISCARD TupleType Builder::getTupleType(TypeRange elementTypes) {
   return TupleType::get(context, elementTypes);
 }
 
-NoneType Builder::getNoneType() { return NoneType::get(context); }
+LLVM_NODISCARD NoneType Builder::getNoneType() {
+  return NoneType::get(context);
+}
 
 //===----------------------------------------------------------------------===//
 // Attributes.
 //===----------------------------------------------------------------------===//
 
-NamedAttribute Builder::getNamedAttr(StringRef name, Attribute val) {
+LLVM_NODISCARD NamedAttribute Builder::getNamedAttr(StringRef name,
+                                                    Attribute val) {
   return NamedAttribute(getStringAttr(name), val);
 }
 
-UnitAttr Builder::getUnitAttr() { return UnitAttr::get(context); }
+LLVM_NODISCARD UnitAttr Builder::getUnitAttr() {
+  return UnitAttr::get(context);
+}
 
-BoolAttr Builder::getBoolAttr(bool value) {
+LLVM_NODISCARD BoolAttr Builder::getBoolAttr(bool value) {
   return BoolAttr::get(context, value);
 }
 
-DictionaryAttr Builder::getDictionaryAttr(ArrayRef<NamedAttribute> value) {
+LLVM_NODISCARD DictionaryAttr
+Builder::getDictionaryAttr(ArrayRef<NamedAttribute> value) {
   return DictionaryAttr::get(context, value);
 }
 
-IntegerAttr Builder::getIndexAttr(int64_t value) {
+LLVM_NODISCARD IntegerAttr Builder::getIndexAttr(int64_t value) {
   return IntegerAttr::get(getIndexType(), APInt(64, value));
 }
 
-IntegerAttr Builder::getI64IntegerAttr(int64_t value) {
+LLVM_NODISCARD IntegerAttr Builder::getI64IntegerAttr(int64_t value) {
   return IntegerAttr::get(getIntegerType(64), APInt(64, value));
 }
 
-DenseIntElementsAttr Builder::getBoolVectorAttr(ArrayRef<bool> values) {
+LLVM_NODISCARD DenseIntElementsAttr
+Builder::getBoolVectorAttr(ArrayRef<bool> values) {
   return DenseIntElementsAttr::get(
       VectorType::get(static_cast<int64_t>(values.size()), getI1Type()),
       values);
 }
 
-DenseIntElementsAttr Builder::getI32VectorAttr(ArrayRef<int32_t> values) {
+LLVM_NODISCARD DenseIntElementsAttr
+Builder::getI32VectorAttr(ArrayRef<int32_t> values) {
   return DenseIntElementsAttr::get(
       VectorType::get(static_cast<int64_t>(values.size()), getIntegerType(32)),
       values);
 }
 
-DenseIntElementsAttr Builder::getI64VectorAttr(ArrayRef<int64_t> values) {
+LLVM_NODISCARD DenseIntElementsAttr
+Builder::getI64VectorAttr(ArrayRef<int64_t> values) {
   return DenseIntElementsAttr::get(
       VectorType::get(static_cast<int64_t>(values.size()), getIntegerType(64)),
       values);
 }
 
-DenseIntElementsAttr Builder::getIndexVectorAttr(ArrayRef<int64_t> values) {
+LLVM_NODISCARD DenseIntElementsAttr
+Builder::getIndexVectorAttr(ArrayRef<int64_t> values) {
   return DenseIntElementsAttr::get(
       VectorType::get(static_cast<int64_t>(values.size()), getIndexType()),
       values);
 }
 
-DenseIntElementsAttr Builder::getI32TensorAttr(ArrayRef<int32_t> values) {
+LLVM_NODISCARD DenseIntElementsAttr
+Builder::getI32TensorAttr(ArrayRef<int32_t> values) {
   return DenseIntElementsAttr::get(
       RankedTensorType::get(static_cast<int64_t>(values.size()),
                             getIntegerType(32)),
       values);
 }
 
-DenseIntElementsAttr Builder::getI64TensorAttr(ArrayRef<int64_t> values) {
+LLVM_NODISCARD DenseIntElementsAttr
+Builder::getI64TensorAttr(ArrayRef<int64_t> values) {
   return DenseIntElementsAttr::get(
       RankedTensorType::get(static_cast<int64_t>(values.size()),
                             getIntegerType(64)),
       values);
 }
 
-DenseIntElementsAttr Builder::getIndexTensorAttr(ArrayRef<int64_t> values) {
+LLVM_NODISCARD DenseIntElementsAttr
+Builder::getIndexTensorAttr(ArrayRef<int64_t> values) {
   return DenseIntElementsAttr::get(
       RankedTensorType::get(static_cast<int64_t>(values.size()),
                             getIndexType()),
       values);
 }
 
-IntegerAttr Builder::getI32IntegerAttr(int32_t value) {
+LLVM_NODISCARD IntegerAttr Builder::getI32IntegerAttr(int32_t value) {
   return IntegerAttr::get(getIntegerType(32), APInt(32, value));
 }
 
-IntegerAttr Builder::getSI32IntegerAttr(int32_t value) {
+LLVM_NODISCARD IntegerAttr Builder::getSI32IntegerAttr(int32_t value) {
   return IntegerAttr::get(getIntegerType(32, /*isSigned=*/true),
                           APInt(32, value, /*isSigned=*/true));
 }
 
-IntegerAttr Builder::getUI32IntegerAttr(uint32_t value) {
+LLVM_NODISCARD IntegerAttr Builder::getUI32IntegerAttr(uint32_t value) {
   return IntegerAttr::get(getIntegerType(32, /*isSigned=*/false),
                           APInt(32, (uint64_t)value, /*isSigned=*/false));
 }
 
-IntegerAttr Builder::getI16IntegerAttr(int16_t value) {
+LLVM_NODISCARD IntegerAttr Builder::getI16IntegerAttr(int16_t value) {
   return IntegerAttr::get(getIntegerType(16), APInt(16, value));
 }
 
-IntegerAttr Builder::getI8IntegerAttr(int8_t value) {
+LLVM_NODISCARD IntegerAttr Builder::getI8IntegerAttr(int8_t value) {
   return IntegerAttr::get(getIntegerType(8), APInt(8, value));
 }
 
-IntegerAttr Builder::getIntegerAttr(Type type, int64_t value) {
+LLVM_NODISCARD IntegerAttr Builder::getIntegerAttr(Type type, int64_t value) {
   if (type.isIndex())
     return IntegerAttr::get(type, APInt(64, value));
   return IntegerAttr::get(
       type, APInt(type.getIntOrFloatBitWidth(), value, type.isSignedInteger()));
 }
 
-IntegerAttr Builder::getIntegerAttr(Type type, const APInt &value) {
+LLVM_NODISCARD IntegerAttr Builder::getIntegerAttr(Type type,
+                                                   const APInt &value) {
   return IntegerAttr::get(type, value);
 }
 
-FloatAttr Builder::getF64FloatAttr(double value) {
+LLVM_NODISCARD FloatAttr Builder::getF64FloatAttr(double value) {
   return FloatAttr::get(getF64Type(), APFloat(value));
 }
 
-FloatAttr Builder::getF32FloatAttr(float value) {
+LLVM_NODISCARD FloatAttr Builder::getF32FloatAttr(float value) {
   return FloatAttr::get(getF32Type(), APFloat(value));
 }
 
-FloatAttr Builder::getF16FloatAttr(float value) {
+LLVM_NODISCARD FloatAttr Builder::getF16FloatAttr(float value) {
   return FloatAttr::get(getF16Type(), value);
 }
 
-FloatAttr Builder::getFloatAttr(Type type, double value) {
+LLVM_NODISCARD FloatAttr Builder::getFloatAttr(Type type, double value) {
   return FloatAttr::get(type, value);
 }
 
-FloatAttr Builder::getFloatAttr(Type type, const APFloat &value) {
+LLVM_NODISCARD FloatAttr Builder::getFloatAttr(Type type,
+                                               const APFloat &value) {
   return FloatAttr::get(type, value);
 }
 
-StringAttr Builder::getStringAttr(const Twine &bytes) {
+LLVM_NODISCARD StringAttr Builder::getStringAttr(const Twine &bytes) {
   return StringAttr::get(context, bytes);
 }
 
-ArrayAttr Builder::getArrayAttr(ArrayRef<Attribute> value) {
+LLVM_NODISCARD ArrayAttr Builder::getArrayAttr(ArrayRef<Attribute> value) {
   return ArrayAttr::get(context, value);
 }
 
-ArrayAttr Builder::getBoolArrayAttr(ArrayRef<bool> values) {
+LLVM_NODISCARD ArrayAttr Builder::getBoolArrayAttr(ArrayRef<bool> values) {
   auto attrs = llvm::to_vector<8>(llvm::map_range(
       values, [this](bool v) -> Attribute { return getBoolAttr(v); }));
   return getArrayAttr(attrs);
 }
 
-ArrayAttr Builder::getI32ArrayAttr(ArrayRef<int32_t> values) {
+LLVM_NODISCARD ArrayAttr Builder::getI32ArrayAttr(ArrayRef<int32_t> values) {
   auto attrs = llvm::to_vector<8>(llvm::map_range(
       values, [this](int32_t v) -> Attribute { return getI32IntegerAttr(v); }));
   return getArrayAttr(attrs);
 }
-ArrayAttr Builder::getI64ArrayAttr(ArrayRef<int64_t> values) {
+LLVM_NODISCARD ArrayAttr Builder::getI64ArrayAttr(ArrayRef<int64_t> values) {
   auto attrs = llvm::to_vector<8>(llvm::map_range(
       values, [this](int64_t v) -> Attribute { return getI64IntegerAttr(v); }));
   return getArrayAttr(attrs);
 }
 
-ArrayAttr Builder::getIndexArrayAttr(ArrayRef<int64_t> values) {
+LLVM_NODISCARD ArrayAttr Builder::getIndexArrayAttr(ArrayRef<int64_t> values) {
   auto attrs = llvm::to_vector<8>(
       llvm::map_range(values, [this](int64_t v) -> Attribute {
         return getIntegerAttr(IndexType::get(getContext()), v);
       }));
   return getArrayAttr(attrs);
 }
 
-ArrayAttr Builder::getF32ArrayAttr(ArrayRef<float> values) {
+LLVM_NODISCARD ArrayAttr Builder::getF32ArrayAttr(ArrayRef<float> values) {
   auto attrs = llvm::to_vector<8>(llvm::map_range(
       values, [this](float v) -> Attribute { return getF32FloatAttr(v); }));
   return getArrayAttr(attrs);
 }
 
-ArrayAttr Builder::getF64ArrayAttr(ArrayRef<double> values) {
+LLVM_NODISCARD ArrayAttr Builder::getF64ArrayAttr(ArrayRef<double> values) {
   auto attrs = llvm::to_vector<8>(llvm::map_range(
       values, [this](double v) -> Attribute { return getF64FloatAttr(v); }));
   return getArrayAttr(attrs);
 }
 
-ArrayAttr Builder::getStrArrayAttr(ArrayRef<StringRef> values) {
+LLVM_NODISCARD ArrayAttr Builder::getStrArrayAttr(ArrayRef<StringRef> values) {
   auto attrs = llvm::to_vector<8>(llvm::map_range(
       values, [this](StringRef v) -> Attribute { return getStringAttr(v); }));
   return getArrayAttr(attrs);
 }
 
-ArrayAttr Builder::getTypeArrayAttr(TypeRange values) {
+LLVM_NODISCARD ArrayAttr Builder::getTypeArrayAttr(TypeRange values) {
   auto attrs = llvm::to_vector<8>(llvm::map_range(
       values, [](Type v) -> Attribute { return TypeAttr::get(v); }));
   return getArrayAttr(attrs);
 }
 
-ArrayAttr Builder::getAffineMapArrayAttr(ArrayRef<AffineMap> values) {
+LLVM_NODISCARD ArrayAttr
+Builder::getAffineMapArrayAttr(ArrayRef<AffineMap> values) {
   auto attrs = llvm::to_vector<8>(llvm::map_range(
       values, [](AffineMap v) -> Attribute { return AffineMapAttr::get(v); }));
   return getArrayAttr(attrs);
 }
 
-Attribute Builder::getZeroAttr(Type type) {
+LLVM_NODISCARD Attribute Builder::getZeroAttr(Type type) {
   if (type.isa<FloatType>())
     return getFloatAttr(type, 0.0);
   if (type.isa<IndexType>())
     return getIndexAttr(0);
   if (auto integerType = type.dyn_cast<IntegerType>())
     return getIntegerAttr(type, APInt(type.cast<IntegerType>().getWidth(), 0));
   if (type.isa<RankedTensorType, VectorType>()) {
     auto vtType = type.cast<ShapedType>();