[mlir][NFC] Use structured binding declaration.

[jacquesguan]

Summary

This patch tries to use structured binding declaration to replace outside decleration.

[Mogball]

mlir/examples/toy/Ch7/mlir/MLIRGen.cpp

459

This was discussed in a similar patch, but I was brought up was that this isn't necessarily more readable. The types were previously explicit, now they're not.

This is only unambiguously better in cases where the types were not already explicit.

mlir/examples/toy/Ch7/mlir/MLIRGen.cpp

mlir::Value mlirGen(LiteralExprAST &lit) {
     // method.
     return builder.create<ConstantOp>(loc(lit.loc()), type, dataAttribute);
   }
 
   /// Emit a struct literal. It will be emitted as an array of
   /// other literals in an Attribute attached to a `toy.struct_constant`
   /// operation.
   mlir::Value mlirGen(StructLiteralExprAST &lit) {
-    mlir::ArrayAttr dataAttr;
-    mlir::Type dataType;
-    std::tie(dataAttr, dataType) = getConstantAttr(lit);
+    auto [dataAttr, dataType] = getConstantAttr(lit);
 
     // Build the MLIR op `toy.struct_constant`. This invokes the
     // `StructConstantOp::build` method.
     return builder.create<StructConstantOp>(loc(lit.loc()), dataType, dataAttr);
   }
 
   /// Recursive helper function to accumulate the data that compose an array
   /// literal. It flattens the nested structure in the supplied vector. For

mlir/lib/Bytecode/Writer/BytecodeWriter.cpp

 
 void BytecodeWriter::writeRegion(EncodingEmitter &emitter, Region *region) {
   // If the region is empty, we only need to emit the number of blocks (which is
   // zero).
   if (region->empty())
     return emitter.emitVarInt(/*numBlocks*/ 0);
 
   // Emit the number of blocks and values within the region.
-  unsigned numBlocks, numValues;
-  std::tie(numBlocks, numValues) = numberingState.getBlockValueCount(region);
+  auto [numBlocks, numValues] = numberingState.getBlockValueCount(region);
   emitter.emitVarInt(numBlocks);
   emitter.emitVarInt(numValues);
 
   // Emit the blocks within the region.
   for (Block &block : *region)
     writeBlock(emitter, &block);
 }
 

mlir/lib/Conversion/SCFToGPU/SCFToGPU.cpp

if (auto constOp = val.getDefiningOp<arith::ConstantOp>())
       return rewriter.create<arith::ConstantOp>(constOp.getLoc(),
                                                 constOp.getValue());
     return {};
   };
 
   for (auto config : llvm::zip(
            mapping, parallelOp.getInductionVars(), parallelOp.getLowerBound(),
            parallelOp.getUpperBound(), parallelOp.getStep())) {
-    Attribute mappingAttribute;
-    Value iv, lowerBound, upperBound, step;
-    std::tie(mappingAttribute, iv, lowerBound, upperBound, step) = config;
+    auto [mappingAttribute, iv, lowerBound, upperBound, step] = config;
     auto annotation =
         mappingAttribute.dyn_cast<gpu::ParallelLoopDimMappingAttr>();
     if (!annotation)
       return parallelOp.emitOpError()
              << "expected mapping attribute for lowering to GPU";
     Value newIndex;
     gpu::Processor processor = annotation.getProcessor();
 

mlir/lib/Target/LLVMIR/ConvertFromLLVMIR.cpp

 
 /// Creates an attribute containing ABI and preferred alignment numbers parsed
 /// a string. The string may be either "abi:preferred" or just "abi". In the
 /// latter case, the prefrred alignment is considered equal to ABI alignment.
 static DenseIntElementsAttr parseDataLayoutAlignment(MLIRContext &ctx,
                                                      StringRef spec) {
   auto i32 = IntegerType::get(&ctx, 32);
 
-  StringRef abiString, preferredString;
-  std::tie(abiString, preferredString) = spec.split(':');
+  auto [abiString, preferredString] = spec.split(':');
   int abi, preferred;
   if (abiString.getAsInteger(/*Radix=*/10, abi))
     return nullptr;
 
   if (preferredString.empty())
     preferred = abi;
   else if (preferredString.getAsInteger(/*Radix=*/10, preferred))
     return nullptr;
mlir::translateDataLayout(const llvm::DataLayout &dataLayout,
   StringSet<> seen;
   while (!layout.empty()) {
     // Split at '-'.
     std::pair<StringRef, StringRef> split = layout.split('-');
     StringRef current;
     std::tie(current, layout) = split;
 
     // Split at ':'.
-    StringRef kind, spec;
-    std::tie(kind, spec) = current.split(':');
+    auto [kind, spec] = current.split(':');
     if (seen.contains(kind))
       continue;
     seen.insert(kind);
 
     char symbol = kind.front();
     StringRef parameter = kind.substr(1);
 
     if (symbol == 'i' || symbol == 'f') {

mlir/tools/mlir-linalg-ods-gen/mlir-linalg-ods-yaml-gen.cpp

static LogicalResult generateNamedGenericOpOds(LinalgOpConfig &opConfig,
   std::string doc;
   if (opConfig.metadata->doc) {
     static const char structuredOpDocFmt[] = R"FMT(
   let summary = [{ {0} }];
   let description = [{
     {1}
   }];
 )FMT";
-    StringRef summary, description;
-    std::tie(summary, description) =
+    auto [summary, description] =
         StringRef(*opConfig.metadata->doc).trim().split('\n');
     doc = llvm::formatv(structuredOpDocFmt, summary.trim(), description.trim());
   }
 
   interfaceNameList = interleaveToString(opConfig.metadata->implements, ", ");
 
   std::string definitionList;
   for (const std::string &definition : opConfig.metadata->defines) {