[mlir][linalg][NFC] Drop emitAccessorPrefix from Linalg dialect

[rriddle]

Nice!

mlir/include/mlir/Dialect/Linalg/IR/LinalgBase.td

let extraClassDeclaration = [{
     using RegionBuilderFunType = llvm::function_ref<
       void(ImplicitLocOpBuilder &b, Block &, ArrayRef<NamedAttribute>)>;
     RegionBuilderFunType getRegionBuilder(StringRef name) {
       return namedStructuredOpRegionBuilders.lookup(name);
     }
     private:
       llvm::StringMap<RegionBuilderFunType> namedStructuredOpRegionBuilders;
   }];
-
-  let emitAccessorPrefix = kEmitAccessorPrefix_Both;
 }
 
 // Define the function attribute enums matching the OpDSL functions.
 def UnaryFnAttr : EnumAttr<Linalg_Dialect, UnaryFn, "unary_fn"> {
   let assemblyFormat = "`<` $value `>`";
 }
 def BinaryFnAttr : EnumAttr<Linalg_Dialect, BinaryFn, "binary_fn"> {
   let assemblyFormat = "`<` $value `>`";
 }
 def TypeFnAttr : EnumAttr<Linalg_Dialect, TypeFn, "type_fn"> {
   let assemblyFormat = "`<` $value `>`";
 }
 
 #endif // LINALG_BASE

mlir/include/mlir/Dialect/Linalg/IR/LinalgInterfaces.td

let extraClassDeclaration = [{
     // Forwarding functions to access interface methods from the
     // DestinationStyleOpInterface.
     // MLIR currently does not support dependent interfaces or interface
     // inheritance. By construction all ops with StructuredOpInterface must
     // implement DestinationStyleOpInterface.
     // TODO: reevalute the need for a cast when a better mechanism exists.
     //========================================================================//
 
-    ValueRange inputs() {
-      return cast<DestinationStyleOpInterface>(*this->getOperation()).inputs();
+    ValueRange getInputs() {
+      return cast<DestinationStyleOpInterface>(*this->getOperation())
+          .getInputs();
     }
 
     int64_t getNumInputs() {
       return cast<DestinationStyleOpInterface>(*this->getOperation())
           .getNumInputs();
     }
 
-    ValueRange outputs() {
+    ValueRange getOutputs() {
       return cast<DestinationStyleOpInterface>(*this->getOperation())
           .getOutputs();
     }
 
     int64_t getNumOutputs() {
       return cast<DestinationStyleOpInterface>(*this->getOperation())
           .getNumOutputs();
     }
def LinalgStructuredInterface : OpInterface<"LinalgOp"> {
 
   let verify = [{ return detail::verifyStructuredOpInterface($_op); }];
   let verifyWithRegions = 1;
 }
 
 // The 'DestinationStyleOpInterface' provides access to the methods relevant
 // for destination-style ops. A destination-style operation has 'n' input
 // arguments and 'm' output arguments. Each op that wants to implement
-// DestinationStyleOpInterface needs to define inputs() and getOutputs()
+// DestinationStyleOpInterface needs to define getInputs() and getOutputs()
 // methods.
 def DestinationStyleOpInterface : OpInterface<"DestinationStyleOpInterface"> {
   let cppNamespace = "::mlir::linalg";
   let methods = [
     //===------------------------------------------------------------------===//
     // Num input/output arguments handling.
     //===------------------------------------------------------------------===//
-    // `inputs` must be defined by each op that wants to implement the
+    // `getInputs` must be defined by each op that wants to implement the
     // DestinationStyleOpInterface.
     InterfaceMethod<
       /*desc=*/[{
         Return the input shape operands.
       }],
       /*retTy=*/"ValueRange",
-      /*methodName=*/"inputs",
+      /*methodName=*/"getInputs",
       /*args=*/(ins)
     >,
-    // These special methods rely on `inputs` and `outputs` being defined by
-    // each op that wants to implement the DestinationStyleOpInterface.
+    // These special methods rely on `getInputs` and `getOutputs` being defined
+    // by each op that wants to implement the DestinationStyleOpInterface.
     InterfaceMethod<
       /*desc=*/[{
         Return the number of inputs.
       }],
       /*retTy=*/"int64_t",
       /*methodName=*/"getNumInputs",
       /*args=*/(ins),
       /*methodBody=*/"",

mlir/lib/Dialect/Linalg/Transforms/SplitReduction.cpp

FailureOr<SplitReductionResult> mlir::linalg::splitReductionByScaling(
   MLIRContext *context = op.getContext();
   // For now assume outputs are 1-1 with reduction neutralElements.
   // TODO: generalize when multi-reduction support is available.
   SmallVector<Value> newOutputs;
   newOutputs.reserve(op.getNumOutputs());
   SmallVector<Operation *> initOrAllocTensorOps;
   SmallVector<linalg::FillOp> fillOps;
   fillOps.reserve(op.getNumOutputs());
-  for (auto it : llvm::zip(op.outputs(), neutralElements)) {
+  for (auto it : llvm::zip(op.getOutputs(), neutralElements)) {
     Value rankedTensor = std::get<0>(it);
     auto t = rankedTensor.getType().cast<RankedTensorType>();
     RankedTensorType newT = RankedTensorType::Builder(t).insertDim(
         reductionDimSize / splitFactor, insertSplitDimension);
     SmallVector<Value> dims =
         tensor::createDynamicDimValues(b, loc, rankedTensor);
     Value initOrAllocTensor;
     if (useAlloc) {
FailureOr<SplitReductionResult> mlir::linalg::splitReductionByScaling(
   // reindexed: k -> k * splitFactor + k', when multi-reduction support is
   // available.
   for (OpOperand *o : op.getOutputOperands())
     newMaps.push_back(insertParallelDim(op, *o, reductionDimPos,
                                         reductionDimSize / splitFactor));
 
   // Step 3. Handle operands.
   // Compute the new input tensors.
-  auto newInputs = llvm::to_vector<4>(op.inputs());
+  auto newInputs = llvm::to_vector<4>(op.getInputs());
   // Add a single shape-only tensor to carry the dimensions without resorting to
   // more complex inversions.
   newInputs.push_back(b.create<linalg::InitTensorOp>(
       loc, ArrayRef<int64_t>{reductionDimSize / splitFactor, splitFactor},
       b.getIntegerType(1)));
   // Output tensors are already good to go.
 
   // Step 4. Create the new op matching the original op with an extra parallel
FailureOr<SplitReductionResult> mlir::linalg::splitReductionByScaling(
   // dimensions from the previous op.
   // For now assume outputs are 1-1 with reduction ops.
   // TODO: a subset of these may not reduce in the first place and do not
   // require a new op, when multi-reduction support is available.
   // TODO: all results can be handled in a single GenericOp, when
   // multi-reduction support is available.
   SmallVector<LinalgOp> results;
   for (auto it :
-       llvm::zip(genericOp->getResults(), op.outputs(), combinerOps)) {
+       llvm::zip(genericOp->getResults(), op.getOutputs(), combinerOps)) {
     Value reindexedOutput = std::get<0>(it);
     Value originalOutput = std::get<1>(it);
     auto originalOutputType = originalOutput.getType().cast<RankedTensorType>();
     Operation *combinerOp = std::get<2>(it);
 
     AffineMap map = b.getMultiDimIdentityMap(originalOutputType.getRank() + 1);
     SmallVector<AffineMap> indexingMaps = {
         map, map.dropResult(insertSplitDimension)};

mlir/lib/Dialect/Linalg/Transforms/Vectorization.cpp

 struct Conv1DGenerator : public StructuredGenerator<LinalgOp> {
   Conv1DGenerator(OpBuilder &builder, LinalgOp linalgOp, int strideW,
                   int dilationW)
       : StructuredGenerator<LinalgOp>(builder, linalgOp), strideW(strideW),
         dilationW(dilationW) {
     // Determine whether `linalgOp` can be generated with this generator
     if (linalgOp.getNumInputs() != 2 || linalgOp.getNumOutputs() != 1)
       return;
-    lhsShaped = linalgOp.inputs()[0];
-    rhsShaped = linalgOp.inputs()[1];
-    resShaped = linalgOp.outputs()[0];
+    lhsShaped = linalgOp.getInputs()[0];
+    rhsShaped = linalgOp.getInputs()[1];
+    resShaped = linalgOp.getOutputs()[0];
     lhsShapedType = lhsShaped.getType().dyn_cast<ShapedType>();
     rhsShapedType = rhsShaped.getType().dyn_cast<ShapedType>();
     resShapedType = resShaped.getType().dyn_cast<ShapedType>();
     if (!lhsShapedType || !rhsShapedType || !resShapedType)
       return;
     if (lhsShapedType.getRank() != 3 ||
         (rhsShapedType.getRank() != 2 && rhsShapedType.getRank() != 3) ||
         resShapedType.getRank() != 3)

mlir/test/mlir-linalg-ods-gen/test-linalg-ods-yaml-gen.yaml

 
 #       ODS:  "Attribute":$strides
 #       ODS:  $_state.addAttribute("strides", strides);
 
 #       ODS:  bool hasDynamicIndexingMaps();
 #  ODS-NEXT:  LogicalResult verifyIndexingMapRequiredAttributes();
 
 #       IMPL:  getSymbolBindings(Test2Op self)
-#       IMPL:  cst2 = self.strides().getValues<int64_t>()[0];
+#       IMPL:  cst2 = self.getStrides().getValues<int64_t>()[0];
 #  IMPL-NEXT:  getAffineConstantExpr(cst2, context)
-#       IMPL:  cst3 = self.strides().getValues<int64_t>()[1];
+#       IMPL:  cst3 = self.getStrides().getValues<int64_t>()[1];
 #  IMPL-NEXT:  getAffineConstantExpr(cst3, context)
 
 #       IMPL:  Test2Op::getIndexingMaps()
 #       IMPL:  = getSymbolBindings(*this);
 #       IMPL:  "affine_map<(d0, d1)[s0, s1, s2, s3] -> (d1 * s2, d0 * s3)>"
 #       IMPL:  "affine_map<(d0, d1)[s0, s1, s2, s3] -> (d0, d1)>"
 
 #       IMPL:  Test2Op::getNumRegionArgs() { return 2; }

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

 // Parameters:
 // {0}: Class name
 static const char structuredOpParserFormat[] = R"FMT(
 ParseResult {0}::parse(OpAsmParser &parser, OperationState &result) {{
   return ::parseNamedStructuredOp(parser, result,
     {0}::getNumRegionArgs(), {0}::getRegionBuilder());
 }
 void {0}::print(OpAsmPrinter &p) {{
-  ::printNamedStructuredOp(p, getOperation(), inputs(), outputs());
+  ::printNamedStructuredOp(p, getOperation(), getInputs(), getOutputs());
 }
 )FMT";
 
 static LogicalResult generateNamedGenericOpOds(LinalgOpConfig &opConfig,
                                                GenerationContext &genContext) {
   if (!genContext.shouldGenerateOds())
     return success();
 
)FMT";
               "  exprs.push_back(getAffineSymbolExpr({0}, context));", i));
         }
 
         // Access an index attribute. Parameters:
         // {0}: Attribute name
         // {1}: Symbol position
         // {2}: Attribute index
         static const char structuredOpAccessAttrFormat[] = R"FMT(
-int64_t cst{1} = self.{0}().getValues<int64_t>()[{2}];
+int64_t cst{1} = self.get{0}().getValues<int64_t>()[{2}];
 exprs.push_back(getAffineConstantExpr(cst{1}, context));
 )FMT";
         // Update all symbol bindings mapped to an attribute.
         for (LinalgOperandDef &arg : opConfig.structuredOp->args) {
           if (arg.kind != LinalgOperandDefKind::IndexAttr)
             continue;
           assert(arg.indexAttrMap);
           for (auto &en :
                llvm::enumerate(arg.indexAttrMap->affineMap().getResults())) {
             if (auto symbol = en.value().dyn_cast<AffineSymbolExpr>()) {
+              std::string argName = arg.name;
+              argName[0] = toupper(argName[0]);
               symbolBindings[symbol.getPosition()] =
-                  llvm::formatv(structuredOpAccessAttrFormat, arg.name,
+                  llvm::formatv(structuredOpAccessAttrFormat, argName,
                                 symbol.getPosition(), en.index());
             }
           }
         }
 
         std::string symbolBindingsStr;
         llvm::raw_string_ostream symbolBindingsSs(symbolBindingsStr);
         llvm::interleave(symbolBindings, symbolBindingsSs, "\n");