[mlir][ODS] Use StringLiteral instead of StringRef when applicable

[vinograd47]

Summary

Use StringLiteral for function return type if it is known to return
constant string literals only.

This will make it visible to API users, that such values can be safely
stored, since they refers to constant data, which will never be deallocated.

StringRef is general is not safe to store for a long term,
since it might refer to temporal data allocated in heap.

[mehdi_amini]

I "think" that's right? Adding @bkramer though :)

[bkramer]

I don't think we have used StringLiteral to convey that "this string lives forever" so far, but I'm not opposed to it.

[vinograd47]

@mehdi_amini I don't have commit access. Could you please land this change?

[antiagainst]

FYI: this breaks GCC 5 build for MLIR: https://buildkite.com/mlir/mlir-core/builds/11335#0b95a5de-d6b4-4c61-b9e5-9fee76a73921

I'll revert this for now.

[antiagainst]

Also, per the comment of StringLiteral (https://github.com/llvm/llvm-project/blob/b198f1f86ce09b86825dd6d80de2c72a617e27f7/llvm/include/llvm/ADT/StringRef.h#L867-L868):

/// In order to avoid the invocation of a global constructor, StringLiteral should *only* be used in a constexpr context

The usage here does not seem to fit into that category?

mlir/include/mlir/IR/OpBase.td

class EnumAttrInfo<string name, list<EnumAttrCaseInfo> cases> {
 
   // The name of the utility function that converts a symbol to the
   // corresponding string. It will have the following signature:
   //
   // ```c++
   // <return-type> <fn-name>(<qualified-enum-class-name>);
   // ```
   string symbolToStringFnName = "stringify" # name;
-  string symbolToStringFnRetType = "::llvm::StringRef";
+  string symbolToStringFnRetType = "::llvm::StringLiteral";
 
   // The name of the utility function that returns the max enum value used
   // within the enum class. It will have the following signature:
   //
   // ```c++
   // static constexpr unsigned <fn-name>();
   // ```
   string maxEnumValFnName = "getMaxEnumValFor" # name;

mlir/test/mlir-tblgen/op-decl.td

 // CHECK:   ::mlir::ValueRange odsOperands;
 // CHECK: };
 
 // CHECK: class AOp : public ::mlir::Op<AOp, ::mlir::OpTrait::AtLeastNRegions<1>::Impl, ::mlir::OpTrait::AtLeastNResults<1>::Impl, ::mlir::OpTrait::ZeroSuccessor, ::mlir::OpTrait::AtLeastNOperands<1>::Impl, ::mlir::OpTrait::IsIsolatedFromAbove
 // CHECK-NOT: ::mlir::OpTrait::IsIsolatedFromAbove
 // CHECK: public:
 // CHECK:   using Op::Op;
 // CHECK:   using Adaptor = AOpAdaptor;
-// CHECK:   static ::llvm::StringRef getOperationName();
+// CHECK:   static ::llvm::StringLiteral getOperationName();
 // CHECK:   ::mlir::Operation::operand_range getODSOperands(unsigned index);
 // CHECK:   ::mlir::Value a();
 // CHECK:   ::mlir::Operation::operand_range b();
 // CHECK:   ::mlir::MutableOperandRange aMutable();
 // CHECK:   ::mlir::MutableOperandRange bMutable();
 // CHECK:   ::mlir::Operation::result_range getODSResults(unsigned index);
 // CHECK:   ::mlir::Value r();
 // CHECK:   ::mlir::Region &someRegion();

mlir/tools/mlir-tblgen/DialectGen.cpp

explicit {0}(::mlir::MLIRContext *context)
     : ::mlir::Dialect(getDialectNamespace(), context,
       ::mlir::TypeID::get<{0}>()) {{
     {2}
     initialize();
   }
   void initialize();
   friend class ::mlir::MLIRContext;
 public:
-  static ::llvm::StringRef getDialectNamespace() { return "{1}"; }
+  static ::llvm::StringLiteral getDialectNamespace() { return "{1}"; }
 )";
 
 /// Registration for a single dependent dialect: to be inserted in the ctor
 /// above for each dependent dialect.
 const char *const dialectRegistrationTemplate = R"(
     getContext()->getOrLoadDialect<{0}>();
 )";
 

mlir/tools/mlir-tblgen/OpDefinitionsGen.cpp

if (auto opTrait = dyn_cast<tblgen::NativeOpTrait>(&trait))
       opClass.addTrait(opTrait->getTrait());
     else if (auto opTrait = dyn_cast<tblgen::InterfaceOpTrait>(&trait))
       opClass.addTrait(opTrait->getTrait());
   }
 }
 
 void OpEmitter::genOpNameGetter() {
   auto *method = opClass.addMethodAndPrune(
-      "::llvm::StringRef", "getOperationName", OpMethod::MP_Static);
+      "::llvm::StringLiteral", "getOperationName", OpMethod::MP_Static);
   method->body() << "  return \"" << op.getOperationName() << "\";\n";
 }
 
 void OpEmitter::genOpAsmInterface() {
   // If the user only has one results or specifically added the Asm trait,
   // then don't generate it for them. We specifically only handle multi result
   // operations, because the name of a single result in the common case is not
   // interesting(generally 'result'/'output'/etc.).

mlir/tools/mlir-tblgen/PassGen.cpp

 const char *const passDeclBegin = R"(
 //===----------------------------------------------------------------------===//
 // {0}
 //===----------------------------------------------------------------------===//
 
 template <typename DerivedT>
 class {0}Base : public {1} {
 public:
+  using Base = {0}Base;
+
   {0}Base() : {1}(::mlir::TypeID::get<DerivedT>()) {{}
   {0}Base(const {0}Base &) : {1}(::mlir::TypeID::get<DerivedT>()) {{}
 
   /// Returns the command-line argument attached to this pass.
+  static ::llvm::StringLiteral getArgumentName() { return "{2}"; }
   ::llvm::StringRef getArgument() const override { return "{2}"; }
 
   /// Returns the derived pass name.
+  static ::llvm::StringLiteral getPassName() { return "{0}"; }
   ::llvm::StringRef getName() const override { return "{0}"; }
 
   /// Support isa/dyn_cast functionality for the derived pass class.
   static bool classof(const ::mlir::Pass *pass) {{
     return pass->getTypeID() == ::mlir::TypeID::get<DerivedT>();
   }
 
   /// A clone method to create a copy of this pass.