[mlir][ods] Enable emitting getter/setter prefix

[jpienaar]

Summary

Allow emitting get & set prefix for accessors generated for ops. If enabled, then the argument/return/region name gets converted from snake_case to UpperCamel and prefix added. The attribute also allows generating both the current "raw" method along with the prefix'd one to make it easier to stage changes.

The option is added on the dialect and currently defaults to existing raw behavior. The expectation is that the staging where both are generated would be short lived and so optimized to keeping the changes local/less invasive (it just generates two functions for each accessor with the same body - most of these internally again call a helper function). But generation can be optimized if needed.

I'm unsure about OpAdaptor classes as there it is all get methods (it is a named view into raw data structures), so prefix doesn't add much.

This starts with emitting raw-only form (as current behavior) as default, then one can opt-in to raw & prefixed, then just prefixed. The default in OpBase will switch to prefixed-only to be consistent with MLIR style guide. And the option potentially removed later (considered enabling specifying prefix but current discussion more pro keeping it limited and stuck with that).

Also add more explicit checking for pruned functions to avoid emitting where no function was added (and so avoiding dereferencing nullptr) during op def/decl generation.

See https://bugs.llvm.org/show_bug.cgi?id=51916 for further discussion.

[lattner]

Cool, I'm super excited to see this!! The ERROR_IF_PRUNED additions seem logically unrelated to this patch, but are valuable and aren't too distracting.

mlir/tools/mlir-tblgen/OpDefinitionsGen.cpp

530

I'd recommend renaming "read" to "isGetter" and making it a parameter instead of a template argument. No need to duplicate all this code, particularly in tblgen

556

Random wishlist: I wish tblgen had some exception lists for common names like "lhs" and "rhs" so that it would turn it into "getLHS" instead of "getLhs". Not really related to this patch though, since this happens with the existing AttrDef accessors.

571

I'd recommend naming this getGetterNames and getSetterNames

589

What is the LINE doing here? This will always expand to line 589 since that is where it is in this file, that can't be what you intend?

817–818

I'd recommend setterName and getterName since getName sounds like an accessor itself and not a noun.

[rriddle]

mlir/include/mlir/IR/OpBase.td

240–242

Can you document these?

mlir/include/mlir/TableGen/Dialect.h

89

Is the hex necessary here? Why not just 0, 1, 2?

mlir/tools/mlir-tblgen/OpDefinitionsGen.cpp

589

This is a macro, so I would expect LINE to expand properly (https://godbolt.org/z/erG8cG8d6)

[lattner]

mlir/tools/mlir-tblgen/OpDefinitionsGen.cpp

589

Yep my mistake got it.

[jpienaar]

Renamed getter/setter get methods and document enums.

[jpienaar]

Remove change to shapebase which will be made in follow up

[rriddle]

Did a quick additional scan, but LG in general

mlir/include/mlir/IR/OpBase.td

299

with no prefix?

mlir/tools/mlir-tblgen/OpDefinitionsGen.cpp

531

nit; Spell out auto here.

549

[jpienaar]

Update comments and spelled out type.

[lattner]

I'm very excited about this work, great job!

mlir/include/mlir/IR/OpBase.td

243

nit: 80 column violation

[jpienaar]

Fixing to line length & rebase

mlir/include/mlir/IR/OpBase.td

 
 // Whether a type is a TupleType.
 def IsTupleTypePred : CPred<"$_self.isa<::mlir::TupleType>()">;
 
 //===----------------------------------------------------------------------===//
 // Dialect definitions
 //===----------------------------------------------------------------------===//
 
+// "Enum" values for emitAccessorPrefix of Dialect.
+defvar kEmitAccessorPrefix_Raw = 0;      // Don't emit any getter/setter prefix.
+defvar kEmitAccessorPrefix_Prefixed = 1; // Only emit with getter/setter prefix.
+defvar kEmitAccessorPrefix_Both = 2;     // Emit both without and with getter/setter prefix.
+
 class Dialect {
   // The name of the dialect.
   string name = ?;
 
   // Short summary of the dialect.
   string summary = ?;
 
   // The description of the dialect.
class Dialect {
   // If this dialect overrides the hook for verifying region result attributes.
   bit hasRegionResultAttrVerify = 0;
 
   // If this dialect overrides the hook for op interface fallback.
   bit hasOperationInterfaceFallback = 0;
 
   // If this dialect overrides the hook for canonicalization patterns.
   bit hasCanonicalizer = 0;
+
+  // Whether to emit raw/with not prefix or format changes, or emit with
+  // accessor with prefix only and UpperCamel suffix or to emit accessors with
+  // both.
+  //
+  // If emitting with prefix is specified then the attribute/operand's
+  // name is converted to UpperCamel from snake_case (which would result in
+  // leaving UpperCamel unchanged while also converting lowerCamel to
+  // UpperCamel) and prefixed with `get` or `set` depending on if it is a getter
+  // or setter.
+  int emitAccessorPrefix = kEmitAccessorPrefix_Raw;
 }
 
 //===----------------------------------------------------------------------===//
 // Type definitions
 //===----------------------------------------------------------------------===//
 
 // A type, carries type constraints.
 class Type<Pred condition, string descr = "",

mlir/include/mlir/TableGen/Dialect.h

public:
   bool operator!=(const Dialect &other) const { return !(*this == other); }
 
   // Compares two dialects by comparing the names of the dialects.
   bool operator<(const Dialect &other) const;
 
   // Returns whether the dialect is defined.
   explicit operator bool() const { return def != nullptr; }
 
+  // Returns how the accessors should be prefixed in dialect.
+  enum class EmitPrefix { Raw = 0, Prefixed = 1, Both = 2 };
+  EmitPrefix getEmitAccessorPrefix() const;
+
 private:
   const llvm::Record *def;
   std::vector<StringRef> dependentDialects;
 };
 } // end namespace tblgen
 } // end namespace mlir
 
 #endif // MLIR_TABLEGEN_DIALECT_H_

mlir/lib/TableGen/Dialect.cpp

 //===- Dialect.cpp - Dialect wrapper class --------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // Dialect wrapper to simplify using TableGen Record defining a MLIR dialect.
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/TableGen/Dialect.h"
+#include "llvm/TableGen/Error.h"
 #include "llvm/TableGen/Record.h"
 
 using namespace mlir;
 using namespace mlir::tblgen;
 Dialect::Dialect(const llvm::Record *def) : def(def) {
   if (def == nullptr)
     return;
   for (StringRef dialect : def->getValueAsListOfStrings("dependentDialects"))

 bool Dialect::hasRegionResultAttrVerify() const {
   return def->getValueAsBit("hasRegionResultAttrVerify");
 }
 
 bool Dialect::hasOperationInterfaceFallback() const {
   return def->getValueAsBit("hasOperationInterfaceFallback");
 }
 
+Dialect::EmitPrefix Dialect::getEmitAccessorPrefix() const {
+  int prefix = def->getValueAsInt("emitAccessorPrefix");
+  if (prefix < 0 || prefix > static_cast<int>(EmitPrefix::Both))
+    PrintFatalError(def->getLoc(), "Invalid accessor prefix value");
+  return static_cast<EmitPrefix>(prefix);
+}
+
 bool Dialect::operator==(const Dialect &other) const {
   return def == other.def;
 }
 
 bool Dialect::operator<(const Dialect &other) const {
   return getName() < other.getName();
 }

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

 // DEF:      void AOp::build(
 // DEF:        some-return-type aAttr, some-return-type bAttr, /*optional*/some-attr-kind cAttr
 // DEF:        odsState.addAttribute(aAttrAttrName(odsState.name), some-const-builder-call(odsBuilder, aAttr));
 
 // DEF:      void AOp::build(
 // DEF:        ::llvm::ArrayRef<::mlir::NamedAttribute> attributes
 // DEF:      odsState.addAttributes(attributes);
 
+// Test the above but with prefix.
+
+def Test2_Dialect : Dialect {
+  let name = "test2";
+  let cppNamespace = "foobar2";
+  let emitAccessorPrefix = kEmitAccessorPrefix_Prefixed;
+}
+def AgetOp : Op<Test2_Dialect, "a_get_op", []> {
+  let arguments = (ins
+      SomeAttr:$aAttr,
+      DefaultValuedAttr<SomeAttr, "4.2">:$bAttr,
+      OptionalAttr<SomeAttr>:$cAttr
+  );
+}
+
+// DECL-LABEL: AgetOp declarations
+
+// Test attribute name methods
+// ---
+
+// DECL:      static ::llvm::ArrayRef<::llvm::StringRef> getAttributeNames()
+// DECL-NEXT:   static ::llvm::StringRef attrNames[] =
+// DECL-SAME:     {::llvm::StringRef("aAttr"), ::llvm::StringRef("bAttr"), ::llvm::StringRef("cAttr")};
+// DECL-NEXT:   return ::llvm::makeArrayRef(attrNames);
+
+// DECL:      ::mlir::Identifier getAAttrAttrName()
+// DECL-NEXT:      return getAttributeNameForIndex(0);
+// DECL:      ::mlir::Identifier getAAttrAttrName(::mlir::OperationName name)
+// DECL-NEXT:      return getAttributeNameForIndex(name, 0);
+
+// DECL:      ::mlir::Identifier getBAttrAttrName()
+// DECL-NEXT:      return getAttributeNameForIndex(1);
+// DECL:      ::mlir::Identifier getBAttrAttrName(::mlir::OperationName name)
+// DECL-NEXT:      return getAttributeNameForIndex(name, 1);
+
+// DECL:      ::mlir::Identifier getCAttrAttrName()
+// DECL-NEXT:      return getAttributeNameForIndex(2);
+// DECL:      ::mlir::Identifier getCAttrAttrName(::mlir::OperationName name)
+// DECL-NEXT:      return getAttributeNameForIndex(name, 2);
+
+// DEF-LABEL: AgetOp definitions
+
+// Test verify method
+// ---
+
+// DEF:      ::mlir::LogicalResult AgetOpAdaptor::verify
+// DEF:      auto tblgen_aAttr = odsAttrs.get("aAttr");
+// DEF-NEXT: if (!tblgen_aAttr) return emitError(loc, "'test2.a_get_op' op ""requires attribute 'aAttr'");
+// DEF:        if (!((some-condition))) return emitError(loc, "'test2.a_get_op' op ""attribute 'aAttr' failed to satisfy constraint: some attribute kind");
+// DEF:      auto tblgen_bAttr = odsAttrs.get("bAttr");
+// DEF-NEXT: if (tblgen_bAttr) {
+// DEF-NEXT:   if (!((some-condition))) return emitError(loc, "'test2.a_get_op' op ""attribute 'bAttr' failed to satisfy constraint: some attribute kind");
+// DEF:      auto tblgen_cAttr = odsAttrs.get("cAttr");
+// DEF-NEXT: if (tblgen_cAttr) {
+// DEF-NEXT:   if (!((some-condition))) return emitError(loc, "'test2.a_get_op' op ""attribute 'cAttr' failed to satisfy constraint: some attribute kind");
+
+// Test getter methods
+// ---
+
+// DEF:      some-attr-kind AgetOp::getAAttrAttr()
+// DEF-NEXT:   (*this)->getAttr(getAAttrAttrName()).template cast<some-attr-kind>()
+// DEF:      some-return-type AgetOp::getAAttr() {
+// DEF-NEXT:   auto attr = getAAttrAttr()
+// DEF-NEXT:   return attr.some-convert-from-storage();
+
+// DEF:      some-attr-kind AgetOp::getBAttrAttr()
+// DEF-NEXT:   return (*this)->getAttr(getBAttrAttrName()).template dyn_cast_or_null<some-attr-kind>()
+// DEF:      some-return-type AgetOp::getBAttr() {
+// DEF-NEXT:   auto attr = getBAttrAttr();
+// 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 AgetOp::getCAttrAttr()
+// DEF-NEXT:   return (*this)->getAttr(getCAttrAttrName()).template dyn_cast_or_null<some-attr-kind>()
+// DEF:      ::llvm::Optional<some-return-type> AgetOp::getCAttr() {
+// DEF-NEXT:   auto attr = getCAttrAttr()
+// DEF-NEXT:   return attr ? ::llvm::Optional<some-return-type>(attr.some-convert-from-storage()) : (::llvm::None);
+
+// Test setter methods
+// ---
+
+// DEF:      void AgetOp::setAAttrAttr(some-attr-kind attr) {
+// DEF-NEXT:   (*this)->setAttr(getAAttrAttrName(), attr);
+// DEF:      void AgetOp::setBAttrAttr(some-attr-kind attr) {
+// DEF-NEXT:   (*this)->setAttr(getBAttrAttrName(), attr);
+// DEF:      void AgetOp::setCAttrAttr(some-attr-kind attr) {
+// DEF-NEXT:   (*this)->setAttr(getCAttrAttrName(), attr);
+
+// Test remove methods
+// ---
+
+// DEF: ::mlir::Attribute AgetOp::removeCAttrAttr() {
+// DEF-NEXT: return (*this)->removeAttr(getCAttrAttrName());
+
+// Test build methods
+// ---
+
+// DEF:      void AgetOp::build(
+// DEF:        odsState.addAttribute(getAAttrAttrName(odsState.name), aAttr);
+// DEF:        odsState.addAttribute(getBAttrAttrName(odsState.name), bAttr);
+// DEF:        if (cAttr) {
+// DEF-NEXT:     odsState.addAttribute(getCAttrAttrName(odsState.name), cAttr);
+
+// DEF:      void AgetOp::build(
+// DEF:        some-return-type aAttr, some-return-type bAttr, /*optional*/some-attr-kind cAttr
+// DEF:        odsState.addAttribute(getAAttrAttrName(odsState.name), some-const-builder-call(odsBuilder, aAttr));
+
+// DEF:      void AgetOp::build(
+// DEF:        ::llvm::ArrayRef<::mlir::NamedAttribute> attributes
+// DEF:      odsState.addAttributes(attributes);
+
 def SomeTypeAttr : TypeAttrBase<"SomeType", "some type attribute">;
 
 def BOp : NS_Op<"b_op", []> {
   let arguments = (ins
     AnyAttr:$any_attr,
     BoolAttr:$bool_attr,
     I32Attr:$i32_attr,
     I64Attr:$i64_attr,

mlir/tools/mlir-tblgen/OpDefinitionsGen.cpp

 #include "mlir/TableGen/OpClass.h"
 #include "mlir/TableGen/Operator.h"
 #include "mlir/TableGen/SideEffects.h"
 #include "mlir/TableGen/Trait.h"
 #include "llvm/ADT/MapVector.h"
 #include "llvm/ADT/Sequence.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/StringSet.h"
+#include "llvm/Support/Debug.h"
 #include "llvm/Support/Signals.h"
 #include "llvm/TableGen/Error.h"
 #include "llvm/TableGen/Record.h"
 #include "llvm/TableGen/TableGenBackend.h"
 
 #define DEBUG_TYPE "mlir-tblgen-opdefgen"
 
 using namespace llvm;
void OpEmitter::emitDef(
     const StaticVerifierFunctionEmitter &staticVerifierEmitter) {
   OpEmitter(op, staticVerifierEmitter).emitDef(os);
 }
 
 void OpEmitter::emitDecl(raw_ostream &os) { opClass.writeDeclTo(os); }
 
 void OpEmitter::emitDef(raw_ostream &os) { opClass.writeDefTo(os); }
 
+// Helper to return the names for accessor.
+static SmallVector<std::string, 2>
+getGetterOrSetterNames(bool isGetter, const Operator &op, StringRef name) {
+  auto prefixType = op.getDialect().getEmitAccessorPrefix();
+  std::string prefix;
+  if (prefixType != Dialect::EmitPrefix::Raw)
+    prefix = isGetter ? "get" : "set";
+
+  SmallVector<std::string, 2> names;
+  bool rawToo = prefixType == Dialect::EmitPrefix::Both;
+
+  auto skip = [&](StringRef newName) {
+    bool shouldSkip = newName == "getOperands";
+    if (!shouldSkip)
+      return false;
+
+    // This note could be avoided where the final function generated would
+    // have been identical. But preferably in the op definition avoiding using
+    // the generic name and then getting a more specialize type is better.
+    PrintNote(op.getLoc(),
+              "Skipping generation of prefixed accessor `" + newName +
+                  "` as overlaps with default one; generating raw form (`" +
+                  name + "`) still");
+    return true;
+  };
+
+  if (!prefix.empty()) {
+    names.push_back(prefix + convertToCamelFromSnakeCase(name, true));
+    // Skip cases which would overlap with default ones for now.
+    if (skip(names.back())) {
+      rawToo = true;
+      names.clear();
+    } else {
+      LLVM_DEBUG(llvm::errs() << "WITH_GETTER(\"" << op.getQualCppClassName()
+                              << "::" << names.back() << "\");\n"
+                              << "WITH_GETTER(\"" << op.getQualCppClassName()
+                              << "Adaptor::" << names.back() << "\");\n";);
+    }
+  }
+
+  if (prefix.empty() || rawToo)
+    names.push_back(name.str());
+  return names;
+}
+static SmallVector<std::string, 2> getGetterNames(const Operator &op,
+                                                  StringRef name) {
+  return getGetterOrSetterNames(/*isGetter=*/true, op, name);
+}
+static std::string getGetterName(const Operator &op, StringRef name) {
+  return getGetterOrSetterNames(/*isGetter=*/true, op, name).front();
+}
+static SmallVector<std::string, 2> getSetterNames(const Operator &op,
+                                                  StringRef name) {
+  return getGetterOrSetterNames(/*isGetter=*/false, op, name);
+}
+
+static void errorIfPruned(size_t line, OpMethod *m, const Twine &methodName,
+                          const Operator &op) {
+  if (m)
+    return;
+  PrintFatalError(op.getLoc(), "Unexpected overlap when generating `" +
+                                   methodName + "` for " +
+                                   op.getOperationName() + " (from line " +
+                                   Twine(line) + ")");
+}
+#define ERROR_IF_PRUNED(M, N, O) errorIfPruned(__LINE__, M, N, O)
+
 void OpEmitter::genAttrNameGetters() {
   // Enumerate the attribute names of this op, assigning each a relative
   // ordering.
   auto addAttrName = [&](StringRef name) {
     unsigned index = attributeNames.size();
     attributeNames.insert({name, index});
   };
   for (const NamedAttribute &namedAttr : op.getAttributes())
     addAttrName(namedAttr.name);
   // Include key attributes from several traits as implicitly registered.
   if (op.getTrait("::mlir::OpTrait::AttrSizedOperandSegments"))
     addAttrName("operand_segment_sizes");
   if (op.getTrait("::mlir::OpTrait::AttrSizedResultSegments"))
     addAttrName("result_segment_sizes");
 
   // Emit the getAttributeNames method.
   {
     auto *method = opClass.addMethodAndPrune(
         "::llvm::ArrayRef<::llvm::StringRef>", "getAttributeNames",
         OpMethod::Property(OpMethod::MP_Static | OpMethod::MP_Inline));
+    ERROR_IF_PRUNED(method, "getAttributeNames", op);
     auto &body = method->body();
     if (attributeNames.empty()) {
       body << "  return {};";
     } else {
       body << "  static ::llvm::StringRef attrNames[] = {";
       llvm::interleaveComma(llvm::make_first_range(attributeNames), body,
                             [&](StringRef attrName) {
                               body << "::llvm::StringRef(\"" << attrName
                                    << "\")";
                             });
       body << "};\n  return ::llvm::makeArrayRef(attrNames);";
     }
   }
   if (attributeNames.empty())
     return;
 
   // Emit the getAttributeNameForIndex methods.
   {
     auto *method = opClass.addMethodAndPrune(
         "::mlir::Identifier", "getAttributeNameForIndex",
         OpMethod::Property(OpMethod::MP_Private | OpMethod::MP_Inline),
         "unsigned", "index");
+    ERROR_IF_PRUNED(method, "getAttributeNameForIndex", op);
     method->body()
         << "  return getAttributeNameForIndex((*this)->getName(), index);";
   }
   {
     auto *method = opClass.addMethodAndPrune(
         "::mlir::Identifier", "getAttributeNameForIndex",
         OpMethod::Property(OpMethod::MP_Private | OpMethod::MP_Inline |
                            OpMethod::MP_Static),
         "::mlir::OperationName name, unsigned index");
+    ERROR_IF_PRUNED(method, "getAttributeNameForIndex", op);
     method->body() << "assert(index < " << attributeNames.size()
                    << " && \"invalid attribute index\");\n"
                       "  return name.getAbstractOperation()"
                       "->getAttributeNames()[index];";
   }
 
   // Generate the <attr>AttrName methods, that expose the attribute names to
   // users.
   const char *attrNameMethodBody = "  return getAttributeNameForIndex({0});";
   for (const std::pair<StringRef, unsigned> &attrIt : attributeNames) {
-    std::string methodName = (attrIt.first + "AttrName").str();
+    for (StringRef name : getGetterNames(op, attrIt.first)) {
+      std::string methodName = (name + "AttrName").str();
 
       // Generate the non-static variant.
       {
         auto *method =
             opClass.addMethodAndPrune("::mlir::Identifier", methodName,
                                       OpMethod::Property(OpMethod::MP_Inline));
-      method->body() << llvm::formatv(attrNameMethodBody, attrIt.second).str();
+        ERROR_IF_PRUNED(method, methodName, op);
+        method->body()
+            << llvm::formatv(attrNameMethodBody, attrIt.second).str();
       }
 
       // Generate the static variant.
       {
         auto *method = opClass.addMethodAndPrune(
             "::mlir::Identifier", methodName,
             OpMethod::Property(OpMethod::MP_Inline | OpMethod::MP_Static),
             "::mlir::OperationName", "name");
+        ERROR_IF_PRUNED(method, methodName, op);
         method->body() << llvm::formatv(attrNameMethodBody,
                                         "name, " + Twine(attrIt.second))
                               .str();
       }
     }
   }
+}
 
 void OpEmitter::genAttrGetters() {
   FmtContext fctx;
   fctx.withBuilder("::mlir::Builder((*this)->getContext())");
 
   // Emit the derived attribute body.
   auto emitDerivedAttr = [&](StringRef name, Attribute attr) {
     if (auto *method = opClass.addMethodAndPrune(attr.getReturnType(), name))
       method->body() << "  " << attr.getDerivedCodeBody() << "\n";
   };
 
   // Emit with return type specified.
   auto emitAttrWithReturnType = [&](StringRef name, Attribute attr) {
     auto *method = opClass.addMethodAndPrune(attr.getReturnType(), name);
+    ERROR_IF_PRUNED(method, name, op);
     auto &body = method->body();
     body << "  auto attr = " << name << "Attr();\n";
     if (attr.hasDefaultValue()) {
       // Returns the default value if not set.
       // TODO: this is inefficient, we are recreating the attribute for every
       // call. This should be set instead.
       std::string defaultValue = std::string(
           tgfmt(attr.getConstBuilderTemplate(), &fctx, attr.getDefaultValue()));
       body << "    if (!attr)\n      return "
            << tgfmt(attr.getConvertFromStorageCall(),
                     &fctx.withSelf(defaultValue))
            << ";\n";
     }
     body << "  return "
          << tgfmt(attr.getConvertFromStorageCall(), &fctx.withSelf("attr"))
          << ";\n";
   };
 
-  // Generate raw named accessor type. This is a wrapper class that allows
-  // referring to the attributes via accessors instead of having to use
-  // the string interface for better compile time verification.
+  // Generate named accessor with Attribute return type. This is a wrapper class
+  // that allows 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 << "AttrName()).template ";
     if (attr.isOptional() || attr.hasDefaultValue())
       body << "dyn_cast_or_null<";
     else
       body << "cast<";
     body << attr.getStorageType() << ">();";
   };
 
   for (const NamedAttribute &namedAttr : op.getAttributes()) {
+    for (StringRef name : getGetterNames(op, namedAttr.name)) {
       if (namedAttr.attr.isDerivedAttr()) {
-      emitDerivedAttr(namedAttr.name, namedAttr.attr);
+        emitDerivedAttr(name, namedAttr.attr);
       } else {
-      emitAttrWithStorageType(namedAttr.name, namedAttr.attr);
-      emitAttrWithReturnType(namedAttr.name, namedAttr.attr);
+        emitAttrWithStorageType(name, namedAttr.attr);
+        emitAttrWithReturnType(name, namedAttr.attr);
+      }
     }
   }
 
   auto derivedAttrs = make_filter_range(op.getAttributes(),
                                         [](const NamedAttribute &namedAttr) {
                                           return namedAttr.attr.isDerivedAttr();
                                         });
   if (!derivedAttrs.empty()) {
     opClass.addTrait("::mlir::DerivedAttributeOpInterface::Trait");
     // Generate helper method to query whether a named attribute is a derived
     // attribute. This enables, for example, avoiding adding an attribute that
     // overlaps with a derived attribute.
     {
       auto *method = opClass.addMethodAndPrune("bool", "isDerivedAttribute",
                                                OpMethod::MP_Static,
                                                "::llvm::StringRef", "name");
+      ERROR_IF_PRUNED(method, "isDerivedAttribute", op);
       auto &body = method->body();
       for (auto namedAttr : derivedAttrs)
         body << "  if (name == \"" << namedAttr.name << "\") return true;\n";
       body << " return false;";
     }
     // Generate method to materialize derived attributes as a DictionaryAttr.
     {
       auto *method = opClass.addMethodAndPrune("::mlir::DictionaryAttr",
                                                "materializeDerivedAttributes");
+      ERROR_IF_PRUNED(method, "materializeDerivedAttributes", op);
       auto &body = method->body();
 
       auto nonMaterializable =
           make_filter_range(derivedAttrs, [](const NamedAttribute &namedAttr) {
             return namedAttr.attr.getConvertFromStorageCall().empty();
           });
       if (!nonMaterializable.empty()) {
         std::string attrs;
// Generate method to materialize derived attributes as a DictionaryAttr.
       body << "});";
     }
   }
 }
 
 void OpEmitter::genAttrSetters() {
   // Generate raw named setter type. This is a wrapper class that allows setting
   // to the attributes via setters instead of having to use the string interface
   // for better compile time verification.
-  auto emitAttrWithStorageType = [&](StringRef name, Attribute attr) {
-    auto *method = opClass.addMethodAndPrune("void", (name + "Attr").str(),
-                                             attr.getStorageType(), "attr");
+  auto emitAttrWithStorageType = [&](StringRef setterName, StringRef getterName,
+                                     Attribute attr) {
+    auto *method = opClass.addMethodAndPrune(
+        "void", (setterName + "Attr").str(), attr.getStorageType(), "attr");
     if (method)
-      method->body() << "  (*this)->setAttr(" << name << "AttrName(), attr);";
+      method->body() << "  (*this)->setAttr(" << getterName
+                     << "AttrName(), attr);";
   };
 
-  for (const NamedAttribute &namedAttr : op.getAttributes())
+  for (const NamedAttribute &namedAttr : op.getAttributes()) {
     if (!namedAttr.attr.isDerivedAttr())
-      emitAttrWithStorageType(namedAttr.name, namedAttr.attr);
+      for (auto names : llvm::zip(getSetterNames(op, namedAttr.name),
+                                  getGetterNames(op, namedAttr.name)))
+        emitAttrWithStorageType(std::get<0>(names), std::get<1>(names),
+                                namedAttr.attr);
+  }
 }
 
 void OpEmitter::genOptionalAttrRemovers() {
   // Generate methods for removing optional attributes, instead of having to
   // use the string interface. Enables better compile time verification.
   auto emitRemoveAttr = [&](StringRef name) {
     auto upperInitial = name.take_front().upper();
     auto suffix = name.drop_front();
     auto *method = opClass.addMethodAndPrune(
         "::mlir::Attribute", ("remove" + upperInitial + suffix + "Attr").str());
     if (!method)
       return;
-    method->body() << "  return (*this)->removeAttr(" << name << "AttrName());";
+    method->body() << "  return (*this)->removeAttr(" << getGetterName(op, name)
+                   << "AttrName());";
   };
 
   for (const NamedAttribute &namedAttr : op.getAttributes())
     if (namedAttr.attr.isOptional())
       emitRemoveAttr(namedAttr.name);
 }
 
 // Generates the code to compute the start and end index of an operand or result
static void generateNamedOperandGetters(const Operator &op, Class &opClass,
   // getter methods.
   generateValueRangeStartAndEnd(opClass, "getODSOperandIndexAndLength",
                                 numVariadicOperands, numNormalOperands,
                                 rangeSizeCall, attrSizedOperands, sizeAttrInit,
                                 const_cast<Operator &>(op).getOperands());
 
   auto *m = opClass.addMethodAndPrune(rangeType, "getODSOperands", "unsigned",
                                       "index");
+  ERROR_IF_PRUNED(m, "getODSOperands", op);
   auto &body = m->body();
   body << formatv(valueRangeReturnCode, rangeBeginCall,
                   "getODSOperandIndexAndLength(index)");
 
   // Then we emit nicer named getter methods by redirecting to the "sink" getter
   // method.
   for (int i = 0; i != numOperands; ++i) {
     const auto &operand = op.getOperand(i);
     if (operand.name.empty())
       continue;
+    for (StringRef name : getGetterNames(op, operand.name)) {
       if (operand.isOptional()) {
-      m = opClass.addMethodAndPrune("::mlir::Value", operand.name);
-      m->body()
-          << "  auto operands = getODSOperands(" << i << ");\n"
-          << "  return operands.empty() ? ::mlir::Value() : *operands.begin();";
+        m = opClass.addMethodAndPrune("::mlir::Value", name);
+        ERROR_IF_PRUNED(m, name, op);
+        m->body() << "  auto operands = getODSOperands(" << i << ");\n"
+                  << "  return operands.empty() ? ::mlir::Value() : "
+                     "*operands.begin();";
       } else if (operand.isVariadicOfVariadic()) {
         StringRef segmentAttr =
             operand.constraint.getVariadicOfVariadicSegmentSizeAttr();
         if (isAdaptor) {
-        m = opClass.addMethodAndPrune("::llvm::SmallVector<::mlir::ValueRange>",
-                                      operand.name);
+          m = opClass.addMethodAndPrune(
+              "::llvm::SmallVector<::mlir::ValueRange>", name);
+          ERROR_IF_PRUNED(m, name, op);
           m->body() << llvm::formatv(variadicOfVariadicAdaptorCalcCode,
                                      segmentAttr, i);
           continue;
         }
 
-      m = opClass.addMethodAndPrune("::mlir::OperandRangeRange", operand.name);
-      m->body() << "  return getODSOperands(" << i << ").split(" << segmentAttr
-                << "Attr());";
+        m = opClass.addMethodAndPrune("::mlir::OperandRangeRange", name);
+        ERROR_IF_PRUNED(m, name, op);
+        m->body() << "  return getODSOperands(" << i << ").split("
+                  << segmentAttr << "Attr());";
       } else if (operand.isVariadic()) {
-      m = opClass.addMethodAndPrune(rangeType, operand.name);
+        m = opClass.addMethodAndPrune(rangeType, name);
+        ERROR_IF_PRUNED(m, name, op);
         m->body() << "  return getODSOperands(" << i << ");";
       } else {
-      m = opClass.addMethodAndPrune("::mlir::Value", operand.name);
+        m = opClass.addMethodAndPrune("::mlir::Value", name);
+        ERROR_IF_PRUNED(m, name, op);
         m->body() << "  return *getODSOperands(" << i << ").begin();";
       }
     }
   }
+}
 
 void OpEmitter::genNamedOperandGetters() {
   // Build the code snippet used for initializing the operand_segment_sizes
   // array.
   std::string attrSizeInitCode;
   if (op.getTrait("::mlir::OpTrait::AttrSizedOperandSegments")) {
     attrSizeInitCode =
         formatv(opSegmentSizeAttrInitCode, "operand_segment_sizesAttrName()")

 
 void OpEmitter::genNamedOperandSetters() {
   auto *attrSizedOperands =
       op.getTrait("::mlir::OpTrait::AttrSizedOperandSegments");
   for (int i = 0, e = op.getNumOperands(); i != e; ++i) {
     const auto &operand = op.getOperand(i);
     if (operand.name.empty())
       continue;
-    auto *m = opClass.addMethodAndPrune(operand.isVariadicOfVariadic()
-                                            ? "::mlir::MutableOperandRangeRange"
-                                            : "::mlir::MutableOperandRange",
-                                        (operand.name + "Mutable").str());
+    for (StringRef name : getGetterNames(op, operand.name)) {
+      auto *m = opClass.addMethodAndPrune(
+          operand.isVariadicOfVariadic() ? "::mlir::MutableOperandRangeRange"
+          (name + "Mutable").str());
+      ERROR_IF_PRUNED(m, name, op);
       auto &body = m->body();
       body << "  auto range = getODSOperandIndexAndLength(" << i << ");\n"
-         << "  auto mutableRange = ::mlir::MutableOperandRange(getOperation(), "
+           << "  auto mutableRange = "
+              "::mlir::MutableOperandRange(getOperation(), "
               "range.first, range.second";
       if (attrSizedOperands)
         body << ", ::mlir::MutableOperandRange::OperandSegment(" << i
              << "u, *getOperation()->getAttrDictionary().getNamed("
                 "operand_segment_sizesAttrName()))";
       body << ");\n";
 
       // If this operand is a nested variadic, we split the range into a
       // MutableOperandRangeRange that provides a range over all of the
       // sub-ranges.
       if (operand.isVariadicOfVariadic()) {
+        //
         body << "  return "
                 "mutableRange.split(*(*this)->getAttrDictionary().getNamed("
-           << operand.constraint.getVariadicOfVariadicSegmentSizeAttr()
+             << getGetterName(
+                    op,
+                    operand.constraint.getVariadicOfVariadicSegmentSizeAttr())
              << "AttrName()));\n";
       } else {
         // Otherwise, we use the full range directly.
         body << "  return mutableRange;\n";
       }
     }
   }
+}
 
 void OpEmitter::genNamedResultGetters() {
   const int numResults = op.getNumResults();
   const int numVariadicResults = op.getNumVariableLengthResults();
   const int numNormalResults = numResults - numVariadicResults;
 
   // If we have more than one variadic results, we need more complicated logic
   // to calculate the value range for each result.
void OpEmitter::genNamedResultGetters() {
 
   generateValueRangeStartAndEnd(
       opClass, "getODSResultIndexAndLength", numVariadicResults,
       numNormalResults, "getOperation()->getNumResults()", attrSizedResults,
       attrSizeInitCode, op.getResults());
 
   auto *m = opClass.addMethodAndPrune("::mlir::Operation::result_range",
                                       "getODSResults", "unsigned", "index");
+  ERROR_IF_PRUNED(m, "getODSResults", op);
   m->body() << formatv(valueRangeReturnCode, "getOperation()->result_begin()",
                        "getODSResultIndexAndLength(index)");
 
   for (int i = 0; i != numResults; ++i) {
     const auto &result = op.getResult(i);
     if (result.name.empty())
       continue;
+    for (StringRef name : getGetterNames(op, result.name)) {
       if (result.isOptional()) {
-      m = opClass.addMethodAndPrune("::mlir::Value", result.name);
+        m = opClass.addMethodAndPrune("::mlir::Value", name);
+        ERROR_IF_PRUNED(m, name, op);
         m->body()
             << "  auto results = getODSResults(" << i << ");\n"
             << "  return results.empty() ? ::mlir::Value() : *results.begin();";
       } else if (result.isVariadic()) {
-      m = opClass.addMethodAndPrune("::mlir::Operation::result_range",
-                                    result.name);
+        m = opClass.addMethodAndPrune("::mlir::Operation::result_range", name);
+        ERROR_IF_PRUNED(m, name, op);
         m->body() << "  return getODSResults(" << i << ");";
       } else {
-      m = opClass.addMethodAndPrune("::mlir::Value", result.name);
+        m = opClass.addMethodAndPrune("::mlir::Value", name);
+        ERROR_IF_PRUNED(m, name, op);
         m->body() << "  return *getODSResults(" << i << ").begin();";
       }
     }
   }
+}
 
 void OpEmitter::genNamedRegionGetters() {
   unsigned numRegions = op.getNumRegions();
   for (unsigned i = 0; i < numRegions; ++i) {
     const auto &region = op.getRegion(i);
     if (region.name.empty())
       continue;
 
+    for (StringRef name : getGetterNames(op, region.name)) {
       // Generate the accessors for a variadic region.
       if (region.isVariadic()) {
         auto *m = opClass.addMethodAndPrune(
-          "::mlir::MutableArrayRef<::mlir::Region>", region.name);
+            "::mlir::MutableArrayRef<::mlir::Region>", name);
+        ERROR_IF_PRUNED(m, name, op);
         m->body() << formatv("  return (*this)->getRegions().drop_front({0});",
                              i);
         continue;
       }
 
-    auto *m = opClass.addMethodAndPrune("::mlir::Region &", region.name);
+      auto *m = opClass.addMethodAndPrune("::mlir::Region &", name);
+      ERROR_IF_PRUNED(m, name, op);
       m->body() << formatv("  return (*this)->getRegion({0});", i);
     }
   }
+}
 
 void OpEmitter::genNamedSuccessorGetters() {
   unsigned numSuccessors = op.getNumSuccessors();
   for (unsigned i = 0; i < numSuccessors; ++i) {
     const NamedSuccessor &successor = op.getSuccessor(i);
     if (successor.name.empty())
       continue;
 
+    for (StringRef name : getGetterNames(op, successor.name)) {
       // Generate the accessors for a variadic successor list.
       if (successor.isVariadic()) {
-      auto *m =
-          opClass.addMethodAndPrune("::mlir::SuccessorRange", successor.name);
+        auto *m = opClass.addMethodAndPrune("::mlir::SuccessorRange", name);
+        ERROR_IF_PRUNED(m, name, op);
         m->body() << formatv(
             "  return {std::next((*this)->successor_begin(), {0}), "
             "(*this)->successor_end()};",
             i);
         continue;
       }
 
-    auto *m = opClass.addMethodAndPrune("::mlir::Block *", successor.name);
+      auto *m = opClass.addMethodAndPrune("::mlir::Block *", name);
+      ERROR_IF_PRUNED(m, name, op);
       m->body() << formatv("  return (*this)->getSuccessor({0});", i);
     }
   }
+}
 
 static bool canGenerateUnwrappedBuilder(Operator &op) {
   // If this op does not have native attributes at all, return directly to avoid
   // redefining builders.
   if (op.getNumNativeAttributes() == 0)
     return false;
 
   bool canGenerate = false;
if (!m)
     return;
 
   auto &body = m->body();
 
   // Push all result types to the operation state
   std::string resultType;
   const auto &namedAttr = op.getAttribute(0);
 
-  body << "  auto attrName = " << namedAttr.name << "AttrName("
-       << builderOpState
+  body << "  auto attrName = " << getGetterName(op, namedAttr.name)
+       << "AttrName(" << builderOpState
        << ".name);\n"
           "  for (auto attr : attributes) {\n"
           "    if (attr.first != attrName) continue;\n";
   if (namedAttr.attr.isTypeAttr()) {
     resultType = "attr.second.cast<::mlir::TypeAttr>().getValue()";
   } else {
     resultType = "attr.second.getType()";
   }
void OpEmitter::genBuilder() {
   for (const Builder &builder : op.getBuilders()) {
     std::string paramStr = getBuilderSignature(builder);
 
     Optional<StringRef> body = builder.getBody();
     OpMethod::Property properties =
         body ? OpMethod::MP_Static : OpMethod::MP_StaticDeclaration;
     auto *method =
         opClass.addMethodAndPrune("void", "build", properties, paramStr);
+    if (body)
+      ERROR_IF_PRUNED(method, "build", op);
 
     FmtContext fctx;
     fctx.withBuilder(odsBuilder);
     fctx.addSubst("_state", builderOpState);
     if (body)
       method->body() << tgfmt(*body, &fctx);
   }
 
if (operand.constraint.isVariadicOfVariadic()) {
            << builderOpState << ".addOperands(range);\n";
 
       // Add the segment attribute.
       body << "  {\n"
            << "    SmallVector<int32_t> rangeSegments;\n"
            << "    for (::mlir::ValueRange range : " << argName << ")\n"
            << "      rangeSegments.push_back(range.size());\n"
            << "    " << builderOpState << ".addAttribute("
-           << operand.constraint.getVariadicOfVariadicSegmentSizeAttr()
+           << getGetterName(
+                  op, operand.constraint.getVariadicOfVariadicSegmentSizeAttr())
            << "AttrName(" << builderOpState << ".name), " << odsBuilder
            << ".getI32TensorAttr(rangeSegments));"
            << "  }\n";
       continue;
     }
 
     if (operand.isOptional())
       body << "  if (" << argName << ")\n  ";
if (isRawValueAttr && canUseUnwrappedRawValue(attr)) {
       // here given we use function arguments. So we need to strip the
       // wrapping quotes.
       if (StringRef(builderTemplate).contains("\"$0\""))
         builderTemplate = replaceAllSubstrs(builderTemplate, "\"$0\"", "$0");
 
       std::string value =
           std::string(tgfmt(builderTemplate, &fctx, namedAttr.name));
       body << formatv("  {0}.addAttribute({1}AttrName({0}.name), {2});\n",
-                      builderOpState, namedAttr.name, value);
+                      builderOpState, getGetterName(op, namedAttr.name), value);
     } else {
-      body << formatv("  {0}.addAttribute({1}AttrName({0}.name), {1});\n",
-                      builderOpState, namedAttr.name);
+      body << formatv("  {0}.addAttribute({1}AttrName({0}.name), {2});\n",
+                      builderOpState, getGetterName(op, namedAttr.name),
+                      namedAttr.name);
     }
     if (emitNotNullCheck)
       body << "  }\n";
   }
 
   // Create the correct number of regions.
   for (const NamedRegion &region : op.getRegions()) {
     if (region.isVariadic())

 void OpEmitter::genCanonicalizerDecls() {
   bool hasCanonicalizeMethod = def.getValueAsBit("hasCanonicalizeMethod");
   if (hasCanonicalizeMethod) {
     // static LogicResult FooOp::
     // canonicalize(FooOp op, PatternRewriter &rewriter);
     SmallVector<OpMethodParameter, 2> paramList;
     paramList.emplace_back(op.getCppClassName(), "op");
     paramList.emplace_back("::mlir::PatternRewriter &", "rewriter");
-    opClass.addMethodAndPrune("::mlir::LogicalResult", "canonicalize",
+    auto *m = opClass.addMethodAndPrune("::mlir::LogicalResult", "canonicalize",
                                         OpMethod::MP_StaticDeclaration,
                                         std::move(paramList));
+    ERROR_IF_PRUNED(m, "canonicalize", op);
   }
 
   // We get a prototype for 'getCanonicalizationPatterns' if requested directly
   // or if using a 'canonicalize' method.
   bool hasCanonicalizer = def.getValueAsBit("hasCanonicalizer");
   if (!hasCanonicalizeMethod && !hasCanonicalizer)
     return;
 
   // We get a body for 'getCanonicalizationPatterns' when using a 'canonicalize'
   // method, but not implementing 'getCanonicalizationPatterns' manually.
   bool hasBody = hasCanonicalizeMethod && !hasCanonicalizer;
 
   // Add a signature for getCanonicalizationPatterns if implemented by the
   // dialect or if synthesized to call 'canonicalize'.
   SmallVector<OpMethodParameter, 2> paramList;
   paramList.emplace_back("::mlir::RewritePatternSet &", "results");
   paramList.emplace_back("::mlir::MLIRContext *", "context");
   auto kind = hasBody ? OpMethod::MP_Static : OpMethod::MP_StaticDeclaration;
   auto *method = opClass.addMethodAndPrune(
       "void", "getCanonicalizationPatterns", kind, std::move(paramList));
 
   // If synthesizing the method, fill it it.
-  if (hasBody)
+  if (hasBody) {
+    ERROR_IF_PRUNED(method, "getCanonicalizationPatterns", op);
     method->body() << "  results.add(canonicalize);\n";
   }
+}
 
 void OpEmitter::genFolderDecls() {
   bool hasSingleResult =
       op.getNumResults() == 1 && op.getNumVariableLengthResults() == 0;
 
   if (def.getValueAsBit("hasFolder")) {
     if (hasSingleResult) {
-      opClass.addMethodAndPrune(
+      auto *m = opClass.addMethodAndPrune(
           "::mlir::OpFoldResult", "fold", OpMethod::MP_Declaration,
           "::llvm::ArrayRef<::mlir::Attribute>", "operands");
+      ERROR_IF_PRUNED(m, "operands", op);
     } else {
       SmallVector<OpMethodParameter, 2> paramList;
       paramList.emplace_back("::llvm::ArrayRef<::mlir::Attribute>", "operands");
       paramList.emplace_back("::llvm::SmallVectorImpl<::mlir::OpFoldResult> &",
                              "results");
-      opClass.addMethodAndPrune("::mlir::LogicalResult", "fold",
-                                OpMethod::MP_Declaration, std::move(paramList));
+      auto *m = opClass.addMethodAndPrune("::mlir::LogicalResult", "fold",
+                                          OpMethod::MP_Declaration,
+                                          std::move(paramList));
+      ERROR_IF_PRUNED(m, "fold", op);
     }
   }
 }
 
 void OpEmitter::genOpInterfaceMethods(const tblgen::InterfaceTrait *opTrait) {
   Interface interface = opTrait->getInterface();
 
   // Get the set of methods that should always be declared.
   auto alwaysDeclaredMethodsVec = opTrait->getAlwaysDeclaredMethods();
   llvm::StringSet<> alwaysDeclaredMethods;
   alwaysDeclaredMethods.insert(alwaysDeclaredMethodsVec.begin(),
                                alwaysDeclaredMethodsVec.end());
 
   for (const InterfaceMethod &method : interface.getMethods()) {
     // Don't declare if the method has a body.
     if (method.getBody())
       continue;
     // Don't declare if the method has a default implementation and the op
     // didn't request that it always be declared.
     if (method.getDefaultImplementation() &&
         !alwaysDeclaredMethods.count(method.getName()))
       continue;
-    genOpInterfaceMethod(method);
+    // Interface methods are allowed to overlap with existing methods, so don't
+    // check if pruned.
+    (void)genOpInterfaceMethod(method);
   }
 }
 
 OpMethod *OpEmitter::genOpInterfaceMethod(const InterfaceMethod &method,
                                           bool declaration) {
   SmallVector<OpMethodParameter, 4> paramList;
   for (const InterfaceMethod::Argument &arg : method.getArguments())
     paramList.emplace_back(arg.type, arg.name);
void OpEmitter::genSideEffectInterfaceMethods() {
   for (auto &it : interfaceEffects) {
     // Generate the 'getEffects' method.
     std::string type = llvm::formatv("::mlir::SmallVectorImpl<::mlir::"
                                      "SideEffects::EffectInstance<{0}>> &",
                                      it.first())
                            .str();
     auto *getEffects =
         opClass.addMethodAndPrune("void", "getEffects", type, "effects");
+    ERROR_IF_PRUNED(getEffects, "getEffects", op);
     auto &body = getEffects->body();
 
     // Add effect instances for each of the locations marked on the operation.
     for (auto &location : it.second) {
       StringRef effect = location.effect.getName();
       StringRef resource = location.effect.getResource();
       if (location.kind == EffectKind::Static) {
         // A static instance has no attached value.
OpMethod *method = [&]() -> OpMethod * {
     for (const InterfaceMethod &interfaceMethod : interface.getMethods()) {
       if (interfaceMethod.getName() == "inferReturnTypes") {
         return genOpInterfaceMethod(interfaceMethod, /*declaration=*/false);
       }
     }
     assert(0 && "unable to find inferReturnTypes interface method");
     return nullptr;
   }();
+  ERROR_IF_PRUNED(method, "inferReturnTypes", op);
   auto &body = method->body();
   body << "  inferredReturnTypes.resize(" << op.getNumResults() << ");\n";
 
   FmtContext fctx;
   fctx.withBuilder("odsBuilder");
   body << "  ::mlir::Builder odsBuilder(context);\n";
 
   auto emitType =
if (!hasStringAttribute(def, "parser") ||
     return;
 
   SmallVector<OpMethodParameter, 2> paramList;
   paramList.emplace_back("::mlir::OpAsmParser &", "parser");
   paramList.emplace_back("::mlir::OperationState &", "result");
   auto *method =
       opClass.addMethodAndPrune("::mlir::ParseResult", "parse",
                                 OpMethod::MP_Static, std::move(paramList));
+  ERROR_IF_PRUNED(method, "parse", op);
 
   FmtContext fctx;
   fctx.addSubst("cppClass", opClass.getClassName());
   auto parser = def.getValueAsString("parser").ltrim().rtrim(" \t\v\f\r");
   method->body() << "  " << tgfmt(parser, &fctx);
 }
 
 void OpEmitter::genPrinter() {
   if (hasStringAttribute(def, "assemblyFormat"))
     return;
 
   auto valueInit = def.getValueInit("printer");
   StringInit *stringInit = dyn_cast<StringInit>(valueInit);
   if (!stringInit)
     return;
 
   auto *method =
       opClass.addMethodAndPrune("void", "print", "::mlir::OpAsmPrinter &", "p");
+  ERROR_IF_PRUNED(method, "print", op);
   FmtContext fctx;
   fctx.addSubst("cppClass", opClass.getClassName());
   auto printer = stringInit->getValue().ltrim().rtrim(" \t\v\f\r");
   method->body() << "  " << tgfmt(printer, &fctx);
 }
 
 void OpEmitter::genVerifier() {
   auto *method = opClass.addMethodAndPrune("::mlir::LogicalResult", "verify");
+  ERROR_IF_PRUNED(method, "verify", op);
   auto &body = method->body();
   body << "  if (::mlir::failed(" << op.getAdaptorName()
        << "(*this).verify((*this)->getLoc()))) "
        << "return ::mlir::failure();\n";
 
   auto *valueInit = def.getValueInit("verifier");
   StringInit *stringInit = dyn_cast<StringInit>(valueInit);
   bool hasCustomVerify = stringInit && !stringInit->getValue().empty();
else if (auto opTrait = dyn_cast<tblgen::InterfaceTrait>(&trait))
       opClass.addTrait(opTrait->getFullyQualifiedTraitName());
   }
 }
 
 void OpEmitter::genOpNameGetter() {
   auto *method = opClass.addMethodAndPrune(
       "::llvm::StringLiteral", "getOperationName",
       OpMethod::Property(OpMethod::MP_Static | OpMethod::MP_Constexpr));
+  ERROR_IF_PRUNED(method, "getOperationName", op);
   method->body() << "  return ::llvm::StringLiteral(\"" << op.getOperationName()
                  << "\");";
 }
 
 void OpEmitter::genOpAsmInterface() {
   // If the user only has one results or specifically added the Asm trait,
   // then don't generate it for them. We specifically only handle multi result
   // operations, because the name of a single result in the common case is not
void OpEmitter::genOpAsmInterface() {
   // Don't add the trait if none of the results have a valid name.
   if (llvm::all_of(resultNames, [](StringRef name) { return name.empty(); }))
     return;
   opClass.addTrait("::mlir::OpAsmOpInterface::Trait");
 
   // Generate the right accessor for the number of results.
   auto *method = opClass.addMethodAndPrune(
       "void", "getAsmResultNames", "::mlir::OpAsmSetValueNameFn", "setNameFn");
+  ERROR_IF_PRUNED(method, "getAsmResultNames", op);
   auto &body = method->body();
   for (int i = 0; i != numResults; ++i) {
     body << "  auto resultGroup" << i << " = getODSResults(" << i << ");\n"
          << "  if (!llvm::empty(resultGroup" << i << "))\n"
          << "    setNameFn(*resultGroup" << i << ".begin(), \""
          << resultNames[i] << "\");\n";
   }
 }
auto *constructor = adaptor.addConstructorAndPrune(
         llvm::formatv("{0}&", op.getCppClassName()).str(), "op");
     constructor->addMemberInitializer("odsOperands", "op->getOperands()");
     constructor->addMemberInitializer("odsAttrs", "op->getAttrDictionary()");
     constructor->addMemberInitializer("odsRegions", "op->getRegions()");
   }
 
   {
     auto *m = adaptor.addMethodAndPrune("::mlir::ValueRange", "getOperands");
+    ERROR_IF_PRUNED(m, "getOperands", op);
     m->body() << "  return odsOperands;";
   }
   std::string sizeAttrInit =
       formatv(adapterSegmentSizeAttrInitCode, "operand_segment_sizes");
   generateNamedOperandGetters(op, adaptor,
                               /*isAdaptor=*/true, sizeAttrInit,
                               /*rangeType=*/"::mlir::ValueRange",
                               /*rangeBeginCall=*/"odsOperands.begin()",
                               /*rangeSizeCall=*/"odsOperands.size()",
                               /*getOperandCallPattern=*/"odsOperands[{0}]");
 
   FmtContext fctx;
   fctx.withBuilder("::mlir::Builder(odsAttrs.getContext())");
 
   auto emitAttr = [&](StringRef name, Attribute attr) {
-    auto &body = adaptor.addMethodAndPrune(attr.getStorageType(), name)->body();
+    auto *method = adaptor.addMethodAndPrune(attr.getStorageType(), name);
+    ERROR_IF_PRUNED(method, "Adaptor::" + name, op);
+    auto &body = method->body();
     body << "  assert(odsAttrs && \"no attributes when constructing adapter\");"
          << "\n  " << attr.getStorageType() << " attr = "
          << "odsAttrs.get(\"" << name << "\").";
     if (attr.hasDefaultValue() || attr.isOptional())
       body << "dyn_cast_or_null<";
     else
       body << "cast<";
     body << attr.getStorageType() << ">();\n";
 
     if (attr.hasDefaultValue()) {
       // Use the default value if attribute is not set.
       // TODO: this is inefficient, we are recreating the attribute for every
       // call. This should be set instead.
       std::string defaultValue = std::string(
           tgfmt(attr.getConstBuilderTemplate(), &fctx, attr.getDefaultValue()));
       body << "  if (!attr)\n    attr = " << defaultValue << ";\n";
     }
     body << "  return attr;\n";
   };
 
   {
     auto *m =
         adaptor.addMethodAndPrune("::mlir::DictionaryAttr", "getAttributes");
+    ERROR_IF_PRUNED(m, "Adaptor::getAttributes", op);
     m->body() << "  return odsAttrs;";
   }
   for (auto &namedAttr : op.getAttributes()) {
     const auto &name = namedAttr.name;
     const auto &attr = namedAttr.attr;
     if (!attr.isDerivedAttr())
       emitAttr(name, attr);
   }
 
   unsigned numRegions = op.getNumRegions();
   if (numRegions > 0) {
     auto *m = adaptor.addMethodAndPrune("::mlir::RegionRange", "getRegions");
+    ERROR_IF_PRUNED(m, "Adaptor::getRegions", op);
     m->body() << "  return odsRegions;";
   }
   for (unsigned i = 0; i < numRegions; ++i) {
     const auto &region = op.getRegion(i);
     if (region.name.empty())
       continue;
 
     // Generate the accessors for a variadic region.
     if (region.isVariadic()) {
       auto *m = adaptor.addMethodAndPrune("::mlir::RegionRange", region.name);
+      ERROR_IF_PRUNED(m, "Adaptor::" + region.name, op);
       m->body() << formatv("  return odsRegions.drop_front({0});", i);
       continue;
     }
 
     auto *m = adaptor.addMethodAndPrune("::mlir::Region &", region.name);
+    ERROR_IF_PRUNED(m, "Adaptor::" + region.name, op);
     m->body() << formatv("  return *odsRegions[{0}];", i);
   }
 
   // Add verification function.
   addVerification();
 }
 
 void OpOperandAdaptorEmitter::addVerification() {
   auto *method = adaptor.addMethodAndPrune("::mlir::LogicalResult", "verify",
                                            "::mlir::Location", "loc");
+  ERROR_IF_PRUNED(method, "verify", op);
   auto &body = method->body();
 
   const char *checkAttrSizedValueSegmentsCode = R"(
   {
     auto sizeAttr = odsAttrs.get("{0}").cast<::mlir::DenseIntElementsAttr>();
     auto numElements = sizeAttr.getType().cast<::mlir::ShapedType>().getNumElements();
     if (numElements != {1})
       return emitError(loc, "'{0}' attribute for specifying {2} segments "