[mlir][tblgen] Consistently use `$_ctxt` instead of `$_ctx`

[zero9178]

Summary

With the exceptions of AttrOrTypeParameter and DerivedAttr, all of MLIR consistently uses $_ctxt as the substitute variable for the MLIRContext in TableGen C++ code.
Usually this does not matter unless one where to reuse some code in multiple fields but it still needlessly inconsistent and prone to error.

This patch fixes that by consistently using _$ctxt everywhere.

mlir/docs/AttributesAndTypes.md

 Which will look like:
 
 ```mlir
 !test.default_valued     // a = 5
 !test.default_valued<10> // a = 10
 ```
 
 For optional `Attribute` or `Type` parameters, the current MLIR context is
-available through `$_ctx`. E.g.
+available through `$_ctxt`. E.g.
 
 ```tablegen
-DefaultValuedParameter<"IntegerType", "IntegerType::get($_ctx, 32)">
+DefaultValuedParameter<"IntegerType", "IntegerType::get($_ctxt, 32)">
 ```
 
 ##### Assembly Format Directives
 
 Attribute and type assembly formats have the following directives:
 
 - `params`: capture all parameters of an attribute or type.
 - `qualified`: mark a parameter to be printed with its leading dialect and

mlir/include/mlir/IR/AttrTypeBase.td

class AttrOrTypeParameter<string type, string desc, string accessorType = ""> {
   // must be default constructible and be contextually convertible to `bool`.
   // Any `Optional<T>` and any attribute type satisfies these requirements.
   bit isOptional = 0;
   // Provide a default value for the parameter. Parameters with default values
   // are considered optional. If a value was not parsed for the parameter, it
   // will be set to the default value. Parameters equal to their default values
   // are elided when printing. Equality is checked using the `comparator` field,
   // which by default is the C++ equality operator. The current MLIR context is
-  // made available through `$_ctx`, e.g., for constructing default values for
+  // made available through `$_ctxt`, e.g., for constructing default values for
   // attributes and types.
   string defaultValue = ?;
 }
 class AttrParameter<string type, string desc, string accessorType = "">
  : AttrOrTypeParameter<type, desc, accessorType>;
 class TypeParameter<string type, string desc, string accessorType = "">
  : AttrOrTypeParameter<type, desc, accessorType>;
 

mlir/include/mlir/IR/OpBase.td

class DerivedAttr<code ret, code b, code convert = ""> :
 
   // Specify how to convert from the derived attribute to an attribute.
   //
   // ## Special placeholders
   //
   // Special placeholders can be used to refer to entities during conversion:
   //
   // * `$_builder` will be replaced by a mlir::Builder instance.
-  // * `$_ctx` will be replaced by the MLIRContext* instance.
+  // * `$_ctxt` will be replaced by the MLIRContext* instance.
   // * `$_self` will be replaced with the derived attribute (value produces
   //    `returnType`).
   let convertFromStorage = convert;
 }
 
 // Derived attribute that returns a mlir::Type.
 class DerivedTypeAttr<code body> : DerivedAttr<"::mlir::Type", body> {
   let convertFromStorage = "::mlir::TypeAttr::get($_self)";

mlir/test/lib/Dialect/Test/TestTypeDefs.td

def TestTypeAPFloat : Test_Type<"TestTypeAPFloat"> {
   );
   let mnemonic = "ap_float";
   let assemblyFormat = "`<` $a `>`";
 }
 
 def TestTypeDefaultValuedType : Test_Type<"TestTypeDefaultValuedType"> {
   let parameters = (ins
     DefaultValuedParameter<"mlir::IntegerType",
-                           "mlir::IntegerType::get($_ctx, 32)">:$type
+                           "mlir::IntegerType::get($_ctxt, 32)">:$type
   );
   let mnemonic = "default_valued_type";
   let assemblyFormat = "`<` (`(` $type^ `)`)? `>`";
 }
 
 def TestTypeCustom : Test_Type<"TestTypeCustom"> {
   let parameters = (ins "int":$a, OptionalParameter<"mlir::Optional<int>">:$b);
   let mnemonic = "custom_type";

mlir/tools/mlir-tblgen/AttrOrTypeFormatGen.cpp

 
 //===----------------------------------------------------------------------===//
 // ParserGen
 //===----------------------------------------------------------------------===//
 
 void DefFormat::genParser(MethodBody &os) {
   FmtContext ctx;
   ctx.addSubst("_parser", "odsParser");
-  ctx.addSubst("_ctx", "odsParser.getContext()");
+  ctx.addSubst("_ctxt", "odsParser.getContext()");
   ctx.withBuilder("odsBuilder");
   if (isa<AttrDef>(def))
     ctx.addSubst("_type", "odsType");
   os.indent();
   os << "::mlir::Builder odsBuilder(odsParser.getContext());\n";
 
   // Declare variables to store all of the parameters. Allocated parameters
   // such as `ArrayRef` and `StringRef` must provide a `storageType`. Store

 
 //===----------------------------------------------------------------------===//
 // PrinterGen
 //===----------------------------------------------------------------------===//
 
 void DefFormat::genPrinter(MethodBody &os) {
   FmtContext ctx;
   ctx.addSubst("_printer", "odsPrinter");
-  ctx.addSubst("_ctx", "getContext()");
+  ctx.addSubst("_ctxt", "getContext()");
   ctx.withBuilder("odsBuilder");
   os.indent();
   os << "::mlir::Builder odsBuilder(getContext());\n";
 
   // Generate printers.
   shouldEmitSpace = true;
   lastWasPunctuation = false;
   for (FormatElement *el : elements)

mlir/tools/mlir-tblgen/OpDefinitionsGen.cpp

// Generate method to materialize derived attributes as a DictionaryAttr.
     interleave(
         derivedAttrs, body,
         [&](const NamedAttribute &namedAttr) {
           auto tmpl = namedAttr.attr.getConvertFromStorageCall();
           std::string name = op.getGetterName(namedAttr.name);
           body << "    {" << name << "AttrName(),\n"
                << tgfmt(tmpl, &fctx.withSelf(name + "()")
                                    .withBuilder("odsBuilder")
-                                   .addSubst("_ctx", "ctx"))
+                                   .addSubst("_ctxt", "ctx"))
                << "}";
         },
         ",\n");
     body << "});";
   }
 }
 
 void OpEmitter::genAttrSetters() {