[mlir][linalg] Generate additional interfaces for named ops.

[stellaraccident]

Summary

• Adds ContractionOpInterface to polymorphic_matmul.

mlir/include/mlir/Dialect/Linalg/IR/LinalgNamedStructuredOps.yaml

 --- !LinalgOpConfig
 metadata: !LinalgOpMetadata
   name: polymorphic_matmul
   cpp_op_name: PolymorphicMatmulOp
   doc: |-
     Type polymorphic matrix multiplication.
 
     This op is presently here to test a new path for generation and will replace
     the existing 'matmul' op when ready. Do not use.
+  implements:
+  - LinalgContractionOpInterface
 structured_op: !LinalgStructuredOpConfig
   args:
   - !<LinalgTensorDef>
     name: A
     usage: input
     shape: affine_map<()[s0, s1, s2] -> (s0, s2)>
   - !<LinalgTensorDef>
     name: B

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

 struct LinalgYAMLContext {
   MLIRContext *mlirContext;
 };
 
 struct LinalgOpMetadata {
   std::string name;
   std::string cppOpName;
   Optional<std::string> doc;
+  SmallVector<std::string> implements;
 };
 
 struct SerializedAffineMap {
   AffineMapAttr affineMapAttr;
 
   AffineMap affineMap() { return affineMapAttr.getValue(); }
 };
 

 
 /// Metadata about the op (name, C++ name, and documentation).
 template <>
 struct MappingTraits<LinalgOpMetadata> {
   static void mapping(IO &io, LinalgOpMetadata &info) {
     io.mapRequired("name", info.name);
     io.mapRequired("cpp_op_name", info.cppOpName);
     io.mapOptional("doc", info.doc);
+    io.mapOptional("implements", info.implements);
   }
 };
 
 /// How the ops indexing maps are produced. Must be one of:
 ///   - static_indexing_maps: A static list of AffineMaps, possibly with
 ///     some symbols that bind to attributes of the op. Each indexing map must
 ///     be normalized over the same list of dimensions, and its symbols must
 ///     match the symbols for argument shapes.

 // {5}: the number of arguments for the op region
 // {6}: builder methods taking standalone attribute parameters
 // {7}: additional methods for attributes used by indexing maps
 static const char structuredOpOdsHeaderFormat[] = R"FMT(
 //===----------------------------------------------------------------------===//
 // Op definition for {0}
 //===----------------------------------------------------------------------===//
 
-def {0} : LinalgStructuredBase_Op<"{1}", [
+def {0} : LinalgStructuredBase_Op<"{1}", !listconcat([
   AttrSizedOperandSegments,
   DeclareOpInterfaceMethods<MemoryEffectsOpInterface>,
-  SingleBlockImplicitTerminator<"YieldOp">
-  /*extraInterfaces=*/{2}]> {
+  SingleBlockImplicitTerminator<"YieldOp">],
+  /*extraInterfaces=*/[{2}])> {
     {3}
     let arguments = (ins
       Variadic<AnyShaped>:$inputs,
       Variadic<AnyShaped>:$outputs{4}
     );
     let results = (outs Variadic<AnyRankedTensor>:$result_tensors);
     let regions = (region AnyRegion:$region);
 
const char *docFmt = R"FMT(
       }];
     )FMT";
     StringRef summary, description;
     std::tie(summary, description) =
         StringRef(*opConfig.metadata->doc).trim().split('\n');
     doc = llvm::formatv(docFmt, summary.trim(), description.trim());
   }
 
+  interfaceNameList = interleaveToString(opConfig.metadata->implements, ", ");
+
   os << llvm::formatv(structuredOpOdsHeaderFormat, opConfig.metadata->cppOpName,
                       opConfig.metadata->name, interfaceNameList, doc, attrList,
                       opConfig.structuredOp->args.size(), attrBuilder,
                       attrMethods);
 
   return success();
 }