[mlir][ods] Cleanup of Class Codegen helper

[Mogball]

Summary

Depends on D113331

[jpienaar]

mlir/include/mlir/TableGen/Class.h

206

Do you want to switch these to doxygen style too given the others are updated?

mlir/lib/TableGen/Class.cpp

55

Mmm, I'm not sure about doxygen style inside function bodies here, these seem more like implementation details rather than user visible considerations.

[Mogball]

Rebase and review comments

mlir/include/mlir/TableGen/Class.h

+//===- Class.h - Helper classes for C++ code emission -----------*- C++ -*-===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+//
+// This file defines several classes for Op C++ code emission. They are only
+// expected to be used by MLIR TableGen backends.
+//
+// We emit the op declaration and definition into separate files: *Ops.h.inc
+// and *Ops.cpp.inc. The former is to be included in the dialect *Ops.h and
+// the latter for dialect *Ops.cpp. This way provides a cleaner interface.
+//
+// In order to do this split, we need to track method signature and
+// implementation logic separately. Signature information is used for both
+// declaration and definition, while implementation logic is only for
+// definition. So we have the following classes for C++ code emission.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef MLIR_TABLEGEN_CLASS_H_
+#define MLIR_TABLEGEN_CLASS_H_
+
+#include "mlir/Support/LLVM.h"
+#include "mlir/TableGen/CodeGenHelpers.h"
+#include "llvm/ADT/SetVector.h"
+#include "llvm/ADT/SmallVector.h"
+#include "llvm/ADT/StringRef.h"
+#include "llvm/ADT/StringSet.h"
+#include "llvm/ADT/Twine.h"
+#include "llvm/Support/raw_ostream.h"
+
+#include <set>
+#include <string>
+
+namespace mlir {
+namespace tblgen {
+class FmtObjectBase;
+
+/// This class contains a single method parameter for a C++ function.
+class MethodParameter {
+public:
+  /// Create a method parameter with a C++ type, parameter name, and an optional
+  /// default value. Marking a parameter as "optional" is a cosmetic effect on
+  /// the generated code.
+  template <typename TypeT, typename NameT, typename DefaultT>
+  MethodParameter(TypeT &&type, NameT &&name, DefaultT &&defaultValue,
+                  bool optional = false)
+      : type(stringify(std::forward<TypeT>(type))),
+        name(stringify(std::forward<NameT>(name))),
+        defaultValue(stringify(std::forward<DefaultT>(defaultValue))),
+        optional(optional) {}
+
+  /// Create a method parameter with a C++ type, parameter name, and no default
+  /// value.
+  template <typename TypeT, typename NameT>
+  MethodParameter(TypeT &&type, NameT &&name, bool optional = false)
+      : MethodParameter(std::forward<TypeT>(type), std::forward<NameT>(name),
+                        /*defaultValue=*/"", optional) {}
+
+  /// Write the parameter as part of a method declaration.
+  void writeDeclTo(raw_ostream &os) const { writeTo(os, /*emitDefault=*/true); }
+  /// Write the parameter as part of a method definition.
+  void writeDefTo(raw_ostream &os) const { writeTo(os, /*emitDefault=*/false); }
+
+  /// Get the C++ type.
+  const std::string &getType() const { return type; }
+  /// Returns true if the parameter has a default value.
+  bool hasDefaultValue() const { return !defaultValue.empty(); }
+
+private:
+  void writeTo(raw_ostream &os, bool emitDefault) const;
+
+  /// The C++ type.
+  std::string type;
+  /// The variable name.
+  std::string name;
+  /// An optional default value. The default value exists if the string is not
+  /// empty.
+  std::string defaultValue;
+  /// Whether the parameter should be indicated as "optional".
+  bool optional;
+};
+
+/// This class contains a list of method parameters for constructor, class
+/// methods, and method signatures.
+class MethodParameters {
+public:
+  /// Create a list of method parameters.
+  MethodParameters(std::initializer_list<MethodParameter> parameters)
+      : parameters(parameters) {}
+  MethodParameters(SmallVector<MethodParameter> parameters)
+      : parameters(std::move(parameters)) {}
+
+  /// Write the parameters as part of a method declaration.
+  void writeDeclTo(raw_ostream &os) const;
+  /// Write the parameters as part of a method definition.
+  void writeDefTo(raw_ostream &os) const;
+
+  /// Determine whether this list of parameters "subsumes" another, which occurs
+  /// when this parameter list is identical to the other and has zero or more
+  /// additional default-valued parameters.
+  bool subsumes(const MethodParameters &other) const;
+
+  /// Return the number of parameters.
+  unsigned getNumParameters() const { return parameters.size(); }
+
+private:
+  llvm::SmallVector<MethodParameter> parameters;
+};
+
+/// This class contains the signature of a C++ method, including the return
+/// type. method name, and method parameters.
+class MethodSignature {
+public:
+  MethodSignature(StringRef retType, StringRef name,
+                  SmallVector<MethodParameter> &&parameters)
+      : returnType(retType), methodName(name),
+        parameters(std::move(parameters)) {}
+  template <typename... Parameters>
+  MethodSignature(StringRef retType, StringRef name, Parameters &&...parameters)
+      : returnType(retType), methodName(name),
+        parameters({std::forward<Parameters>(parameters)...}) {}
+
+  /// Determine whether a method with this signature makes a method with
+  /// `other` signature redundant. This occurs if the signatures have the same
+  /// name and this signature's parameteres subsume the other's.
+  ///
+  /// A method that makes another method redundant with a different return type
+  /// can replace the other, the assumption being that the subsuming method
+  /// provides a more resolved return type, e.g. IntegerAttr vs. Attribute.
+  bool makesRedundant(const MethodSignature &other) const;
+
+  /// Get the name of the method.
+  StringRef getName() const { return methodName; }
+
+  /// Get the number of parameters.
+  unsigned getNumParameters() const { return parameters.getNumParameters(); }
+
+  /// Write the signature as part of a method declaration.
+  void writeDeclTo(raw_ostream &os) const;
+
+  /// Write the signature as part of a method definition. `namePrefix` is to be
+  /// prepended to the method name (typically namespaces for qualifying the
+  /// method definition).
+  void writeDefTo(raw_ostream &os, StringRef namePrefix) const;
+
+private:
+  /// The method's C++ return type.
+  std::string returnType;
+  /// The method name.
+  std::string methodName;
+  /// The method's parameter list.
+  MethodParameters parameters;
+};
+
+/// Class for holding the body of an op's method for C++ code emission
+class MethodBody {
+public:
+  explicit MethodBody(bool declOnly);
+
+  MethodBody &operator<<(Twine content);
+  MethodBody &operator<<(int content);
+  MethodBody &operator<<(const FmtObjectBase &content);
+
+  void writeTo(raw_ostream &os) const;
+
+private:
+  /// Whether this class should record method body.
+  bool isEffective;
+  /// The body of the method.
+  std::string body;
+};
+
+/// Class for holding an op's method for C++ code emission
+class Method {
+public:
+  /// Properties (qualifiers) of class methods. Bitfield is used here to help
+  /// querying properties.
+  enum Property {
+    MP_None = 0x0,
+    MP_Static = 0x1,
+    MP_Constructor = 0x2,
+    MP_Private = 0x4,
+    MP_Declaration = 0x8,
+    MP_Inline = 0x10,
+    MP_Constexpr = 0x20 | MP_Inline,
+    MP_StaticDeclaration = MP_Static | MP_Declaration,
+  };
+
+  template <typename... Args>
+  Method(StringRef retType, StringRef name, Property property, Args &&...args)
+      : properties(property),
+        methodSignature(retType, name, std::forward<Args>(args)...),
+        methodBody(properties & MP_Declaration) {}
+
+  Method(Method &&) = default;
+  Method &operator=(Method &&) = default;
+
+  virtual ~Method() = default;
+
+  MethodBody &body() { return methodBody; }
+
+  /// Returns true if this is a static method.
+  bool isStatic() const { return properties & MP_Static; }
+
+  /// Returns true if this is a private method.
+  bool isPrivate() const { return properties & MP_Private; }
+
+  /// Returns true if this is an inline method.
+  bool isInline() const { return properties & MP_Inline; }
+
+  /// Returns the name of this method.
+  StringRef getName() const { return methodSignature.getName(); }
+
+  /// Returns if this method makes the `other` method redundant.
+  bool makesRedundant(const Method &other) const {
+    return methodSignature.makesRedundant(other.methodSignature);
+  }
+
+  /// Writes the method as a declaration to the given `os`.
+  virtual void writeDeclTo(raw_ostream &os) const;
+
+  /// Writes the method as a definition to the given `os`. `namePrefix` is the
+  /// prefix to be prepended to the method name (typically namespaces for
+  /// qualifying the method definition).
+  virtual void writeDefTo(raw_ostream &os, StringRef namePrefix) const;
+
+protected:
+  /// A collection of method properties.
+  Property properties;
+  /// The signature of the method.
+  MethodSignature methodSignature;
+  /// The body of the method, if it has one.
+  MethodBody methodBody;
+};
+
+} // end namespace tblgen
+} // end namespace mlir
+
+/// The OR of two method properties should return method properties. Ensure that
+/// this function is visible to `Class`.
+inline constexpr mlir::tblgen::Method::Property
+operator|(mlir::tblgen::Method::Property lhs,
+          mlir::tblgen::Method::Property rhs) {
+  return mlir::tblgen::Method::Property(static_cast<unsigned>(lhs) |
+                                        static_cast<unsigned>(rhs));
+}
+
+namespace mlir {
+namespace tblgen {
+
+/// Class for holding an op's constructor method for C++ code emission.
+class Constructor : public Method {
+public:
+  template <typename... Parameters>
+  Constructor(StringRef className, Property property,
+              Parameters &&...parameters)
+      : Method("", className, property,
+               std::forward<Parameters>(parameters)...) {}
+
+  /// Add member initializer to constructor initializing `name` with `value`.
+  void addMemberInitializer(StringRef name, StringRef value);
+
+  /// Writes the method as a definition to the given `os`. `namePrefix` is the
+  /// prefix to be prepended to the method name (typically namespaces for
+  /// qualifying the method definition).
+  void writeDefTo(raw_ostream &os, StringRef namePrefix) const override;
+
+private:
+  /// Member initializers.
+  std::string memberInitializers;
+};
+
+/// A class used to emit C++ classes from Tablegen.  Contains a list of public
+/// methods and a list of private fields to be emitted.
+class Class {
+public:
+  explicit Class(StringRef name);
+
+  /// Add a new constructor to this class and prune and constructors made
+  /// redundant by it. Returns null if the constructor was not added. Else,
+  /// returns a pointer to the new constructor.
+  template <typename... Parameters>
+  Constructor *addConstructorAndPrune(Parameters &&...parameters) {
+    return addConstructorAndPrune(
+        Constructor(getClassName(), Method::MP_Constructor,
+                    std::forward<Parameters>(parameters)...));
+  }
+
+  /// Add a new method to this class and prune any methods made redundant by it.
+  /// Returns null if the method was not added (because an existing method would
+  /// make it redundant). Else, returns a pointer to the new method.
+  template <typename... Parameters>
+  Method *addMethod(StringRef retType, StringRef name,
+                    Method::Property properties, Parameters &&...parameters) {
+    return addMethodAndPrune(Method(retType, name, properties,
+                                    std::forward<Parameters>(parameters)...));
+  }
+
+  /// Add a method with statically-known properties.
+  template <Method::Property Properties = Method::MP_None,
+            typename... Parameters>
+  Method *addMethod(StringRef retType, StringRef name,
+                    Parameters &&...parameters) {
+    return addMethod(retType, name, Properties,
+                             std::forward<Parameters>(parameters)...);
+  }
+
+  /// Add a static method.
+  template <Method::Property Properties = Method::MP_None,
+            typename... Parameters>
+  Method *addStaticMethod(StringRef retType, StringRef name,
+                          Parameters &&...parameters) {
+    return addMethod<Properties | Method::MP_Static>(
+        retType, name, std::forward<Parameters>(parameters)...);
+  }
+
+  /// Add an inline static method.
+  template <Method::Property Properties = Method::MP_None,
+            typename... Parameters>
+  Method *addStaticInlineMethod(StringRef retType, StringRef name,
+                                Parameters &&...parameters) {
+    return addMethod<Properties | Method::MP_Static | Method::MP_Inline>(
+        retType, name, std::forward<Parameters>(parameters)...);
+  }
+
+  /// Add an inline method.
+  template <Method::Property Properties = Method::MP_None,
+            typename... Parameters>
+  Method *addInlineMethod(StringRef retType, StringRef name,
+                          Parameters &&...parameters) {
+    return addMethod<Properties | Method::MP_Inline>(
+        retType, name, std::forward<Parameters>(parameters)...);
+  }
+
+  /// Add a declaration for a method.
+  template <Method::Property Properties = Method::MP_None,
+            typename... Parameters>
+  Method *declareMethod(StringRef retType, StringRef name,
+                        Parameters &&...parameters) {
+    return addMethod<Properties | Method::MP_Declaration>(
+        retType, name, std::forward<Parameters>(parameters)...);
+  }
+
+  /// Add a declaration for a static method.
+  template <Method::Property Properties = Method::MP_None,
+            typename... Parameters>
+  Method *declareStaticMethod(StringRef retType, StringRef name,
+                              Parameters &&...parameters) {
+    return addMethod<Properties | Method::MP_StaticDeclaration>(
+        retType, name, std::forward<Parameters>(parameters)...);
+  }
+
+  /// Creates a new field in this class.
+  void newField(StringRef type, StringRef name, StringRef defaultValue = "");
+
+  /// Writes this op's class as a declaration to the given `os`.
+  void writeDeclTo(raw_ostream &os) const;
+  /// Writes the method definitions in this op's class to the given `os`.
+  void writeDefTo(raw_ostream &os) const;
+
+  /// Returns the C++ class name of the op.
+  StringRef getClassName() const { return className; }
+
+protected:
+  /// Get a list of all the methods to emit, filtering out hidden ones.
+  void forAllMethods(llvm::function_ref<void(const Method &)> func) const {
+    llvm::for_each(constructors, [&](auto &ctor) { func(ctor); });
+    llvm::for_each(methods, [&](auto &method) { func(method); });
+  }
+
+  /// Add a new constructor if it is not made redundant by any existing
+  /// constructors and prune and existing constructors made redundant.
+  Constructor *addConstructorAndPrune(Constructor &&newCtor);
+  /// Add a new method if it is not made redundant by any existing methods and
+  /// prune and existing methods made redundant.
+  Method *addMethodAndPrune(Method &&newMethod);
+
+  /// The C++ class name.
+  std::string className;
+  /// The list of constructors.
+  std::vector<Constructor> constructors;
+  /// The list of class methods.
+  std::vector<Method> methods;
+  /// The list of class members.
+  SmallVector<std::string, 4> fields;
+};
+
+// Class for holding an op for C++ code emission
+class OpClass : public Class {
+public:
+  explicit OpClass(StringRef name, StringRef extraClassDeclaration = "");
+
+  /// Adds an op trait.
+  void addTrait(Twine trait);
+
+  /// Writes this op's class as a declaration to the given `os`.  Redefines
+  /// Class::writeDeclTo to also emit traits and extra class declarations.
+  void writeDeclTo(raw_ostream &os) const;
+
+private:
+  StringRef extraClassDeclaration;
+  llvm::SetVector<std::string, SmallVector<std::string>, StringSet<>> traits;
+};
+
+} // namespace tblgen
+} // namespace mlir
+
+#endif // MLIR_TABLEGEN_CLASS_H_

mlir/include/mlir/TableGen/CodeGenHelpers.h

private:
   /// The set of attribute constraints used in the current file.
   ConstraintMap attrConstraints;
   /// The set of successor constraints used in the current file.
   ConstraintMap successorConstraints;
   /// The set of region constraints used in the current file.
   ConstraintMap regionConstraints;
 };
 
-// Escape a string using C++ encoding. E.g. foo"bar -> foo\x22bar.
+/// Escape a string using C++ encoding. E.g. foo"bar -> foo\x22bar.
 std::string escapeString(StringRef value);
 
+namespace detail {
+template <typename> struct stringifier {
+  template <typename T> static std::string apply(T &&t) {
+    return std::string(std::forward<T>(t));
+  }
+};
+template <> struct stringifier<Twine> {
+  static std::string apply(const Twine &twine) {
+    return twine.str();
+  }
+};
+} // end namespace detail
+
+/// Generically convert a value to a std::string.
+template <typename T> std::string stringify(T &&t) {
+  return detail::stringifier<std::remove_reference_t<std::remove_const_t<T>>>::
+      apply(std::forward<T>(t));
+}
+
 } // namespace tblgen
 } // namespace mlir
 
 #endif // MLIR_TABLEGEN_CODEGENHELPERS_H

mlir/include/mlir/TableGen/OpClass.h

-//===- OpClass.h - Helper classes for Op C++ code emission ------*- C++ -*-===//
-//
-// 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
-//
-//===----------------------------------------------------------------------===//
-//
-// This file defines several classes for Op C++ code emission. They are only
-// expected to be used by MLIR TableGen backends.
-//
-// We emit the op declaration and definition into separate files: *Ops.h.inc
-// and *Ops.cpp.inc. The former is to be included in the dialect *Ops.h and
-// the latter for dialect *Ops.cpp. This way provides a cleaner interface.
-//
-// In order to do this split, we need to track method signature and
-// implementation logic separately. Signature information is used for both
-// declaration and definition, while implementation logic is only for
-// definition. So we have the following classes for C++ code emission.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef MLIR_TABLEGEN_OPCLASS_H_
-#define MLIR_TABLEGEN_OPCLASS_H_
-
-#include "mlir/Support/LLVM.h"
-#include "llvm/ADT/SetVector.h"
-#include "llvm/ADT/SmallVector.h"
-#include "llvm/ADT/StringRef.h"
-#include "llvm/ADT/StringSet.h"
-#include "llvm/Support/raw_ostream.h"
-
-#include <set>
-#include <string>
-
-namespace mlir {
-namespace tblgen {
-class FmtObjectBase;
-
-// Class for holding a single parameter of an op's method for C++ code emission.
-class OpMethodParameter {
-public:
-  // Properties (qualifiers) for the parameter.
-  enum Property {
-    PP_None = 0x0,
-    PP_Optional = 0x1,
-  };
-
-  OpMethodParameter(StringRef type, StringRef name, StringRef defaultValue = "",
-                    Property properties = PP_None)
-      : type(type), name(name), defaultValue(defaultValue),
-        properties(properties) {}
-
-  OpMethodParameter(StringRef type, StringRef name, Property property)
-      : OpMethodParameter(type, name, "", property) {}
-
-  // Writes the parameter as a part of a method declaration to `os`.
-  void writeDeclTo(raw_ostream &os) const { writeTo(os, /*emitDefault=*/true); }
-
-  // Writes the parameter as a part of a method definition to `os`
-  void writeDefTo(raw_ostream &os) const { writeTo(os, /*emitDefault=*/false); }
-
-  const std::string &getType() const { return type; }
-  bool hasDefaultValue() const { return !defaultValue.empty(); }
-
-private:
-  void writeTo(raw_ostream &os, bool emitDefault) const;
-
-  std::string type;
-  std::string name;
-  std::string defaultValue;
-  Property properties;
-};
-
-// Base class for holding parameters of an op's method for C++ code emission.
-class OpMethodParameters {
-public:
-  // Discriminator for LLVM-style RTTI.
-  enum ParamsKind {
-    // Separate type and name for each parameter is not known.
-    PK_Unresolved,
-    // Each parameter is resolved to a type and name.
-    PK_Resolved,
-  };
-
-  OpMethodParameters(ParamsKind kind) : kind(kind) {}
-  virtual ~OpMethodParameters() {}
-
-  // LLVM-style RTTI support.
-  ParamsKind getKind() const { return kind; }
-
-  // Writes the parameters as a part of a method declaration to `os`.
-  virtual void writeDeclTo(raw_ostream &os) const = 0;
-
-  // Writes the parameters as a part of a method definition to `os`
-  virtual void writeDefTo(raw_ostream &os) const = 0;
-
-  // Factory methods to create the correct type of `OpMethodParameters`
-  // object based on the arguments.
-  static std::unique_ptr<OpMethodParameters> create();
-
-  static std::unique_ptr<OpMethodParameters> create(StringRef params);
-
-  static std::unique_ptr<OpMethodParameters>
-  create(llvm::SmallVectorImpl<OpMethodParameter> &&params);
-
-  static std::unique_ptr<OpMethodParameters>
-  create(StringRef type, StringRef name, StringRef defaultValue = "");
-
-private:
-  const ParamsKind kind;
-};
-
-// Class for holding unresolved parameters.
-class OpMethodUnresolvedParameters : public OpMethodParameters {
-public:
-  OpMethodUnresolvedParameters(StringRef params)
-      : OpMethodParameters(PK_Unresolved), parameters(params) {}
-
-  // write the parameters as a part of a method declaration to the given `os`.
-  void writeDeclTo(raw_ostream &os) const override;
-
-  // write the parameters as a part of a method definition to the given `os`
-  void writeDefTo(raw_ostream &os) const override;
-
-  // LLVM-style RTTI support.
-  static bool classof(const OpMethodParameters *params) {
-    return params->getKind() == PK_Unresolved;
-  }
-
-private:
-  std::string parameters;
-};
-
-// Class for holding resolved parameters.
-class OpMethodResolvedParameters : public OpMethodParameters {
-public:
-  OpMethodResolvedParameters() : OpMethodParameters(PK_Resolved) {}
-
-  OpMethodResolvedParameters(llvm::SmallVectorImpl<OpMethodParameter> &&params)
-      : OpMethodParameters(PK_Resolved) {
-    for (OpMethodParameter &param : params)
-      parameters.emplace_back(std::move(param));
-  }
-
-  OpMethodResolvedParameters(StringRef type, StringRef name,
-                             StringRef defaultValue)
-      : OpMethodParameters(PK_Resolved) {
-    parameters.emplace_back(type, name, defaultValue);
-  }
-
-  // Returns the number of parameters.
-  size_t getNumParameters() const { return parameters.size(); }
-
-  // Returns if this method makes the `other` method redundant. Note that this
-  // is more than just finding conflicting methods. This method determines if
-  // the 2 set of parameters are conflicting and if so, returns true if this
-  // method has a more general set of parameters that can replace all possible
-  // calls to the `other` method.
-  bool makesRedundant(const OpMethodResolvedParameters &other) const;
-
-  // write the parameters as a part of a method declaration to the given `os`.
-  void writeDeclTo(raw_ostream &os) const override;
-
-  // write the parameters as a part of a method definition to the given `os`
-  void writeDefTo(raw_ostream &os) const override;
-
-  // LLVM-style RTTI support.
-  static bool classof(const OpMethodParameters *params) {
-    return params->getKind() == PK_Resolved;
-  }
-
-private:
-  llvm::SmallVector<OpMethodParameter, 4> parameters;
-};
-
-// Class for holding the signature of an op's method for C++ code emission
-class OpMethodSignature {
-public:
-  template <typename... Args>
-  OpMethodSignature(StringRef retType, StringRef name, Args &&...args)
-      : returnType(retType), methodName(name),
-        parameters(OpMethodParameters::create(std::forward<Args>(args)...)) {}
-  OpMethodSignature(OpMethodSignature &&) = default;
-
-  // Returns if a method with this signature makes a method with `other`
-  // signature redundant. Only supports resolved parameters.
-  bool makesRedundant(const OpMethodSignature &other) const;
-
-  // Returns the number of parameters (for resolved parameters).
-  size_t getNumParameters() const {
-    return cast<OpMethodResolvedParameters>(parameters.get())
-        ->getNumParameters();
-  }
-
-  // Returns the name of the method.
-  StringRef getName() const { return methodName; }
-
-  // Writes the signature as a method declaration to the given `os`.
-  void writeDeclTo(raw_ostream &os) const;
-
-  // Writes the signature as the start of a method definition to the given `os`.
-  // `namePrefix` is the prefix to be prepended to the method name (typically
-  // namespaces for qualifying the method definition).
-  void writeDefTo(raw_ostream &os, StringRef namePrefix) const;
-
-private:
-  std::string returnType;
-  std::string methodName;
-  std::unique_ptr<OpMethodParameters> parameters;
-};
-
-// Class for holding the body of an op's method for C++ code emission
-class OpMethodBody {
-public:
-  explicit OpMethodBody(bool declOnly);
-
-  OpMethodBody &operator<<(Twine content);
-  OpMethodBody &operator<<(int content);
-  OpMethodBody &operator<<(const FmtObjectBase &content);
-
-  void writeTo(raw_ostream &os) const;
-
-private:
-  // Whether this class should record method body.
-  bool isEffective;
-  std::string body;
-};
-
-// Class for holding an op's method for C++ code emission
-class OpMethod {
-public:
-  // Properties (qualifiers) of class methods. Bitfield is used here to help
-  // querying properties.
-  enum Property {
-    MP_None = 0x0,
-    MP_Static = 0x1,
-    MP_Constructor = 0x2,
-    MP_Private = 0x4,
-    MP_Declaration = 0x8,
-    MP_Inline = 0x10,
-    MP_Constexpr = 0x20 | MP_Inline,
-    MP_StaticDeclaration = MP_Static | MP_Declaration,
-  };
-
-  template <typename... Args>
-  OpMethod(StringRef retType, StringRef name, Property property, unsigned id,
-           Args &&...args)
-      : properties(property),
-        methodSignature(retType, name, std::forward<Args>(args)...),
-        methodBody(properties & MP_Declaration), id(id) {}
-
-  OpMethod(OpMethod &&) = default;
-
-  virtual ~OpMethod() = default;
-
-  OpMethodBody &body() { return methodBody; }
-
-  // Returns true if this is a static method.
-  bool isStatic() const { return properties & MP_Static; }
-
-  // Returns true if this is a private method.
-  bool isPrivate() const { return properties & MP_Private; }
-
-  // Returns true if this is an inline method.
-  bool isInline() const { return properties & MP_Inline; }
-
-  // Returns the name of this method.
-  StringRef getName() const { return methodSignature.getName(); }
-
-  // Returns the ID for this method
-  unsigned getID() const { return id; }
-
-  // Returns if this method makes the `other` method redundant.
-  bool makesRedundant(const OpMethod &other) const {
-    return methodSignature.makesRedundant(other.methodSignature);
-  }
-
-  // Writes the method as a declaration to the given `os`.
-  virtual void writeDeclTo(raw_ostream &os) const;
-
-  // Writes the method as a definition to the given `os`. `namePrefix` is the
-  // prefix to be prepended to the method name (typically namespaces for
-  // qualifying the method definition).
-  virtual void writeDefTo(raw_ostream &os, StringRef namePrefix) const;
-
-protected:
-  Property properties;
-  OpMethodSignature methodSignature;
-  OpMethodBody methodBody;
-  const unsigned id;
-};
-
-// Class for holding an op's constructor method for C++ code emission.
-class OpConstructor : public OpMethod {
-public:
-  template <typename... Args>
-  OpConstructor(StringRef className, Property property, unsigned id,
-                Args &&...args)
-      : OpMethod("", className, property, id, std::forward<Args>(args)...) {}
-
-  // Add member initializer to constructor initializing `name` with `value`.
-  void addMemberInitializer(StringRef name, StringRef value);
-
-  // Writes the method as a definition to the given `os`. `namePrefix` is the
-  // prefix to be prepended to the method name (typically namespaces for
-  // qualifying the method definition).
-  void writeDefTo(raw_ostream &os, StringRef namePrefix) const override;
-
-private:
-  // Member initializers.
-  std::string memberInitializers;
-};
-
-// A class used to emit C++ classes from Tablegen.  Contains a list of public
-// methods and a list of private fields to be emitted.
-class Class {
-public:
-  explicit Class(StringRef name);
-
-  // Adds a new method to this class and prune redundant methods. Returns null
-  // if the method was not added (because an existing method would make it
-  // redundant), else returns a pointer to the added method. Note that this call
-  // may also delete existing methods that are made redundant by a method to the
-  // class.
-  template <typename... Args>
-  OpMethod *addMethodAndPrune(StringRef retType, StringRef name,
-                              OpMethod::Property properties, Args &&...args) {
-    auto newMethod = std::make_unique<OpMethod>(
-        retType, name, properties, nextMethodID++, std::forward<Args>(args)...);
-    return addMethodAndPrune(methods, std::move(newMethod));
-  }
-
-  template <typename... Args>
-  OpMethod *addMethodAndPrune(StringRef retType, StringRef name,
-                              Args &&...args) {
-    return addMethodAndPrune(retType, name, OpMethod::MP_None,
-                             std::forward<Args>(args)...);
-  }
-
-  template <typename... Args>
-  OpConstructor *addConstructorAndPrune(Args &&...args) {
-    auto newConstructor = std::make_unique<OpConstructor>(
-        getClassName(), OpMethod::MP_Constructor, nextMethodID++,
-        std::forward<Args>(args)...);
-    return addMethodAndPrune(constructors, std::move(newConstructor));
-  }
-
-  // Creates a new field in this class.
-  void newField(StringRef type, StringRef name, StringRef defaultValue = "");
-
-  // Writes this op's class as a declaration to the given `os`.
-  void writeDeclTo(raw_ostream &os) const;
-  // Writes the method definitions in this op's class to the given `os`.
-  void writeDefTo(raw_ostream &os) const;
-
-  // Returns the C++ class name of the op.
-  StringRef getClassName() const { return className; }
-
-protected:
-  // Get a list of all the methods to emit, filtering out hidden ones.
-  void forAllMethods(llvm::function_ref<void(const OpMethod &)> func) const {
-    using ConsRef = const std::unique_ptr<OpConstructor> &;
-    using MethodRef = const std::unique_ptr<OpMethod> &;
-    llvm::for_each(constructors, [&](ConsRef ptr) { func(*ptr); });
-    llvm::for_each(methods, [&](MethodRef ptr) { func(*ptr); });
-  }
-
-  // For deterministic code generation, keep methods sorted in the order in
-  // which they were generated.
-  template <typename MethodTy>
-  struct MethodCompare {
-    bool operator()(const std::unique_ptr<MethodTy> &x,
-                    const std::unique_ptr<MethodTy> &y) const {
-      return x->getID() < y->getID();
-    }
-  };
-
-  template <typename MethodTy>
-  using MethodSet =
-      std::set<std::unique_ptr<MethodTy>, MethodCompare<MethodTy>>;
-
-  template <typename MethodTy>
-  MethodTy *addMethodAndPrune(MethodSet<MethodTy> &set,
-                              std::unique_ptr<MethodTy> &&newMethod) {
-    // Check if the new method will be made redundant by existing methods.
-    for (auto &method : set)
-      if (method->makesRedundant(*newMethod))
-        return nullptr;
-
-    // We can add this a method to the set. Prune any existing methods that will
-    // be made redundant by adding this new method. Note that the redundant
-    // check between two methods is more than a conflict check. makesRedundant()
-    // below will check if the new method conflicts with an existing method and
-    // if so, returns true if the new method makes the existing method redundant
-    // because all calls to the existing method can be subsumed by the new
-    // method. So makesRedundant() does a combined job of finding conflicts and
-    // deciding which of the 2 conflicting methods survive.
-    //
-    // Note: llvm::erase_if does not work with sets of std::unique_ptr, so doing
-    // it manually here.
-    for (auto it = set.begin(), end = set.end(); it != end;) {
-      if (newMethod->makesRedundant(*(it->get())))
-        it = set.erase(it);
-      else
-        ++it;
-    }
-
-    MethodTy *ret = newMethod.get();
-    set.insert(std::move(newMethod));
-    return ret;
-  }
-
-  std::string className;
-  MethodSet<OpConstructor> constructors;
-  MethodSet<OpMethod> methods;
-  unsigned nextMethodID = 0;
-  SmallVector<std::string, 4> fields;
-};
-
-// Class for holding an op for C++ code emission
-class OpClass : public Class {
-public:
-  explicit OpClass(StringRef name, StringRef extraClassDeclaration = "");
-
-  // Adds an op trait.
-  void addTrait(Twine trait);
-
-  // Writes this op's class as a declaration to the given `os`.  Redefines
-  // Class::writeDeclTo to also emit traits and extra class declarations.
-  void writeDeclTo(raw_ostream &os) const;
-
-private:
-  StringRef extraClassDeclaration;
-  SmallVector<std::string, 4> traitsVec;
-  StringSet<> traitsSet;
-};
-
-} // namespace tblgen
-} // namespace mlir
-
-#endif // MLIR_TABLEGEN_OPCLASS_H_

mlir/lib/TableGen/CMakeLists.txt

 # This library is unusual, since mlir-tblgen depends on it, which is
 # built with DISABLE_LLVM_LINK_LLVM_DYLIB, this must also be built
 # with that option.  Otherwise builds with LLVM_BUILD_LLVM_DYLIB and
 # LLVM_LINK_LLVM_DYLIB fail.  (Note that even if this has no llvm
 # component dependencies, LLVM_LINK_LLVM_DYLIB tends to introduce a
 # dependence on libLLVM.so)  However, it must also be linkable against
 # libMLIR.so in some contexts (see unittests/Tablegen, for instance, which
 # has a dependence on MLIRIR, which must depend on libLLVM.so).  This works
 # in this special case because this library is static.
 
 llvm_add_library(MLIRTableGen STATIC
   Argument.cpp
   Attribute.cpp
   AttrOrTypeDef.cpp
   Builder.cpp
+  Class.cpp
   Constraint.cpp
   Dialect.cpp
   Format.cpp
   Interfaces.cpp
   Operator.cpp
-  OpClass.cpp
   Pass.cpp
   Pattern.cpp
   Predicate.cpp
   Region.cpp
   SideEffects.cpp
   Successor.cpp
   Trait.cpp
   Type.cpp

mlir/lib/TableGen/Class.cpp

-//===- OpClass.cpp - Helper classes for Op C++ code emission --------------===//
+//===- Class.cpp - Helper classes for Op C++ code emission --------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
-#include "mlir/TableGen/OpClass.h"
+#include "mlir/TableGen/Class.h"
 
 #include "mlir/TableGen/Format.h"
 #include "llvm/ADT/Sequence.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/raw_ostream.h"
 #include <unordered_set>
 
 #define DEBUG_TYPE "mlir-tblgen-opclass"
 
 using namespace mlir;
 using namespace mlir::tblgen;
 
-namespace {
-
 // Returns space to be emitted after the given C++ `type`. return "" if the
 // ends with '&' or '*', or is empty, else returns " ".
-StringRef getSpaceAfterType(StringRef type) {
+static StringRef getSpaceAfterType(StringRef type) {
   return (type.empty() || type.endswith("&") || type.endswith("*")) ? "" : " ";
 }
 
-} // namespace
-
 //===----------------------------------------------------------------------===//
-// OpMethodParameter definitions
+// MethodParameter definitions
 //===----------------------------------------------------------------------===//
 
-void OpMethodParameter::writeTo(raw_ostream &os, bool emitDefault) const {
-  if (properties & PP_Optional)
+void MethodParameter::writeTo(raw_ostream &os, bool emitDefault) const {
+  if (optional)
     os << "/*optional*/";
   os << type << getSpaceAfterType(type) << name;
-  if (emitDefault && !defaultValue.empty())
+  if (emitDefault && hasDefaultValue())
     os << " = " << defaultValue;
 }
 
 //===----------------------------------------------------------------------===//
-// OpMethodParameters definitions
-//===----------------------------------------------------------------------===//
-
-// Factory methods to construct the correct type of `OpMethodParameters`
-// object based on the arguments.
-std::unique_ptr<OpMethodParameters> OpMethodParameters::create() {
-  return std::make_unique<OpMethodResolvedParameters>();
-}
-
-std::unique_ptr<OpMethodParameters>
-OpMethodParameters::create(StringRef params) {
-  return std::make_unique<OpMethodUnresolvedParameters>(params);
-}
-
-std::unique_ptr<OpMethodParameters>
-OpMethodParameters::create(llvm::SmallVectorImpl<OpMethodParameter> &&params) {
-  return std::make_unique<OpMethodResolvedParameters>(std::move(params));
-}
-
-std::unique_ptr<OpMethodParameters>
-OpMethodParameters::create(StringRef type, StringRef name,
-                           StringRef defaultValue) {
-  return std::make_unique<OpMethodResolvedParameters>(type, name, defaultValue);
-}
-
-//===----------------------------------------------------------------------===//
-// OpMethodUnresolvedParameters definitions
+// MethodParameters definitions
 //===----------------------------------------------------------------------===//
-void OpMethodUnresolvedParameters::writeDeclTo(raw_ostream &os) const {
-  os << parameters;
-}
 
-void OpMethodUnresolvedParameters::writeDefTo(raw_ostream &os) const {
-  // We need to remove the default values for parameters in method definition.
-  // TODO: We are using '=' and ',' as delimiters for parameter
-  // initializers. This is incorrect for initializer list with more than one
-  // element. Change to a more robust approach.
-  llvm::SmallVector<StringRef, 4> tokens;
-  StringRef params = parameters;
-  while (!params.empty()) {
-    std::pair<StringRef, StringRef> parts = params.split("=");
-    tokens.push_back(parts.first);
-    params = parts.second.split(',').second;
-  }
-  llvm::interleaveComma(tokens, os, [&](StringRef token) { os << token; });
+void MethodParameters::writeDeclTo(raw_ostream &os) const {
+  llvm::interleaveComma(parameters, os,
+                        [&os](auto &param) { param.writeDeclTo(os); });
+void MethodParameters::writeDefTo(raw_ostream &os) const {
+  llvm::interleaveComma(parameters, os,
+                        [&os](auto &param) { param.writeDefTo(os); });
 }
 
-//===----------------------------------------------------------------------===//
-// OpMethodResolvedParameters definitions
-//===----------------------------------------------------------------------===//
-
-// Returns true if a method with these parameters makes a method with parameters
-// `other` redundant. This should return true only if all possible calls to the
-// other method can be replaced by calls to this method.
-bool OpMethodResolvedParameters::makesRedundant(
-    const OpMethodResolvedParameters &other) const {
-  const size_t otherNumParams = other.getNumParameters();
-  const size_t thisNumParams = getNumParameters();
-
-  // All calls to the other method can be replaced this method only if this
-  // method has the same or more arguments number of arguments as the other, and
-  // the common arguments have the same type.
-  if (thisNumParams < otherNumParams)
+bool MethodParameters::subsumes(const MethodParameters &other) const {
+  // These parameters do not subsume the others if there are fewer parameters
+  // or their types do not match.
+  if (parameters.size() < other.parameters.size())
     return false;
-  for (int idx : llvm::seq<int>(0, otherNumParams))
-    if (parameters[idx].getType() != other.parameters[idx].getType())
-      return false;
+  if (!std::equal(
+          other.parameters.begin(), other.parameters.end(), parameters.begin(),
+          [](auto &lhs, auto &rhs) { return lhs.getType() == rhs.getType(); }))
 
-  // If all the common arguments have the same type, we can elide the other
-  // method if this method has the same number of arguments as other or the
-  // first argument after the common ones has a default value (and by C++
-  // requirement, all the later ones will also have a default value).
-  return thisNumParams == otherNumParams ||
-         parameters[otherNumParams].hasDefaultValue();
-}
-
-void OpMethodResolvedParameters::writeDeclTo(raw_ostream &os) const {
-  llvm::interleaveComma(parameters, os, [&](const OpMethodParameter &param) {
-    param.writeDeclTo(os);
-  });
-}
-
-void OpMethodResolvedParameters::writeDefTo(raw_ostream &os) const {
-  llvm::interleaveComma(parameters, os, [&](const OpMethodParameter &param) {
-    param.writeDefTo(os);
-  });
+  // If all the common parameters have the same type, we can elide the other
+  // method if this method has the same number of parameters as other or if the
+  // first paramater after the common parameters has a default value (and, as
+  // required by C++, subsequent parameters will have default values too).
+  return parameters.size() == other.parameters.size() ||
+         parameters[other.parameters.size()].hasDefaultValue();
 }
 
 //===----------------------------------------------------------------------===//
-// OpMethodSignature definitions
+// MethodSignature definitions
 //===----------------------------------------------------------------------===//
 
-// Returns if a method with this signature makes a method with `other` signature
-// redundant. Only supports resolved parameters.
-bool OpMethodSignature::makesRedundant(const OpMethodSignature &other) const {
-  if (methodName != other.methodName)
-    return false;
-  auto *resolvedThis = dyn_cast<OpMethodResolvedParameters>(parameters.get());
-  auto *resolvedOther =
-      dyn_cast<OpMethodResolvedParameters>(other.parameters.get());
-  if (resolvedThis && resolvedOther)
-    return resolvedThis->makesRedundant(*resolvedOther);
-  return false;
+bool MethodSignature::makesRedundant(const MethodSignature &other) const {
+  return methodName == other.methodName &&
+         parameters.subsumes(other.parameters);
 }
 
-void OpMethodSignature::writeDeclTo(raw_ostream &os) const {
+void MethodSignature::writeDeclTo(raw_ostream &os) const {
   os << returnType << getSpaceAfterType(returnType) << methodName << "(";
-  parameters->writeDeclTo(os);
+  parameters.writeDeclTo(os);
   os << ")";
 }
 
-void OpMethodSignature::writeDefTo(raw_ostream &os,
-                                   StringRef namePrefix) const {
+void MethodSignature::writeDefTo(raw_ostream &os, StringRef namePrefix) const {
   os << returnType << getSpaceAfterType(returnType) << namePrefix
      << (namePrefix.empty() ? "" : "::") << methodName << "(";
-  parameters->writeDefTo(os);
+  parameters.writeDefTo(os);
   os << ")";
 }
 
 //===----------------------------------------------------------------------===//
-// OpMethodBody definitions
+// MethodBody definitions
 //===----------------------------------------------------------------------===//
 
-OpMethodBody::OpMethodBody(bool declOnly) : isEffective(!declOnly) {}
+MethodBody::MethodBody(bool declOnly) : isEffective(!declOnly) {}
 
-OpMethodBody &OpMethodBody::operator<<(Twine content) {
+MethodBody &MethodBody::operator<<(Twine content) {
   if (isEffective)
     body.append(content.str());
   return *this;
 }
 
-OpMethodBody &OpMethodBody::operator<<(int content) {
+MethodBody &MethodBody::operator<<(int content) {
   if (isEffective)
     body.append(std::to_string(content));
   return *this;
 }
 
-OpMethodBody &OpMethodBody::operator<<(const FmtObjectBase &content) {
+MethodBody &MethodBody::operator<<(const FmtObjectBase &content) {
   if (isEffective)
     body.append(content.str());
   return *this;
 }
 
-void OpMethodBody::writeTo(raw_ostream &os) const {
+void MethodBody::writeTo(raw_ostream &os) const {
   auto bodyRef = StringRef(body).drop_while([](char c) { return c == '\n'; });
   os << bodyRef;
   if (bodyRef.empty() || bodyRef.back() != '\n')
     os << "\n";
 }
 
 //===----------------------------------------------------------------------===//
-// OpMethod definitions
+// Method definitions
 //===----------------------------------------------------------------------===//
 
-void OpMethod::writeDeclTo(raw_ostream &os) const {
+void Method::writeDeclTo(raw_ostream &os) const {
   os.indent(2);
   if (isStatic())
     os << "static ";
   if ((properties & MP_Constexpr) == MP_Constexpr)
     os << "constexpr ";
   methodSignature.writeDeclTo(os);
   if (!isInline()) {
     os << ";";
   } else {
     os << " {\n";
     methodBody.writeTo(os.indent(2));
     os.indent(2) << "}";
   }
 }
 
-void OpMethod::writeDefTo(raw_ostream &os, StringRef namePrefix) const {
+void Method::writeDefTo(raw_ostream &os, StringRef namePrefix) const {
   // Do not write definition if the method is decl only.
   if (properties & MP_Declaration)
     return;
   // Do not generate separate definition for inline method
   if (isInline())
     return;
   methodSignature.writeDefTo(os, namePrefix);
   os << " {\n";
   methodBody.writeTo(os);
   os << "}";
 }
 
 //===----------------------------------------------------------------------===//
-// OpConstructor definitions
+// Constructor definitions
 //===----------------------------------------------------------------------===//
 
-void OpConstructor::addMemberInitializer(StringRef name, StringRef value) {
+void Constructor::addMemberInitializer(StringRef name, StringRef value) {
   memberInitializers.append(std::string(llvm::formatv(
       "{0}{1}({2})", memberInitializers.empty() ? " : " : ", ", name, value)));
 }
 
-void OpConstructor::writeDefTo(raw_ostream &os, StringRef namePrefix) const {
+void Constructor::writeDefTo(raw_ostream &os, StringRef namePrefix) const {
   // Do not write definition if the method is decl only.
   if (properties & MP_Declaration)
     return;
 
   methodSignature.writeDefTo(os, namePrefix);
   os << " " << memberInitializers << " {\n";
   methodBody.writeTo(os);
-  os << "}";
+  os << "}\n";
 }
 
 //===----------------------------------------------------------------------===//
 // Class definitions
 //===----------------------------------------------------------------------===//
 
 Class::Class(StringRef name) : className(name) {}
 
 void Class::newField(StringRef type, StringRef name, StringRef defaultValue) {
   std::string varName = formatv("{0} {1}", type, name).str();
   std::string field = defaultValue.empty()
                           ? varName
                           : formatv("{0} = {1}", varName, defaultValue).str();
   fields.push_back(std::move(field));
 }
+
 void Class::writeDeclTo(raw_ostream &os) const {
   bool hasPrivateMethod = false;
   os << "class " << className << " {\n";
   os << "public:\n";
 
-  forAllMethods([&](const OpMethod &method) {
+  forAllMethods([&](const Method &method) {
     if (!method.isPrivate()) {
       method.writeDeclTo(os);
       os << '\n';
     } else {
       hasPrivateMethod = true;
     }
   });
 
   os << '\n';
   os << "private:\n";
   if (hasPrivateMethod) {
-    forAllMethods([&](const OpMethod &method) {
+    forAllMethods([&](const Method &method) {
       if (method.isPrivate()) {
         method.writeDeclTo(os);
         os << '\n';
       }
     });
     os << '\n';
   }
 
   for (const auto &field : fields)
     os.indent(2) << field << ";\n";
   os << "};\n";
 }
 
 void Class::writeDefTo(raw_ostream &os) const {
-  forAllMethods([&](const OpMethod &method) {
+  forAllMethods([&](const Method &method) {
     method.writeDefTo(os, className);
-    os << "\n\n";
+    os << "\n";
   });
 }
 
+// Insert a new method into a list of methods, if it would not be pruned, and
+// prune and existing methods.
+template <typename ContainerT, typename MethodT>
+MethodT *insertAndPrune(ContainerT &methods, MethodT newMethod) {
+  if (llvm::any_of(methods, [&](auto &method) {
+        return method.makesRedundant(newMethod);
+      }))
+    return nullptr;
+
+  llvm::erase_if(
+      methods, [&](auto &method) { return newMethod.makesRedundant(method); });
+  methods.push_back(std::move(newMethod));
+  return &methods.back();
+}
+
+Method *Class::addMethodAndPrune(Method &&newMethod) {
+  return insertAndPrune(methods, std::move(newMethod));
+}
+
+Constructor *Class::addConstructorAndPrune(Constructor &&newCtor) {
+  return insertAndPrune(constructors, std::move(newCtor));
+}
+
 //===----------------------------------------------------------------------===//
 // OpClass definitions
 //===----------------------------------------------------------------------===//
 
 OpClass::OpClass(StringRef name, StringRef extraClassDeclaration)
     : Class(name), extraClassDeclaration(extraClassDeclaration) {}
 
-void OpClass::addTrait(Twine trait) {
-  auto traitStr = trait.str();
-  if (traitsSet.insert(traitStr).second)
-    traitsVec.push_back(std::move(traitStr));
-}
+void OpClass::addTrait(Twine trait) { traits.insert(trait.str()); }
 
 void OpClass::writeDeclTo(raw_ostream &os) const {
   os << "class " << className << " : public ::mlir::Op<" << className;
-  for (const auto &trait : traitsVec)
+  for (const auto &trait : traits)
     os << ", " << trait;
   os << "> {\npublic:\n"
      << "  using Op::Op;\n"
      << "  using Op::print;\n"
      << "  using Adaptor = " << className << "Adaptor;\n";
 
   bool hasPrivateMethod = false;
-  forAllMethods([&](const OpMethod &method) {
+  forAllMethods([&](const Method &method) {
     if (!method.isPrivate()) {
       method.writeDeclTo(os);
       os << "\n";
     } else {
       hasPrivateMethod = true;
     }
   });
 
   // TODO: Add line control markers to make errors easier to debug.
   if (!extraClassDeclaration.empty())
     os << extraClassDeclaration << "\n";
 
   if (hasPrivateMethod) {
     os << "\nprivate:\n";
-    forAllMethods([&](const OpMethod &method) {
+    forAllMethods([&](const Method &method) {
       if (method.isPrivate()) {
         method.writeDeclTo(os);
         os << "\n";
       }
     });
   }
 
   os << "};\n";
 }

mlir/tools/mlir-tblgen/DialectGen.cpp

 //===- DialectGen.cpp - MLIR dialect definitions generator ----------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // DialectGen uses the description of dialects to generate C++ definitions.
 //
 //===----------------------------------------------------------------------===//
 
+#include "mlir/TableGen/Class.h"
 #include "mlir/TableGen/CodeGenHelpers.h"
 #include "mlir/TableGen/Format.h"
 #include "mlir/TableGen/GenInfo.h"
 #include "mlir/TableGen/Interfaces.h"
-#include "mlir/TableGen/OpClass.h"
 #include "mlir/TableGen/Operator.h"
 #include "mlir/TableGen/Trait.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/Sequence.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Signals.h"
 #include "llvm/TableGen/Error.h"

mlir/tools/mlir-tblgen/OpDefinitionsGen.cpp

 //===- OpDefinitionsGen.cpp - MLIR op definitions generator ---------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // OpDefinitionsGen uses the description of operations to generate C++
 // definitions for ops.
 //
 //===----------------------------------------------------------------------===//
 
 #include "OpFormatGen.h"
 #include "OpGenHelpers.h"
+#include "mlir/TableGen/Class.h"
 #include "mlir/TableGen/CodeGenHelpers.h"
 #include "mlir/TableGen/Format.h"
 #include "mlir/TableGen/GenInfo.h"
 #include "mlir/TableGen/Interfaces.h"
-#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"
private:
   };
 
   // Builds the parameter list for build() method of this op. This method writes
   // to `paramList` the comma-separated parameter list and updates
   // `resultTypeNames` with the names for parameters for specifying result
   // types. `inferredAttributes` is populated with any attributes that are
   // elided from the build list. The given `typeParamKind` and `attrParamKind`
   // controls how result types and attributes are placed in the parameter list.
-  void buildParamList(llvm::SmallVectorImpl<OpMethodParameter> &paramList,
+  void buildParamList(SmallVectorImpl<MethodParameter> &paramList,
                       llvm::StringSet<> &inferredAttributes,
                       SmallVectorImpl<std::string> &resultTypeNames,
                       TypeParamKind typeParamKind,
                       AttrParamKind attrParamKind = AttrParamKind::WrappedAttr);
 
   // Adds op arguments and regions into operation state for build() methods.
   void
-  genCodeForAddingArgAndRegionForBuilder(OpMethodBody &body,
+  genCodeForAddingArgAndRegionForBuilder(MethodBody &body,
                                          llvm::StringSet<> &inferredAttributes,
                                          bool isRawValueAttr = false);
 
   // Generates canonicalizer declaration for the operation.
   void genCanonicalizerDecls();
 
   // Generates the folder declaration for the operation.
   void genFolderDecls();
 
   // Generates the parser for the operation.
   void genParser();
 
   // Generates the printer for the operation.
   void genPrinter();
 
   // Generates verify method for the operation.
   void genVerifier();
 
   // Generates verify statements for operands and results in the operation.
   // The generated code will be attached to `body`.
-  void genOperandResultVerifier(OpMethodBody &body,
-                                Operator::value_range values,
+  void genOperandResultVerifier(MethodBody &body, Operator::value_range values,
                                 StringRef valueKind);
 
   // Generates verify statements for regions in the operation.
   // The generated code will be attached to `body`.
-  void genRegionVerifier(OpMethodBody &body);
+  void genRegionVerifier(MethodBody &body);
 
   // Generates verify statements for successors in the operation.
   // The generated code will be attached to `body`.
-  void genSuccessorVerifier(OpMethodBody &body);
+  void genSuccessorVerifier(MethodBody &body);
 
   // Generates the traits used by the object.
   void genTraits();
 
   // Generate the OpInterface methods for all interfaces.
   void genOpInterfaceMethods();
 
   // Generate op interface methods for the given interface.
   void genOpInterfaceMethods(const tblgen::InterfaceTrait *trait);
 
   // Generate op interface method for the given interface method. If
   // 'declaration' is true, generates a declaration, else a definition.
-  OpMethod *genOpInterfaceMethod(const tblgen::InterfaceMethod &method,
-                                 bool declaration = true);
+  Method *genOpInterfaceMethod(const tblgen::InterfaceMethod &method,
 
   // Generate the side effect interface methods.
   void genSideEffectInterfaceMethods();
 
   // Generate the type inference interface methods.
   void genTypeInterfaceMethods();
 
 private:
for (int i = 0, e = op.getNumResults(); i < e; ++i) {
     if (!value.name.empty())
       ctx.addSubst(value.name, emitHelper.getResult(i).str());
   }
 }
 
 // Generate attribute verification. If an op instance is not available, then
 // attribute checks that require one will not be emitted.
 static void genAttributeVerifier(
-    const OpOrAdaptorHelper &emitHelper, FmtContext &ctx, OpMethodBody &body,
+    const OpOrAdaptorHelper &emitHelper, FmtContext &ctx, MethodBody &body,
     const StaticVerifierFunctionEmitter &staticVerifierEmitter) {
   // Check that a required attribute exists.
   //
   // {0}: Attribute variable name.
   // {1}: Emit error prefix.
   // {2}: Attribute name.
   const char *const verifyRequiredAttr = R"(
     if (!{0})
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); }
 
-static void errorIfPruned(size_t line, OpMethod *m, const Twine &methodName,
+static void errorIfPruned(size_t line, Method *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() {
   // A map of attribute names (including implicit attributes) registered to the
   // current operation, to the relative order in which they were registered.
   llvm::MapVector<StringRef, unsigned> attributeNames;
 
   // 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.
-  std::string operandSizes = "operand_segment_sizes";
   if (op.getTrait("::mlir::OpTrait::AttrSizedOperandSegments"))
-    addAttrName(operandSizes);
-  std::string attrSizes = "result_segment_sizes";
+    addAttrName("operand_segment_sizes");
   if (op.getTrait("::mlir::OpTrait::AttrSizedResultSegments"))
-    addAttrName(attrSizes);
+    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));
+    auto *method = opClass.addStaticInlineMethod(
+        "::llvm::ArrayRef<::llvm::StringRef>", "getAttributeNames");
     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(
+    auto *method = opClass.addInlineMethod<Method::MP_Private>(
         "::mlir::Identifier", "getAttributeNameForIndex",
-        OpMethod::Property(OpMethod::MP_Private | OpMethod::MP_Inline),
-        "unsigned", "index");
+        MethodParameter("unsigned", "index"));
     ERROR_IF_PRUNED(method, "getAttributeNameForIndex", op);
     method->body()
         << "  return getAttributeNameForIndex((*this)->getName(), index);";
   }
   {
-    auto *method = opClass.addMethodAndPrune(
+    auto *method = opClass.addStaticInlineMethod<Method::MP_Private>(
         "::mlir::Identifier", "getAttributeNameForIndex",
-        OpMethod::Property(OpMethod::MP_Private | OpMethod::MP_Inline |
-                           OpMethod::MP_Static),
-        "::mlir::OperationName name, unsigned index");
+        MethodParameter("::mlir::OperationName", "name"),
+        MethodParameter("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) {
     for (StringRef name : op.getGetterNames(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));
+            opClass.addInlineMethod("::mlir::Identifier", methodName);
         ERROR_IF_PRUNED(method, methodName, op);
         method->body()
             << llvm::formatv(attrNameMethodBody, attrIt.second).str();
       }
 
       // Generate the static variant.
       {
-        auto *method = opClass.addMethodAndPrune(
+        auto *method = opClass.addStaticInlineMethod(
             "::mlir::Identifier", methodName,
-            OpMethod::Property(OpMethod::MP_Inline | OpMethod::MP_Static),
-            "::mlir::OperationName", "name");
+            MethodParameter("::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))
+    if (auto *method = opClass.addMethod(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);
+    auto *method = opClass.addMethod(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 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());
+        opClass.addMethod(attr.getStorageType(), (name + "Attr").str());
     if (!method)
       return;
     method->body() << formatv(
         "  return {0}.{1}<{2}>();", formatv(opGetAttr, name),
         attr.isOptional() || attr.hasDefaultValue() ? "dyn_cast_or_null"
                                                     : "cast",
         attr.getStorageType());
   };
 
   for (const NamedAttribute &namedAttr : op.getAttributes()) {
     for (StringRef name : op.getGetterNames(namedAttr.name)) {
       if (namedAttr.attr.isDerivedAttr()) {
         emitDerivedAttr(name, namedAttr.attr);
       } else {
         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();
+  if (derivedAttrs.empty())
+    return;
+
+    auto *method =
+        opClass.addStaticMethod("bool", "isDerivedAttribute",
+                                MethodParameter("::llvm::StringRef", "name"));
+    auto *method = opClass.addMethod("::mlir::DictionaryAttr",
 
-      auto nonMaterializable =
-          make_filter_range(derivedAttrs, [](const NamedAttribute &namedAttr) {
-            return namedAttr.attr.getConvertFromStorageCall().empty();
-          });
-      if (!nonMaterializable.empty()) {
-        std::string attrs;
-        llvm::raw_string_ostream os(attrs);
-        interleaveComma(nonMaterializable, os, [&](const NamedAttribute &attr) {
-          os << op.getGetterName(attr.name);
-        });
-        PrintWarning(
-            op.getLoc(),
-            formatv(
-                "op has non-materializable derived attributes '{0}', skipping",
-                os.str()));
-        body << formatv("  emitOpError(\"op has non-materializable derived "
-                        "attributes '{0}'\");\n",
-                        attrs);
-        body << "  return nullptr;";
-        return;
-      }
 
-      body << "  ::mlir::MLIRContext* ctx = getContext();\n";
-      body << "  ::mlir::Builder odsBuilder(ctx); (void)odsBuilder;\n";
-      body << "  return ::mlir::DictionaryAttr::get(";
-      body << "  ctx, {\n";
-      interleave(
-          derivedAttrs, body,
-          [&](const NamedAttribute &namedAttr) {
-            auto tmpl = namedAttr.attr.getConvertFromStorageCall();
-            std::string name = op.getGetterName(namedAttr.name);
-            body << "    {" << name << "AttrName(),\n"
-                 << tgfmt(tmpl, &fctx.withSelf(name + "()")
-                                     .withBuilder("odsBuilder")
-                                     .addSubst("_ctx", "ctx"))
-                 << "}";
-          },
-          ",\n");
-      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 setterName, StringRef getterName,
                                      Attribute attr) {
-    auto *method = opClass.addMethodAndPrune(
-        "void", (setterName + "Attr").str(), attr.getStorageType(), "attr");
+    auto *method =
+        opClass.addMethod("void", (setterName + "Attr").str(),
+                          MethodParameter(attr.getStorageType(), "attr"));
     if (method)
       method->body() << formatv("  (*this)->setAttr({0}AttrName(), attr);",
                                 getterName);
   };
 
   for (const NamedAttribute &namedAttr : op.getAttributes()) {
-    if (!namedAttr.attr.isDerivedAttr())
-      for (auto names : llvm::zip(op.getSetterNames(namedAttr.name),
-                                  op.getGetterNames(namedAttr.name)))
-        emitAttrWithStorageType(std::get<0>(names), std::get<1>(names),
-                                namedAttr.attr);
+    if (namedAttr.attr.isDerivedAttr())
+      continue;
   }
 }
 
 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(
+    auto *method = opClass.addMethod(
         "::mlir::Attribute", ("remove" + upperInitial + suffix + "Attr").str());
     if (!method)
       return;
     method->body() << formatv("  return (*this)->removeAttr({0}AttrName());",
                               op.getGetterName(name));
   };
 
   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
 // range.
 template <typename RangeT>
 static void
 generateValueRangeStartAndEnd(Class &opClass, StringRef methodName,
                               int numVariadic, int numNonVariadic,
                               StringRef rangeSizeCall, bool hasAttrSegmentSize,
                               StringRef sizeAttrInit, RangeT &&odsValues) {
-  auto *method = opClass.addMethodAndPrune("std::pair<unsigned, unsigned>",
-                                           methodName, "unsigned", "index");
+  auto *method = opClass.addMethod("std::pair<unsigned, unsigned>", methodName,
+                                   MethodParameter("unsigned", "index"));
   if (!method)
     return;
   auto &body = method->body();
   if (numVariadic == 0) {
     body << "  return {index, 1};\n";
   } else if (hasAttrSegmentSize) {
     body << sizeAttrInit << attrSizedSegmentValueRangeCalcCode;
   } else {
     // Because the op can have arbitrarily interleaved variadic and non-variadic
     // operands, we need to embed a list in the "sink" getter method for
     // calculation at run-time.
-    llvm::SmallVector<StringRef, 4> isVariadic;
+    SmallVector<StringRef, 4> isVariadic;
     isVariadic.reserve(llvm::size(odsValues));
     for (auto &it : odsValues)
       isVariadic.push_back(it.isVariableLength() ? "true" : "false");
     std::string isVariadicList = llvm::join(isVariadic, ", ");
     body << formatv(sameVariadicSizeValueRangeCalcCode, isVariadicList,
                     numNonVariadic, numVariadic, rangeSizeCall, "operand");
   }
 }
static void generateNamedOperandGetters(const Operator &op, Class &opClass,
 
   // First emit a few "sink" getter methods upon which we layer all nicer named
   // getter methods.
   generateValueRangeStartAndEnd(opClass, "getODSOperandIndexAndLength",
                                 numVariadicOperands, numNormalOperands,
                                 rangeSizeCall, attrSizedOperands, sizeAttrInit,
                                 const_cast<Operator &>(op).getOperands());
 
-  auto *m = opClass.addMethodAndPrune(rangeType, "getODSOperands", "unsigned",
-                                      "index");
+  auto *m = opClass.addMethod(rangeType, "getODSOperands",
+                              MethodParameter("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 : op.getGetterNames(operand.name)) {
       if (operand.isOptional()) {
-        m = opClass.addMethodAndPrune("::mlir::Value", name);
+        m = opClass.addMethod("::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()) {
         std::string segmentAttr = op.getGetterName(
             operand.constraint.getVariadicOfVariadicSegmentSizeAttr());
         if (isAdaptor) {
-          m = opClass.addMethodAndPrune(
-              "::llvm::SmallVector<::mlir::ValueRange>", name);
+          m = opClass.addMethod("::llvm::SmallVector<::mlir::ValueRange>",
+                                name);
           ERROR_IF_PRUNED(m, name, op);
           m->body() << llvm::formatv(variadicOfVariadicAdaptorCalcCode,
                                      segmentAttr, i);
           continue;
         }
 
-        m = opClass.addMethodAndPrune("::mlir::OperandRangeRange", name);
+        m = opClass.addMethod("::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, name);
+        m = opClass.addMethod(rangeType, name);
         ERROR_IF_PRUNED(m, name, op);
         m->body() << "  return getODSOperands(" << i << ");";
       } else {
-        m = opClass.addMethodAndPrune("::mlir::Value", name);
+        m = opClass.addMethod("::mlir::Value", name);
         ERROR_IF_PRUNED(m, name, op);
         m->body() << "  return *getODSOperands(" << i << ").begin();";
       }
     }
   }
 }
 
 void OpEmitter::genNamedOperandGetters() {

 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;
     for (StringRef name : op.getGetterNames(operand.name)) {
-      auto *m = opClass.addMethodAndPrune(
-          operand.isVariadicOfVariadic() ? "::mlir::MutableOperandRangeRange"
-                                         : "::mlir::MutableOperandRange",
+      auto *m = opClass.addMethod(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(), "
               "range.first, range.second";
       if (attrSizedOperands)
         body << ", ::mlir::MutableOperandRange::OperandSegment(" << i
if (attrSizedResults) {
     attrSizeInitCode = formatv(opSegmentSizeAttrInitCode, attr).str();
   }
 
   generateValueRangeStartAndEnd(
       opClass, "getODSResultIndexAndLength", numVariadicResults,
       numNormalResults, "getOperation()->getNumResults()", attrSizedResults,
       attrSizeInitCode, op.getResults());
 
-  auto *m = opClass.addMethodAndPrune("::mlir::Operation::result_range",
-                                      "getODSResults", "unsigned", "index");
+  auto *m =
+      opClass.addMethod("::mlir::Operation::result_range", "getODSResults",
+                        MethodParameter("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 : op.getGetterNames(result.name)) {
       if (result.isOptional()) {
-        m = opClass.addMethodAndPrune("::mlir::Value", name);
+        m = opClass.addMethod("::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", name);
+        m = opClass.addMethod("::mlir::Operation::result_range", name);
         ERROR_IF_PRUNED(m, name, op);
         m->body() << "  return getODSResults(" << i << ");";
       } else {
-        m = opClass.addMethodAndPrune("::mlir::Value", name);
+        m = opClass.addMethod("::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 : op.getGetterNames(region.name)) {
       // Generate the accessors for a variadic region.
       if (region.isVariadic()) {
-        auto *m = opClass.addMethodAndPrune(
-            "::mlir::MutableArrayRef<::mlir::Region>", name);
+        auto *m =
+            opClass.addMethod("::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 &", name);
+      auto *m = opClass.addMethod("::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 : op.getGetterNames(successor.name)) {
       // Generate the accessors for a variadic successor list.
       if (successor.isVariadic()) {
-        auto *m = opClass.addMethodAndPrune("::mlir::SuccessorRange", name);
+        auto *m = opClass.addMethod("::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 *", name);
+      auto *m = opClass.addMethod("::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
void OpEmitter::genSeparateArgParamBuilder() {
   attrBuilderType.push_back(AttrParamKind::WrappedAttr);
   if (canGenerateUnwrappedBuilder(op))
     attrBuilderType.push_back(AttrParamKind::UnwrappedValue);
 
   // Emit with separate builders with or without unwrapped attributes and/or
   // inferring result type.
   auto emit = [&](AttrParamKind attrType, TypeParamKind paramKind,
                   bool inferType) {
-    llvm::SmallVector<OpMethodParameter, 4> paramList;
-    llvm::SmallVector<std::string, 4> resultNames;
+    SmallVector<MethodParameter> paramList;
+    SmallVector<std::string, 4> resultNames;
     llvm::StringSet<> inferredAttributes;
     buildParamList(paramList, inferredAttributes, resultNames, paramKind,
                    attrType);
 
-    auto *m = opClass.addMethodAndPrune("void", "build", OpMethod::MP_Static,
-                                        std::move(paramList));
+    auto *m = opClass.addStaticMethod("void", "build", std::move(paramList));
     // If the builder is redundant, skip generating the method.
     if (!m)
       return;
     auto &body = m->body();
     genCodeForAddingArgAndRegionForBuilder(body, inferredAttributes,
                                            /*isRawValueAttr=*/attrType ==
                                                AttrParamKind::UnwrappedValue);
 
for (auto attrType : attrBuilderType) {
     emit(attrType, TypeParamKind::Collective, /*inferType=*/false);
   }
 }
 
 void OpEmitter::genUseOperandAsResultTypeCollectiveParamBuilder() {
   int numResults = op.getNumResults();
 
   // Signature
-  llvm::SmallVector<OpMethodParameter, 4> paramList;
+  SmallVector<MethodParameter> paramList;
   paramList.emplace_back("::mlir::OpBuilder &", "odsBuilder");
   paramList.emplace_back("::mlir::OperationState &", builderOpState);
   paramList.emplace_back("::mlir::ValueRange", "operands");
   // Provide default value for `attributes` when its the last parameter
   StringRef attributesDefaultValue = op.getNumVariadicRegions() ? "" : "{}";
   paramList.emplace_back("::llvm::ArrayRef<::mlir::NamedAttribute>",
                          "attributes", attributesDefaultValue);
   if (op.getNumVariadicRegions())
     paramList.emplace_back("unsigned", "numRegions");
 
-  auto *m = opClass.addMethodAndPrune("void", "build", OpMethod::MP_Static,
-                                      std::move(paramList));
+  auto *m = opClass.addStaticMethod("void", "build", std::move(paramList));
   // If the builder is redundant, skip generating the method
   if (!m)
     return;
   auto &body = m->body();
 
   // Operands
   body << "  " << builderOpState << ".addOperands(operands);\n";
 
void OpEmitter::genUseOperandAsResultTypeCollectiveParamBuilder() {
   // Result types
   SmallVector<std::string, 2> resultTypes(numResults, "operands[0].getType()");
   body << "  " << builderOpState << ".addTypes({"
        << llvm::join(resultTypes, ", ") << "});\n\n";
 }
 
 void OpEmitter::genInferredTypeCollectiveParamBuilder() {
   // TODO: Expand to support regions.
-  SmallVector<OpMethodParameter, 4> paramList;
+  SmallVector<MethodParameter> paramList;
   paramList.emplace_back("::mlir::OpBuilder &", "odsBuilder");
   paramList.emplace_back("::mlir::OperationState &", builderOpState);
   paramList.emplace_back("::mlir::ValueRange", "operands");
   paramList.emplace_back("::llvm::ArrayRef<::mlir::NamedAttribute>",
                          "attributes", "{}");
-  auto *m = opClass.addMethodAndPrune("void", "build", OpMethod::MP_Static,
-                                      std::move(paramList));
+  auto *m = opClass.addStaticMethod("void", "build", std::move(paramList));
   // If the builder is redundant, skip generating the method
   if (!m)
     return;
   auto &body = m->body();
 
   int numResults = op.getNumResults();
   int numVariadicResults = op.getNumVariableLengthResults();
   int numNonVariadicResults = numResults - numVariadicResults;
void OpEmitter::genInferredTypeCollectiveParamBuilder() {
 
   body << formatv(R"(
     } else
       ::llvm::report_fatal_error("Failed to infer result type(s).");)",
                   opClass.getClassName(), builderOpState);
 }
 
 void OpEmitter::genUseOperandAsResultTypeSeparateParamBuilder() {
-  llvm::SmallVector<OpMethodParameter, 4> paramList;
-  llvm::SmallVector<std::string, 4> resultNames;
+  SmallVector<MethodParameter> paramList;
+  SmallVector<std::string, 4> resultNames;
   llvm::StringSet<> inferredAttributes;
   buildParamList(paramList, inferredAttributes, resultNames,
                  TypeParamKind::None);
 
-  auto *m = opClass.addMethodAndPrune("void", "build", OpMethod::MP_Static,
-                                      std::move(paramList));
+  auto *m = opClass.addStaticMethod("void", "build", std::move(paramList));
   // If the builder is redundant, skip generating the method
   if (!m)
     return;
   auto &body = m->body();
   genCodeForAddingArgAndRegionForBuilder(body, inferredAttributes);
 
   auto numResults = op.getNumResults();
   if (numResults == 0)
     return;
 
   // Push all result types to the operation state
   const char *index = op.getOperand(0).isVariadic() ? ".front()" : "";
   std::string resultType =
       formatv("{0}{1}.getType()", getArgumentName(op, 0), index).str();
   body << "  " << builderOpState << ".addTypes({" << resultType;
   for (int i = 1; i != numResults; ++i)
     body << ", " << resultType;
   body << "});\n\n";
 }
 
 void OpEmitter::genUseAttrAsResultTypeBuilder() {
-  SmallVector<OpMethodParameter, 4> paramList;
+  SmallVector<MethodParameter> paramList;
   paramList.emplace_back("::mlir::OpBuilder &", "odsBuilder");
   paramList.emplace_back("::mlir::OperationState &", builderOpState);
   paramList.emplace_back("::mlir::ValueRange", "operands");
   paramList.emplace_back("::llvm::ArrayRef<::mlir::NamedAttribute>",
                          "attributes", "{}");
-  auto *m = opClass.addMethodAndPrune("void", "build", OpMethod::MP_Static,
-                                      std::move(paramList));
+  auto *m = opClass.addStaticMethod("void", "build", std::move(paramList));
   // If the builder is redundant, skip generating the method
   if (!m)
     return;
 
   auto &body = m->body();
 
   // Push all result types to the operation state
   std::string resultType;
void OpEmitter::genUseAttrAsResultTypeBuilder() {
   SmallVector<std::string, 2> resultTypes(op.getNumResults(), resultType);
   body << "    " << builderOpState << ".addTypes({"
        << llvm::join(resultTypes, ", ") << "});\n";
   body << "  }\n";
 }
 
 /// Returns a signature of the builder. Updates the context `fctx` to enable
 /// replacement of $_builder and $_state in the body.
-static std::string getBuilderSignature(const Builder &builder) {
+static SmallVector<MethodParameter>
+getBuilderSignature(const Builder &builder) {
   ArrayRef<Builder::Parameter> params(builder.getParameters());
 
   // Inject builder and state arguments.
-  llvm::SmallVector<std::string, 8> arguments;
+  SmallVector<MethodParameter> arguments;
   arguments.reserve(params.size() + 2);
-  arguments.push_back(
-      llvm::formatv("::mlir::OpBuilder &{0}", odsBuilder).str());
-  arguments.push_back(
-      llvm::formatv("::mlir::OperationState &{0}", builderOpState).str());
+  arguments.emplace_back("::mlir::OpBuilder &", odsBuilder);
+  arguments.emplace_back("::mlir::OperationState &", builderOpState);
 
   for (unsigned i = 0, e = params.size(); i < e; ++i) {
     // If no name is provided, generate one.
     Optional<StringRef> paramName = params[i].getName();
     std::string name =
         paramName ? paramName->str() : "odsArg" + std::to_string(i);
 
-    std::string defaultValue;
+    StringRef defaultValue;
     if (Optional<StringRef> defaultParamValue = params[i].getDefaultValue())
-      defaultValue = llvm::formatv(" = {0}", *defaultParamValue).str();
-    arguments.push_back(
-        llvm::formatv("{0} {1}{2}", params[i].getCppType(), name, defaultValue)
-            .str());
+      defaultValue = *defaultParamValue;
+
+    arguments.emplace_back(params[i].getCppType(), std::move(name),
+                           defaultValue);
   }
 
-  return llvm::join(arguments, ", ");
+  return arguments;
 }
 
 void OpEmitter::genBuilder() {
   // Handle custom builders if provided.
   for (const Builder &builder : op.getBuilders()) {
-    std::string paramStr = getBuilderSignature(builder);
+    SmallVector<MethodParameter> arguments = getBuilderSignature(builder);
 
     Optional<StringRef> body = builder.getBody();
-    OpMethod::Property properties =
-        body ? OpMethod::MP_Static : OpMethod::MP_StaticDeclaration;
+    Method::Property properties =
+        body ? Method::MP_Static : Method::MP_StaticDeclaration;
     auto *method =
-        opClass.addMethodAndPrune("void", "build", properties, paramStr);
+        opClass.addMethod("void", "build", properties, std::move(arguments));
     if (body)
       ERROR_IF_PRUNED(method, "build", op);
 
     FmtContext fctx;
     fctx.withBuilder(odsBuilder);
     fctx.addSubst("_state", builderOpState);
     if (body)
       method->body() << tgfmt(*body, &fctx);
void OpEmitter::genCollectiveParamBuilder() {
   int numResults = op.getNumResults();
   int numVariadicResults = op.getNumVariableLengthResults();
   int numNonVariadicResults = numResults - numVariadicResults;
 
   int numOperands = op.getNumOperands();
   int numVariadicOperands = op.getNumVariableLengthOperands();
   int numNonVariadicOperands = numOperands - numVariadicOperands;
 
-  SmallVector<OpMethodParameter, 4> paramList;
+  SmallVector<MethodParameter> paramList;
   paramList.emplace_back("::mlir::OpBuilder &", "");
   paramList.emplace_back("::mlir::OperationState &", builderOpState);
   paramList.emplace_back("::mlir::TypeRange", "resultTypes");
   paramList.emplace_back("::mlir::ValueRange", "operands");
   // Provide default value for `attributes` when its the last parameter
   StringRef attributesDefaultValue = op.getNumVariadicRegions() ? "" : "{}";
   paramList.emplace_back("::llvm::ArrayRef<::mlir::NamedAttribute>",
                          "attributes", attributesDefaultValue);
   if (op.getNumVariadicRegions())
     paramList.emplace_back("unsigned", "numRegions");
 
-  auto *m = opClass.addMethodAndPrune("void", "build", OpMethod::MP_Static,
-                                      std::move(paramList));
+  auto *m = opClass.addStaticMethod("void", "build", std::move(paramList));
   // If the builder is redundant, skip generating the method
   if (!m)
     return;
   auto &body = m->body();
 
   // Operands
   if (numVariadicOperands == 0 || numNonVariadicOperands != 0)
     body << "  assert(operands.size()"
void OpEmitter::genCollectiveParamBuilder() {
   body << "  " << builderOpState << ".addTypes(resultTypes);\n";
 
   // Generate builder that infers type too.
   // TODO: Expand to handle regions and successors.
   if (canInferType(op) && op.getNumSuccessors() == 0)
     genInferredTypeCollectiveParamBuilder();
 }
 
-void OpEmitter::buildParamList(SmallVectorImpl<OpMethodParameter> &paramList,
+void OpEmitter::buildParamList(SmallVectorImpl<MethodParameter> &paramList,
                                llvm::StringSet<> &inferredAttributes,
                                SmallVectorImpl<std::string> &resultTypeNames,
                                TypeParamKind typeParamKind,
                                AttrParamKind attrParamKind) {
   resultTypeNames.clear();
   auto numResults = op.getNumResults();
   resultTypeNames.reserve(numResults);
 
   paramList.emplace_back("::mlir::OpBuilder &", "odsBuilder");
   paramList.emplace_back("::mlir::OperationState &", builderOpState);
 
   switch (typeParamKind) {
   case TypeParamKind::None:
     break;
   case TypeParamKind::Separate: {
     // Add parameters for all return types
     for (int i = 0; i < numResults; ++i) {
       const auto &result = op.getResult(i);
       std::string resultName = std::string(result.name);
       if (resultName.empty())
         resultName = std::string(formatv("resultType{0}", i));
 
       StringRef type =
           result.isVariadic() ? "::mlir::TypeRange" : "::mlir::Type";
-      OpMethodParameter::Property properties = OpMethodParameter::PP_None;
-      if (result.isOptional())
-        properties = OpMethodParameter::PP_Optional;
 
-      paramList.emplace_back(type, resultName, properties);
+      paramList.emplace_back(type, resultName, result.isOptional());
       resultTypeNames.emplace_back(std::move(resultName));
     }
   } break;
   case TypeParamKind::Collective: {
     paramList.emplace_back("::mlir::TypeRange", "resultTypes");
     resultTypeNames.push_back("resultTypes");
   } break;
   }
if (const auto *operand = arg.dyn_cast<NamedTypeConstraint *>()) {
       StringRef type;
       if (operand->isVariadicOfVariadic())
         type = "::llvm::ArrayRef<::mlir::ValueRange>";
       else if (operand->isVariadic())
         type = "::mlir::ValueRange";
       else
         type = "::mlir::Value";
 
-      OpMethodParameter::Property properties = OpMethodParameter::PP_None;
-      if (operand->isOptional())
-        properties = OpMethodParameter::PP_Optional;
       paramList.emplace_back(type, getArgumentName(op, numOperands++),
-                             properties);
+                             operand->isOptional());
       continue;
     }
     const NamedAttribute &namedAttr = *arg.get<NamedAttribute *>();
     const Attribute &attr = namedAttr.attr;
 
     // inferred attributes don't need to be added to the param list.
     if (inferredAttributes.contains(namedAttr.name))
       continue;
 
-    OpMethodParameter::Property properties = OpMethodParameter::PP_None;
-    if (attr.isOptional())
-      properties = OpMethodParameter::PP_Optional;
-
     StringRef type;
     switch (attrParamKind) {
     case AttrParamKind::WrappedAttr:
       type = attr.getStorageType();
       break;
     case AttrParamKind::UnwrappedValue:
       if (canUseUnwrappedRawValue(attr))
         type = attr.getReturnType();
       else
         type = attr.getStorageType();
       break;
     }
 
     // Attach default value if requested and possible.
     std::string defaultValue;
     if (attrParamKind == AttrParamKind::UnwrappedValue &&
         i >= defaultValuedAttrStartIndex) {
       defaultValue += attr.getDefaultValue();
     }
-    paramList.emplace_back(type, namedAttr.name, defaultValue, properties);
+    paramList.emplace_back(type, namedAttr.name, defaultValue,
+                           attr.isOptional());
   }
 
   /// Insert parameters for each successor.
   for (const NamedSuccessor &succ : op.getSuccessors()) {
     StringRef type =
         succ.isVariadic() ? "::mlir::BlockRange" : "::mlir::Block *";
     paramList.emplace_back(type, succ.name);
   }
 
   /// Insert parameters for variadic regions.
   for (const NamedRegion &region : op.getRegions())
     if (region.isVariadic())
       paramList.emplace_back("unsigned",
                              llvm::formatv("{0}Count", region.name).str());
 }
 
 void OpEmitter::genCodeForAddingArgAndRegionForBuilder(
-    OpMethodBody &body, llvm::StringSet<> &inferredAttributes,
+    MethodBody &body, llvm::StringSet<> &inferredAttributes,
     bool isRawValueAttr) {
   // Push all operands to the result.
   for (int i = 0, e = op.getNumOperands(); i < e; ++i) {
     std::string argName = getArgumentName(op, i);
     NamedTypeConstraint &operand = op.getOperand(i);
     if (operand.constraint.isVariadicOfVariadic()) {
       body << "  for (::mlir::ValueRange range : " << argName << ")\n   "
            << builderOpState << ".addOperands(range);\n";
void OpEmitter::genCodeForAddingArgAndRegionForBuilder(
   }
 }
 
 void OpEmitter::genCanonicalizerDecls() {
   bool hasCanonicalizeMethod = def.getValueAsBit("hasCanonicalizeMethod");
   if (hasCanonicalizeMethod) {
     // static LogicResult FooOp::
     // canonicalize(FooOp op, PatternRewriter &rewriter);
-    SmallVector<OpMethodParameter, 2> paramList;
+    SmallVector<MethodParameter> paramList;
     paramList.emplace_back(op.getCppClassName(), "op");
     paramList.emplace_back("::mlir::PatternRewriter &", "rewriter");
-    auto *m = opClass.addMethodAndPrune("::mlir::LogicalResult", "canonicalize",
-                                        OpMethod::MP_StaticDeclaration,
-                                        std::move(paramList));
+    auto *m = opClass.declareStaticMethod("::mlir::LogicalResult",
+                                          "canonicalize", 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;
+  SmallVector<MethodParameter> 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));
+  auto kind = hasBody ? Method::MP_Static : Method::MP_StaticDeclaration;
+  auto *method = opClass.addMethod("void", "getCanonicalizationPatterns", kind,
+                                   std::move(paramList));
 
   // If synthesizing the method, fill it it.
   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) {
-      auto *m = opClass.addMethodAndPrune(
-          "::mlir::OpFoldResult", "fold", OpMethod::MP_Declaration,
-          "::llvm::ArrayRef<::mlir::Attribute>", "operands");
+      auto *m = opClass.declareMethod(
+          "::mlir::OpFoldResult", "fold",
+          MethodParameter("::llvm::ArrayRef<::mlir::Attribute>", "operands"));
       ERROR_IF_PRUNED(m, "operands", op);
     } else {
-      SmallVector<OpMethodParameter, 2> paramList;
+      SmallVector<MethodParameter> paramList;
       paramList.emplace_back("::llvm::ArrayRef<::mlir::Attribute>", "operands");
       paramList.emplace_back("::llvm::SmallVectorImpl<::mlir::OpFoldResult> &",
                              "results");
-      auto *m = opClass.addMethodAndPrune("::mlir::LogicalResult", "fold",
-                                          OpMethod::MP_Declaration,
-                                          std::move(paramList));
+      auto *m = opClass.declareMethod("::mlir::LogicalResult", "fold",
       ERROR_IF_PRUNED(m, "fold", op);
     }
   }
 }
 
 void OpEmitter::genOpInterfaceMethods(const tblgen::InterfaceTrait *opTrait) {
   Interface interface = opTrait->getInterface();
 
if (method.getDefaultImplementation() &&
         !alwaysDeclaredMethods.count(method.getName()))
       continue;
     // 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;
+Method *OpEmitter::genOpInterfaceMethod(const InterfaceMethod &method,
+  SmallVector<MethodParameter> paramList;
   for (const InterfaceMethod::Argument &arg : method.getArguments())
     paramList.emplace_back(arg.type, arg.name);
 
-  auto properties = method.isStatic() ? OpMethod::MP_Static : OpMethod::MP_None;
+  auto properties = method.isStatic() ? Method::MP_Static : Method::MP_None;
   if (declaration)
     properties =
-        static_cast<OpMethod::Property>(properties | OpMethod::MP_Declaration);
-  return opClass.addMethodAndPrune(method.getReturnType(), method.getName(),
-                                   properties, std::move(paramList));
+        static_cast<Method::Property>(properties | Method::MP_Declaration);
+  return opClass.addMethod(method.getReturnType(), method.getName(), properties,
+                           std::move(paramList));
 }
 
 void OpEmitter::genOpInterfaceMethods() {
   for (const auto &trait : op.getTraits()) {
     if (const auto *opTrait = dyn_cast<tblgen::InterfaceTrait>(&trait))
       if (opTrait->shouldDeclareMethods())
         genOpInterfaceMethods(opTrait);
   }
const char *addEffectCode =
       "  effects.emplace_back({0}::get(), {1}{2}::get());\n";
 
   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");
+    auto *getEffects = opClass.addMethod("void", "getEffects",
+                                         MethodParameter(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) {

 void OpEmitter::genTypeInterfaceMethods() {
   if (!op.allResultTypesKnown())
     return;
   // Generate 'inferReturnTypes' method declaration using the interface method
   // declared in 'InferTypeOpInterface' op interface.
   const auto *trait = dyn_cast<InterfaceTrait>(
       op.getTrait("::mlir::InferTypeOpInterface::Trait"));
   Interface interface = trait->getInterface();
-  OpMethod *method = [&]() -> OpMethod * {
+  Method *method = [&]() -> Method * {
     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 =
-      [&](const tblgen::Operator::ArgOrType &type) -> OpMethodBody & {
+  auto emitType = [&](const tblgen::Operator::ArgOrType &type) -> MethodBody & {
     if (!type.isArg())
       return body << tgfmt(*type.getType().getBuilderCall(), &fctx);
     auto argIndex = type.getArg();
     assert(!op.getArg(argIndex).is<NamedAttribute *>());
     auto arg = op.getArgToOperandOrAttribute(argIndex);
     if (arg.kind() == Operator::OperandOrAttribute::Kind::Operand)
       return body << "operands[" << arg.operandOrAttributeIndex()
                   << "].getType()";
void OpEmitter::genTypeInterfaceMethods() {
   body << "  return ::mlir::success();";
 }
 
 void OpEmitter::genParser() {
   if (!hasStringAttribute(def, "parser") ||
       hasStringAttribute(def, "assemblyFormat"))
     return;
 
-  SmallVector<OpMethodParameter, 2> paramList;
+  SmallVector<MethodParameter> 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));
+  auto *method = opClass.addStaticMethod("::mlir::ParseResult", "parse",
+                                         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");
+  auto *method = opClass.addMethod(
+      "void", "print", MethodParameter("::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);
 }
 
 /// Generate verification on native traits requiring attributes.
-static void genNativeTraitAttrVerifier(OpMethodBody &body,
+static void genNativeTraitAttrVerifier(MethodBody &body,
                                        const OpOrAdaptorHelper &emitHelper) {
   // Check that the variadic segment sizes attribute exists and contains the
   // expected number of elements.
   //
   // {0}: Attribute name.
   // {1}: Expected number of elements.
   // {2}: "operand" or "result".
   // {3}: Attribute getter call.
if (traitName == "::mlir::OpTrait::AttrSizedOperandSegments") {
       body << formatv(
           checkAttrSizedValueSegmentsCode, attrName, op.getNumResults(),
           "result", emitHelper.getAttr(attrName), emitHelper.emitErrorPrefix());
     }
   }
 }
 
 void OpEmitter::genVerifier() {
-  auto *method = opClass.addMethodAndPrune("::mlir::LogicalResult", "verify");
+  auto *method = opClass.addMethod("::mlir::LogicalResult", "verify");
   ERROR_IF_PRUNED(method, "verify", op);
   auto &body = method->body();
 
   OpOrAdaptorHelper emitHelper(op, /*isOp=*/true);
   genNativeTraitAttrVerifier(body, emitHelper);
 
   auto *valueInit = def.getValueInit("verifier");
   StringInit *stringInit = dyn_cast<StringInit>(valueInit);
if (hasCustomVerify) {
     fctx.addSubst("cppClass", opClass.getClassName());
     auto printer = stringInit->getValue().ltrim().rtrim(" \t\v\f\r");
     body << "  " << tgfmt(printer, &fctx);
   } else {
     body << "  return ::mlir::success();\n";
   }
 }
 
-void OpEmitter::genOperandResultVerifier(OpMethodBody &body,
+void OpEmitter::genOperandResultVerifier(MethodBody &body,
                                          Operator::value_range values,
                                          StringRef valueKind) {
   // Check that an optional value is at most 1 element.
   //
   // {0}: Value index.
   // {1}: "operand" or "result"
   const char *const verifyOptional = R"(
     if (valueGroup{0}.size() > 1) {
for (auto staticValue : llvm::enumerate(values)) {
     StringRef constraintFn =
         staticVerifierEmitter.getTypeConstraintFn(value.constraint);
     body << formatv(verifyValues, staticValue.index(), constraintFn, valueKind);
   }
 
   body << "  }\n";
 }
 
-void OpEmitter::genRegionVerifier(OpMethodBody &body) {
+void OpEmitter::genRegionVerifier(MethodBody &body) {
   /// Code to verify a region.
   ///
   /// {0}: Getter for the regions.
   /// {1}: The region constraint.
   /// {2}: The region's name.
   /// {3}: The region description.
   const char *const verifyRegion = R"(
     for (auto &region : {0})
auto getRegion = region.isVariadic()
                          : formatv(getSingleRegion, it.index()).str();
     auto constraintFn =
         staticVerifierEmitter.getRegionConstraintFn(region.constraint);
     body << formatv(verifyRegion, getRegion, constraintFn, region.name);
   }
   body << "  }\n";
 }
 
-void OpEmitter::genSuccessorVerifier(OpMethodBody &body) {
+void OpEmitter::genSuccessorVerifier(MethodBody &body) {
   const char *const verifySuccessor = R"(
     for (auto *successor : {0})
       if (::mlir::failed({1}(*this, successor, "{2}", index++)))
         return ::mlir::failure();
 )";
   /// Get a single successor.
   ///
   /// {0}: The successor's name.
for (const auto &trait : op.getTraits()) {
     if (auto *opTrait = dyn_cast<tblgen::NativeTrait>(&trait))
       opClass.addTrait(opTrait->getFullyQualifiedTraitName());
     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));
+  auto *method = opClass.addStaticMethod<Method::MP_Constexpr>(
+      "::llvm::StringLiteral", "getOperationName");
   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
for (int i = 0; i != numResults; ++i)
     resultNames[i] = op.getResultName(i);
 
   // 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");
+  auto *method = opClass.addMethod(
+      "void", "getAsmResultNames",
+      MethodParameter("::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";
   }
OpOperandAdaptorEmitter::OpOperandAdaptorEmitter(
     : op(op), adaptor(op.getAdaptorName()),
       staticVerifierEmitter(staticVerifierEmitter) {
   adaptor.newField("::mlir::ValueRange", "odsOperands");
   adaptor.newField("::mlir::DictionaryAttr", "odsAttrs");
   adaptor.newField("::mlir::RegionRange", "odsRegions");
   const auto *attrSizedOperands =
       op.getTrait("::mlir::OpTrait::AttrSizedOperandSegments");
   {
-    SmallVector<OpMethodParameter, 2> paramList;
+    SmallVector<MethodParameter> paramList;
     paramList.emplace_back("::mlir::ValueRange", "values");
     paramList.emplace_back("::mlir::DictionaryAttr", "attrs",
                            attrSizedOperands ? "" : "nullptr");
     paramList.emplace_back("::mlir::RegionRange", "regions", "{}");
     auto *constructor = adaptor.addConstructorAndPrune(std::move(paramList));
 
     constructor->addMemberInitializer("odsOperands", "values");
     constructor->addMemberInitializer("odsAttrs", "attrs");
     constructor->addMemberInitializer("odsRegions", "regions");
   }
 
   {
     auto *constructor = adaptor.addConstructorAndPrune(
-        llvm::formatv("{0}&", op.getCppClassName()).str(), "op");
+        MethodParameter(op.getCppClassName() + " &", "op"));
     constructor->addMemberInitializer("odsOperands", "op->getOperands()");
     constructor->addMemberInitializer("odsAttrs", "op->getAttrDictionary()");
     constructor->addMemberInitializer("odsRegions", "op->getRegions()");
   }
 
   {
-    auto *m = adaptor.addMethodAndPrune("::mlir::ValueRange", "getOperands");
+    auto *m = adaptor.addMethod("::mlir::ValueRange", "getOperands");
     ERROR_IF_PRUNED(m, "getOperands", op);
     m->body() << "  return odsOperands;";
   }
   std::string attr = "operand_segment_sizes";
   std::string sizeAttrInit = formatv(adapterSegmentSizeAttrInitCode, attr);
   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, StringRef emitName, Attribute attr) {
-    auto *method = adaptor.addMethodAndPrune(attr.getStorageType(), emitName);
+    auto *method = adaptor.addMethod(attr.getStorageType(), emitName);
     ERROR_IF_PRUNED(method, "Adaptor::" + emitName, 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");
+    auto *m = adaptor.addMethod("::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()) {
       for (const auto &emitName : op.getGetterNames(name))
         emitAttr(name, emitName, attr);
     }
   }
 
   unsigned numRegions = op.getNumRegions();
   if (numRegions > 0) {
-    auto *m = adaptor.addMethodAndPrune("::mlir::RegionRange", "getRegions");
+    auto *m = adaptor.addMethod("::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.
     for (StringRef name : op.getGetterNames(region.name)) {
       if (region.isVariadic()) {
-        auto *m = adaptor.addMethodAndPrune("::mlir::RegionRange", name);
+        auto *m = adaptor.addMethod("::mlir::RegionRange", name);
         ERROR_IF_PRUNED(m, "Adaptor::" + name, op);
         m->body() << formatv("  return odsRegions.drop_front({0});", i);
         continue;
       }
 
-      auto *m = adaptor.addMethodAndPrune("::mlir::Region &", name);
+      auto *m = adaptor.addMethod("::mlir::Region &", name);
       ERROR_IF_PRUNED(m, "Adaptor::" + 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");
+  auto *method = adaptor.addMethod("::mlir::LogicalResult", "verify",
+                                   MethodParameter("::mlir::Location", "loc"));
   ERROR_IF_PRUNED(method, "verify", op);
   auto &body = method->body();
 
   OpOrAdaptorHelper emitHelper(op, /*isOp=*/false);
   genNativeTraitAttrVerifier(body, emitHelper);
   FmtContext verifyCtx;
   populateSubstitutions(emitHelper, verifyCtx);
 

mlir/tools/mlir-tblgen/OpFormatGen.cpp

 //===- OpFormatGen.cpp - MLIR operation asm format generator --------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "OpFormatGen.h"
 #include "FormatGen.h"
 #include "mlir/Support/LogicalResult.h"
+#include "mlir/TableGen/Class.h"
 #include "mlir/TableGen/Format.h"
 #include "mlir/TableGen/GenInfo.h"
 #include "mlir/TableGen/Interfaces.h"
-#include "mlir/TableGen/OpClass.h"
 #include "mlir/TableGen/Operator.h"
 #include "mlir/TableGen/Trait.h"
 #include "llvm/ADT/MapVector.h"
 #include "llvm/ADT/Sequence.h"
 #include "llvm/ADT/SetVector.h"
 #include "llvm/ADT/SmallBitVector.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/TypeSwitch.h"
using SuccessorVariable =
     VariableElement<NamedSuccessor, Element::Kind::SuccessorVariable>;
 } // end anonymous namespace
 
 //===----------------------------------------------------------------------===//
 // DirectiveElement
 
 namespace {
 /// This class implements single kind directives.
-template <Element::Kind type>
-class DirectiveElement : public Element {
+template <Element::Kind type> class DirectiveElement : public Element {
 public:
   DirectiveElement() : Element(type){};
   static bool classof(const Element *ele) { return ele->getKind() == type; }
 };
 /// This class represents the `operands` directive. This directive represents
 /// all of the operands of an operation.
 using OperandsDirective = DirectiveElement<Element::Kind::OperandsDirective>;
 
OperationFormat(const Operator &op)
 
     hasSingleBlockTrait =
         hasImplicitTermTrait || op.getTrait("::mlir::OpTrait::SingleBlock");
   }
 
   /// Generate the operation parser from this format.
   void genParser(Operator &op, OpClass &opClass);
   /// Generate the parser code for a specific format element.
-  void genElementParser(Element *element, OpMethodBody &body,
+  void genElementParser(Element *element, MethodBody &body,
                         FmtContext &attrTypeCtx);
   /// Generate the c++ to resolve the types of operands and results during
   /// parsing.
-  void genParserTypeResolution(Operator &op, OpMethodBody &body);
+  void genParserTypeResolution(Operator &op, MethodBody &body);
   /// Generate the c++ to resolve regions during parsing.
-  void genParserRegionResolution(Operator &op, OpMethodBody &body);
+  void genParserRegionResolution(Operator &op, MethodBody &body);
   /// Generate the c++ to resolve successors during parsing.
-  void genParserSuccessorResolution(Operator &op, OpMethodBody &body);
+  void genParserSuccessorResolution(Operator &op, MethodBody &body);
   /// Generate the c++ to handling variadic segment size traits.
-  void genParserVariadicSegmentResolution(Operator &op, OpMethodBody &body);
+  void genParserVariadicSegmentResolution(Operator &op, MethodBody &body);
 
   /// Generate the operation printer from this format.
   void genPrinter(Operator &op, OpClass &opClass);
 
   /// Generate the printer code for a specific format element.
-  void genElementPrinter(Element *element, OpMethodBody &body, Operator &op,
+  void genElementPrinter(Element *element, MethodBody &body, Operator &op,
                          bool &shouldEmitSpace, bool &lastWasPunctuation);
 
   /// The various elements in this format.
   std::vector<std::unique_ptr<Element>> elements;
 
   /// A flag indicating if all operand/result types were seen. If the format
   /// contains these, it can not contain individual type resolvers.
   bool allOperands, allOperandTypes, allResultTypes;
static StringRef getTypeListName(Element *arg, ArgumentLengthKind &lengthKind) {
   if (isa<OperandsDirective>(arg))
     return "allOperand";
   if (isa<ResultsDirective>(arg))
     return "allResult";
   llvm_unreachable("unknown 'type' directive argument");
 }
 
 /// Generate the parser for a literal value.
-static void genLiteralParser(StringRef value, OpMethodBody &body) {
+static void genLiteralParser(StringRef value, MethodBody &body) {
   // Handle the case of a keyword/identifier.
   if (value.front() == '_' || isalpha(value.front())) {
     body << "Keyword(\"" << value << "\")";
     return;
   }
   body << (StringRef)StringSwitch<StringRef>(value)
               .Case("->", "Arrow()")
               .Case(":", "Colon()")
body << (StringRef)StringSwitch<StringRef>(value)
               .Case("]", "RSquare()")
               .Case("?", "Question()")
               .Case("+", "Plus()")
               .Case("*", "Star()");
 }
 
 /// Generate the storage code required for parsing the given element.
 static void genElementParserStorage(Element *element, const Operator &op,
-                                    OpMethodBody &body) {
+                                    MethodBody &body) {
   if (auto *optional = dyn_cast<OptionalElement>(element)) {
     auto elements = optional->getThenElements();
 
     // If the anchor is a unit attribute, it won't be parsed directly so elide
     // it.
     auto *anchor = dyn_cast<AttributeVariable>(optional->getAnchor());
     Element *elidedAnchorElement = nullptr;
     if (anchor && anchor != &*elements.begin() && anchor->isUnitAttr())
if (auto *optional = dyn_cast<OptionalElement>(element)) {
     body << "  ::llvm::ArrayRef<::mlir::Type> "
          << getTypeListName(dir->getInputs(), ignored) << "Types;\n";
     body << "  ::llvm::ArrayRef<::mlir::Type> "
          << getTypeListName(dir->getResults(), ignored) << "Types;\n";
   }
 }
 
 /// Generate the parser for a parameter to a custom directive.
-static void genCustomParameterParser(Element &param, OpMethodBody &body) {
+static void genCustomParameterParser(Element &param, MethodBody &body) {
   if (auto *attr = dyn_cast<AttributeVariable>(&param)) {
     body << attr->getVar()->name << "Attr";
   } else if (isa<AttrDictDirective>(&param)) {
     body << "result.attributes";
   } else if (auto *operand = dyn_cast<OperandVariable>(&param)) {
     StringRef name = operand->getVar()->name;
     ArgumentLengthKind lengthKind = getArgumentLengthKind(operand->getVar());
     if (lengthKind == ArgumentLengthKind::VariadicOfVariadic)
if (auto *attr = dyn_cast<AttributeVariable>(&param)) {
     else
       body << formatv("{0}RawTypes[0]", listName);
   } else {
     llvm_unreachable("unknown custom directive parameter");
   }
 }
 
 /// Generate the parser for a custom directive.
-static void genCustomDirectiveParser(CustomDirective *dir, OpMethodBody &body) {
+static void genCustomDirectiveParser(CustomDirective *dir, MethodBody &body) {
   body << "  {\n";
 
   // Preprocess the directive variables.
   // * Add a local variable for optional operands and types. This provides a
   //   better API to the user defined parser methods.
   // * Set the location of operand variables.
   for (Element &param : dir->getArguments()) {
     if (auto *operand = dyn_cast<OperandVariable>(&param)) {
if (auto *attr = dyn_cast<AttributeVariable>(&param)) {
       }
     }
   }
 
   body << "  }\n";
 }
 
 /// Generate the parser for a enum attribute.
-static void genEnumAttrParser(const NamedAttribute *var, OpMethodBody &body,
+static void genEnumAttrParser(const NamedAttribute *var, MethodBody &body,
                               FmtContext &attrTypeCtx) {
   Attribute baseAttr = var->attr.getBaseAttr();
   const EnumAttr &enumAttr = cast<EnumAttr>(baseAttr);
   std::vector<EnumAttrCase> cases = enumAttr.getAllCases();
 
   // Generate the code for building an attribute for this enum.
   std::string attrBuilderStr;
   {
static void genEnumAttrParser(const NamedAttribute *var, MethodBody &body,
   }
 
   body << formatv(enumAttrParserCode, var->name, enumAttr.getCppNamespace(),
                   enumAttr.getStringToSymbolFnName(), attrBuilderStr,
                   validCaseKeywordsStr, errorMessage);
 }
 
 void OperationFormat::genParser(Operator &op, OpClass &opClass) {
-  llvm::SmallVector<OpMethodParameter, 4> paramList;
+  SmallVector<MethodParameter> 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));
+  auto *method = opClass.addStaticMethod("::mlir::ParseResult", "parse",
+                                         std::move(paramList));
   auto &body = method->body();
 
   // Generate variables to store the operands and type within the format. This
   // allows for referencing these variables in the presence of optional
   // groupings.
   for (auto &element : elements)
     genElementParserStorage(&*element, op, body);
 
void OperationFormat::genParser(Operator &op, OpClass &opClass) {
   genParserTypeResolution(op, body);
   genParserRegionResolution(op, body);
   genParserSuccessorResolution(op, body);
   genParserVariadicSegmentResolution(op, body);
 
   body << "  return ::mlir::success();\n";
 }
 
-void OperationFormat::genElementParser(Element *element, OpMethodBody &body,
+void OperationFormat::genElementParser(Element *element, MethodBody &body,
                                        FmtContext &attrTypeCtx) {
   /// Optional Group.
   if (auto *optional = dyn_cast<OptionalElement>(element)) {
     auto elements = llvm::drop_begin(optional->getThenElements(),
                                      optional->getParseStart());
 
     // Generate a special optional parser for the first element to gate the
     // parsing of the rest of the elements.
if (auto *optional = dyn_cast<OptionalElement>(element)) {
     body << formatv(functionalTypeParserCode,
                     getTypeListName(dir->getInputs(), ignored),
                     getTypeListName(dir->getResults(), ignored));
   } else {
     llvm_unreachable("unknown format element");
   }
 }
 
-void OperationFormat::genParserTypeResolution(Operator &op,
-                                              OpMethodBody &body) {
+void OperationFormat::genParserTypeResolution(Operator &op, MethodBody &body) {
   // If any of type resolutions use transformed variables, make sure that the
   // types of those variables are resolved.
   SmallPtrSet<const NamedTypeConstraint *, 8> verifiedVariables;
   FmtContext verifierFCtx;
   for (TypeResolution &resolver :
        llvm::concat<TypeResolution>(resultTypes, operandTypes)) {
     Optional<StringRef> transformer = resolver.getVarTransformer();
     if (!transformer)
void OperationFormat::genParserTypeResolution(Operator &op, MethodBody &body) {
   }
 
   // Handle return type inference once all operands have been resolved
   if (infersResultTypes)
     body << formatv(inferReturnTypesParserCode, op.getCppClassName());
 }
 
 void OperationFormat::genParserRegionResolution(Operator &op,
-                                                OpMethodBody &body) {
+                                                MethodBody &body) {
   // Check for the case where all regions were parsed.
   bool hasAllRegions = llvm::any_of(
       elements, [](auto &elt) { return isa<RegionsDirective>(elt.get()); });
   if (hasAllRegions) {
     body << "  result.addRegions(fullRegions);\n";
     return;
   }
 
   // Otherwise, handle each region individually.
   for (const NamedRegion &region : op.getRegions()) {
     if (region.isVariadic())
       body << "  result.addRegions(" << region.name << "Regions);\n";
     else
       body << "  result.addRegion(std::move(" << region.name << "Region));\n";
   }
 }
 
 void OperationFormat::genParserSuccessorResolution(Operator &op,
-                                                   OpMethodBody &body) {
+                                                   MethodBody &body) {
   // Check for the case where all successors were parsed.
   bool hasAllSuccessors = llvm::any_of(
       elements, [](auto &elt) { return isa<SuccessorsDirective>(elt.get()); });
   if (hasAllSuccessors) {
     body << "  result.addSuccessors(fullSuccessors);\n";
     return;
   }
 
   // Otherwise, handle each successor individually.
   for (const NamedSuccessor &successor : op.getSuccessors()) {
     if (successor.isVariadic())
       body << "  result.addSuccessors(" << successor.name << "Successors);\n";
     else
       body << "  result.addSuccessors(" << successor.name << "Successor);\n";
   }
 }
 
 void OperationFormat::genParserVariadicSegmentResolution(Operator &op,
-                                                         OpMethodBody &body) {
+                                                         MethodBody &body) {
   if (!allOperands) {
     if (op.getTrait("::mlir::OpTrait::AttrSizedOperandSegments")) {
       body << "  result.addAttribute(\"operand_segment_sizes\", "
            << "parser.getBuilder().getI32VectorAttr({";
       auto interleaveFn = [&](const NamedTypeConstraint &operand) {
         // If the operand is variadic emit the parsed size.
         if (operand.isVariableLength())
           body << "static_cast<int32_t>(" << operand.name << "Operands.size())";

 const char *enumAttrBeginPrinterCode = R"(
   {
     auto caseValue = {0}();
     auto caseValueStr = {1}(caseValue);
 )";
 
 /// Generate the printer for the 'attr-dict' directive.
 static void genAttrDictPrinter(OperationFormat &fmt, Operator &op,
-                               OpMethodBody &body, bool withKeyword) {
+                               MethodBody &body, bool withKeyword) {
   body << "  _odsPrinter.printOptionalAttrDict"
        << (withKeyword ? "WithKeyword" : "")
        << "((*this)->getAttrs(), /*elidedAttrs=*/{";
   // Elide the variadic segment size attributes if necessary.
   if (!fmt.allOperands &&
       op.getTrait("::mlir::OpTrait::AttrSizedOperandSegments"))
     body << "\"operand_segment_sizes\", ";
   if (!fmt.allResultTypes &&
       op.getTrait("::mlir::OpTrait::AttrSizedResultSegments"))
     body << "\"result_segment_sizes\", ";
   if (!fmt.inferredAttributes.empty()) {
     for (const auto &attr : fmt.inferredAttributes)
       body << "\"" << attr.getKey() << "\", ";
   }
   llvm::interleaveComma(
       fmt.usedAttributes, body,
       [&](const NamedAttribute *attr) { body << "\"" << attr->name << "\""; });
   body << "});\n";
 }
 
 /// Generate the printer for a literal value. `shouldEmitSpace` is true if a
 /// space should be emitted before this element. `lastWasPunctuation` is true if
 /// the previous element was a punctuation literal.
-static void genLiteralPrinter(StringRef value, OpMethodBody &body,
+static void genLiteralPrinter(StringRef value, MethodBody &body,
                               bool &shouldEmitSpace, bool &lastWasPunctuation) {
   body << "  _odsPrinter";
 
   // Don't insert a space for certain punctuation.
   if (shouldEmitSpace && shouldEmitSpaceBefore(value, lastWasPunctuation))
     body << " << ' '";
   body << " << \"" << value << "\";\n";
 
   // Insert a space after certain literals.
   shouldEmitSpace =
       value.size() != 1 || !StringRef("<({[").contains(value.front());
   lastWasPunctuation = !(value.front() == '_' || isalpha(value.front()));
 }
 
 /// Generate the printer for a space. `shouldEmitSpace` and `lastWasPunctuation`
 /// are set to false.
-static void genSpacePrinter(bool value, OpMethodBody &body,
-                            bool &shouldEmitSpace, bool &lastWasPunctuation) {
+static void genSpacePrinter(bool value, MethodBody &body, bool &shouldEmitSpace,
+                            bool &lastWasPunctuation) {
   if (value) {
     body << "  _odsPrinter << ' ';\n";
     lastWasPunctuation = false;
   } else {
     lastWasPunctuation = true;
   }
   shouldEmitSpace = false;
 }
 
 /// Generate the printer for a custom directive parameter.
 static void genCustomDirectiveParameterPrinter(Element *element,
                                                const Operator &op,
-                                               OpMethodBody &body) {
+                                               MethodBody &body) {
   if (auto *attr = dyn_cast<AttributeVariable>(element)) {
     body << op.getGetterName(attr->getVar()->name) << "Attr()";
 
   } else if (isa<AttrDictDirective>(element)) {
     body << "getOperation()->getAttrDictionary()";
 
   } else if (auto *operand = dyn_cast<OperandVariable>(element)) {
     body << op.getGetterName(operand->getVar()->name) << "()";
else
       body << name << "().getType()";
   } else {
     llvm_unreachable("unknown custom directive parameter");
   }
 }
 
 /// Generate the printer for a custom directive.
 static void genCustomDirectivePrinter(CustomDirective *customDir,
-                                      const Operator &op, OpMethodBody &body) {
+                                      const Operator &op, MethodBody &body) {
   body << "  print" << customDir->getName() << "(_odsPrinter, *this";
   for (Element &param : customDir->getArguments()) {
     body << ", ";
     genCustomDirectiveParameterPrinter(&param, op, body);
   }
   body << ");\n";
 }
 
 /// Generate the printer for a region with the given variable name.
-static void genRegionPrinter(const Twine &regionName, OpMethodBody &body,
+static void genRegionPrinter(const Twine &regionName, MethodBody &body,
                              bool hasImplicitTermTrait) {
   if (hasImplicitTermTrait)
     body << llvm::formatv(regionSingleBlockImplicitTerminatorPrinterCode,
                           regionName);
   else
     body << "  _odsPrinter.printRegion(" << regionName << ");\n";
 }
 static void genVariadicRegionPrinter(const Twine &regionListName,
-                                     OpMethodBody &body,
+                                     MethodBody &body,
                                      bool hasImplicitTermTrait) {
   body << "    llvm::interleaveComma(" << regionListName
        << ", _odsPrinter, [&](::mlir::Region &region) {\n      ";
   genRegionPrinter("region", body, hasImplicitTermTrait);
   body << "    });\n";
 }
 
 /// Generate the C++ for an operand to a (*-)type directive.
-static OpMethodBody &genTypeOperandPrinter(Element *arg, const Operator &op,
-                                           OpMethodBody &body) {
+static MethodBody &genTypeOperandPrinter(Element *arg, const Operator &op,
+                                         MethodBody &body) {
   if (isa<OperandsDirective>(arg))
     return body << "getOperation()->getOperandTypes()";
   if (isa<ResultsDirective>(arg))
     return body << "getOperation()->getResultTypes()";
   auto *operand = dyn_cast<OperandVariable>(arg);
   auto *var = operand ? operand->getVar() : cast<ResultVariable>(arg)->getVar();
   if (var->isVariadicOfVariadic())
     return body << llvm::formatv("{0}().join().getTypes()",
                                  op.getGetterName(var->name));
   if (var->isVariadic())
     return body << op.getGetterName(var->name) << "().getTypes()";
   if (var->isOptional())
     return body << llvm::formatv(
                "({0}() ? ::llvm::ArrayRef<::mlir::Type>({0}().getType()) : "
                "::llvm::ArrayRef<::mlir::Type>())",
                op.getGetterName(var->name));
   return body << "::llvm::ArrayRef<::mlir::Type>("
               << op.getGetterName(var->name) << "().getType())";
 }
 
 /// Generate the printer for an enum attribute.
 static void genEnumAttrPrinter(const NamedAttribute *var, const Operator &op,
-                               OpMethodBody &body) {
+                               MethodBody &body) {
   Attribute baseAttr = var->attr.getBaseAttr();
   const EnumAttr &enumAttr = cast<EnumAttr>(baseAttr);
   std::vector<EnumAttrCase> cases = enumAttr.getAllCases();
 
   body << llvm::formatv(enumAttrBeginPrinterCode,
                         (var->attr.isOptional() ? "*" : "") +
                             op.getGetterName(var->name),
                         enumAttr.getSymbolToStringFnName());
static void genEnumAttrPrinter(const NamedAttribute *var, const Operator &op,
   }
 
   body << "    _odsPrinter << caseValueStr;\n"
           "  }\n";
 }
 
 /// Generate the check for the anchor of an optional group.
 static void genOptionalGroupPrinterAnchor(Element *anchor, const Operator &op,
-                                          OpMethodBody &body) {
+                                          MethodBody &body) {
   TypeSwitch<Element *>(anchor)
       .Case<OperandVariable, ResultVariable>([&](auto *element) {
         const NamedTypeConstraint *var = element->getVar();
         std::string name = op.getGetterName(var->name);
         if (var->isOptional())
           body << "  if (" << name << "()) {\n";
         else if (var->isVariadic())
           body << "  if (!" << name << "().empty()) {\n";
TypeSwitch<Element *>(anchor)
         genOptionalGroupPrinterAnchor(element->getInputs(), op, body);
       })
       .Case<AttributeVariable>([&](AttributeVariable *attr) {
         body << "  if ((*this)->getAttr(\"" << attr->getVar()->name
              << "\")) {\n";
       });
 }
 
-void OperationFormat::genElementPrinter(Element *element, OpMethodBody &body,
+void OperationFormat::genElementPrinter(Element *element, MethodBody &body,
                                         Operator &op, bool &shouldEmitSpace,
                                         bool &lastWasPunctuation) {
   if (LiteralElement *literal = dyn_cast<LiteralElement>(element))
     return genLiteralPrinter(literal->getLiteral(), body, shouldEmitSpace,
                              lastWasPunctuation);
 
   // Emit a whitespace element.
   if (isa<NewlineElement>(element)) {
if (auto *attr = dyn_cast<AttributeVariable>(element)) {
     genTypeOperandPrinter(dir->getInputs(), op, body) << ", ";
     genTypeOperandPrinter(dir->getResults(), op, body) << ");\n";
   } else {
     llvm_unreachable("unknown format element");
   }
 }
 
 void OperationFormat::genPrinter(Operator &op, OpClass &opClass) {
-  auto *method = opClass.addMethodAndPrune("void", "print",
-                                           "::mlir::OpAsmPrinter &_odsPrinter");
+  auto *method = opClass.addMethod(
+      "void", "print",
+      MethodParameter("::mlir::OpAsmPrinter &", "_odsPrinter"));
   auto &body = method->body();
 
   // Flags for if we should emit a space, and if the last element was
   // punctuation.
   bool shouldEmitSpace = true, lastWasPunctuation = false;
   for (auto &element : elements)
     genElementPrinter(element.get(), body, op, shouldEmitSpace,
                       lastWasPunctuation);
 }
 
 //===----------------------------------------------------------------------===//
 // FormatParser
 //===----------------------------------------------------------------------===//
 
 /// Function to find an element within the given range that has the same name as
 /// 'name'.
-template <typename RangeT>
-static auto findArg(RangeT &&range, StringRef name) {
+template <typename RangeT> static auto findArg(RangeT &&range, StringRef name) {
   auto it = llvm::find_if(range, [=](auto &arg) { return arg.name == name; });
   return it != range.end() ? &*it : nullptr;
 }
 
 namespace {
 /// This class implements a parser for an instance of an operation assembly
 /// format.
 class FormatParser {