[mlir] Remove methods from mlir::OpState that just forward to mlir::Operation.

[csigg]

Summary

All call sites have been converted in previous changes.

[mehdi_amini]

Sweet! Good job on this cleanup :)

[csigg]

Include a few few fixes that I missed.

[csigg]

Rebase.

[csigg]

Changing call sites I missed in FIROps.td.

[csigg]

More flang changes.

[csigg]

Moving the remaining call site changes to a separate revision (D93194).

[csigg]

Rebase.

mlir/include/mlir/IR/OpDefinition.h

public:
   operator Operation *() const { return state; }
 
   /// Shortcut of `->` to access a member of Operation.
   Operation *operator->() const { return state; }
 
   /// Return the operation that this refers to.
   Operation *getOperation() { return state; }
 
-  /// Return the dialect that this refers to.
-  Dialect *getDialect() { return getOperation()->getDialect(); }
-
-  /// Return the parent Region of this operation.
-  Region *getParentRegion() { return getOperation()->getParentRegion(); }
-
-  /// Returns the closest surrounding operation that contains this operation
-  /// or nullptr if this is a top-level operation.
-  Operation *getParentOp() { return getOperation()->getParentOp(); }
-
-  /// Return the closest surrounding parent operation that is of type 'OpTy'.
-  template <typename OpTy> OpTy getParentOfType() {
-    return getOperation()->getParentOfType<OpTy>();
-  }
-
-  /// Returns the closest surrounding parent operation with trait `Trait`.
-  template <template <typename T> class Trait>
-  Operation *getParentWithTrait() {
-    return getOperation()->getParentWithTrait<Trait>();
-  }
-
   /// Return the context this operation belongs to.
   MLIRContext *getContext() { return getOperation()->getContext(); }
 
   /// Print the operation to the given stream.
   void print(raw_ostream &os, OpPrintingFlags flags = llvm::None) {
     state->print(os, flags);
   }
   void print(raw_ostream &os, AsmState &asmState,
public:
 
   /// Return all of the attributes on this operation.
   ArrayRef<NamedAttribute> getAttrs() { return state->getAttrs(); }
 
   /// A utility iterator that filters out non-dialect attributes.
   using dialect_attr_iterator = Operation::dialect_attr_iterator;
   using dialect_attr_range = Operation::dialect_attr_range;
 
-  /// Return a range corresponding to the dialect attributes for this operation.
-  dialect_attr_range getDialectAttrs() { return state->getDialectAttrs(); }
-  dialect_attr_iterator dialect_attr_begin() {
-    return state->dialect_attr_begin();
-  }
-  dialect_attr_iterator dialect_attr_end() { return state->dialect_attr_end(); }
-
-  /// Return an attribute with the specified name.
-  Attribute getAttr(StringRef name) { return state->getAttr(name); }
-
-  /// If the operation has an attribute of the specified type, return it.
-  template <typename AttrClass> AttrClass getAttrOfType(StringRef name) {
-    return getAttr(name).dyn_cast_or_null<AttrClass>();
-  }
-
-  /// If the an attribute exists with the specified name, change it to the new
-  /// value.  Otherwise, add a new attribute with the specified name/value.
-  void setAttr(Identifier name, Attribute value) {
-    state->setAttr(name, value);
-  }
-  void setAttr(StringRef name, Attribute value) {
-    setAttr(Identifier::get(name, getContext()), value);
-  }
-
-  /// Set the attributes held by this operation.
-  void setAttrs(ArrayRef<NamedAttribute> attributes) {
-    state->setAttrs(attributes);
-  }
-  void setAttrs(MutableDictionaryAttr newAttrs) { state->setAttrs(newAttrs); }
-
   /// Set the dialect attributes for this operation, and preserve all dependent.
   template <typename DialectAttrs> void setDialectAttrs(DialectAttrs &&attrs) {
     state->setDialectAttrs(std::move(attrs));
   }
 
   /// Remove the attribute with the specified name if it exists.  The return
   /// value indicates whether the attribute was present or not.
   MutableDictionaryAttr::RemoveResult removeAttr(Identifier name) {

mlir/lib/Target/LLVMIR/ConvertFromLLVMIR.cpp

if (!functionType)
     return failure();
 
   b.setInsertionPoint(module.getBody(), getFuncInsertPt());
   LLVMFuncOp fop =
       b.create<LLVMFuncOp>(UnknownLoc::get(context), f->getName(), functionType,
                            convertLinkageFromLLVM(f->getLinkage()));
 
   if (FlatSymbolRefAttr personality = getPersonalityAsAttr(f))
-    fop.setAttr(b.getIdentifier("personality"), personality);
+    fop->setAttr(b.getIdentifier("personality"), personality);
   else if (f->hasPersonalityFn())
     emitWarning(UnknownLoc::get(context),
                 "could not deduce personality, skipping it");
 
   if (f->isDeclaration())
     return success();
 
   // Eagerly create all blocks.

mlir/test/mlir-tblgen/op-attribute.td

 // DEF:      auto tblgen_cAttr = odsAttrs.get("cAttr");
 // DEF-NEXT: if (tblgen_cAttr) {
 // DEF-NEXT:   if (!((some-condition))) return emitError(loc, "'test.a_op' op ""attribute 'cAttr' failed to satisfy constraint: some attribute kind");
 
 // Test getter methods
 // ---
 
 // DEF:      some-attr-kind AOp::aAttrAttr()
-// DEF-NEXT:   (*this)->getAttr("aAttr").cast<some-attr-kind>()
+// DEF-NEXT:   (*this)->getAttr("aAttr").template cast<some-attr-kind>()
 // DEF:      some-return-type AOp::aAttr() {
 // DEF-NEXT:   auto attr = aAttrAttr()
 // DEF-NEXT:   return attr.some-convert-from-storage();
 
 // DEF:      some-attr-kind AOp::bAttrAttr()
-// DEF-NEXT:   return (*this)->getAttr("bAttr").dyn_cast_or_null<some-attr-kind>()
+// DEF-NEXT:   return (*this)->getAttr("bAttr").template dyn_cast_or_null<some-attr-kind>()
 // DEF:      some-return-type AOp::bAttr() {
 // DEF-NEXT:   auto attr = bAttrAttr();
 // DEF-NEXT:   if (!attr)
 // DEF-NEXT:       return some-const-builder-call(::mlir::Builder((*this)->getContext()), 4.2).some-convert-from-storage();
 // DEF-NEXT:   return attr.some-convert-from-storage();
 
 // DEF:      some-attr-kind AOp::cAttrAttr()
-// DEF-NEXT:   return (*this)->getAttr("cAttr").dyn_cast_or_null<some-attr-kind>()
+// DEF-NEXT:   return (*this)->getAttr("cAttr").template dyn_cast_or_null<some-attr-kind>()
 // DEF:      ::llvm::Optional<some-return-type> AOp::cAttr() {
 // DEF-NEXT:   auto attr = cAttrAttr()
 // DEF-NEXT:   return attr ? ::llvm::Optional<some-return-type>(attr.some-convert-from-storage()) : (::llvm::None);
 
 // Test setter methods
 // ---
 
 // DEF:      void AOp::aAttrAttr(some-attr-kind attr) {

mlir/tools/mlir-tblgen/OpDefinitionsGen.cpp

 // (variadic or not).
 //
 // {0}: The name of the attribute specifying the segment sizes.
 const char *adapterSegmentSizeAttrInitCode = R"(
   assert(odsAttrs && "missing segment size attribute for op");
   auto sizeAttr = odsAttrs.get("{0}").cast<::mlir::DenseIntElementsAttr>();
 )";
 const char *opSegmentSizeAttrInitCode = R"(
-  auto sizeAttr =
-      getOperation()->getAttrOfType<::mlir::DenseIntElementsAttr>("{0}");
+  auto sizeAttr = (*this)->getAttrOfType<::mlir::DenseIntElementsAttr>("{0}");
 )";
 const char *attrSizedSegmentValueRangeCalcCode = R"(
   unsigned start = 0;
   for (unsigned i = 0; i < index; ++i)
     start += (*(sizeAttr.begin() + i)).getZExtValue();
   unsigned size = (*(sizeAttr.begin() + index)).getZExtValue();
   return {start, size};
 )";
void OpEmitter::genAttrGetters() {
   // referring to the attributes via accessors instead of having to use
   // the string interface for better compile time verification.
   auto emitAttrWithStorageType = [&](StringRef name, Attribute attr) {
     auto *method =
         opClass.addMethodAndPrune(attr.getStorageType(), (name + "Attr").str());
     if (!method)
       return;
     auto &body = method->body();
-    body << "  return (*this)->getAttr(\"" << name << "\").";
+    body << "  return (*this)->getAttr(\"" << name << "\").template ";
     if (attr.isOptional() || attr.hasDefaultValue())
       body << "dyn_cast_or_null<";
     else
       body << "cast<";
     body << attr.getStorageType() << ">();";
   };
 
   for (auto &namedAttr : op.getAttributes()) {

mlir/unittests/Pass/PassManagerTest.cpp

 };
 
 /// Simple pass to annotate a FuncOp with the results of analysis.
 /// Note: not using FunctionPass as it skip external functions.
 struct AnnotateFunctionPass
     : public PassWrapper<AnnotateFunctionPass, OperationPass<FuncOp>> {
   void runOnOperation() override {
     FuncOp op = getOperation();
-    Builder builder(op.getParentOfType<ModuleOp>());
+    Builder builder(op->getParentOfType<ModuleOp>());
 
     auto &ga = getAnalysis<GenericAnalysis>();
     auto &sa = getAnalysis<OpSpecificAnalysis>();
 
-    op.setAttr("isFunc", builder.getBoolAttr(ga.isFunc));
-    op.setAttr("isSecret", builder.getBoolAttr(sa.isSecret));
+    op->setAttr("isFunc", builder.getBoolAttr(ga.isFunc));
+    op->setAttr("isSecret", builder.getBoolAttr(sa.isSecret));
   }
 };
 
 TEST(PassManagerTest, OpSpecificAnalysis) {
   MLIRContext context;
   Builder builder(&context);
 
   // Create a module with 2 functions.
TEST(PassManagerTest, OpSpecificAnalysis) {
   // Instantiate and run our pass.
   PassManager pm(&context);
   pm.addNestedPass<FuncOp>(std::make_unique<AnnotateFunctionPass>());
   LogicalResult result = pm.run(module.get());
   EXPECT_TRUE(succeeded(result));
 
   // Verify that each function got annotated with expected attributes.
   for (FuncOp func : module->getOps<FuncOp>()) {
-    ASSERT_TRUE(func.getAttr("isFunc").isa<BoolAttr>());
-    EXPECT_TRUE(func.getAttr("isFunc").cast<BoolAttr>().getValue());
+    ASSERT_TRUE(func->getAttr("isFunc").isa<BoolAttr>());
+    EXPECT_TRUE(func->getAttr("isFunc").cast<BoolAttr>().getValue());
 
     bool isSecret = func.getName() == "secret";
-    ASSERT_TRUE(func.getAttr("isSecret").isa<BoolAttr>());
-    EXPECT_EQ(func.getAttr("isSecret").cast<BoolAttr>().getValue(), isSecret);
+    ASSERT_TRUE(func->getAttr("isSecret").isa<BoolAttr>());
+    EXPECT_EQ(func->getAttr("isSecret").cast<BoolAttr>().getValue(), isSecret);
   }
 }
 
 namespace {
 struct InvalidPass : Pass {
   InvalidPass() : Pass(TypeID::get<InvalidPass>(), StringRef("invalid_op")) {}
   StringRef getName() const override { return "Invalid Pass"; }
   void runOnOperation() override {}