[mlir] Move attr -> properties to not require Operation

[jpienaar]

Summary

This allows for converting before/without an Operation is created.

[jpienaar]

Fix missed order change

[jpienaar]

One more ...

[mehdi_amini]

Nice: surprisingly small patch :)

mlir/include/mlir/IR/ExtensibleDialect.h

 
 #ifndef MLIR_IR_EXTENSIBLEDIALECT_H
 #define MLIR_IR_EXTENSIBLEDIALECT_H
 
 #include "mlir/IR/Dialect.h"
 #include "mlir/IR/DialectInterface.h"
 #include "mlir/IR/MLIRContext.h"
 #include "mlir/IR/OpDefinition.h"
+#include "mlir/IR/OperationSupport.h"
 #include "mlir/Support/TypeID.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/Support/ErrorHandling.h"
 #include <optional>
 
 namespace mlir {
 class AsmParser;
 class AsmPrinter;
public:
   }
   int getOpPropertyByteSize() final { return 0; }
   void initProperties(OperationName opName, OpaqueProperties storage,
                       OpaqueProperties init) final {}
   void deleteProperties(OpaqueProperties prop) final {}
   void populateDefaultProperties(OperationName opName,
                                  OpaqueProperties properties) final {}
 
-  LogicalResult setPropertiesFromAttr(Operation *op, Attribute attr,
+  LogicalResult setPropertiesFromAttr(OperationName opName,
+                                      OpaqueProperties properties,
+                                      Attribute attr,
                                       InFlightDiagnostic *diag) final {
     return failure();
   }
   Attribute getPropertiesAsAttr(Operation *op) final { return {}; }
   void copyProperties(OpaqueProperties lhs, OpaqueProperties rhs) final {}
   llvm::hash_code hashProperties(OpaqueProperties prop) final { return {}; }
 
 private:

mlir/include/mlir/IR/OperationSupport.h

struct InterfaceConcept {
     verifyInherentAttrs(OperationName opName, NamedAttrList &attributes,
                         function_ref<InFlightDiagnostic()> getDiag) = 0;
     virtual int getOpPropertyByteSize() = 0;
     virtual void initProperties(OperationName opName, OpaqueProperties storage,
                                 OpaqueProperties init) = 0;
     virtual void deleteProperties(OpaqueProperties) = 0;
     virtual void populateDefaultProperties(OperationName opName,
                                            OpaqueProperties properties) = 0;
-    virtual LogicalResult setPropertiesFromAttr(Operation *, Attribute,
+    virtual LogicalResult setPropertiesFromAttr(OperationName, OpaqueProperties,
+                                                Attribute,
                                                 InFlightDiagnostic *) = 0;
     virtual Attribute getPropertiesAsAttr(Operation *) = 0;
     virtual void copyProperties(OpaqueProperties, OpaqueProperties) = 0;
     virtual llvm::hash_code hashProperties(OpaqueProperties) = 0;
   };
 
 public:
   class Impl : public InterfaceConcept {
struct UnregisteredOpModel : public Impl {
     verifyInherentAttrs(OperationName opName, NamedAttrList &attributes,
                         function_ref<InFlightDiagnostic()> getDiag) final;
     int getOpPropertyByteSize() final;
     void initProperties(OperationName opName, OpaqueProperties storage,
                         OpaqueProperties init) final;
     void deleteProperties(OpaqueProperties) final;
     void populateDefaultProperties(OperationName opName,
                                    OpaqueProperties properties) final;
-    LogicalResult setPropertiesFromAttr(Operation *, Attribute,
-                                        InFlightDiagnostic *) final;
+    LogicalResult setPropertiesFromAttr(OperationName, OpaqueProperties,
+                                        Attribute, InFlightDiagnostic *) final;
     Attribute getPropertiesAsAttr(Operation *) final;
     void copyProperties(OpaqueProperties, OpaqueProperties) final;
     llvm::hash_code hashProperties(OpaqueProperties) final;
   };
 
 public:
   OperationName(StringRef name, MLIRContext *context);
 
public:
 
   /// 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,
+  setOpPropertiesFromAttribute(OperationName opName,
+                               OpaqueProperties properties, Attribute attr,
                                InFlightDiagnostic *diagnostic) const {
-    return getImpl()->setPropertiesFromAttr(op, properties, diagnostic);
+    return getImpl()->setPropertiesFromAttr(opName, properties, attr,
+                                            diagnostic);
   }
 
   void copyOpProperties(OpaqueProperties lhs, OpaqueProperties rhs) const {
     return getImpl()->copyProperties(lhs, rhs);
   }
 
   llvm::hash_code hashOpProperties(OpaqueProperties properties) const {
     return getImpl()->hashProperties(properties);
struct Model : public Impl {
     }
     void populateDefaultProperties(OperationName opName,
                                    OpaqueProperties properties) final {
       if constexpr (hasProperties)
         ConcreteOp::populateDefaultProperties(opName,
                                               *properties.as<Properties *>());
     }
 
-    LogicalResult setPropertiesFromAttr(Operation *op, Attribute attr,
+    LogicalResult setPropertiesFromAttr(OperationName opName,
+                                        OpaqueProperties properties,
+                                        Attribute attr,
                                         InFlightDiagnostic *diag) final {
-      if constexpr (hasProperties)
-        return ConcreteOp::setPropertiesFromAttr(
-            cast<ConcreteOp>(op).getProperties(), attr, diag);
+      if constexpr (hasProperties) {
+        auto p = properties.as<Properties *>();
+        return ConcreteOp::setPropertiesFromAttr(*p, attr, diag);
+      }
       if (diag)
         *diag << "This operation does not support properties";
       return failure();
     }
     Attribute getPropertiesAsAttr(Operation *op) final {
       if constexpr (hasProperties) {
         auto concreteOp = cast<ConcreteOp>(op);
         return ConcreteOp::getPropertiesAsAttr(concreteOp->getContext(),

mlir/lib/IR/MLIRContext.cpp

 #include "mlir/IR/BuiltinAttributes.h"
 #include "mlir/IR/BuiltinDialect.h"
 #include "mlir/IR/Diagnostics.h"
 #include "mlir/IR/Dialect.h"
 #include "mlir/IR/ExtensibleDialect.h"
 #include "mlir/IR/IntegerSet.h"
 #include "mlir/IR/Location.h"
 #include "mlir/IR/OpImplementation.h"
+#include "mlir/IR/OperationSupport.h"
 #include "mlir/IR/Types.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/DenseSet.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/StringSet.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/Support/Allocator.h"
 #include "llvm/Support/CommandLine.h"

 }
 void OperationName::UnregisteredOpModel::deleteProperties(
     OpaqueProperties prop) {
   prop.as<Attribute *>()->~Attribute();
 }
 void OperationName::UnregisteredOpModel::populateDefaultProperties(
     OperationName opName, OpaqueProperties properties) {}
 LogicalResult OperationName::UnregisteredOpModel::setPropertiesFromAttr(
-    Operation *op, Attribute attr, InFlightDiagnostic *diag) {
-  *op->getPropertiesStorage().as<Attribute *>() = attr;
+    OperationName opName, OpaqueProperties properties, Attribute attr,
+    InFlightDiagnostic *diag) {
+  *properties.as<Attribute *>() = attr;
   return success();
 }
 Attribute
 OperationName::UnregisteredOpModel::getPropertiesAsAttr(Operation *op) {
   return *op->getPropertiesStorage().as<Attribute *>();
 }
 void OperationName::UnregisteredOpModel::copyProperties(OpaqueProperties lhs,
                                                         OpaqueProperties rhs) {

mlir/lib/IR/Operation.cpp

 LogicalResult
 Operation::setPropertiesFromAttribute(Attribute attr,
                                       InFlightDiagnostic *diagnostic) {
   std::optional<RegisteredOperationName> info = getRegisteredInfo();
   if (LLVM_UNLIKELY(!info)) {
     *getPropertiesStorage().as<Attribute *>() = attr;
     return success();
   }
-  return info->setOpPropertiesFromAttribute(this, attr, diagnostic);
+  return info->setOpPropertiesFromAttribute(
+      this->getName(), attr, this->getPropertiesStorage(), diagnostic);
 }
 
 void Operation::copyProperties(OpaqueProperties rhs) {
   name.copyOpProperties(getPropertiesStorage(), rhs);
 }
 
 llvm::hash_code Operation::hashProperties() {
   return name.hashOpProperties(getPropertiesStorage());