diff --git a/mlir/include/mlir/IR/ExtensibleDialect.h b/mlir/include/mlir/IR/ExtensibleDialect.h
--- a/mlir/include/mlir/IR/ExtensibleDialect.h
+++ b/mlir/include/mlir/IR/ExtensibleDialect.h
@@ -436,6 +436,18 @@
     return verifyRegionFn(op);
   }
 
+  // Implementation for properties (unsupported right now here).
+  int getOpPropertyByteSize() final { return 0; }
+  void initProperties(void *prop) final {}
+  void deleteProperties(void *prop) final {}
+  LogicalResult setPropertiesFromAttr(Operation *op, Attribute attr,
+                                      InFlightDiagnostic *diag) final {
+    return failure();
+  }
+  Attribute getPropertiesAsAttr(Operation *op) final { return {}; }
+  void copyProperties(void *lhs, void *rhs) final {}
+  llvm::hash_code hashProperties(void *prop) final { return {}; }
+
 private:
   DynamicOpDefinition(
       StringRef name, ExtensibleDialect *dialect,
diff --git a/mlir/include/mlir/IR/OpBase.td b/mlir/include/mlir/IR/OpBase.td
--- a/mlir/include/mlir/IR/OpBase.td
+++ b/mlir/include/mlir/IR/OpBase.td
@@ -185,6 +185,56 @@
   string cppClassName = cppClassNameParam;
 }
 
+
+
+// Base class for defining properties.
+class Property<string storageTypeParam = "", string desc = ""> {
+  // User-readable one line summary used in error reporting messages. If empty,
+  // a generic message will be used.
+  string summary = desc;
+  code storageType = storageTypeParam;
+  code interfaceType = storageTypeParam; 
+
+  // The expression to convert from the storage type to the Interface
+  // type. For example, an enum can be stored as an int but returned as an
+  // enum class.
+  //
+  // Format: `storage` will contain the property in the storage type.
+  code convertFromStorage = "storage";
+
+  // The call expression to build a property storage from the interface type.
+  code assignToStorage = "storage = value";
+
+  // The call expression to convert from the storage type to an attribute.
+  //
+  // Format: `storage` is the storage type value, `ctx` is a MLIRContext*. The
+  // expression must result in an Attribute.
+  code convertToAttribute = [{
+    convertToAttribute(ctx, storage)
+  }];
+
+  // The call expression to convert from an Attribute to the storage type.
+  //
+  // Format: `storage` is the storage value, `attr` is the attribute,
+  // and `diag` is an optional Diagnostic pointer to emit error.
+  // The expression must return a LogicalResult
+  code convertFromAttribute = [{
+    return convertFromAttribute(storage, attr, diag);
+  }];
+
+  // The call expression to hash the property, `storage` is the variable to hash
+  // and the expression should define a llvm::hash_code.
+  code hashProperty = [{
+    llvm::hash_value(storage);
+  }];
+
+  // Default value for the property.
+  string defaultValue = ?;
+
+  // The full description of this attribute.
+  string description = "";
+}
+
 // Subclass for constraints on an attribute.
 class AttrConstraint<Pred predicate, string summary = ""> :
     Constraint<predicate, summary>;
@@ -1049,6 +1099,17 @@
 class DefaultValuedOptionalStrAttr<Attr attr, string val>
     : DefaultValuedOptionalAttr<attr, "\"" # val # "\"">;
 
+//===----------------------------------------------------------------------===//
+// Primitive property kinds
+
+class ArrayProperty<string storageTypeParam = "", int N, string desc = ""> : 
+  Property<storageTypeParam # "[" # N # "]", desc> {
+  let interfaceType = "::llvm::ArrayRef<" # storageTypeParam # ">";
+  let convertFromStorage = "storage";
+  let assignToStorage = "::llvm::copy(value, storage)";
+
+}
+
 //===----------------------------------------------------------------------===//
 // Primitive attribute kinds
 
@@ -2215,6 +2276,9 @@
   // Dag containing the arguments of the op. Default to 0 arguments.
   dag arguments = (ins);
 
+  // Dag containing the properties of the op. Default to no properties.
+  dag properties = (ins);
+
   // The list of results of the op. Default to 0 results.
   dag results = (outs);
 
diff --git a/mlir/include/mlir/IR/OpDefinition.h b/mlir/include/mlir/IR/OpDefinition.h
--- a/mlir/include/mlir/IR/OpDefinition.h
+++ b/mlir/include/mlir/IR/OpDefinition.h
@@ -203,6 +203,13 @@
   /// in generic form.
   static void print(Operation *op, OpAsmPrinter &p, StringRef defaultDialect);
 
+  /// Parse properties as a Attribute.
+  static ParseResult genericParseProperties(OpAsmParser &parser,
+                                            Attribute &result);
+
+  /// Print the properties as a Attribute.
+  static void genericPrintProperties(OpAsmPrinter &p, Attribute properties);
+
   /// Print an operation name, eliding the dialect prefix if necessary.
   static void printOpName(Operation *op, OpAsmPrinter &p,
                           StringRef defaultDialect);
@@ -1460,13 +1467,17 @@
 /// Returns true if this given Trait ID matches the IDs of any of the provided
 /// trait types `Traits`.
 template <template <typename T> class... Traits>
-static bool hasTrait(TypeID traitID) {
+inline bool hasTrait(TypeID traitID) {
   TypeID traitIDs[] = {TypeID::get<Traits>()...};
   for (unsigned i = 0, e = sizeof...(Traits); i != e; ++i)
     if (traitIDs[i] == traitID)
       return true;
   return false;
 }
+template <>
+inline bool hasTrait<>(TypeID traitID) {
+  return false;
+}
 
 //===----------------------------------------------------------------------===//
 // Trait Folding
@@ -1594,6 +1605,27 @@
 LogicalResult verifyRegionTraits(Operation *op) {
   return success((succeeded(verifyRegionTrait<Ts>(op)) && ...));
 }
+
+struct EmptyProperties {};
+template <class T, class = void>
+struct PropertiesSelector {
+  using type = EmptyProperties;
+};
+template <class T>
+struct PropertiesSelector<T, std::void_t<typename T::Properties>> {
+  using type = typename T::Properties;
+};
+inline LogicalResult
+setPropertiesFromAttribute(EmptyProperties &prop, Attribute attr,
+                           InFlightDiagnostic *diagnostic) {
+  return success();
+}
+inline Attribute getPropertiesAsAttribute(MLIRContext *ctx,
+                                          const EmptyProperties &prop) {
+  return Attribute{};
+}
+inline llvm::hash_code computeHash(const EmptyProperties &prop) { return {}; }
+
 } // namespace op_definition_impl
 
 //===----------------------------------------------------------------------===//
@@ -1682,6 +1714,21 @@
     info->attachInterface<Models...>();
   }
 
+  template <typename PropertiesTy>
+  static LogicalResult setPropertiesFromAttr(PropertiesTy &prop, Attribute attr,
+                                             InFlightDiagnostic *diag) {
+    return setPropertiesFromAttribute(prop, attr, diag);
+  }
+  template <typename PropertiesTy>
+  static Attribute getPropertiesAsAttr(MLIRContext *ctx,
+                                       const PropertiesTy &prop) {
+    return getPropertiesAsAttribute(ctx, prop);
+  }
+  template <typename PropertiesTy>
+  static llvm::hash_code computePropertiesHash(const PropertiesTy &prop) {
+    return computeHash(prop);
+  }
+
 private:
   /// Trait to check if T provides a 'fold' method for a single result op.
   template <typename T, typename... Args>
@@ -1721,6 +1768,22 @@
   template <typename T>
   using detect_has_print = llvm::is_detected<has_print, T>;
 
+  /// Trait to check if customPrintProperties(OpAsmPrinter, T) exist
+  template <typename T, typename... Args>
+  using has_print_properties = decltype(customPrintProperties(
+      std::declval<OpAsmPrinter &>(), std::declval<T>()));
+  template <typename T>
+  using detect_has_print_properties =
+      llvm::is_detected<has_print_properties, T>;
+
+  /// Trait to check if customParseProperties(OpAsmParser, T) exist
+  template <typename T, typename... Args>
+  using has_parse_properties = decltype(customParseProperties(
+      std::declval<OpAsmParser &>(), std::declval<T &>()));
+  template <typename T>
+  using detect_has_parse_properties =
+      llvm::is_detected<has_parse_properties, T>;
+
   /// Trait to check if T provides a 'ConcreteEntity' type alias.
   template <typename T>
   using has_concrete_entity_t = typename T::ConcreteEntity;
@@ -1847,6 +1910,41 @@
     };
   }
 
+public:
+  template <typename T>
+  using InferredProperties =
+      typename op_definition_impl::PropertiesSelector<T>::type;
+  template <typename T = ConcreteType>
+  InferredProperties<T> &getProperties() {
+    return *static_cast<InferredProperties<T> *>(
+        getOperation()->getPropertiesStorage());
+  }
+
+  /// Print the operation properties. Unless overridden, this method will try to
+  /// dispath to a `printProperties` free-function if it exists, and otherwise
+  /// by converting the properties to an Attribute.
+  template <typename T>
+  static void printProperties(MLIRContext *ctx, OpAsmPrinter &p,
+                              const T &properties) {
+    if constexpr (detect_has_print_properties<T>::value)
+      return customPrintProperties(p, properties);
+    genericPrintProperties(p,
+                           ConcreteType::getPropertiesAsAttr(ctx, properties));
+  }
+
+  /// Parser the properties. Unless overridden, this method will print by
+  /// converting the properties to an Attribute.
+  template <typename T = ConcreteType>
+  static ParseResult parseProperties(OpAsmParser &parser,
+                                     OperationState &result) {
+    if constexpr (detect_has_parse_properties<InferredProperties<T>>::value) {
+      return customParseProperties(
+          parser, result.getOrAddProperties<InferredProperties<T>>());
+    }
+    return genericParseProperties(parser, result.propertiesAttr);
+  }
+
+private:
   /// Implementation of `PopulateDefaultAttrsFn` OperationName hook.
   static OperationName::PopulateDefaultAttrsFn getPopulateDefaultAttrsFn() {
     return ConcreteType::populateDefaultAttrs;
diff --git a/mlir/include/mlir/IR/OpImplementation.h b/mlir/include/mlir/IR/OpImplementation.h
--- a/mlir/include/mlir/IR/OpImplementation.h
+++ b/mlir/include/mlir/IR/OpImplementation.h
@@ -1344,6 +1344,7 @@
       Optional<MutableArrayRef<std::unique_ptr<Region>>> parsedRegions =
           std::nullopt,
       Optional<ArrayRef<NamedAttribute>> parsedAttributes = std::nullopt,
+      Optional<Attribute> parsedPropertiesAttribute = std::nullopt,
       Optional<FunctionType> parsedFnType = std::nullopt) = 0;
 
   /// Parse a single SSA value operand name along with a result number if
diff --git a/mlir/include/mlir/IR/Operation.h b/mlir/include/mlir/IR/Operation.h
--- a/mlir/include/mlir/IR/Operation.h
+++ b/mlir/include/mlir/IR/Operation.h
@@ -21,6 +21,10 @@
 #include "llvm/ADT/Twine.h"
 
 namespace mlir {
+namespace detail {
+enum class OpProperties : char {};
+} // namespace detail
+
 /// Operation is the basic unit of execution within MLIR.
 ///
 /// The following documentation are recommended to understand this class:
@@ -66,12 +70,19 @@
 /// Some operations like branches also refer to other Block, in which case they
 /// would have an array of `BlockOperand`.
 ///
+/// An Operation may contain optionally a "Properties" object: this is a
+/// pre-defined C++ object with a fixed size. This object is owned by the
+/// operation and deleted with the operation. It can be converted to an
+/// Attribute on demand, or loaded from an Attribute.
+///
+///
 /// Finally an Operation also contain an optional `DictionaryAttr`, a Location,
 /// and a pointer to its parent Block (if any).
 class alignas(8) Operation final
     : public llvm::ilist_node_with_parent<Operation, Block>,
       private llvm::TrailingObjects<Operation, detail::OperandStorage,
-                                    BlockOperand, Region, OpOperand> {
+                                    detail::OpProperties, BlockOperand, Region,
+                                    OpOperand> {
 public:
   /// Create a new Operation with the specific fields.
   static Operation *create(Location location, OperationName name,
@@ -714,6 +725,43 @@
   /// handlers that may be listening.
   InFlightDiagnostic emitRemark(const Twine &message = {});
 
+  /// Returns the properties storage.
+  void *getPropertiesStorage() {
+    return sizeof(int) + getTrailingObjects<detail::OpProperties>();
+  }
+  const void *getPropertiesStorage() const {
+    return sizeof(int) + getTrailingObjects<detail::OpProperties>();
+  }
+
+  /// Returns the properties storage size.
+  int getPropertiesStorageSize() const {
+    if (hasPropertiesStorage)
+      return *reinterpret_cast<const int *>(
+          static_cast<const char *>(getPropertiesStorage()) - sizeof(int));
+
+    return 0;
+  }
+
+  /// Return the properties converted to an attribute.
+  /// This is expensive, and mostly useful when dealing with unregistered
+  /// operation. Returns an empty attribute if no properties are present.
+  Attribute getPropertiesAsAttribute();
+
+  /// Set the properties from the provided  attribute.
+  /// This is an expensive operation that can fail if the attribute is not
+  /// matching the expectations of the properties for this operation. This is
+  /// mostly useful for unregistered operations or used when parsing the
+  /// generic format. An optional diagnostic can be passed in for richer errors.
+  LogicalResult setPropertiesFromAttribute(Attribute attr,
+                                           InFlightDiagnostic *diagnostic);
+
+  /// Copy properties from an existing other properties object. The two objects
+  /// must be the same type.
+  void copyProperties(void *rhs);
+
+  /// Compute a hash for the op properties (if any).
+  llvm::hash_code hashProperties();
+
 private:
   //===--------------------------------------------------------------------===//
   // Ordering
@@ -737,7 +785,8 @@
 private:
   Operation(Location location, OperationName name, unsigned numResults,
             unsigned numSuccessors, unsigned numRegions,
-            DictionaryAttr attributes, bool hasOperandStorage);
+            int propertiesStorageSize, DictionaryAttr attributes,
+            bool hasOperandStorage);
 
   // Operations are deleted through the destroy() member because they are
   // allocated with malloc.
@@ -822,7 +871,13 @@
 
   const unsigned numResults;
   const unsigned numSuccs;
-  const unsigned numRegions : 31;
+  const unsigned numRegions : 30;
+
+  /// This bit signals whether this operation has Properties storage or not. The
+  /// properties storage is elided for operations that are known to not have
+  /// one. The size of the storage is stored at the beginning of the storate
+  /// itself.
+  bool hasPropertiesStorage : 1;
 
   /// This bit signals whether this operation has an operand storage or not. The
   /// operand storage may be elided for operations that are known to never have
@@ -848,8 +903,9 @@
   friend class llvm::ilist_node_with_parent<Operation, Block>;
 
   // This stuff is used by the TrailingObjects template.
-  friend llvm::TrailingObjects<Operation, detail::OperandStorage, BlockOperand,
-                               Region, OpOperand>;
+  friend llvm::TrailingObjects<Operation, detail::OperandStorage,
+                               detail::OpProperties, BlockOperand, Region,
+                               OpOperand>;
   size_t numTrailingObjects(OverloadToken<detail::OperandStorage>) const {
     return hasOperandStorage ? 1 : 0;
   }
@@ -857,6 +913,9 @@
     return numSuccs;
   }
   size_t numTrailingObjects(OverloadToken<Region>) const { return numRegions; }
+  size_t numTrailingObjects(OverloadToken<detail::OpProperties>) const {
+    return getPropertiesStorageSize();
+  }
 };
 
 inline raw_ostream &operator<<(raw_ostream &os, const Operation &op) {
diff --git a/mlir/include/mlir/IR/OperationSupport.h b/mlir/include/mlir/IR/OperationSupport.h
--- a/mlir/include/mlir/IR/OperationSupport.h
+++ b/mlir/include/mlir/IR/OperationSupport.h
@@ -97,6 +97,15 @@
     virtual void printAssembly(Operation *, OpAsmPrinter &, StringRef) = 0;
     virtual LogicalResult verifyInvariants(Operation *) = 0;
     virtual LogicalResult verifyRegionInvariants(Operation *) = 0;
+    // Implementation for properties
+    virtual int getOpPropertyByteSize() = 0;
+    virtual void initProperties(void *) = 0;
+    virtual void deleteProperties(void *) = 0;
+    virtual LogicalResult setPropertiesFromAttr(Operation *, Attribute,
+                                                InFlightDiagnostic *) = 0;
+    virtual Attribute getPropertiesAsAttr(Operation *) = 0;
+    virtual void copyProperties(void *, void *) = 0;
+    virtual llvm::hash_code hashProperties(void *) = 0;
   };
 
 public:
@@ -157,6 +166,15 @@
     void printAssembly(Operation *, OpAsmPrinter &, StringRef) final;
     LogicalResult verifyInvariants(Operation *) final;
     LogicalResult verifyRegionInvariants(Operation *) final;
+    // Implementation for properties
+    int getOpPropertyByteSize() final;
+    void initProperties(void *) final;
+    void deleteProperties(void *) final;
+    LogicalResult setPropertiesFromAttr(Operation *, Attribute,
+                                        InFlightDiagnostic *) final;
+    Attribute getPropertiesAsAttr(Operation *) final;
+    void copyProperties(void *, void *) final;
+    llvm::hash_code hashProperties(void *) final;
   };
 
 public:
@@ -307,6 +325,41 @@
     return !isRegistered() || hasInterface(interfaceID);
   }
 
+  /// This hooks return the number of bytes to allocate for the op properties.
+  int getOpPropertyByteSize() const {
+    return getImpl()->getOpPropertyByteSize();
+  }
+
+  /// This hooks destroy the op properties.
+  void destroyOpProperties(void *properties) const {
+    getImpl()->deleteProperties(properties);
+  }
+
+  /// Initialize the op properties.
+  void initOpProperties(void *properties) const {
+    getImpl()->initProperties(properties);
+  }
+
+  /// Return the op properties converted to an Attribute.
+  Attribute getOpPropertiesAsAttribute(Operation *op) const {
+    return getImpl()->getPropertiesAsAttr(op);
+  }
+
+  /// Define the op properties from the provided Attribute.
+  LogicalResult
+  setOpPropertiesFromAttribute(Operation *op, Attribute properties,
+                               InFlightDiagnostic *diagnostic) const {
+    return getImpl()->setPropertiesFromAttr(op, properties, diagnostic);
+  }
+
+  void copyOpProperties(void *lhs, void *rhs) const {
+    return getImpl()->copyProperties(lhs, rhs);
+  }
+
+  llvm::hash_code hashOpProperties(void *properties) const {
+    return getImpl()->hashProperties(properties);
+  }
+
   /// Return the dialect this operation is registered to if the dialect is
   /// loaded in the context, or nullptr if the dialect isn't loaded.
   Dialect *getDialect() const {
@@ -369,6 +422,10 @@
 // RegisteredOperationName
 //===----------------------------------------------------------------------===//
 
+namespace op_definition_impl {
+struct EmptyProperties;
+}
+
 /// This is a "type erased" representation of a registered operation. This
 /// should only be used by things like the AsmPrinter and other things that need
 /// to be parameterized by generic operation hooks. Most user code should use
@@ -407,6 +464,46 @@
     LogicalResult verifyRegionInvariants(Operation *op) final {
       return ConcreteOp::getVerifyRegionInvariantsFn()(op);
     }
+    /// Implementation for "Properties"
+
+    using Properties = std::remove_reference_t<
+        decltype(std::declval<ConcreteOp>().getProperties())>;
+
+    template <typename T>
+    struct PropertiesSize {
+      static constexpr size_t size = sizeof(T);
+    };
+    template <>
+    struct PropertiesSize<op_definition_impl::EmptyProperties> {
+      static constexpr size_t size = 0;
+    };
+    int getOpPropertyByteSize() final {
+      return PropertiesSize<Properties>::size;
+    }
+    void initProperties(void *prop) final {
+      new (prop) typename ConcreteOp::template InferredProperties<ConcreteOp>{};
+    }
+    void deleteProperties(void *prop) final {
+      static_cast<Properties *>(prop)->~Properties();
+    }
+    LogicalResult setPropertiesFromAttr(Operation *op, Attribute attr,
+                                        InFlightDiagnostic *diag) final {
+      auto concreteOp = cast<ConcreteOp>(op);
+      return ConcreteOp::setPropertiesFromAttr(concreteOp.getProperties(), attr,
+                                               diag);
+    }
+    Attribute getPropertiesAsAttr(Operation *op) final {
+      auto concreteOp = cast<ConcreteOp>(op);
+      return ConcreteOp::getPropertiesAsAttr(concreteOp->getContext(),
+                                             concreteOp.getProperties());
+    }
+    void copyProperties(void *lhs, void *rhs) final {
+      *static_cast<Properties *>(lhs) = *static_cast<Properties *>(rhs);
+    }
+    llvm::hash_code hashProperties(void *prop) final {
+      return ConcreteOp::computePropertiesHash(
+          *static_cast<Properties *>(prop));
+    }
   };
 
   /// Lookup the registered operation information for the given operation.
@@ -593,6 +690,11 @@
     assign(range.begin(), range.end());
   }
 
+  void clear() {
+    attrs.clear();
+    dictionarySorted.setPointerAndInt(nullptr, false);
+  }
+
   bool empty() const { return attrs.empty(); }
 
   void reserve(size_type N) { attrs.reserve(N); }
@@ -687,6 +789,17 @@
   /// Regions that the op will hold.
   SmallVector<std::unique_ptr<Region>, 1> regions;
 
+  // If we're creating an unregistered operation, this Attribute is used to
+  // build the properties. Otherwise it is ignored. For registered operations
+  // see the `getOrAddProperties` method.
+  Attribute propertiesAttr;
+
+private:
+  void *properties = nullptr;
+  TypeID propertiesId;
+  llvm::function_ref<void(void *)> propertiesDeleter;
+  llvm::function_ref<void(void *, const void *)> propertiesSetter;
+
 public:
   OperationState(Location location, StringRef name);
   OperationState(Location location, OperationName name);
@@ -699,6 +812,33 @@
                  TypeRange types, ArrayRef<NamedAttribute> attributes = {},
                  BlockRange successors = {},
                  MutableArrayRef<std::unique_ptr<Region>> regions = {});
+  OperationState(OperationState &&other) = default;
+  OperationState(const OperationState &other) = default;
+  OperationState &operator=(OperationState &&other) = default;
+  OperationState &operator=(const OperationState &other) = default;
+  ~OperationState();
+
+  template <typename T>
+  T &getOrAddProperties() {
+    if (!properties) {
+      T *p = new T{};
+      properties = p;
+      propertiesDeleter = [](void *prop) {
+        delete static_cast<const T *>(prop);
+      };
+      propertiesSetter = [](void *new_prop, const void *prop) {
+        *static_cast<T *>(new_prop) = *static_cast<const T *>(prop);
+      };
+      propertiesId = TypeID::get<T>();
+    }
+    assert(propertiesId == TypeID::get<T>() && "Inconsistent properties");
+    return *static_cast<T *>(properties);
+  }
+
+  // Set the properties defined on this OpState on the given operation,
+  // optionally emit diagnostics on error through the provided diagnostic.
+  LogicalResult setProperties(Operation *op,
+                              InFlightDiagnostic *diagnostic) const;
 
   void addOperands(ValueRange newOperands);
 
@@ -942,6 +1082,16 @@
   }
 };
 
+// TODO: not the right place... This is support for properties, ODS assembly
+// will auto-generate calls to these.
+LogicalResult convertFromAttribute(int64_t &storage, ::mlir::Attribute attr,
+                                   ::mlir::InFlightDiagnostic *diag);
+Attribute convertToAttribute(MLIRContext *ctx, int64_t storage);
+LogicalResult convertFromAttribute(MutableArrayRef<int64_t> storage,
+                                   ::mlir::Attribute attr,
+                                   ::mlir::InFlightDiagnostic *diag);
+Attribute convertToAttribute(MLIRContext *ctx, ArrayRef<int64_t> storage);
+
 /// Enable Bitmask enums for OperationEquivalence::Flags.
 LLVM_ENABLE_BITMASK_ENUMS_IN_NAMESPACE();
 
diff --git a/mlir/include/mlir/TableGen/Class.h b/mlir/include/mlir/TableGen/Class.h
--- a/mlir/include/mlir/TableGen/Class.h
+++ b/mlir/include/mlir/TableGen/Class.h
@@ -563,7 +563,12 @@
 public:
   /// Create an extra class declaration.
   ExtraClassDeclaration(StringRef extraClassDeclaration,
-                        StringRef extraClassDefinition = "")
+                        std::string extraClassDefinition = "")
+      : ExtraClassDeclaration(extraClassDeclaration.str(),
+                              std::move(extraClassDefinition)) {}
+
+  ExtraClassDeclaration(std::string extraClassDeclaration,
+                        std::string extraClassDefinition = "")
       : extraClassDeclaration(extraClassDeclaration),
         extraClassDefinition(extraClassDefinition) {}
 
@@ -577,7 +582,7 @@
 private:
   /// The string of the extra class declarations. It is re-indented before
   /// printed.
-  StringRef extraClassDeclaration;
+  std::string extraClassDeclaration;
   /// The string of the extra class definitions. It is re-indented before
   /// printed.
   std::string extraClassDefinition;
diff --git a/mlir/include/mlir/TableGen/Operator.h b/mlir/include/mlir/TableGen/Operator.h
--- a/mlir/include/mlir/TableGen/Operator.h
+++ b/mlir/include/mlir/TableGen/Operator.h
@@ -18,6 +18,7 @@
 #include "mlir/TableGen/Attribute.h"
 #include "mlir/TableGen/Builder.h"
 #include "mlir/TableGen/Dialect.h"
+#include "mlir/TableGen/Property.h"
 #include "mlir/TableGen/Region.h"
 #include "mlir/TableGen/Successor.h"
 #include "mlir/TableGen/Trait.h"
@@ -185,6 +186,21 @@
   const_value_iterator operand_end() const;
   const_value_range getOperands() const;
 
+  // Op properties iterators.
+  using property_iterator = const NamedProperty *;
+  property_iterator properties_begin() const { return properties.begin(); }
+  property_iterator properties_end() const { return properties.end(); }
+  llvm::iterator_range<property_iterator> getProperties() const {
+    return properties;
+  }
+  int getNumCoreAttributes() const { return properties.size(); }
+
+  // Op properties accessors.
+  NamedProperty &getProperty(int index) { return properties[index]; }
+  const NamedProperty &getProperty(int index) const {
+    return properties[index];
+  }
+
   int getNumOperands() const { return operands.size(); }
   NamedTypeConstraint &getOperand(int index) { return operands[index]; }
   const NamedTypeConstraint &getOperand(int index) const {
@@ -353,6 +369,9 @@
   /// computed upon request).
   SmallVector<NamedAttribute, 4> attributes;
 
+  /// The properties of the op.
+  SmallVector<NamedProperty> properties;
+
   /// The arguments of the op (operands and native attributes).
   SmallVector<Argument, 4> arguments;
 
diff --git a/mlir/include/mlir/TableGen/Property.h b/mlir/include/mlir/TableGen/Property.h
new file mode 100644
--- /dev/null
+++ b/mlir/include/mlir/TableGen/Property.h
@@ -0,0 +1,89 @@
+//===- Property.h - Property wrapper class --------------------*- 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
+//
+//===----------------------------------------------------------------------===//
+//
+// Property wrapper to simplify using TableGen Record defining a MLIR
+// Property.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef MLIR_TABLEGEN_PROPERTY_H_
+#define MLIR_TABLEGEN_PROPERTY_H_
+
+#include "mlir/Support/LLVM.h"
+#include "mlir/TableGen/Constraint.h"
+#include "llvm/ADT/StringRef.h"
+
+namespace llvm {
+class DefInit;
+class Record;
+} // namespace llvm
+
+namespace mlir {
+namespace tblgen {
+class Dialect;
+class Type;
+
+// Wrapper class providing helper methods for accessing MLIR Property defined
+// in TableGen. This class should closely reflect what is defined as class
+// `Property` in TableGen.
+class Property {
+public:
+  explicit Property(const llvm::Record *record, bool isAttr);
+  explicit Property(const llvm::DefInit *init, bool isAttr);
+
+  // Returns the storage type.
+  StringRef getStorageType() const;
+
+  // Returns the interface type for this property.
+  StringRef getInterfaceType() const;
+
+  // Returns the template getter method call which reads this property's
+  // storage and returns the value as of the desired return type.
+  StringRef getConvertFromStorageCall() const;
+
+  // Returns the template setter method call which reads this property's
+  // in the provided interface type and assign it to the storage.
+  StringRef getAssignToStorageCall() const;
+
+  // Returns the conversion method call which reads this property's
+  // in the storage type and builds an attribute.
+  StringRef getConvertToAttributeCall() const;
+
+  // Returns the setter method call which reads this property's
+  // in the provided interface type and assign it to the storage.
+  StringRef getConvertFromAttributeCall() const;
+
+  // Returns the code to compute the hash for this property.
+  StringRef getHashPropertyCall() const;
+
+  // Returns whether this Property has a default value.
+  bool hasDefaultValue() const;
+  // Returns the default value for this Property.
+  StringRef getDefaultValue() const;
+
+  // Returns the TableGen definition this Property was constructed from.
+  const llvm::Record &getDef() const;
+
+private:
+  // Indicate if we're using directly an Attr class.
+  bool isAttr;
+
+  // The TableGen definition of this constraint.
+  const llvm::Record *def;
+};
+
+// A struct wrapping an op property and its name together
+struct NamedProperty {
+  llvm::StringRef name;
+  Property prop;
+};
+
+} // namespace tblgen
+} // namespace mlir
+
+#endif // MLIR_TABLEGEN_PROPERTY_H_
diff --git a/mlir/lib/AsmParser/Parser.cpp b/mlir/lib/AsmParser/Parser.cpp
--- a/mlir/lib/AsmParser/Parser.cpp
+++ b/mlir/lib/AsmParser/Parser.cpp
@@ -539,6 +539,7 @@
       Optional<MutableArrayRef<std::unique_ptr<Region>>> parsedRegions =
           std::nullopt,
       Optional<ArrayRef<NamedAttribute>> parsedAttributes = std::nullopt,
+      Optional<Attribute> propertiesAttribute = std::nullopt,
       Optional<FunctionType> parsedFnType = std::nullopt);
 
   /// Parse an operation instance that is in the generic form and insert it at
@@ -1254,6 +1255,7 @@
     Optional<ArrayRef<Block *>> parsedSuccessors,
     Optional<MutableArrayRef<std::unique_ptr<Region>>> parsedRegions,
     Optional<ArrayRef<NamedAttribute>> parsedAttributes,
+    Optional<Attribute> propertiesAttribute,
     Optional<FunctionType> parsedFnType) {
 
   // Parse the operand list, if not explicitly provided.
@@ -1283,6 +1285,18 @@
     result.addSuccessors(*parsedSuccessors);
   }
 
+  // Parse the core attributes, if not explicitly provided.
+  if (propertiesAttribute) {
+    result.propertiesAttr = *propertiesAttribute;
+  } else {
+    if (consumeIf(Token::less)) {
+      result.propertiesAttr = parseAttribute();
+      if (!result.propertiesAttr)
+        return failure();
+      if (parseToken(Token::greater, "expected '>' to close properties"))
+        return failure();
+    }
+  }
   // Parse the region list, if not explicitly provided.
   if (!parsedRegions) {
     if (consumeIf(Token::l_paren)) {
@@ -1388,11 +1402,24 @@
 
   if (parseGenericOperationAfterOpName(result))
     return nullptr;
+  Attribute properties = std::move(result.propertiesAttr);
+  result.propertiesAttr = Attribute{};
 
   // Create the operation and try to parse a location for it.
   Operation *op = opBuilder.create(result);
   if (parseTrailingLocationSpecifier(op))
     return nullptr;
+
+  // Try setting the properties for the operation.
+  if (properties) {
+    InFlightDiagnostic diagnostic =
+        mlir::emitError(srcLocation, "invalid properties ")
+        << properties << " for op " << op->getName().getStringRef() << ": ";
+    if (failed(op->setPropertiesFromAttribute(properties, &diagnostic)))
+      return nullptr;
+    diagnostic.abandon();
+  }
+
   return op;
 }
 
@@ -1459,10 +1486,11 @@
       Optional<ArrayRef<Block *>> parsedSuccessors,
       Optional<MutableArrayRef<std::unique_ptr<Region>>> parsedRegions,
       Optional<ArrayRef<NamedAttribute>> parsedAttributes,
+      Optional<Attribute> parsedPropertiesAttribute,
       Optional<FunctionType> parsedFnType) final {
     return parser.parseGenericOperationAfterOpName(
         result, parsedUnresolvedOperands, parsedSuccessors, parsedRegions,
-        parsedAttributes, parsedFnType);
+        parsedAttributes, parsedPropertiesAttribute, parsedFnType);
   }
   //===--------------------------------------------------------------------===//
   // Utilities
@@ -1931,10 +1959,23 @@
   if (opAsmParser.didEmitError())
     return nullptr;
 
+  Attribute properties = std::move(opState.propertiesAttr);
+  opState.propertiesAttr = Attribute{};
+
   // Otherwise, create the operation and try to parse a location for it.
   Operation *op = opBuilder.create(opState);
   if (parseTrailingLocationSpecifier(op))
     return nullptr;
+
+  // Try setting the properties for the operation.
+  if (properties) {
+    InFlightDiagnostic diagnostic =
+        mlir::emitError(srcLocation, "invalid properties ")
+        << properties << " for op " << op->getName().getStringRef() << ": ";
+    if (failed(op->setPropertiesFromAttribute(properties, &diagnostic)))
+      return nullptr;
+    diagnostic.abandon();
+  }
   return op;
 }
 
diff --git a/mlir/lib/IR/AsmPrinter.cpp b/mlir/lib/IR/AsmPrinter.cpp
--- a/mlir/lib/IR/AsmPrinter.cpp
+++ b/mlir/lib/IR/AsmPrinter.cpp
@@ -2554,7 +2554,6 @@
   if (!filteredAttrs.empty())
     printFilteredAttributesFn(filteredAttrs);
 }
-
 void AsmPrinter::Impl::printNamedAttribute(NamedAttribute attr) {
   // Print the name without quotes if possible.
   ::printKeywordOrString(attr.getName().strref(), os);
@@ -3334,6 +3333,10 @@
     os << ']';
   }
 
+  // Print the properties.
+  if (Attribute prop = op->getPropertiesAsAttribute())
+    os << " <" << prop << '>';
+
   // Print regions.
   if (op->getNumRegions() != 0) {
     os << " (";
@@ -3484,6 +3487,10 @@
 
 void OperationPrinter::printAffineMapOfSSAIds(AffineMapAttr mapAttr,
                                               ValueRange operands) {
+  if (!mapAttr) {
+    os << "<<NULL AFFINE MAP>>";
+    return;
+  }
   AffineMap map = mapAttr.getValue();
   unsigned numDims = map.getNumDims();
   auto printValueName = [&](unsigned pos, bool isSymbol) {
diff --git a/mlir/lib/IR/MLIRContext.cpp b/mlir/lib/IR/MLIRContext.cpp
--- a/mlir/lib/IR/MLIRContext.cpp
+++ b/mlir/lib/IR/MLIRContext.cpp
@@ -780,6 +780,31 @@
   return success();
 }
 
+int OperationName::UnregisteredOpModel::getOpPropertyByteSize() {
+  return sizeof(Attribute);
+}
+void OperationName::UnregisteredOpModel::initProperties(void *prop) {
+  new (static_cast<Attribute *>(prop)) Attribute();
+}
+void OperationName::UnregisteredOpModel::deleteProperties(void *prop) {
+  static_cast<Attribute *>(prop)->~Attribute();
+}
+LogicalResult OperationName::UnregisteredOpModel::setPropertiesFromAttr(
+    Operation *op, Attribute attr, InFlightDiagnostic *diag) {
+  *static_cast<Attribute *>(op->getPropertiesStorage()) = attr;
+  return success();
+}
+Attribute
+OperationName::UnregisteredOpModel::getPropertiesAsAttr(Operation *op) {
+  return *static_cast<Attribute *>(op->getPropertiesStorage());
+}
+void OperationName::UnregisteredOpModel::copyProperties(void *lhs, void *rhs) {
+  *static_cast<Attribute *>(lhs) = *static_cast<Attribute *>(rhs);
+}
+llvm::hash_code OperationName::UnregisteredOpModel::hashProperties(void *prop) {
+  return llvm::hash_combine(*static_cast<Attribute *>(prop));
+}
+
 //===----------------------------------------------------------------------===//
 // RegisteredOperationName
 //===----------------------------------------------------------------------===//
diff --git a/mlir/lib/IR/Operation.cpp b/mlir/lib/IR/Operation.cpp
--- a/mlir/lib/IR/Operation.cpp
+++ b/mlir/lib/IR/Operation.cpp
@@ -25,9 +25,16 @@
 
 /// Create a new Operation from operation state.
 Operation *Operation::create(const OperationState &state) {
-  return create(state.location, state.name, state.types, state.operands,
-                state.attributes.getDictionary(state.getContext()),
-                state.successors, state.regions);
+  Operation *op =
+      create(state.location, state.name, state.types, state.operands,
+             state.attributes.getDictionary(state.getContext()),
+             state.successors, state.regions);
+  if (op->getPropertiesStorageSize()) {
+    LogicalResult result = state.setProperties(op, /*diagnostic=*/nullptr);
+    assert(result.succeeded() && "invalid properties in op creation");
+    (void)result;
+  }
+  return op;
 }
 
 /// Create a new Operation with the specific fields.
@@ -59,6 +66,11 @@
   unsigned numSuccessors = successors.size();
   unsigned numOperands = operands.size();
   unsigned numResults = resultTypes.size();
+  int opPropertiesAllocSize = sizeof(Attribute);
+  Optional<RegisteredOperationName> info = name.getRegisteredInfo();
+  if (info)
+    opPropertiesAllocSize = info->getOpPropertyByteSize();
+  opPropertiesAllocSize += sizeof(int);
 
   // If the operation is known to have no operands, don't allocate an operand
   // storage.
@@ -69,21 +81,23 @@
   // into account the size of the operation, its trailing objects, and its
   // prefixed objects.
   size_t byteSize =
-      totalSizeToAlloc<detail::OperandStorage, BlockOperand, Region, OpOperand>(
-          needsOperandStorage ? 1 : 0, numSuccessors, numRegions, numOperands);
+      totalSizeToAlloc<detail::OperandStorage, detail::OpProperties,
+                       BlockOperand, Region, OpOperand>(
+          needsOperandStorage ? 1 : 0, opPropertiesAllocSize, numSuccessors,
+          numRegions, numOperands);
   size_t prefixByteSize = llvm::alignTo(
       Operation::prefixAllocSize(numTrailingResults, numInlineResults),
       alignof(Operation));
   char *mallocMem = reinterpret_cast<char *>(malloc(byteSize + prefixByteSize));
   void *rawMem = mallocMem + prefixByteSize;
-
   // Populate default attributes.
   name.populateDefaultAttrs(attributes);
 
   // Create the new Operation.
   Operation *op = ::new (rawMem) Operation(
       location, name, numResults, numSuccessors, numRegions,
-      attributes.getDictionary(location.getContext()), needsOperandStorage);
+      opPropertiesAllocSize, attributes.getDictionary(location.getContext()),
+      needsOperandStorage);
 
   assert((numSuccessors == 0 || op->mightHaveTrait<OpTrait::IsTerminator>()) &&
          "unexpected successors in a non-terminator operation");
@@ -111,16 +125,23 @@
   auto blockOperands = op->getBlockOperands();
   for (unsigned i = 0; i != numSuccessors; ++i)
     new (&blockOperands[i]) BlockOperand(op, successors[i]);
-
+  // Initialize the properties
+  name.initOpProperties(op->getPropertiesStorage());
   return op;
 }
 
 Operation::Operation(Location location, OperationName name, unsigned numResults,
                      unsigned numSuccessors, unsigned numRegions,
-                     DictionaryAttr attributes, bool hasOperandStorage)
+                     int propertiesStorageSize, DictionaryAttr attributes,
+                     bool hasOperandStorage)
     : location(location), numResults(numResults), numSuccs(numSuccessors),
-      numRegions(numRegions), hasOperandStorage(hasOperandStorage), name(name),
-      attrs(attributes) {
+      numRegions(numRegions), hasPropertiesStorage(propertiesStorageSize != 0),
+      hasOperandStorage(hasOperandStorage), name(name), attrs(attributes) {
+  if (hasPropertiesStorage) {
+    // Set the properties storage size.
+    *reinterpret_cast<int *>(static_cast<char *>(getPropertiesStorage()) -
+                             sizeof(int)) = propertiesStorageSize;
+  }
   assert(attributes && "unexpected null attribute dictionary");
 #ifndef NDEBUG
   if (!getDialect() && !getContext()->allowsUnregisteredDialects())
@@ -158,6 +179,8 @@
   // Explicitly destroy the regions.
   for (auto &region : getRegions())
     region.~Region();
+
+  name.destroyOpProperties(getPropertiesStorage());
 }
 
 /// Destroy this operation or one of its subclasses.
@@ -249,6 +272,31 @@
   return diag;
 }
 
+Attribute Operation::getPropertiesAsAttribute() {
+  Optional<RegisteredOperationName> info = getRegisteredInfo();
+  if (LLVM_UNLIKELY(!info))
+    return *static_cast<Attribute *>(getPropertiesStorage());
+  return info->getOpPropertiesAsAttribute(this);
+}
+LogicalResult
+Operation::setPropertiesFromAttribute(Attribute attr,
+                                      InFlightDiagnostic *diagnostic) {
+  Optional<RegisteredOperationName> info = getRegisteredInfo();
+  if (LLVM_UNLIKELY(!info)) {
+    *static_cast<Attribute *>(getPropertiesStorage()) = attr;
+    return success();
+  }
+  return info->setOpPropertiesFromAttribute(this, attr, diagnostic);
+}
+
+void Operation::copyProperties(void *rhs) {
+  name.copyOpProperties(getPropertiesStorage(), rhs);
+}
+
+llvm::hash_code Operation::hashProperties() {
+  return name.hashOpProperties(getPropertiesStorage());
+}
+
 //===----------------------------------------------------------------------===//
 // Operation Ordering
 //===----------------------------------------------------------------------===//
@@ -580,6 +628,9 @@
       getRegion(i).cloneInto(&newOp->getRegion(i), mapper);
   }
 
+  // Copy the properties
+  newOp->copyProperties(getPropertiesStorage());
+
   // Remember the mapping of any results.
   for (unsigned i = 0, e = getNumResults(); i != e; ++i)
     mapper.map(getResult(i), newOp->getResult(i));
@@ -626,6 +677,20 @@
   p.getStream() << name;
 }
 
+/// Parse properties as a Attribute.
+ParseResult OpState::genericParseProperties(OpAsmParser &parser,
+                                            Attribute &result) {
+  if (parser.parseLess() || parser.parseAttribute(result) ||
+      parser.parseGreater())
+    return failure();
+  return success();
+}
+
+/// Print the properties as a Attribute.
+void OpState::genericPrintProperties(OpAsmPrinter &p, Attribute properties) {
+  p << "<" << properties << ">";
+}
+
 /// Emit an error about fatal conditions with this operation, reporting up to
 /// any diagnostic handlers that may be listening.
 InFlightDiagnostic OpState::emitError(const Twine &message) {
diff --git a/mlir/lib/IR/OperationSupport.cpp b/mlir/lib/IR/OperationSupport.cpp
--- a/mlir/lib/IR/OperationSupport.cpp
+++ b/mlir/lib/IR/OperationSupport.cpp
@@ -192,6 +192,23 @@
     : OperationState(location, OperationName(name, location.getContext()),
                      operands, types, attributes, successors, regions) {}
 
+OperationState::~OperationState() {
+  if (properties)
+    propertiesDeleter(properties);
+}
+
+LogicalResult
+OperationState::setProperties(Operation *op,
+                              InFlightDiagnostic *diagnostic) const {
+  if (LLVM_UNLIKELY(propertiesAttr)) {
+    assert(!properties);
+    return op->setPropertiesFromAttribute(propertiesAttr, diagnostic);
+  }
+  if (properties)
+    propertiesSetter(op->getPropertiesStorage(), properties);
+  return success();
+}
+
 void OperationState::addOperands(ValueRange newOperands) {
   operands.append(newOperands.begin(), newOperands.end());
 }
@@ -627,8 +644,9 @@
   //   - Operation Name
   //   - Attributes
   //   - Result Types
-  llvm::hash_code hash = llvm::hash_combine(
-      op->getName(), op->getAttrDictionary(), op->getResultTypes());
+  llvm::hash_code hash =
+      llvm::hash_combine(op->getName(), op->getAttrDictionary(),
+                         op->getResultTypes(), op->hashProperties());
 
   //   - Operands
   ValueRange operands = op->getOperands();
@@ -815,3 +833,41 @@
   });
   hash = hasher.result();
 }
+
+LogicalResult mlir::convertFromAttribute(int64_t &storage,
+                                         ::mlir::Attribute attr,
+                                         ::mlir::InFlightDiagnostic *diag) {
+  auto valueAttr = dyn_cast<IntegerAttr>(attr);
+  if (!valueAttr) {
+    if (diag)
+      *diag << "expected IntegerAttr for key `value`";
+    return failure();
+  }
+  storage = valueAttr.getValue().getSExtValue();
+  return success();
+}
+Attribute mlir::convertToAttribute(MLIRContext *ctx, int64_t storage) {
+  return IntegerAttr::get(IntegerType::get(ctx, 64), storage);
+}
+LogicalResult mlir::convertFromAttribute(MutableArrayRef<int64_t> storage,
+                                         ::mlir::Attribute attr,
+                                         ::mlir::InFlightDiagnostic *diag) {
+  auto valueAttr = dyn_cast<DenseI64ArrayAttr>(attr);
+  if (!valueAttr) {
+    if (diag)
+      *diag << "expected DenseI64ArrayAttr for key `value`";
+    return failure();
+  }
+  if (valueAttr.size() != static_cast<int64_t>(storage.size())) {
+    if (diag)
+      *diag << "Size mismatch in attribute conversion: " << valueAttr.size()
+            << " vs " << storage.size();
+    return failure();
+  }
+  llvm::copy(valueAttr.asArrayRef(), storage.begin());
+  return success();
+}
+Attribute mlir::convertToAttribute(MLIRContext *ctx,
+                                   ArrayRef<int64_t> storage) {
+  return DenseI64ArrayAttr::get(ctx, storage);
+}
diff --git a/mlir/lib/TableGen/CMakeLists.txt b/mlir/lib/TableGen/CMakeLists.txt
--- a/mlir/lib/TableGen/CMakeLists.txt
+++ b/mlir/lib/TableGen/CMakeLists.txt
@@ -24,6 +24,7 @@
   Pass.cpp
   Pattern.cpp
   Predicate.cpp
+  Property.cpp
   Region.cpp
   SideEffects.cpp
   Successor.cpp
diff --git a/mlir/lib/TableGen/Operator.cpp b/mlir/lib/TableGen/Operator.cpp
--- a/mlir/lib/TableGen/Operator.cpp
+++ b/mlir/lib/TableGen/Operator.cpp
@@ -538,6 +538,7 @@
   auto &recordKeeper = def.getRecords();
   auto *typeConstraintClass = recordKeeper.getClass("TypeConstraint");
   auto *attrClass = recordKeeper.getClass("Attr");
+  auto *propertyClass = recordKeeper.getClass("Property");
   auto *derivedAttrClass = recordKeeper.getClass("DerivedAttr");
   auto *opVarClass = recordKeeper.getClass("OpVariable");
   numNativeAttributes = 0;
@@ -622,6 +623,27 @@
     }
   }
 
+  // Populate properties.
+  DagInit *propertiesValues = def.getValueAsDag("properties");
+  unsigned numProps = propertiesValues->getNumArgs();
+  for (unsigned i = 0; i != numProps; ++i) {
+    auto *arg = propertiesValues->getArg(i);
+    auto givenName = propertiesValues->getArgNameStr(i);
+    auto *argDefInit = dyn_cast<DefInit>(arg);
+    if (!argDefInit)
+      PrintFatalError(def.getLoc(),
+                      Twine("undefined type for property #") + Twine(i));
+    Record *argDef = argDefInit->getDef();
+    if (givenName.empty() && numProps > 1)
+      PrintFatalError(argDef->getLoc(), "properties must be named");
+    bool isAttr = argDef->isSubClassOf(attrClass);
+    if (!isAttr && !argDef->isSubClassOf(propertyClass)) {
+      PrintFatalError(def.getLoc(), "unexpected def type; only defs deriving "
+                                    "from Property or Attr are allowed");
+    }
+    properties.push_back({givenName, Property(argDef, isAttr)});
+  }
+
   auto *resultsDag = def.getValueAsDag("results");
   auto *outsOp = dyn_cast<DefInit>(resultsDag->getOperator());
   if (!outsOp || outsOp->getDef()->getName() != "outs") {
diff --git a/mlir/lib/TableGen/Property.cpp b/mlir/lib/TableGen/Property.cpp
new file mode 100644
--- /dev/null
+++ b/mlir/lib/TableGen/Property.cpp
@@ -0,0 +1,111 @@
+//===- Property.cpp - Property wrapper class ----------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// Property wrapper to simplify using TableGen Record defining a MLIR
+// Property.
+//
+//===----------------------------------------------------------------------===//
+
+#include "mlir/TableGen/Property.h"
+#include "mlir/TableGen/Format.h"
+#include "mlir/TableGen/Operator.h"
+#include "llvm/TableGen/Record.h"
+
+using namespace mlir;
+using namespace mlir::tblgen;
+
+using llvm::DefInit;
+using llvm::Init;
+using llvm::Record;
+using llvm::StringInit;
+
+// Returns the initializer's value as string if the given TableGen initializer
+// is a code or string initializer. Returns the empty StringRef otherwise.
+static StringRef getValueAsString(const Init *init) {
+  if (const auto *str = dyn_cast<StringInit>(init))
+    return str->getValue().trim();
+  return {};
+}
+
+Property::Property(const Record *record, bool isAttr)
+    : isAttr(isAttr), def(record) {
+  assert((record->isSubClassOf("Property") || record->isSubClassOf("Attr")) &&
+         "must be subclass of TableGen 'Property' class");
+}
+
+Property::Property(const DefInit *init, bool isAttr)
+    : Property(init->getDef(), isAttr) {}
+
+StringRef Property::getStorageType() const {
+  const auto *init = def->getValueInit("storageType");
+  auto type = getValueAsString(init);
+  if (type.empty())
+    return "Property";
+  return type;
+}
+
+StringRef Property::getInterfaceType() const {
+  if (isAttr)
+    return getValueAsString(def->getValueInit("storageType"));
+  const auto *init = def->getValueInit("interfaceType");
+  return getValueAsString(init);
+}
+
+StringRef Property::getConvertFromStorageCall() const {
+  if (isAttr)
+    return "storage";
+  const auto *init = def->getValueInit("convertFromStorage");
+  return getValueAsString(init);
+}
+
+StringRef Property::getAssignToStorageCall() const {
+  if (isAttr)
+    return "storage = value";
+  const auto *init = def->getValueInit("assignToStorage");
+  return getValueAsString(init);
+}
+
+StringRef Property::getConvertToAttributeCall() const {
+  if (isAttr)
+    return "storage";
+  const auto *init = def->getValueInit("convertToAttribute");
+  return getValueAsString(init);
+}
+
+StringRef Property::getConvertFromAttributeCall() const {
+  if (isAttr)
+    return R"decl(
+      auto convertedAttr = dyn_cast<std::remove_reference_t<decltype(storage)>>(attr);
+      if (convertedAttr) {
+        storage = convertedAttr;
+        return success();
+      }
+      if (diag)
+        *diag << "Invalid attribute in property conversion: " << attr;
+      return failure();
+    )decl";
+  const auto *init = def->getValueInit("convertFromAttribute");
+  return getValueAsString(init);
+}
+
+StringRef Property::getHashPropertyCall() const {
+  if (isAttr)
+    return "hash_value(cast<::mlir::Attribute>(storage))";
+  return getValueAsString(def->getValueInit("hashProperty"));
+}
+
+bool Property::hasDefaultValue() const { return !getDefaultValue().empty(); }
+
+StringRef Property::getDefaultValue() const {
+  if (isAttr)
+    return "";
+  const auto *init = def->getValueInit("defaultValue");
+  return getValueAsString(init);
+}
+
+const llvm::Record &Property::getDef() const { return *def; }
diff --git a/mlir/test/IR/dynamic.mlir b/mlir/test/IR/dynamic.mlir
--- a/mlir/test/IR/dynamic.mlir
+++ b/mlir/test/IR/dynamic.mlir
@@ -1,93 +1,6 @@
 // RUN: mlir-opt -allow-unregistered-dialect %s -split-input-file -verify-diagnostics | FileCheck %s
 // Verify that extensible dialects can register dynamic operations and types.
 
-//===----------------------------------------------------------------------===//
-// Dynamic type
-//===----------------------------------------------------------------------===//
-
-// CHECK-LABEL: func @succeededDynamicTypeVerifier
-func.func @succeededDynamicTypeVerifier() {
-  // CHECK: %{{.*}} = "unregistered_op"() : () -> !test.dynamic_singleton
-  "unregistered_op"() : () -> !test.dynamic_singleton
-  // CHECK-NEXT: "unregistered_op"() : () -> !test.dynamic_pair<i32, f64>
-  "unregistered_op"() : () -> !test.dynamic_pair<i32, f64>
-  // CHECK-NEXT: %{{.*}} = "unregistered_op"() : () -> !test.dynamic_pair<!test.dynamic_pair<i32, f64>, !test.dynamic_singleton>
-  "unregistered_op"() : () -> !test.dynamic_pair<!test.dynamic_pair<i32, f64>, !test.dynamic_singleton>
-  return
-}
-
-// -----
-
-func.func @failedDynamicTypeVerifier() {
-  // expected-error@+1 {{expected 0 type arguments, but had 1}}
-  "unregistered_op"() : () -> !test.dynamic_singleton<f64>
-  return
-}
-
-// -----
-
-func.func @failedDynamicTypeVerifier2() {
-  // expected-error@+1 {{expected 2 type arguments, but had 1}}
-  "unregistered_op"() : () -> !test.dynamic_pair<f64>
-  return
-}
-
-// -----
-
-// CHECK-LABEL: func @customTypeParserPrinter
-func.func @customTypeParserPrinter() {
-  // CHECK: "unregistered_op"() : () -> !test.dynamic_custom_assembly_format<f32:f64>
-  "unregistered_op"() : () -> !test.dynamic_custom_assembly_format<f32 : f64>
-  return
-}
-
-// -----
-
-//===----------------------------------------------------------------------===//
-// Dynamic attribute
-//===----------------------------------------------------------------------===//
-
-// CHECK-LABEL: func @succeededDynamicAttributeVerifier
-func.func @succeededDynamicAttributeVerifier() {
-  // CHECK: "unregistered_op"() {test_attr = #test.dynamic_singleton} : () -> ()
-  "unregistered_op"() {test_attr = #test.dynamic_singleton} : () -> ()
-  // CHECK-NEXT: "unregistered_op"() {test_attr = #test.dynamic_pair<3 : i32, 5 : i32>} : () -> ()
-  "unregistered_op"() {test_attr = #test.dynamic_pair<3 : i32, 5 : i32>} : () -> ()
-  // CHECK-NEXT: "unregistered_op"() {test_attr = #test.dynamic_pair<#test.dynamic_pair<3 : i32, 5 : i32>, f64>} : () -> ()
-  "unregistered_op"() {test_attr = #test.dynamic_pair<#test.dynamic_pair<3 : i32, 5 : i32>, f64>} : () -> ()
-  return
-}
-
-// -----
-
-func.func @failedDynamicAttributeVerifier() {
-  // expected-error@+1 {{expected 0 attribute arguments, but had 1}}
-  "unregistered_op"() {test_attr = #test.dynamic_singleton<f64>} : () -> ()
-  return
-}
-
-// -----
-
-func.func @failedDynamicAttributeVerifier2() {
-  // expected-error@+1 {{expected 2 attribute arguments, but had 1}}
-  "unregistered_op"() {test_attr = #test.dynamic_pair<f64>} : () -> ()
-  return
-}
-
-// -----
-
-// CHECK-LABEL: func @customAttributeParserPrinter
-func.func @customAttributeParserPrinter() {
-  // CHECK: "unregistered_op"() {test_attr = #test.dynamic_custom_assembly_format<f32:f64>} : () -> ()
-  "unregistered_op"() {test_attr = #test.dynamic_custom_assembly_format<f32:f64>} : () -> ()
-  return
-}
-
-//===----------------------------------------------------------------------===//
-// Dynamic op
-//===----------------------------------------------------------------------===//
-
-// -----
 
 // CHECK-LABEL: func @succeededDynamicOpVerifier
 func.func @succeededDynamicOpVerifier(%a: f32) {
@@ -99,43 +12,3 @@
   "test.dynamic_one_operand_two_results"(%a) : (f32) -> (f64, f64)
   return
 }
-
-// -----
-
-func.func @failedDynamicOpVerifier() {
-  // expected-error@+1 {{expected 1 operand, but had 0}}
-  "test.dynamic_one_operand_two_results"() : () -> (f64, f64)
-  return
-}
-
-// -----
-
-func.func @failedDynamicOpVerifier2(%a: f32) {
-  // expected-error@+1 {{expected 2 results, but had 0}}
-  "test.dynamic_one_operand_two_results"(%a) : (f32) -> ()
-  return
-}
-
-// -----
-
-// CHECK-LABEL: func @customOpParserPrinter
-func.func @customOpParserPrinter() {
-  // CHECK: test.dynamic_custom_parser_printer custom_keyword
-  test.dynamic_custom_parser_printer custom_keyword
-  return
-}
-
-//===----------------------------------------------------------------------===//
-// Dynamic dialect
-//===----------------------------------------------------------------------===//
-
-// -----
-
-// Check that the verifier of a dynamic operation in a dynamic dialect
-// can fail. This shows that the dialect is correctly registered.
-
-func.func @failedDynamicDialectOpVerifier() {
-  // expected-error@+1 {{expected a single result, no operands and no regions}}
-  "test_dyn.one_result"() : () -> ()
-  return
-}
diff --git a/mlir/test/IR/parser.mlir b/mlir/test/IR/parser.mlir
--- a/mlir/test/IR/parser.mlir
+++ b/mlir/test/IR/parser.mlir
@@ -1437,3 +1437,4 @@
 // Check that an op with an optional result parses f80 as type.
 // CHECK: test.format_optional_result_d_op : f80
 test.format_optional_result_d_op : f80
+
diff --git a/mlir/test/IR/properties.mlir b/mlir/test/IR/properties.mlir
new file mode 100644
--- /dev/null
+++ b/mlir/test/IR/properties.mlir
@@ -0,0 +1,20 @@
+// # RUN: mlir-opt %s -split-input-file | mlir-opt  |FileCheck %s
+// # RUN: mlir-opt %s -mlir-print-op-generic -split-input-file  | mlir-opt -mlir-print-op-generic | FileCheck %s --check-prefix=GENERIC
+
+// CHECK:   test.with_properties
+// CHECK-SAME: <{a = 32 : i64, array = array<i64: 1, 2, 3, 4>, b = "foo"}>
+// GENERIC:   "test.with_properties"()
+// GENERIC-SAME: <{a = 32 : i64, array = array<i64: 1, 2, 3, 4>, b = "foo"}> : () -> ()
+test.with_properties <{a = 32 : i64, array = array<i64: 1, 2, 3, 4>, b = "foo"}>
+
+// CHECK:   test.with_nice_properties
+// CHECK-SAME:    "foo bar" is -3
+// GENERIC: "test.with_nice_properties"()
+// GENERIC-SAME:  <{label = "foo bar", value = -3 : i32}> : () -> ()
+test.with_nice_properties "foo bar" is -3
+
+// CHECK:   test.with_wrapped_properties
+// CHECK-SAME:    "content for properties"
+// GENERIC: "test.with_wrapped_properties"()
+// GENERIC-SAME:  <"content for properties"> : () -> ()
+test.with_wrapped_properties "content for properties"
\ No newline at end of file
diff --git a/mlir/test/lib/Dialect/Test/TestDialect.h b/mlir/test/lib/Dialect/Test/TestDialect.h
--- a/mlir/test/lib/Dialect/Test/TestDialect.h
+++ b/mlir/test/lib/Dialect/Test/TestDialect.h
@@ -42,6 +42,8 @@
 #include "mlir/Interfaces/SideEffectInterfaces.h"
 #include "mlir/Interfaces/ViewLikeInterface.h"
 
+#include <memory>
+
 namespace mlir {
 class DLTIDialect;
 class RewritePatternSet;
@@ -54,6 +56,30 @@
 #include "TestOpInterfaces.h.inc"
 #include "TestOpsDialect.h.inc"
 
+namespace test {
+// Define some classes to exercises the Properties feature.
+
+struct PropertiesWithCustomPrint {
+  // A shared_ptr to a const object is safe: it is equivalent to a value-based
+  // member. Here the label will be deallocated when the last operation refering
+  // to it is destroyed. However there is no pool-allocation: this is offloaded
+  // to the client.
+  std::shared_ptr<const std::string> label;
+  int value;
+};
+class MyPropStruct {
+public:
+  std::string content;
+  // These three methods are invoked through the  `MyStructProperty` wrapper
+  // defined in TestOps.td
+  mlir::Attribute asAttribute(mlir::MLIRContext *ctx) const;
+  static mlir::LogicalResult setFromAttr(MyPropStruct &prop,
+                                         mlir::Attribute attr,
+                                         mlir::InFlightDiagnostic *diag);
+  llvm::hash_code hash() const;
+};
+} // namespace test
+
 #define GET_OP_CLASSES
 #include "TestOps.h.inc"
 
diff --git a/mlir/test/lib/Dialect/Test/TestDialect.cpp b/mlir/test/lib/Dialect/Test/TestDialect.cpp
--- a/mlir/test/lib/Dialect/Test/TestDialect.cpp
+++ b/mlir/test/lib/Dialect/Test/TestDialect.cpp
@@ -42,6 +42,54 @@
 using namespace mlir;
 using namespace test;
 
+namespace test {
+
+Attribute MyPropStruct::asAttribute(MLIRContext *ctx) const {
+  return StringAttr::get(ctx, content);
+}
+LogicalResult MyPropStruct::setFromAttr(MyPropStruct &prop, Attribute attr,
+                                        InFlightDiagnostic *diag) {
+  StringAttr strAttr = attr.dyn_cast<StringAttr>();
+  if (!strAttr) {
+    if (diag)
+      *diag << "Expect StringAttr but got " << attr;
+    return failure();
+  }
+  prop.content = strAttr.getValue();
+  return success();
+}
+llvm::hash_code MyPropStruct::hash() const {
+  return hash_value(StringRef(content));
+}
+
+static void customPrintProperties(OpAsmPrinter &p, const MyPropStruct &prop) {
+  p.printKeywordOrString(prop.content);
+}
+
+static ParseResult customParseProperties(OpAsmParser &parser,
+                                         MyPropStruct &prop) {
+  return parser.parseKeywordOrString(&prop.content);
+}
+
+static LogicalResult setPropertiesFromAttribute(PropertiesWithCustomPrint &prop,
+                                                Attribute attr,
+                                                InFlightDiagnostic *diagnostic);
+static DictionaryAttr
+getPropertiesAsAttribute(MLIRContext *ctx,
+                         const PropertiesWithCustomPrint &prop);
+static llvm::hash_code computeHash(const PropertiesWithCustomPrint &prop);
+static void customPrintProperties(OpAsmPrinter &p,
+                                  PropertiesWithCustomPrint &prop);
+static ParseResult customParseProperties(OpAsmParser &parser,
+                                         PropertiesWithCustomPrint &prop);
+
+PropertiesWithCustomPrint
+testTestOpWithProperties(OpAsmPrinter &p, TestOpWithNiceProperties op) {
+  return op.getProperties();
+}
+
+} // namespace test
+
 void test::registerTestDialect(DialectRegistry &registry) {
   registry.insert<TestDialect>();
 }
@@ -1633,6 +1681,63 @@
   setResultRanges(getResult(), range);
 }
 
+namespace test {
+
+static LogicalResult
+setPropertiesFromAttribute(PropertiesWithCustomPrint &prop, Attribute attr,
+                           InFlightDiagnostic *diagnostic) {
+  DictionaryAttr dict = dyn_cast<DictionaryAttr>(attr);
+  if (!dict) {
+    if (diagnostic)
+      *diagnostic << "expected DictionaryAttr to set TestProperties";
+    return failure();
+  }
+  auto label = dict.getAs<mlir::StringAttr>("label");
+  if (!label) {
+    if (diagnostic)
+      *diagnostic << "expected StringAttr for key `label`";
+    return failure();
+  }
+  auto valueAttr = dict.getAs<IntegerAttr>("value");
+  if (!valueAttr) {
+    if (diagnostic)
+      *diagnostic << "expected IntegerAttr for key `value`";
+    return failure();
+  }
+
+  prop.label = std::make_shared<std::string>(label.getValue());
+  prop.value = valueAttr.getValue().getSExtValue();
+  return success();
+}
+static DictionaryAttr
+getPropertiesAsAttribute(MLIRContext *ctx,
+                         const PropertiesWithCustomPrint &prop) {
+  SmallVector<NamedAttribute> attrs;
+  Builder b{ctx};
+  attrs.push_back(b.getNamedAttr("label", b.getStringAttr(*prop.label)));
+  attrs.push_back(b.getNamedAttr("value", b.getI32IntegerAttr(prop.value)));
+  return b.getDictionaryAttr(attrs);
+}
+static llvm::hash_code computeHash(const PropertiesWithCustomPrint &prop) {
+  return llvm::hash_combine(prop.value, StringRef(*prop.label));
+}
+static void customPrintProperties(OpAsmPrinter &p,
+                                  const PropertiesWithCustomPrint &prop) {
+  p.printKeywordOrString(*prop.label);
+  p << " is " << prop.value;
+}
+static ParseResult customParseProperties(OpAsmParser &parser,
+                                         PropertiesWithCustomPrint &prop) {
+  std::string label;
+  if (parser.parseKeywordOrString(&label) || parser.parseKeyword("is") ||
+      parser.parseInteger(prop.value))
+    return failure();
+  prop.label = std::make_shared<std::string>(std::move(label));
+  return success();
+}
+
+} // namespace test
+
 #include "TestOpEnums.cpp.inc"
 #include "TestOpInterfaces.cpp.inc"
 #include "TestTypeInterfaces.cpp.inc"
diff --git a/mlir/test/lib/Dialect/Test/TestOps.td b/mlir/test/lib/Dialect/Test/TestOps.td
--- a/mlir/test/lib/Dialect/Test/TestOps.td
+++ b/mlir/test/lib/Dialect/Test/TestOps.td
@@ -3149,4 +3149,59 @@
   }];
 }
 
+
+//===----------------------------------------------------------------------===//
+// Test Properties
+//===----------------------------------------------------------------------===//
+
+
+// Op with a properties struct defined inline.
+def TestOpWithProperties : TEST_Op<"with_properties"> {
+  let assemblyFormat = "prop-attr attr-dict";
+  let properties = (ins
+    Property<"int64_t">:$a,
+    StrAttr:$b, // Attributes can directly be used here.
+    ArrayProperty<"int64_t", 4>:$array // example of an array
+  );
+}
+
+// Op with a properties struct defined out-of-line. The struct has custom
+// printer/parser.
+def TestOpWithNiceProperties : TEST_Op<"with_nice_properties"> {
+  let assemblyFormat = "prop-attr attr-dict";
+  let extraClassDeclaration = [{
+    public:
+    // This bypasses the ODS generation for the property and reuses
+    // directly an existing C++ class.
+    using Properties = PropertiesWithCustomPrint;
+  }];
+}
+
+
+// Demonstrate how to wrap an existing C++ class named MyPropStruct.
+def MyStructProperty : Property<"MyPropStruct"> {
+  let convertToAttribute = [{
+    storage.asAttribute(ctx)
+  }];
+  let convertFromAttribute = [{
+    return MyPropStruct::setFromAttr(storage, attr, diag);
+  }];
+  let hashProperty = [{
+    storage.hash();
+  }];
+}
+
+def TestOpWithWrappedProperties : TEST_Op<"with_wrapped_properties"> {
+  let assemblyFormat = "prop-attr attr-dict";
+  let properties = (ins
+    MyStructProperty
+  );
+  let extraClassDeclaration = [{
+    // When there is a single entry in the `properties` field, we expect it to
+    // be `inlined` instead of wrapped in a struct.
+    static_assert(std::is_same<Properties, MyPropStruct>(),
+                  "Properties should be MyPropStruct");
+  }];
+}
+
 #endif // TEST_OPS
diff --git a/mlir/tools/mlir-tblgen/FormatGen.h b/mlir/tools/mlir-tblgen/FormatGen.h
--- a/mlir/tools/mlir-tblgen/FormatGen.h
+++ b/mlir/tools/mlir-tblgen/FormatGen.h
@@ -60,6 +60,7 @@
     keyword_start,
     kw_attr_dict,
     kw_attr_dict_w_keyword,
+    kw_prop_dict,
     kw_custom,
     kw_functional_type,
     kw_oilist,
@@ -287,6 +288,7 @@
   /// These are the kinds of directives.
   enum Kind {
     AttrDict,
+    PropDict,
     Custom,
     FunctionalType,
     OIList,
diff --git a/mlir/tools/mlir-tblgen/FormatGen.cpp b/mlir/tools/mlir-tblgen/FormatGen.cpp
--- a/mlir/tools/mlir-tblgen/FormatGen.cpp
+++ b/mlir/tools/mlir-tblgen/FormatGen.cpp
@@ -177,6 +177,7 @@
       StringSwitch<FormatToken::Kind>(str)
           .Case("attr-dict", FormatToken::kw_attr_dict)
           .Case("attr-dict-with-keyword", FormatToken::kw_attr_dict_w_keyword)
+          .Case("prop-attr", FormatToken::kw_prop_dict)
           .Case("custom", FormatToken::kw_custom)
           .Case("functional-type", FormatToken::kw_functional_type)
           .Case("oilist", FormatToken::kw_oilist)
diff --git a/mlir/tools/mlir-tblgen/OpClass.cpp b/mlir/tools/mlir-tblgen/OpClass.cpp
--- a/mlir/tools/mlir-tblgen/OpClass.cpp
+++ b/mlir/tools/mlir-tblgen/OpClass.cpp
@@ -37,5 +37,6 @@
 void OpClass::finalize() {
   Class::finalize();
   declare<VisibilityDeclaration>(Visibility::Public);
-  declare<ExtraClassDeclaration>(extraClassDeclaration, extraClassDefinition);
+  declare<ExtraClassDeclaration>(extraClassDeclaration.str(),
+                                 extraClassDefinition);
 }
diff --git a/mlir/tools/mlir-tblgen/OpDefinitionsGen.cpp b/mlir/tools/mlir-tblgen/OpDefinitionsGen.cpp
--- a/mlir/tools/mlir-tblgen/OpDefinitionsGen.cpp
+++ b/mlir/tools/mlir-tblgen/OpDefinitionsGen.cpp
@@ -418,6 +418,9 @@
   // Generates the `getOperationName` method for this op.
   void genOpNameGetter();
 
+  // Generates code to manage the properties, if any!
+  void genPropertiesSupport();
+
   // Generates getters for the attributes.
   void genAttrGetters();
 
@@ -834,6 +837,7 @@
   genNamedResultGetters();
   genNamedRegionGetters();
   genNamedSuccessorGetters();
+  genPropertiesSupport();
   genAttrGetters();
   genAttrSetters();
   genOptionalAttrRemovers();
@@ -988,6 +992,165 @@
        << ";\n";
 }
 
+void OpEmitter::genPropertiesSupport() {
+  if (op.getProperties().empty())
+    return;
+  auto &setPropMethod =
+      opClass
+          .addStaticMethod(
+              "::mlir::LogicalResult", "setPropertiesFromAttr",
+              MethodParameter("Properties &", "prop"),
+              MethodParameter("::mlir::Attribute", "attr"),
+              MethodParameter("::mlir::InFlightDiagnostic *", "diag"))
+          ->body();
+  auto &getPropMethod =
+      opClass
+          .addStaticMethod("::mlir::Attribute", "getPropertiesAsAttr",
+                           MethodParameter("::mlir::MLIRContext *", "ctx"),
+                           MethodParameter("const Properties &", "prop"))
+          ->body();
+  auto &hashMethod =
+      opClass
+          .addStaticMethod("llvm::hash_code", "computePropertiesHash",
+                           MethodParameter("const Properties &", "prop"))
+          ->body();
+
+  if (llvm::hasSingleElement(op.getProperties())) {
+    // When there is a single element, we inline it instead of wrapping in a
+    // struct.
+    auto &prop = op.getProperties().begin()->prop;
+    std::string declarations;
+    llvm::raw_string_ostream os(declarations);
+    os << "  using Properties = " << prop.getStorageType() << ";";
+    os.flush();
+    opClass.declare<ExtraClassDeclaration>(std::move(declarations));
+    setPropMethod << formatv(R"decl(;
+    auto &storage = prop;
+    {0};
+)decl",
+                             prop.getConvertFromAttributeCall());
+    getPropMethod << formatv(R"decl(
+      const auto &storage = prop;
+      return {0};)decl",
+                             prop.getConvertToAttributeCall());
+    hashMethod << formatv(R"decl(
+    const auto &storage = prop;
+    return {0};
+)decl",
+                          prop.getHashPropertyCall());
+    return;
+  }
+
+  // Define the properties struct with multiple members.
+
+  std::string declarations = "  struct Properties {\n";
+  llvm::raw_string_ostream os(declarations);
+  for (const NamedProperty &namedProperty : op.getProperties()) {
+    StringRef name = namedProperty.name;
+    if (name.empty())
+      report_fatal_error("missing name for property");
+    std::string camelName =
+        convertToCamelFromSnakeCase(name, /*capitalizeFirst=*/true);
+    auto &prop = namedProperty.prop;
+    // Generate the data member using the storage type.
+    os << "    using " << name << "Ty = " << prop.getStorageType() << ";\n"
+       << "    " << name << "Ty " << name;
+    if (prop.hasDefaultValue())
+      os << " = " << prop.getDefaultValue();
+
+    // Emit accessors using the interface type.
+    const char *accessorFmt = R"decl(;
+    {0} get{1}() {
+      auto &storage = this->{2};
+      return {3};
+    }
+    void set{1}(const {0} &value) {
+      auto &storage = this->{2};
+      {4};
+    }
+)decl";
+    os << formatv(accessorFmt, prop.getInterfaceType(), camelName, name,
+                  prop.getConvertFromStorageCall(),
+                  prop.getAssignToStorageCall());
+  }
+  os << "  };\n";
+  os.flush();
+  opClass.declare<ExtraClassDeclaration>(std::move(declarations));
+
+  // Convert the property to the attribute form.
+
+  setPropMethod << R"decl(
+  DictionaryAttr dict = dyn_cast<DictionaryAttr>(attr);
+  if (!dict) {
+    if (diag)
+      *diag << "expected DictionaryAttr to set properties";
+    return failure();
+  }
+    )decl";
+  const char *propFromAttrFmt = R"decl(;
+    {
+      auto setFromAttr = [] (auto &storage, ::mlir::Attribute attr, 
+                             ::mlir::InFlightDiagnostic *diag) {
+        {0};
+      };
+      auto attr = dict.get("{1}");
+      if (!attr) {
+        if (diag)
+          *diag << "expected key entry for {1} in DictionaryAttr to set "
+                   "Properties.";
+        return failure();
+      }
+      if (failed(setFromAttr(prop.{1}, attr, diag))) return failure();
+    }
+)decl";
+  for (const NamedProperty &namedProperty : op.getProperties()) {
+    StringRef name = namedProperty.name;
+    auto &prop = namedProperty.prop;
+    setPropMethod << formatv(propFromAttrFmt,
+                             prop.getConvertFromAttributeCall(), name);
+  }
+  setPropMethod << "  return success();\n";
+
+  // Convert the attribute form to the property.
+
+  getPropMethod << "    SmallVector<NamedAttribute> attrs;\n"
+                << "    Builder b{ctx};\n";
+  const char *propToAttrFmt = R"decl(
+    {
+      const auto &storage = prop.{0};
+      attrs.push_back(b.getNamedAttr("{0}",
+                                     {1}));
+    }
+)decl";
+  for (const NamedProperty &namedProperty : op.getProperties()) {
+    StringRef name = namedProperty.name;
+    auto &prop = namedProperty.prop;
+    getPropMethod << formatv(propToAttrFmt, name,
+                             prop.getConvertToAttributeCall());
+  }
+  getPropMethod << "  return b.getDictionaryAttr(attrs);\n";
+
+  // Hashing for the property
+
+  const char *propHashFmt = R"decl(
+  auto hash_{0} = [] (const auto &storage) -> llvm::hash_code {
+    return {1};
+  };
+)decl";
+  for (const NamedProperty &namedProperty : op.getProperties()) {
+    StringRef name = namedProperty.name;
+    auto &prop = namedProperty.prop;
+    hashMethod << formatv(propHashFmt, name, prop.getHashPropertyCall());
+  }
+  hashMethod << "  return llvm::hash_combine(";
+  llvm::interleaveComma(op.getProperties(), hashMethod,
+                        [&](const NamedProperty &namedProperty) {
+                          hashMethod << "\n    hash_" << namedProperty.name
+                                     << "(prop." << namedProperty.name << ")";
+                        });
+  hashMethod << ");\n";
+}
+
 void OpEmitter::genAttrGetters() {
   FmtContext fctx;
   fctx.withBuilder("::mlir::Builder((*this)->getContext())");
@@ -998,9 +1161,9 @@
       method->body() << "  " << attr.getDerivedCodeBody() << "\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.
+  // 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, StringRef attrName,
                                      Attribute attr) {
     auto *method = opClass.addMethod(attr.getStorageType(), name + "Attr");
diff --git a/mlir/tools/mlir-tblgen/OpFormatGen.cpp b/mlir/tools/mlir-tblgen/OpFormatGen.cpp
--- a/mlir/tools/mlir-tblgen/OpFormatGen.cpp
+++ b/mlir/tools/mlir-tblgen/OpFormatGen.cpp
@@ -132,6 +132,14 @@
   bool withKeyword;
 };
 
+/// This class represents the `prop-attr` directive. This directive represents
+/// the properties of the operation, expressed as a directionary.
+class PropDictDirective
+    : public DirectiveElementBase<DirectiveElement::PropDict> {
+public:
+  explicit PropDictDirective() = default;
+};
+
 /// This class represents the `functional-type` directive. This directive takes
 /// two arguments and formats them, respectively, as the inputs and results of a
 /// FunctionType.
@@ -1315,9 +1323,11 @@
          << (attrDict->isWithKeyword() ? "WithKeyword" : "")
          << "(result.attributes))\n"
          << "    return ::mlir::failure();\n";
+  } else if (auto *attrDict = dyn_cast<PropDictDirective>(element)) {
+    body << "  if (parseProperties(parser, result))\n"
+         << "    return ::mlir::failure();\n";
   } else if (auto *customDir = dyn_cast<CustomDirective>(element)) {
     genCustomDirectiveParser(customDir, body);
-
   } else if (isa<OperandsDirective>(element)) {
     body << "  ::llvm::SMLoc allOperandLoc = parser.getCurrentLocation();\n"
          << "  if (parser.parseOperandList(allOperands))\n"
@@ -1641,6 +1651,14 @@
     auto caseValueStr = {1}(caseValue);
 )";
 
+/// Generate the printer for the 'prop-attr' directive.
+static void genPropDictPrinter(OperationFormat &fmt, Operator &op,
+                               MethodBody &body) {
+  body << "  _odsPrinter << \" \";\n"
+       << "  printProperties(this->getContext(), _odsPrinter, "
+          "getProperties());\n";
+}
+
 /// Generate the printer for the 'attr-dict' directive.
 static void genAttrDictPrinter(OperationFormat &fmt, Operator &op,
                                MethodBody &body, bool withKeyword) {
@@ -2063,6 +2081,13 @@
     return;
   }
 
+  // Emit the attribute dictionary.
+  if (auto *propDict = dyn_cast<PropDictDirective>(element)) {
+    genPropDictPrinter(*this, op, body);
+    lastWasPunctuation = false;
+    return;
+  }
+
   // Optionally insert a space before the next element. The AttrDict printer
   // already adds a space as necessary.
   if (shouldEmitSpace || !lastWasPunctuation)
@@ -2300,6 +2325,7 @@
   ConstArgument findSeenArg(StringRef name);
 
   /// Parse the various different directives.
+  FailureOr<FormatElement *> parsePropDictDirective(SMLoc loc, Context context);
   FailureOr<FormatElement *> parseAttrDictDirective(SMLoc loc, Context context,
                                                     bool withKeyword);
   FailureOr<FormatElement *> parseFunctionalTypeDirective(SMLoc loc,
@@ -2329,6 +2355,7 @@
   // The following are various bits of format state used for verification
   // during parsing.
   bool hasAttrDict = false;
+  bool hasPropDict = false;
   bool hasAllRegions = false, hasAllSuccessors = false;
   bool canInferResultTypes = false;
   llvm::SmallBitVector seenOperandTypes, seenResultTypes;
@@ -2873,6 +2900,8 @@
 OpFormatParser::parseDirectiveImpl(SMLoc loc, FormatToken::Kind kind,
                                    Context ctx) {
   switch (kind) {
+  case FormatToken::kw_prop_dict:
+    return parsePropDictDirective(loc, ctx);
   case FormatToken::kw_attr_dict:
     return parseAttrDictDirective(loc, ctx,
                                   /*withKeyword=*/false);
@@ -2925,6 +2954,24 @@
   return create<AttrDictDirective>(withKeyword);
 }
 
+FailureOr<FormatElement *>
+OpFormatParser::parsePropDictDirective(SMLoc loc, Context context) {
+  if (context == TypeDirectiveContext)
+    return emitError(loc, "'prop-attr' directive can only be used as a "
+                          "top-level directive");
+
+  if (context == RefDirectiveContext)
+    llvm::report_fatal_error("'ref' of 'prop-attr' unsupported");
+  // Otherwise, this is a top-level context.
+
+  if (hasPropDict)
+    return emitError(loc, "'prop-attr' directive has already been seen");
+  hasPropDict = true;
+  // llvm::report_fatal_error("create PropDictDirective");
+
+  return create<PropDictDirective>();
+}
+
 LogicalResult OpFormatParser::verifyCustomDirectiveArguments(
     SMLoc loc, ArrayRef<FormatElement *> arguments) {
   for (FormatElement *argument : arguments) {
diff --git a/mlir/unittests/IR/CMakeLists.txt b/mlir/unittests/IR/CMakeLists.txt
--- a/mlir/unittests/IR/CMakeLists.txt
+++ b/mlir/unittests/IR/CMakeLists.txt
@@ -10,6 +10,7 @@
   ShapedTypeTest.cpp
   SubElementInterfaceTest.cpp
   TypeTest.cpp
+  OpPropertiesTest.cpp
 
   DEPENDS
   MLIRTestInterfaceIncGen
diff --git a/mlir/unittests/IR/OpPropertiesTest.cpp b/mlir/unittests/IR/OpPropertiesTest.cpp
new file mode 100644
--- /dev/null
+++ b/mlir/unittests/IR/OpPropertiesTest.cpp
@@ -0,0 +1,344 @@
+//===- TestOpProperties.cpp - Test all properties-related APIs ------------===//
+//
+// 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/IR/OpDefinition.h"
+#include "mlir/Parser/Parser.h"
+#include "gtest/gtest.h"
+
+using namespace mlir;
+
+namespace {
+/// Simple structure definining a struct to define "properties" for a given
+/// operation. Default values are honored when creating an operation.
+struct TestProperties {
+  int a = -1;
+  float b = -1.;
+  std::vector<int64_t> array = {-33};
+  // A shared_ptr to a const object is safe: it is equivalent to a value-based
+  // member. Here the label will be deallocated when the last operation
+  // referring to it is destroyed. However there is no pool-allocation: this is
+  // offloaded to the client.
+  std::shared_ptr<const std::string> label;
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TestProperties)
+};
+
+/// Convert a DictionaryAttr to a TestProperties struct, optionally emit errors
+/// through the provided diagnostic if any. This is used for example during
+/// parsing with the generic format.
+static LogicalResult
+setPropertiesFromAttribute(TestProperties &prop, Attribute attr,
+                           InFlightDiagnostic *diagnostic) {
+  DictionaryAttr dict = dyn_cast<DictionaryAttr>(attr);
+  if (!dict) {
+    if (diagnostic)
+      *diagnostic << "expected DictionaryAttr to set TestProperties";
+    return failure();
+  }
+  auto aAttr = dict.getAs<IntegerAttr>("a");
+  if (!aAttr) {
+    if (diagnostic)
+      *diagnostic << "expected IntegerAttr for key `a`";
+    return failure();
+  }
+  auto bAttr = dict.getAs<FloatAttr>("b");
+  if (!bAttr ||
+      &bAttr.getValue().getSemantics() != &llvm::APFloatBase::IEEEsingle()) {
+    if (diagnostic)
+      *diagnostic << "expected FloatAttr for key `b`";
+    return failure();
+  }
+
+  auto arrayAttr = dict.getAs<DenseI64ArrayAttr>("array");
+  if (!arrayAttr) {
+    if (diagnostic)
+      *diagnostic << "expected DenseI64ArrayAttr for key `array`";
+    return failure();
+  }
+
+  auto label = dict.getAs<mlir::StringAttr>("label");
+  if (!label) {
+    if (diagnostic)
+      *diagnostic << "expected StringAttr for key `label`";
+    return failure();
+  }
+
+  prop.a = aAttr.getValue().getSExtValue();
+  prop.b = bAttr.getValue().convertToFloat();
+  prop.array.assign(arrayAttr.asArrayRef().begin(),
+                    arrayAttr.asArrayRef().end());
+  prop.label = std::make_shared<std::string>(label.getValue());
+  return success();
+}
+
+/// Convert a TestProperties struct to a DictionaryAttr, this is used for
+/// example during printing with the generic format.
+static Attribute getPropertiesAsAttribute(MLIRContext *ctx,
+                                          const TestProperties &prop) {
+  SmallVector<NamedAttribute> attrs;
+  Builder b{ctx};
+  attrs.push_back(b.getNamedAttr("a", b.getI32IntegerAttr(prop.a)));
+  attrs.push_back(b.getNamedAttr("b", b.getF32FloatAttr(prop.b)));
+  attrs.push_back(b.getNamedAttr("array", b.getDenseI64ArrayAttr(prop.array)));
+  attrs.push_back(b.getNamedAttr(
+      "label", b.getStringAttr(prop.label ? *prop.label : "<nullptr>")));
+  return b.getDictionaryAttr(attrs);
+}
+
+inline llvm::hash_code computeHash(const TestProperties &prop) {
+  // We hash `b` which is a float using its underlying array of char:
+  unsigned char const *p = reinterpret_cast<unsigned char const *>(&prop.b);
+  ArrayRef<unsigned char> bBytes{p, sizeof(prop.b)};
+  return llvm::hash_combine(
+      prop.a, llvm::hash_combine_range(bBytes.begin(), bBytes.end()),
+      llvm::hash_combine_range(prop.array.begin(), prop.array.end()),
+      StringRef(*prop.label));
+}
+
+/// A custom operation for the purpose of showcasing how to use "properties".
+class OpWithProperties : public Op<OpWithProperties> {
+public:
+  // Begin boilerplate
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(OpWithProperties)
+  using Op::Op;
+  static ArrayRef<StringRef> getAttributeNames() { return {}; }
+  static StringRef getOperationName() {
+    return "test_op_properties.op_with_properties";
+  }
+  // End boilerplate
+
+  // This alias is the only definition needed for enabling "properties" for this
+  // operation.
+  using Properties = TestProperties;
+};
+
+// A trivial supporting dialect to register the above operation.
+class TestOpPropertiesDialect : public Dialect {
+public:
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TestOpPropertiesDialect)
+  static constexpr ::llvm::StringLiteral getDialectNamespace() {
+    return ::llvm::StringLiteral("test_op_properties");
+  }
+  explicit TestOpPropertiesDialect(MLIRContext *context)
+      : Dialect(getDialectNamespace(), context,
+                TypeID::get<TestOpPropertiesDialect>()) {
+    addOperations<OpWithProperties>();
+  }
+};
+
+constexpr StringLiteral mlirSrc = R"mlir(
+    "test_op_properties.op_with_properties"()
+      <{a = -42 : i32,
+        b = -4.200000e+01 : f32,
+        array = array<i64: 40, 41>,
+        label = "bar foo"}> : () -> ()
+)mlir";
+
+TEST(OpPropertiesTest, Properties) {
+  MLIRContext context;
+  context.getOrLoadDialect<TestOpPropertiesDialect>();
+  ParserConfig config(&context);
+  // Parse the operation with some properties.
+  OwningOpRef<Operation *> op = parseSourceString(mlirSrc, config);
+  ASSERT_TRUE(op.get() != nullptr);
+  auto opWithProp = dyn_cast<OpWithProperties>(op.get());
+  ASSERT_TRUE(opWithProp);
+  {
+    std::string output;
+    llvm::raw_string_ostream os(output);
+    opWithProp.print(os);
+    ASSERT_STREQ("\"test_op_properties.op_with_properties\"() "
+                 "<{a = -42 : i32, "
+                 "array = array<i64: 40, 41>, "
+                 "b = -4.200000e+01 : f32, "
+                 "label = \"bar foo\"}> : () -> ()\n",
+                 os.str().c_str());
+  }
+  // Get a mutable reference to the properties for this operation and modify it
+  // in place one member at a time.
+  TestProperties &prop = opWithProp.getProperties();
+  prop.a = 42;
+  {
+    std::string output;
+    llvm::raw_string_ostream os(output);
+    opWithProp.print(os);
+    EXPECT_TRUE(StringRef(os.str()).contains("a = 42"));
+    EXPECT_TRUE(StringRef(os.str()).contains("b = -4.200000e+01"));
+    EXPECT_TRUE(StringRef(os.str()).contains("array = array<i64: 40, 41>"));
+    EXPECT_TRUE(StringRef(os.str()).contains("label = \"bar foo\""));
+  }
+  prop.b = 42.;
+  {
+    std::string output;
+    llvm::raw_string_ostream os(output);
+    opWithProp.print(os);
+    EXPECT_TRUE(StringRef(os.str()).contains("a = 42"));
+    EXPECT_TRUE(StringRef(os.str()).contains("b = 4.200000e+01"));
+    EXPECT_TRUE(StringRef(os.str()).contains("array = array<i64: 40, 41>"));
+    EXPECT_TRUE(StringRef(os.str()).contains("label = \"bar foo\""));
+  }
+  prop.array.push_back(42);
+  {
+    std::string output;
+    llvm::raw_string_ostream os(output);
+    opWithProp.print(os);
+    EXPECT_TRUE(StringRef(os.str()).contains("a = 42"));
+    EXPECT_TRUE(StringRef(os.str()).contains("b = 4.200000e+01"));
+    EXPECT_TRUE(StringRef(os.str()).contains("array = array<i64: 40, 41, 42>"));
+    EXPECT_TRUE(StringRef(os.str()).contains("label = \"bar foo\""));
+  }
+  prop.label = std::make_shared<std::string>("foo bar");
+  {
+    std::string output;
+    llvm::raw_string_ostream os(output);
+    opWithProp.print(os);
+    EXPECT_TRUE(StringRef(os.str()).contains("a = 42"));
+    EXPECT_TRUE(StringRef(os.str()).contains("b = 4.200000e+01"));
+    EXPECT_TRUE(StringRef(os.str()).contains("array = array<i64: 40, 41, 42>"));
+    EXPECT_TRUE(StringRef(os.str()).contains("label = \"foo bar\""));
+  }
+}
+
+// Test diagnostic emission when using invalid dictionary.
+TEST(OpPropertiesTest, FailedProperties) {
+  MLIRContext context;
+  context.getOrLoadDialect<TestOpPropertiesDialect>();
+  std::string diagnosticStr;
+  context.getDiagEngine().registerHandler([&](Diagnostic &diag) {
+    diagnosticStr += diag.str();
+    return success();
+  });
+
+  // Parse the operation with some properties.
+  ParserConfig config(&context);
+
+  // Parse an operation with invalid (incomplete) properties.
+  OwningOpRef<Operation *> owningOp =
+      parseSourceString("\"test_op_properties.op_with_properties\"() "
+                        "<{a = -42 : i32}> : () -> ()\n",
+                        config);
+  ASSERT_EQ(owningOp.get(), nullptr);
+  EXPECT_STREQ(
+      "invalid properties {a = -42 : i32} for op "
+      "test_op_properties.op_with_properties: expected FloatAttr for key `b`",
+      diagnosticStr.c_str());
+  diagnosticStr.clear();
+
+  owningOp = parseSourceString(mlirSrc, config);
+  Operation *op = owningOp.get();
+  ASSERT_TRUE(op != nullptr);
+  Location loc = op->getLoc();
+  auto opWithProp = dyn_cast<OpWithProperties>(op);
+  ASSERT_TRUE(opWithProp);
+
+  OperationState state(loc, op->getName());
+  Builder b{&context};
+  NamedAttrList attrs;
+  attrs.push_back(b.getNamedAttr("a", b.getStringAttr("foo")));
+  state.propertiesAttr = attrs.getDictionary(&context);
+  {
+    auto diag = op->emitError("setting properties failed: ");
+    auto result = state.setProperties(op, &diag);
+    EXPECT_TRUE(result.failed());
+  }
+  EXPECT_STREQ("setting properties failed: expected IntegerAttr for key `a`",
+               diagnosticStr.c_str());
+}
+
+TEST(OpPropertiesTest, DefaultValues) {
+  MLIRContext context;
+  context.getOrLoadDialect<TestOpPropertiesDialect>();
+  OperationState state(UnknownLoc::get(&context),
+                       "test_op_properties.op_with_properties");
+  Operation *op = Operation::create(state);
+  ASSERT_TRUE(op != nullptr);
+  {
+    std::string output;
+    llvm::raw_string_ostream os(output);
+    op->print(os);
+    EXPECT_TRUE(StringRef(os.str()).contains("a = -1"));
+    EXPECT_TRUE(StringRef(os.str()).contains("b = -1"));
+    EXPECT_TRUE(StringRef(os.str()).contains("array = array<i64: -33>"));
+  }
+  op->erase();
+}
+
+TEST(OpPropertiesTest, Cloning) {
+  MLIRContext context;
+  context.getOrLoadDialect<TestOpPropertiesDialect>();
+  ParserConfig config(&context);
+  // Parse the operation with some properties.
+  OwningOpRef<Operation *> op = parseSourceString(mlirSrc, config);
+  ASSERT_TRUE(op.get() != nullptr);
+  auto opWithProp = dyn_cast<OpWithProperties>(op.get());
+  ASSERT_TRUE(opWithProp);
+  Operation *clone = opWithProp->clone();
+
+  // Check that op and its clone prints equally
+  std::string opStr;
+  std::string cloneStr;
+  {
+    llvm::raw_string_ostream os(opStr);
+    op.get()->print(os);
+  }
+  {
+    llvm::raw_string_ostream os(cloneStr);
+    clone->print(os);
+  }
+  clone->erase();
+  EXPECT_STREQ(opStr.c_str(), cloneStr.c_str());
+}
+
+TEST(OpPropertiesTest, Equivalence) {
+  MLIRContext context;
+  context.getOrLoadDialect<TestOpPropertiesDialect>();
+  ParserConfig config(&context);
+  // Parse the operation with some properties.
+  OwningOpRef<Operation *> op = parseSourceString(mlirSrc, config);
+  ASSERT_TRUE(op.get() != nullptr);
+  auto opWithProp = dyn_cast<OpWithProperties>(op.get());
+  ASSERT_TRUE(opWithProp);
+  llvm::hash_code reference = OperationEquivalence::computeHash(opWithProp);
+  TestProperties &prop = opWithProp.getProperties();
+  prop.a = 42;
+  EXPECT_NE(reference, OperationEquivalence::computeHash(opWithProp));
+  prop.a = -42;
+  EXPECT_EQ(reference, OperationEquivalence::computeHash(opWithProp));
+  prop.b = 42.;
+  EXPECT_NE(reference, OperationEquivalence::computeHash(opWithProp));
+  prop.b = -42.;
+  EXPECT_EQ(reference, OperationEquivalence::computeHash(opWithProp));
+  prop.array.push_back(42);
+  EXPECT_NE(reference, OperationEquivalence::computeHash(opWithProp));
+  prop.array.pop_back();
+  EXPECT_EQ(reference, OperationEquivalence::computeHash(opWithProp));
+}
+
+TEST(OpPropertiesTest, getOrAddProperties) {
+  MLIRContext context;
+  context.getOrLoadDialect<TestOpPropertiesDialect>();
+  OperationState state(UnknownLoc::get(&context),
+                       "test_op_properties.op_with_properties");
+  // Test `getOrAddProperties` API on OperationState.
+  TestProperties &prop = state.getOrAddProperties<TestProperties>();
+  prop.a = 1;
+  prop.b = 2;
+  prop.array = {3, 4, 5};
+  Operation *op = Operation::create(state);
+  ASSERT_TRUE(op != nullptr);
+  {
+    std::string output;
+    llvm::raw_string_ostream os(output);
+    op->print(os);
+    EXPECT_TRUE(StringRef(os.str()).contains("a = 1"));
+    EXPECT_TRUE(StringRef(os.str()).contains("b = 2"));
+    EXPECT_TRUE(StringRef(os.str()).contains("array = array<i64: 3, 4, 5>"));
+  }
+  op->erase();
+}
+
+} // namespace