Eliminate all uses of Identifier::is() in the source tree, this doesn't remove the definition of it (yet). NFC.

[rriddle]

mlir/include/mlir/IR/Identifier.h

85–86

nit: Can we use /// here?

mlir/lib/Dialect/SPIRV/Serialization/Serializer.cpp

830

Do you even need the lambda anymore, i.e., could you use llvm::is_contained now?

898

Same here.

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

411

Same here.

mlir/tools/mlir-tblgen/SPIRVUtilsGen.cpp

619

Same here

[lattner]

mlir/include/mlir/IR/Identifier.h

85–86

This is a general comment, not a doc comment for that operator.

mlir/lib/Dialect/SPIRV/Serialization/Serializer.cpp

830

I don't think that is_contained works for any of these, because it is only comparing against the first element of the pair, not against the element of the sequence.

That said, I think the real issue here is that attribute lists are being processed pervasively as ArrayRef<NamedAttributes>, which doesn't have useful helper functions. Defining a proper type for this could make sense, but that is beyond the scope of this patch.

mlir/include/mlir/IR/Identifier.h

private:
   explicit Identifier(const EntryType *entry) : entry(entry) {}
 };
 
 inline raw_ostream &operator<<(raw_ostream &os, Identifier identifier) {
   identifier.print(os);
   return os;
 }
 
 // Identifier/Identifier equality comparisons are defined inline.
-inline bool operator==(Identifier lhs, StringRef rhs) { return lhs.is(rhs); }
-inline bool operator!=(Identifier lhs, StringRef rhs) { return !lhs.is(rhs); }
-inline bool operator==(StringRef lhs, Identifier rhs) { return rhs.is(lhs); }
-inline bool operator!=(StringRef lhs, Identifier rhs) { return !rhs.is(lhs); }
+inline bool operator==(Identifier lhs, StringRef rhs) {
+  return lhs.strref() == rhs;
+}
+inline bool operator!=(Identifier lhs, StringRef rhs) { return !(lhs == rhs); }
+
+inline bool operator==(StringRef lhs, Identifier rhs) {
+  return rhs.strref() == lhs;
+}
+inline bool operator!=(StringRef lhs, Identifier rhs) { return !(lhs == rhs); }
 
 // Make identifiers hashable.
 inline llvm::hash_code hash_value(Identifier arg) {
   // Identifiers are uniqued, so we can just hash the pointer they contain.
   return llvm::hash_value(arg.getAsOpaquePointer());
 }
 } // end namespace mlir
 

mlir/lib/Conversion/GPUToNVVM/LowerGpuOpsToNVVMOps.cpp

TypeConverter::SignatureConversion signatureConversion(
         gpuFuncOp.front().getNumArguments());
     typeConverter.convertFunctionSignature(
         gpuFuncOp.getType(), /*isVariadic=*/false, signatureConversion);
 
     // Create the new function operation. Only copy those attributes that are
     // not specific to function modeling.
     SmallVector<NamedAttribute, 4> attributes;
     for (const auto &attr : gpuFuncOp.getAttrs()) {
-      if (attr.first.is(SymbolTable::getSymbolAttrName()) ||
-          attr.first.is(impl::getTypeAttrName()) ||
-          attr.first.is(gpu::GPUFuncOp::getNumWorkgroupAttributionsAttrName()))
+      if (attr.first == SymbolTable::getSymbolAttrName() ||
+          attr.first == impl::getTypeAttrName() ||
+          attr.first == gpu::GPUFuncOp::getNumWorkgroupAttributionsAttrName())
         continue;
       attributes.push_back(attr);
     }
     auto llvmFuncOp = rewriter.create<LLVM::LLVMFuncOp>(
         gpuFuncOp.getLoc(), gpuFuncOp.getName(), funcType,
         LLVM::Linkage::External, attributes);
 
     {

mlir/lib/Conversion/GPUToSPIRV/ConvertGPUToSPIRV.cpp

for (auto argType : enumerate(funcOp.getType().getInputs())) {
       signatureConverter.addInputs(argType.index(), convertedType);
     }
   }
   auto newFuncOp = rewriter.create<spirv::FuncOp>(
       funcOp.getLoc(), funcOp.getName(),
       rewriter.getFunctionType(signatureConverter.getConvertedTypes(),
                                llvm::None));
   for (const auto &namedAttr : funcOp.getAttrs()) {
-    if (namedAttr.first.is(impl::getTypeAttrName()) ||
-        namedAttr.first.is(SymbolTable::getSymbolAttrName()))
+    if (namedAttr.first == impl::getTypeAttrName() ||
+        namedAttr.first == SymbolTable::getSymbolAttrName())
       continue;
     newFuncOp.setAttr(namedAttr.first, namedAttr.second);
   }
   rewriter.inlineRegionBefore(funcOp.getBody(), newFuncOp.getBody(),
                               newFuncOp.end());
   rewriter.applySignatureConversion(&newFuncOp.getBody(), signatureConverter);
   rewriter.eraseOp(funcOp);
 

mlir/lib/Conversion/StandardToLLVM/StandardToLLVM.cpp

 
 /// Only retain those attributes that are not constructed by
 /// `LLVMFuncOp::build`. If `filterArgAttrs` is set, also filter out argument
 /// attributes.
 static void filterFuncAttributes(ArrayRef<NamedAttribute> attrs,
                                  bool filterArgAttrs,
                                  SmallVectorImpl<NamedAttribute> &result) {
   for (const auto &attr : attrs) {
-    if (attr.first.is(SymbolTable::getSymbolAttrName()) ||
-        attr.first.is(impl::getTypeAttrName()) ||
-        attr.first.is("std.varargs") ||
+    if (attr.first == SymbolTable::getSymbolAttrName() ||
+        attr.first == impl::getTypeAttrName() || attr.first == "std.varargs" ||
         (filterArgAttrs && impl::isArgAttrName(attr.first.strref())))
       continue;
     result.push_back(attr);
   }
 }
 
 /// Creates an auxiliary function with pointer-to-memref-descriptor-struct
 /// arguments instead of unpacked arguments. This function can be called from C

mlir/lib/Dialect/GPU/IR/GPUDialect.cpp

 #define GET_OP_LIST
 #include "mlir/Dialect/GPU/GPUOps.cpp.inc"
       >();
 }
 
 LogicalResult GPUDialect::verifyOperationAttribute(Operation *op,
                                                    NamedAttribute attr) {
   if (!attr.second.isa<UnitAttr>() ||
-      !attr.first.is(getContainerModuleAttrName()))
+      attr.first != getContainerModuleAttrName())
     return success();
 
   auto module = dyn_cast<ModuleOp>(op);
   if (!module)
     return op->emitError("expected '")
            << getContainerModuleAttrName() << "' attribute to be attached to '"
            << ModuleOp::getOperationName() << '\'';
 

mlir/lib/Dialect/SPIRV/SPIRVLowering.cpp

FuncOpConversion::matchAndRewrite(FuncOp funcOp, ArrayRef<Value> operands,
   // Create the converted spv.func op.
   auto newFuncOp = rewriter.create<spirv::FuncOp>(
       funcOp.getLoc(), funcOp.getName(),
       rewriter.getFunctionType(signatureConverter.getConvertedTypes(),
                                llvm::None));
 
   // Copy over all attributes other than the function name and type.
   for (const auto &namedAttr : funcOp.getAttrs()) {
-    if (!namedAttr.first.is(impl::getTypeAttrName()) &&
-        !namedAttr.first.is(SymbolTable::getSymbolAttrName()))
+    if (namedAttr.first != impl::getTypeAttrName() &&
+        namedAttr.first != SymbolTable::getSymbolAttrName())
       newFuncOp.setAttr(namedAttr.first, namedAttr.second);
   }
 
   rewriter.inlineRegionBefore(funcOp.getBody(), newFuncOp.getBody(),
                               newFuncOp.end());
   rewriter.applySignatureConversion(&newFuncOp.getBody(), signatureConverter);
   rewriter.eraseOp(funcOp);
   return success();

mlir/lib/Dialect/SPIRV/Serialization/Serializer.cpp

if (!argID) {
       return emitError(op.getLoc(), "operand 0 has a use before def");
     }
     operands.push_back(argID);
   }
   encodeInstructionInto(functionHeader, spirv::getOpcode<spirv::VariableOp>(),
                         operands);
   for (auto attr : op.getAttrs()) {
     if (llvm::any_of(elidedAttrs,
-                     [&](StringRef elided) { return attr.first.is(elided); })) {
+                     [&](StringRef elided) { return attr.first == elided; })) {
       continue;
     }
     if (failed(processDecoration(op.getLoc(), resultID, attr))) {
       return failure();
     }
   }
   return success();
 }
if (failed(encodeInstructionInto(typesGlobalValues, spirv::Opcode::OpVariable,
                                    operands))) {
     elidedAttrs.push_back("initializer");
     return failure();
   }
 
   // Encode decorations.
   for (auto attr : varOp.getAttrs()) {
     if (llvm::any_of(elidedAttrs,
-                     [&](StringRef elided) { return attr.first.is(elided); })) {
+                     [&](StringRef elided) { return attr.first == elided; })) {
       continue;
     }
     if (failed(processDecoration(varOp.getLoc(), resultID, attr))) {
       return failure();
     }
   }
   return success();
 }

mlir/lib/IR/Attributes.cpp

auto compare = [](NamedAttribute attr, StringRef name) -> bool {
     // This is correct even when attr.first.data()[name.size()] is not a zero
     // string terminator, because we only care about a less than comparison.
     // This can't use memcmp, because it doesn't guarantee that it will stop
     // reading both buffers if one is shorter than the other, even if there is
     // a difference.
     return strncmp(attr.first.data(), name.data(), name.size()) < 0;
   };
   auto it = llvm::lower_bound(values, name, compare);
-  return it != values.end() && it->first.is(name) ? it->second : Attribute();
+  return it != values.end() && it->first == name ? it->second : Attribute();
 }
 Attribute DictionaryAttr::get(Identifier name) const {
   for (auto elt : getValue())
     if (elt.first == name)
       return elt.second;
   return nullptr;
 }
 

mlir/lib/IR/TypeUtilities.cpp

SmallVector<Type, 10> mlir::getFlattenedTypes(TupleType t) {
   return fTypes;
 }
 
 /// Return true if the specified type is an opaque type with the specified
 /// dialect and typeData.
 bool mlir::isOpaqueTypeWithName(Type type, StringRef dialect,
                                 StringRef typeData) {
   if (auto opaque = type.dyn_cast<mlir::OpaqueType>())
-    return opaque.getDialectNamespace().is(dialect) &&
+    return opaque.getDialectNamespace() == dialect &&
            opaque.getTypeData() == typeData;
   return false;
 }
 
 /// Returns success if the given two shapes are compatible. That is, they have
 /// the same size and each pair of the elements are equal or one of them is
 /// dynamic.
 LogicalResult mlir::verifyCompatibleShape(ArrayRef<int64_t> shape1,

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

for (size_t i = 0, e = parser.getNumResults(); i != e; ++i)
     result.addTypes(parser.getBuilder().getIntegerType(32));
 
   if (parser.parseOptionalAttrDictWithKeyword(result.attributes))
     return failure();
 
   // If the attribute dictionary contains no 'names' attribute, infer it from
   // the SSA name (if specified).
   bool hadNames = llvm::any_of(result.attributes, [](NamedAttribute attr) {
-    return attr.first.is("names");
+    return attr.first == "names";
   });
 
   // If there was no name specified, check to see if there was a useful name
   // specified in the asm file.
   if (hadNames || parser.getNumResults() == 0)
     return success();
 
   SmallVector<StringRef, 4> names;

mlir/tools/mlir-tblgen/SPIRVUtilsGen.cpp

 /// SPIR-V binary.
 static void emitDecorationSerialization(const Operator &op, StringRef tabs,
                                         StringRef opVar, StringRef elidedAttrs,
                                         StringRef resultID, raw_ostream &os) {
   if (op.getNumResults() == 1) {
     // All non-argument attributes translated into OpDecorate instruction
     os << tabs << formatv("for (auto attr : {0}.getAttrs()) {{\n", opVar);
     os << tabs
        << formatv("  if (llvm::any_of({0}, [&](StringRef elided)", elidedAttrs);
-    os << " {return attr.first.is(elided);})) {\n";
+    os << " {return attr.first == elided;})) {\n";
     os << tabs << "    continue;\n";
     os << tabs << "  }\n";
     os << tabs
        << formatv(
               "  if (failed(processDecoration({0}.getLoc(), {1}, attr))) {{\n",
               opVar, resultID);
     os << tabs << "    return failure();\n";
     os << tabs << "  }\n";