[mlir] Add constBuilderCall to TypeAttr to simplify builders

mlir/include/mlir/IR/OpBase.td

Attr<And<[
             # retType # ">()">]>,
     summary> {
   let storageType = [{ ::mlir::TypeAttr }];
   let returnType = retType;
   let valueType = NoneType;
   let convertFromStorage = "$_self.getValue().cast<" # retType # ">()";
 }
 
-def TypeAttr : TypeAttrBase<"::mlir::Type", "any type attribute">;
+def TypeAttr : TypeAttrBase<"::mlir::Type", "any type attribute"> {
+  let constBuilderCall = "::mlir::TypeAttr::get($0)";
+}
 
 // The mere presence of unit attributes has a meaning.  Therefore, unit
 // attributes are always treated as optional and accessors to them return
 // "true" if the attribute is present and "false" otherwise.
 def UnitAttr : Attr<CPred<"$_self.isa<::mlir::UnitAttr>()">, "unit attribute"> {
   let storageType = [{ ::mlir::UnitAttr }];
   let constBuilderCall = "$_builder.getUnitAttr()";
   let convertFromStorage = "$_self != nullptr";

mlir/lib/Conversion/StandardToSPIRV/StandardToSPIRV.cpp

matchAndRewrite(AllocOp operation, ArrayRef<Value> operands,
     {
       OpBuilder::InsertionGuard guard(rewriter);
       Block &entryBlock = *parent->getRegion(0).begin();
       rewriter.setInsertionPointToStart(&entryBlock);
       auto varOps = entryBlock.getOps<spirv::GlobalVariableOp>();
       std::string varName =
           std::string("__workgroup_mem__") +
           std::to_string(std::distance(varOps.begin(), varOps.end()));
-      varOp = rewriter.create<spirv::GlobalVariableOp>(
-          loc, TypeAttr::get(spirvType), varName,
-          /*initializer = */ nullptr);
+      varOp = rewriter.create<spirv::GlobalVariableOp>(loc, spirvType, varName,
+                                                       /*initializer=*/nullptr);
     }
 
     // Get pointer to global variable at the current scope.
     rewriter.replaceOpWithNewOp<spirv::AddressOfOp>(operation, varOp);
     return success();
   }
 };
 

mlir/lib/Dialect/StandardOps/Transforms/TensorConstantBufferize.cpp

module.walk([&](ConstantOp op) {
     SmallString<64> buf;
     llvm::raw_svector_ostream os(buf);
     interleave(type.getShape(), os, "x");
     os << "x" << type.getElementType();
 
     auto global = globalBuilder.create<GlobalMemrefOp>(
         op.getLoc(), (Twine("__constant_") + os.str()).str(),
         /*sym_visibility=*/globalBuilder.getStringAttr("private"),
-        /*type=*/
-        TypeAttr::get(typeConverter.convertType(type)), /*initial_value=*/
-        op.getValue().cast<ElementsAttr>(), /*constant=*/true);
+        /*type=*/typeConverter.convertType(type),
+        /*initial_value=*/op.getValue().cast<ElementsAttr>(),
+        /*constant=*/true);
     symbolTable.insert(global);
     // The symbol table inserts at the end of the module, but globals are a bit
     // nicer if they are at the beginning.
     global->moveBefore(&module.front());
     globals[op.getValue()] = global;
   });
 }
 } // namespace