[mlir] Add `empty` to `StringAttr`

[Mogball]

Summary

It was common to see value.getValue().empty() or value.size()
instead of the idiomatic value.empty().

Depends on D159455

mlir/include/mlir/IR/BuiltinAttributes.td

let extraClassDeclaration = [{
     std::string str() const { return getValue().str(); }
 
     /// Return a pointer to the start of the string data.
     const char *data() const { return getValue().data(); }
 
     /// Return the number of bytes in this string.
     size_t size() const { return getValue().size(); }
 
+    /// Return whether the string is empty.
+    bool empty() const { return getValue().empty(); }
+
     /// Iterate over the underlying string data.
     StringRef::iterator begin() const { return getValue().begin(); }
     StringRef::iterator end() const { return getValue().end(); }
 
     /// Compare the underlying string value to the one in `rhs`.
     int compare(StringAttr rhs) const {
       if (*this == rhs)
         return 0;

mlir/lib/Dialect/EmitC/IR/EmitC.cpp

 
 /// The constant op requires that the attribute's type matches the return type.
 LogicalResult emitc::ConstantOp::verify() {
   if (llvm::isa<emitc::OpaqueAttr>(getValueAttr()))
     return success();
 
   // Value must not be empty
   StringAttr strAttr = llvm::dyn_cast<StringAttr>(getValueAttr());
-  if (strAttr && strAttr.getValue().empty())
+  if (strAttr && strAttr.empty())
     return emitOpError() << "value must not be empty";
 
   auto value = cast<TypedAttr>(getValueAttr());
   Type type = getType();
   if (!llvm::isa<NoneType>(value.getType()) && type != value.getType())
     return emitOpError() << "requires attribute's type (" << value.getType()
                          << ") to match op's return type (" << type << ")";
   return success();
 }
 
-OpFoldResult emitc::ConstantOp::fold(FoldAdaptor adaptor) {
-  return getValue();
-}
+OpFoldResult emitc::ConstantOp::fold(FoldAdaptor adaptor) { return getValue(); }
 
 //===----------------------------------------------------------------------===//
 // IncludeOp
 //===----------------------------------------------------------------------===//
 
 void IncludeOp::print(OpAsmPrinter &p) {
   bool standardInclude = getIsStandardInclude();
 

mlir/lib/Target/LLVMIR/DebugTranslation.cpp

llvm::DIType *DebugTranslation::translateImpl(DINullTypeAttr attr) {
   // a void result type. If it is at the end, it models a variadic function.
   // Translate the explicit DINullTypeAttr to a nullptr since LLVM IR metadata
   // does not have an explicit void result type nor a variadic type
   // representation.
   return nullptr;
 }
 
 llvm::MDString *DebugTranslation::getMDStringOrNull(StringAttr stringAttr) {
-  if (!stringAttr || stringAttr.getValue().empty())
+  if (!stringAttr || stringAttr.empty())
     return nullptr;
   return llvm::MDString::get(llvmCtx, stringAttr);
 }
 
 llvm::DIBasicType *DebugTranslation::translateImpl(DIBasicTypeAttr attr) {
   return llvm::DIBasicType::get(
       llvmCtx, attr.getTag(), getMDStringOrNull(attr.getName()),
       attr.getSizeInBits(),

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

if (auto str = dyn_cast<StringAttr>(value[i]))
         setNameFn(getResult(i), str.getValue());
 }
 
 void CustomResultsNameOp::getAsmResultNames(
     function_ref<void(Value, StringRef)> setNameFn) {
   ArrayAttr value = getNames();
   for (size_t i = 0, e = value.size(); i != e; ++i)
     if (auto str = dyn_cast<StringAttr>(value[i]))
-      if (!str.getValue().empty())
+      if (!str.empty())
         setNameFn(getResult(i), str.getValue());
 }
 
 //===----------------------------------------------------------------------===//
 // ResultTypeWithTraitOp
 //===----------------------------------------------------------------------===//
 
 LogicalResult ResultTypeWithTraitOp::verify() {

mlir/unittests/IR/AttributeTest.cpp

TEST(SparseElementsAttrTest, GetZero) {
 
   auto zeroFloatValue =
       cast<FloatAttr>(sparseFloat.getValues<Attribute>()[{1, 1}]);
   EXPECT_EQ(zeroFloatValue.getValueAsDouble(), 0.0f);
   EXPECT_TRUE(zeroFloatValue.getType() == floatTy);
 
   auto zeroStringValue =
       cast<StringAttr>(sparseString.getValues<Attribute>()[{1, 1}]);
-  EXPECT_TRUE(zeroStringValue.getValue().empty());
+  EXPECT_TRUE(zeroStringValue.empty());
   EXPECT_TRUE(zeroStringValue.getType() == stringTy);
 }
 
 //===----------------------------------------------------------------------===//
 // SubElements
 //===----------------------------------------------------------------------===//
 
 TEST(SubElementTest, Nested) {