[mlir][IR] Remove the concept of `OperationProperties`

[rriddle]

Summary

These properties were useful for a few things before traits had a better integration story, but don't really carry their weight well these days. Most of these properties are already checked via traits in most of the code. It is better to align the system around traits, and improve the performance/cost of traits in general.

[jpienaar]

mlir/lib/Dialect/Affine/IR/AffineOps.cpp

391

Alternatively a helper function may make this nicer to read

!isKnownIsolatedFromAbove(region->getParentOp())

and it just simply queries the trait.

[silvas]

Nice. Looks good. I assume you checked this doesn't regress anything significantly in practice?

mlir/include/mlir/IR/Operation.h

485

nit: absOp makes me think of mathematical abs. spell out abstractOp

[rriddle]

In D96088#2543833, @silvas wrote:

Nice. Looks good. I assume you checked this doesn't regress anything significantly in practice?

Yeah, for the benchmarks I was running there was no visible change in execution outside of noise.

mlir/lib/Dialect/Affine/IR/AffineOps.cpp

391

I'd prefer to keep this consistent with other traits for now.

[rriddle]

comments

mlir/include/mlir/IR/OpDefinition.h

 
 //===----------------------------------------------------------------------===//
 // Terminator Traits
 
 /// This class provides the API for ops that are known to be terminators.
 template <typename ConcreteType>
 class IsTerminator : public TraitBase<ConcreteType, IsTerminator> {
 public:
-  static AbstractOperation::OperationProperties getTraitProperties() {
-    return static_cast<AbstractOperation::OperationProperties>(
-        OperationProperty::Terminator);
-  }
   static LogicalResult verifyTrait(Operation *op) {
     return impl::verifyIsTerminator(op);
   }
 };
 
 /// This class provides verification for ops that are known to have zero
 /// successors.
 template <typename ConcreteType>

 public:
   static LogicalResult verifyTrait(Operation *op) {
     return impl::verifyResultsAreSignlessIntegerLike(op);
   }
 };
 
 /// This class adds property that the operation is commutative.
 template <typename ConcreteType>
-class IsCommutative : public TraitBase<ConcreteType, IsCommutative> {
-public:
-  static AbstractOperation::OperationProperties getTraitProperties() {
-    return static_cast<AbstractOperation::OperationProperties>(
-        OperationProperty::Commutative);
-  }
-};
+class IsCommutative : public TraitBase<ConcreteType, IsCommutative> {};
 
 /// This class adds property that the operation is an involution.
 /// This means a unary to unary operation "f" that satisfies f(f(x)) = x
 template <typename ConcreteType>
 class IsInvolution : public TraitBase<ConcreteType, IsInvolution> {
 public:
   static LogicalResult verifyTrait(Operation *op) {
     static_assert(ConcreteType::template hasTrait<OneResult>(),

 };
 
 /// This class provides the API for ops that are known to be isolated from
 /// above.
 template <typename ConcreteType>
 class IsIsolatedFromAbove
     : public TraitBase<ConcreteType, IsIsolatedFromAbove> {
 public:
-  static AbstractOperation::OperationProperties getTraitProperties() {
-    return static_cast<AbstractOperation::OperationProperties>(
-        OperationProperty::IsolatedFromAbove);
-  }
   static LogicalResult verifyTrait(Operation *op) {
     for (auto &region : op->getRegions())
       if (!region.isIsolatedFromAbove(op->getLoc()))
         return failure();
     return success();
   }
 };
 

 template <typename TraitTupleT>
 static std::enable_if_t<std::tuple_size<TraitTupleT>::value == 0, LogicalResult>
 foldTraits(Operation *op, ArrayRef<Attribute> operands,
            SmallVectorImpl<OpFoldResult> &results) {
   return failure();
 }
 
 //===----------------------------------------------------------------------===//
-// Trait Properties
-
-/// Trait to check if T provides a `getTraitProperties` method.
-template <typename T, typename... Args>
-using has_get_trait_properties = decltype(T::getTraitProperties());
-template <typename T>
-using detect_has_get_trait_properties =
-    llvm::is_detected<has_get_trait_properties, T>;
-
-/// The internal implementation of `getTraitProperties` below that returns the
-/// OR of invoking `getTraitProperties` on all of the provided trait types `Ts`.
-template <typename... Ts>
-static AbstractOperation::OperationProperties
-getTraitPropertiesImpl(std::tuple<Ts...> *) {
-  AbstractOperation::OperationProperties result = 0;
-  (void)std::initializer_list<int>{(result |= Ts::getTraitProperties(), 0)...};
-  return result;
-}
-
-/// Given a tuple type containing a set of traits that contain a
-/// `getTraitProperties` method, return the OR of all of the results of invoking
-/// those methods.
-template <typename TraitTupleT>
-static AbstractOperation::OperationProperties getTraitProperties() {
-  return getTraitPropertiesImpl((TraitTupleT *)nullptr);
-}
-
-//===----------------------------------------------------------------------===//
 // Trait Verification
 
 /// Trait to check if T provides a `verifyTrait` method.
 template <typename T, typename... Args>
 using has_verify_trait = decltype(T::verifyTrait(std::declval<Operation *>()));
 template <typename T>
 using detect_has_verify_trait = llvm::is_detected<has_verify_trait, T>;
 
private:
   using FoldableTraitsTupleT = typename detail::FilterTypes<
       op_definition_impl::detect_has_any_fold_trait,
       Traits<ConcreteType>...>::type;
   /// A tuple type containing the traits that have a verify function.
   using VerifiableTraitsTupleT =
       typename detail::FilterTypes<op_definition_impl::detect_has_verify_trait,
                                    Traits<ConcreteType>...>::type;
 
-  /// Returns the properties of this operation by combining the properties
-  /// defined by the traits.
-  static AbstractOperation::OperationProperties getOperationProperties() {
-    return op_definition_impl::getTraitProperties<typename detail::FilterTypes<
-        op_definition_impl::detect_has_get_trait_properties,
-        Traits<ConcreteType>...>::type>();
-  }
-
   /// Returns an interface map containing the interfaces registered to this
   /// operation.
   static detail::InterfaceMap getInterfaceMap() {
     return detail::InterfaceMap::template get<Traits<ConcreteType>...>();
   }
 
   /// Return the internal implementations of each of the AbstractOperation
   /// hooks.

mlir/include/mlir/IR/Operation.h

Block *getSuccessor(unsigned index) {
     return getBlockOperands()[index].get();
   }
   void setSuccessor(Block *block, unsigned index);
 
   //===--------------------------------------------------------------------===//
   // Accessors for various properties of operations
   //===--------------------------------------------------------------------===//
 
-  /// Returns whether the operation is commutative.
-  bool isCommutative() {
-    if (auto *absOp = getAbstractOperation())
-      return absOp->hasProperty(OperationProperty::Commutative);
-    return false;
-  }
-
-  /// Represents the status of whether an operation is a terminator. We
-  /// represent an 'unknown' status because we want to support unregistered
-  /// terminators.
-  enum class TerminatorStatus { Terminator, NonTerminator, Unknown };
-
-  /// Returns the status of whether this operation is a terminator or not.
-  TerminatorStatus getTerminatorStatus() {
-    if (auto *absOp = getAbstractOperation()) {
-      return absOp->hasProperty(OperationProperty::Terminator)
-                 ? TerminatorStatus::Terminator
-                 : TerminatorStatus::NonTerminator;
-    }
-    return TerminatorStatus::Unknown;
-  }
-
-  /// Returns true if the operation is known to be a terminator.
-  bool isKnownTerminator() {
-    return getTerminatorStatus() == TerminatorStatus::Terminator;
-  }
-
-  /// Returns true if the operation is known to *not* be a terminator.
-  bool isKnownNonTerminator() {
-    return getTerminatorStatus() == TerminatorStatus::NonTerminator;
-  }
-
-  /// Returns true if the operation is known to be completely isolated from
-  /// enclosing regions, i.e., no internal regions reference values defined
-  /// above this operation.
-  bool isKnownIsolatedFromAbove() {
-    if (auto *absOp = getAbstractOperation())
-      return absOp->hasProperty(OperationProperty::IsolatedFromAbove);
-    return false;
-  }
-
   /// Attempt to fold this operation with the specified constant operand values
   /// - the elements in "operands" will correspond directly to the operands of
   /// the operation, but may be null if non-constant. If folding is successful,
   /// this fills in the `results` vector. If not, `results` is unspecified.
   LogicalResult fold(ArrayRef<Attribute> operands,
                      SmallVectorImpl<OpFoldResult> &results);
 
   /// Returns true if the operation was registered with a particular trait, e.g.
   /// hasTrait<OperandsAreSignlessIntegerLike>().
   template <template <typename T> class Trait> bool hasTrait() {
-    auto *absOp = getAbstractOperation();
-    return absOp ? absOp->hasTrait<Trait>() : false;
+    const AbstractOperation *abstractOp = getAbstractOperation();
+    return abstractOp ? abstractOp->hasTrait<Trait>() : false;
+  }
+
+  /// Returns true if the operation is *might* have the provided trait. This
+  /// means that either the operation is unregistered, or it was registered with
+  /// the provide trait.
+  template <template <typename T> class Trait> bool mightHaveTrait() {
+    const AbstractOperation *abstractOp = getAbstractOperation();
+    return abstractOp ? abstractOp->hasTrait<Trait>() : true;
   }
 
   //===--------------------------------------------------------------------===//
   // Operation Walkers
   //===--------------------------------------------------------------------===//
 
   /// Walk the operation in postorder, calling the callback for each nested
   /// operation(including this one). The callback method can take any of the
   /// following forms:
   ///   void(Operation*) : Walk all operations opaquely.
   ///     * op->walk([](Operation *nestedOp) { ...});
   ///   void(OpT) : Walk all operations of the given derived type.
   ///     * op->walk([](ReturnOp returnOp) { ...});
   ///   WalkResult(Operation*|OpT) : Walk operations, but allow for
   ///                                interruption/cancellation.
   ///     * op->walk([](... op) {

mlir/include/mlir/IR/OperationSupport.h

 template <typename ValueRangeT> class ValueTypeRange;
 
 class OwningRewritePatternList;
 
 //===----------------------------------------------------------------------===//
 // AbstractOperation
 //===----------------------------------------------------------------------===//
 
-enum class OperationProperty {
-  /// This bit is set for an operation if it is a commutative
-  /// operation: that is an operator where order of operands does not
-  /// change the result of the operation.  For example, in a binary
-  /// commutative operation, "a op b" and "b op a" produce the same
-  /// results.
-  Commutative = 0x1,
-
-  /// This bit is set for an operation if it is a terminator: that means
-  /// an operation at the end of a block.
-  Terminator = 0x2,
-
-  /// This bit is set for operations that are completely isolated from above.
-  /// This is used for operations whose regions are explicit capture only, i.e.
-  /// they are never allowed to implicitly reference values defined above the
-  /// parent operation.
-  IsolatedFromAbove = 0x4,
-};
-
 /// 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
 /// the concrete operation types.
 class AbstractOperation {
 public:
-  using OperationProperties = uint32_t;
-
   using GetCanonicalizationPatternsFn = void (*)(OwningRewritePatternList &,
                                                  MLIRContext *);
   using FoldHookFn = LogicalResult (*)(Operation *, ArrayRef<Attribute>,
                                        SmallVectorImpl<OpFoldResult> &);
   using HasTraitFn = bool (*)(TypeID);
   using ParseAssemblyFn = ParseResult (*)(OpAsmParser &, OperationState &);
   using PrintAssemblyFn = void (*)(Operation *, OpAsmPrinter &);
   using VerifyInvariantsFn = LogicalResult (*)(Operation *);
public:
 
   /// This hook returns any canonicalization pattern rewrites that the operation
   /// supports, for use by the canonicalization pass.
   void getCanonicalizationPatterns(OwningRewritePatternList &results,
                                    MLIRContext *context) const {
     return getCanonicalizationPatternsFn(results, context);
   }
 
-  /// Returns whether the operation has a particular property.
-  bool hasProperty(OperationProperty property) const {
-    return opProperties & static_cast<OperationProperties>(property);
-  }
-
   /// Returns an instance of the concept object for the given interface if it
   /// was registered to this operation, null otherwise. This should not be used
   /// directly.
   template <typename T> typename T::Concept *getInterface() const {
     return interfaceMap.lookup<T>();
   }
 
   /// Returns true if the operation has a particular trait.
   template <template <typename T> class Trait> bool hasTrait() const {
     return hasTraitFn(TypeID::get<Trait>());
   }
 
   /// Look up the specified operation in the specified MLIRContext and return a
   /// pointer to it if present.  Otherwise, return a null pointer.
   static const AbstractOperation *lookup(StringRef opName,
                                          MLIRContext *context);
 
   /// This constructor is used by Dialect objects when they register the list of
   /// operations they contain.
   template <typename T> static void insert(Dialect &dialect) {
-    insert(T::getOperationName(), dialect, T::getOperationProperties(),
-           TypeID::get<T>(), T::getParseAssemblyFn(), T::getPrintAssemblyFn(),
+    insert(T::getOperationName(), dialect, TypeID::get<T>(),
+           T::getParseAssemblyFn(), T::getPrintAssemblyFn(),
            T::getVerifyInvariantsFn(), T::getFoldHookFn(),
            T::getGetCanonicalizationPatternsFn(), T::getInterfaceMap(),
            T::getHasTraitFn());
   }
 
 private:
-  static void insert(StringRef name, Dialect &dialect,
-                     OperationProperties opProperties, TypeID typeID,
+  static void insert(StringRef name, Dialect &dialect, TypeID typeID,
                      ParseAssemblyFn parseAssembly,
                      PrintAssemblyFn printAssembly,
                      VerifyInvariantsFn verifyInvariants, FoldHookFn foldHook,
                      GetCanonicalizationPatternsFn getCanonicalizationPatterns,
                      detail::InterfaceMap &&interfaceMap, HasTraitFn hasTrait);
 
-  AbstractOperation(StringRef name, Dialect &dialect,
-                    OperationProperties opProperties, TypeID typeID,
+  AbstractOperation(StringRef name, Dialect &dialect, TypeID typeID,
                     ParseAssemblyFn parseAssembly,
                     PrintAssemblyFn printAssembly,
                     VerifyInvariantsFn verifyInvariants, FoldHookFn foldHook,
                     GetCanonicalizationPatternsFn getCanonicalizationPatterns,
                     detail::InterfaceMap &&interfaceMap, HasTraitFn hasTrait);
 
-  /// The properties of the operation.
-  const OperationProperties opProperties;
-
   /// A map of interfaces that were registered to this operation.
   detail::InterfaceMap interfaceMap;
 
   /// Internal callback hooks provided by the op implementation.
   FoldHookFn foldHookFn;
   GetCanonicalizationPatternsFn getCanonicalizationPatternsFn;
   HasTraitFn hasTraitFn;
   ParseAssemblyFn parseAssemblyFn;

mlir/lib/CAPI/IR/IR.cpp

MlirOperation mlirBlockGetFirstOperation(MlirBlock block) {
   return wrap(&cppBlock->front());
 }
 
 MlirOperation mlirBlockGetTerminator(MlirBlock block) {
   Block *cppBlock = unwrap(block);
   if (cppBlock->empty())
     return wrap(static_cast<Operation *>(nullptr));
   Operation &back = cppBlock->back();
-  if (!back.isKnownTerminator())
+  if (!back.hasTrait<OpTrait::IsTerminator>())
     return wrap(static_cast<Operation *>(nullptr));
   return wrap(&back);
 }
 
 void mlirBlockAppendOwnedOperation(MlirBlock block, MlirOperation operation) {
   unwrap(block)->push_back(unwrap(operation));
 }
 

mlir/lib/Dialect/Affine/IR/AffineOps.cpp

bool mlir::isValidSymbol(Value value, Region *region) {
   // A top-level value is a valid symbol.
   if (region && ::isTopLevelValue(value, region))
     return true;
 
   auto *defOp = value.getDefiningOp();
   if (!defOp) {
     // A block argument that is not a top-level value is a valid symbol if it
     // dominates region's parent op.
-    if (region && !region->getParentOp()->isKnownIsolatedFromAbove())
+    Operation *regionOp = region ? region->getParentOp() : nullptr;
+    if (regionOp && !regionOp->hasTrait<OpTrait::IsIsolatedFromAbove>())
       if (auto *parentOpRegion = region->getParentOp()->getParentRegion())
         return isValidSymbol(value, parentOpRegion);
     return false;
   }
 
   // Constant operation is ok.
   Attribute operandCst;
   if (matchPattern(defOp, m_Constant(&operandCst)))
     return true;
 
   // Affine apply operation is ok if all of its operands are ok.
   if (auto applyOp = dyn_cast<AffineApplyOp>(defOp))
     return applyOp.isValidSymbol(region);
 
   // Dim op results could be valid symbols at any level.
   if (auto dimOp = dyn_cast<DimOp>(defOp))
     return isDimOpValidSymbol(dimOp, region);
 
   // Check for values dominating `region`'s parent op.
-  if (region && !region->getParentOp()->isKnownIsolatedFromAbove())
+  Operation *regionOp = region ? region->getParentOp() : nullptr;
+  if (regionOp && !regionOp->hasTrait<OpTrait::IsIsolatedFromAbove>())
     if (auto *parentRegion = region->getParentOp()->getParentRegion())
       return isValidSymbol(value, parentRegion);
 
   return false;
 }
 
 // Returns true if 'value' is a valid index to an affine operation (e.g.
 // affine.load, affine.store, affine.dma_start, affine.dma_wait) where

mlir/lib/Dialect/Affine/Transforms/AffineDataCopyGeneration.cpp

if ((forOp = dyn_cast<AffineForOp>(&*it)) && copyNests.count(forOp) == 0) {
       // We simply include this op in the current range and continue for more.
       ++it;
     }
   }
 
   // Generate the copy for the final block range.
   if (curBegin != block->end()) {
     // Can't be a terminator because it would have been skipped above.
-    assert(!curBegin->isKnownTerminator() && "can't be a terminator");
+    assert(!curBegin->hasTrait<OpTrait::IsTerminator>() &&
+           "can't be a terminator");
     // Exclude the affine.yield - hence, the std::prev.
     affineDataCopyGenerate(/*begin=*/curBegin, /*end=*/std::prev(block->end()),
                            copyOptions, /*filterMemRef=*/llvm::None, copyNests);
   }
 
   return success();
 }
 

mlir/lib/Dialect/GPU/Transforms/AsyncRegionRewriter.cpp

 namespace {
 class GpuAsyncRegionPass : public GpuAsyncRegionPassBase<GpuAsyncRegionPass> {
   struct ThreadTokenCallback;
   struct DeferWaitCallback;
   void runOnFunction() override;
 };
 } // namespace
 
-static bool isTerminator(Operation *op) { return !op->isKnownNonTerminator(); }
+static bool isTerminator(Operation *op) {
+  return op->mightHaveTrait<OpTrait::IsTerminator>();
+}
 static bool hasSideEffects(Operation *op) {
   return !MemoryEffectOpInterface::hasNoEffect(op);
 }
 
 // Region walk callback which makes GPU ops implementing the AsyncOpInterface
 // execute asynchronously.
 struct GpuAsyncRegionPass::ThreadTokenCallback {
   ThreadTokenCallback(MLIRContext &context) : builder(&context) {}

mlir/lib/Dialect/StandardOps/Transforms/FuncBufferize.cpp

target.addLegalOp<ModuleOp, ModuleTerminatorOp, TensorLoadOp,
                       TensorToMemrefOp>();
     target.addDynamicallyLegalOp<ReturnOp>(
         [&](ReturnOp op) { return typeConverter.isLegal(op); });
     // Mark terminators as legal if they have the ReturnLike trait or
     // implement the BranchOpInterface and have valid types. If they do not
     // implement the trait or interface, mark them as illegal no matter what.
     target.markUnknownOpDynamicallyLegal([&](Operation *op) {
       // If it is not a terminator, ignore it.
-      if (op->isKnownNonTerminator())
+      if (!op->mightHaveTrait<OpTrait::IsTerminator>())
         return true;
       // If it is not the last operation in the block, also ignore it. We do
       // this to handle unknown operations, as well.
       Block *block = op->getBlock();
       if (!block || &block->back() != op)
         return true;
       // ReturnLike operations have to be legalized with their parent. For
       // return this is handled, for other ops they remain as is.

mlir/lib/EDSC/Builders.cpp

 }
 
 void mlir::edsc::appendToBlock(Block *block,
                                function_ref<void(ValueRange)> builderFn) {
   assert(ScopedContext::getContext() != nullptr && "ScopedContext not set up");
   OpBuilder &builder = ScopedContext::getBuilderRef();
 
   OpBuilder::InsertionGuard guard(builder);
-  if (block->empty() || block->back().isKnownNonTerminator())
+  if (block->empty() || !block->back().mightHaveTrait<OpTrait::IsTerminator>())
     builder.setInsertionPointToEnd(block);
   else
     builder.setInsertionPoint(&block->back());
   builderFn(block->getArguments());
 }
 
 Block *mlir::edsc::buildInNewBlock(TypeRange argTypes,
                                    function_ref<void(ValueRange)> builderFn) {

mlir/lib/IR/AsmPrinter.cpp

unsigned SSANameState::getBlockID(Block *block) {
   auto it = blockIDs.find(block);
   return it != blockIDs.end() ? it->second : NameSentinel;
 }
 
 void SSANameState::shadowRegionArgs(Region &region, ValueRange namesToUse) {
   assert(!region.empty() && "cannot shadow arguments of an empty region");
   assert(region.getNumArguments() == namesToUse.size() &&
          "incorrect number of names passed in");
-  assert(region.getParentOp()->isKnownIsolatedFromAbove() &&
+  assert(region.getParentOp()->hasTrait<OpTrait::IsIsolatedFromAbove>() &&
          "only KnownIsolatedFromAbove ops can shadow names");
 
   SmallVector<char, 16> nameStr;
   for (unsigned i = 0, e = namesToUse.size(); i != e; ++i) {
     auto nameToUse = namesToUse[i];
     if (nameToUse == nullptr)
       continue;
     auto nameToReplace = region.getArgument(i);
void Operation::print(raw_ostream &os, OpPrintingFlags flags) {
   if (!getParent() && !flags.shouldUseLocalScope()) {
     AsmState state(this);
     state.getImpl().initializeAliases(this, flags);
     print(os, state, flags);
     return;
   }
 
   // Find the operation to number from based upon the provided flags.
-  Operation *printedOp = this;
+  Operation *op = this;
   bool shouldUseLocalScope = flags.shouldUseLocalScope();
   do {
     // If we are printing local scope, stop at the first operation that is
     // isolated from above.
-    if (shouldUseLocalScope && printedOp->isKnownIsolatedFromAbove())
+    if (shouldUseLocalScope && op->hasTrait<OpTrait::IsIsolatedFromAbove>())
       break;
 
     // Otherwise, traverse up to the next parent.
-    Operation *parentOp = printedOp->getParentOp();
+    Operation *parentOp = op->getParentOp();
     if (!parentOp)
       break;
-    printedOp = parentOp;
+    op = parentOp;
   } while (true);
 
-  AsmState state(printedOp);
+  AsmState state(op);
   print(os, state, flags);
 }
 void Operation::print(raw_ostream &os, AsmState &state, OpPrintingFlags flags) {
   OperationPrinter printer(os, flags, state.getImpl());
   if (!getParent() && !flags.shouldUseLocalScope())
     printer.printTopLevelOperation(this);
   else
     printer.print(this);

mlir/lib/IR/Block.cpp

 
 //===----------------------------------------------------------------------===//
 // Terminator management
 //===----------------------------------------------------------------------===//
 
 /// Get the terminator operation of this block. This function asserts that
 /// the block has a valid terminator operation.
 Operation *Block::getTerminator() {
-  assert(!empty() && !back().isKnownNonTerminator());
+  assert(!empty() && back().mightHaveTrait<OpTrait::IsTerminator>());
   return &back();
 }
 
 // Indexed successor access.
 unsigned Block::getNumSuccessors() {
   return empty() ? 0 : back().getNumSuccessors();
 }
 

mlir/lib/IR/MLIRContext.cpp

const AbstractOperation *AbstractOperation::lookup(StringRef opName,
   auto &impl = context->getImpl();
   auto it = impl.registeredOperations.find(opName);
   if (it != impl.registeredOperations.end())
     return &it->second;
   return nullptr;
 }
 
 void AbstractOperation::insert(
-    StringRef name, Dialect &dialect, OperationProperties opProperties,
-    TypeID typeID, ParseAssemblyFn parseAssembly, PrintAssemblyFn printAssembly,
+    StringRef name, Dialect &dialect, TypeID typeID,
+    ParseAssemblyFn parseAssembly, PrintAssemblyFn printAssembly,
     VerifyInvariantsFn verifyInvariants, FoldHookFn foldHook,
     GetCanonicalizationPatternsFn getCanonicalizationPatterns,
     detail::InterfaceMap &&interfaceMap, HasTraitFn hasTrait) {
-  AbstractOperation opInfo(name, dialect, opProperties, typeID, parseAssembly,
-                           printAssembly, verifyInvariants, foldHook,
-                           getCanonicalizationPatterns, std::move(interfaceMap),
-                           hasTrait);
+  AbstractOperation opInfo(
+      name, dialect, typeID, parseAssembly, printAssembly, verifyInvariants,
+      foldHook, getCanonicalizationPatterns, std::move(interfaceMap), hasTrait);
 
   auto &impl = dialect.getContext()->getImpl();
   assert(impl.multiThreadedExecutionContext == 0 &&
          "Registering a new operation kind while in a multi-threaded execution "
          "context");
   if (!impl.registeredOperations.insert({name, std::move(opInfo)}).second) {
     llvm::errs() << "error: operation named '" << name
                  << "' is already registered.\n";
     abort();
   }
 }
 
 AbstractOperation::AbstractOperation(
-    StringRef name, Dialect &dialect, OperationProperties opProperties,
-    TypeID typeID, ParseAssemblyFn parseAssembly, PrintAssemblyFn printAssembly,
+    StringRef name, Dialect &dialect, TypeID typeID,
+    ParseAssemblyFn parseAssembly, PrintAssemblyFn printAssembly,
     VerifyInvariantsFn verifyInvariants, FoldHookFn foldHook,
     GetCanonicalizationPatternsFn getCanonicalizationPatterns,
     detail::InterfaceMap &&interfaceMap, HasTraitFn hasTrait)
     : name(Identifier::get(name, dialect.getContext())), dialect(dialect),
-      typeID(typeID), opProperties(opProperties),
-      interfaceMap(std::move(interfaceMap)), foldHookFn(foldHook),
+      typeID(typeID), interfaceMap(std::move(interfaceMap)),
+      foldHookFn(foldHook),
       getCanonicalizationPatternsFn(getCanonicalizationPatterns),
       hasTraitFn(hasTrait), parseAssemblyFn(parseAssembly),
       printAssemblyFn(printAssembly), verifyInvariantsFn(verifyInvariants) {}
 
 //===----------------------------------------------------------------------===//
 // AbstractType
 //===----------------------------------------------------------------------===//
 

mlir/lib/IR/Operation.cpp

Operation *Operation::create(Location location, OperationName name,
   char *mallocMem = reinterpret_cast<char *>(malloc(byteSize + prefixByteSize));
   void *rawMem = mallocMem + prefixByteSize;
 
   // Create the new Operation.
   Operation *op =
       ::new (rawMem) Operation(location, name, resultTypes, numSuccessors,
                                numRegions, attributes, needsOperandStorage);
 
-  assert((numSuccessors == 0 || !op->isKnownNonTerminator()) &&
+  assert((numSuccessors == 0 || op->mightHaveTrait<OpTrait::IsTerminator>()) &&
          "unexpected successors in a non-terminator operation");
 
   // Initialize the results.
   for (unsigned i = 0; i < numInlineResults; ++i)
     new (op->getInlineResult(i)) detail::InLineOpResult();
   for (unsigned i = 0; i < numTrailingResults; ++i)
     new (op->getTrailingResult(i)) detail::TrailingOpResult(i);
 

 void impl::ensureRegionTerminator(
     Region &region, OpBuilder &builder, Location loc,
     function_ref<Operation *(OpBuilder &, Location)> buildTerminatorOp) {
   OpBuilder::InsertionGuard guard(builder);
   if (region.empty())
     builder.createBlock(&region);
 
   Block &block = region.back();
-  if (!block.empty() && block.back().isKnownTerminator())
+  if (!block.empty() && block.back().hasTrait<OpTrait::IsTerminator>())
     return;
 
   builder.setInsertionPointToEnd(&block);
   builder.insert(buildTerminatorOp(builder, loc));
 }
 
 /// Create a simple OpBuilder and forward to the OpBuilder version of this
 /// function.

mlir/lib/IR/Verifier.cpp

if (op.getNumSuccessors() != 0)
       return op.emitError(
           "operation with block successors must terminate its parent block");
 
     if (failed(verifyOperation(op)))
       return failure();
   }
 
   // Verify the terminator.
-  if (failed(verifyOperation(block.back())))
+  Operation &terminator = block.back();
+  if (failed(verifyOperation(terminator)))
     return failure();
-  if (block.back().isKnownNonTerminator())
+  if (!terminator.mightHaveTrait<OpTrait::IsTerminator>())
     return block.back().emitError("block with no terminator");
 
   // Verify that this block is not branching to a block of a different
   // region.
   for (Block *successor : block.getSuccessors())
     if (successor->getParent() != block.getParent())
       return block.back().emitOpError(
           "branching to block of a different region");

mlir/lib/Interfaces/SideEffectInterfaces.cpp

static bool wouldOpBeTriviallyDeadImpl(Operation *rootOp) {
   }
 
   // If we get here, none of the operations had effects that prevented marking
   // 'op' as dead.
   return true;
 }
 
 bool mlir::wouldOpBeTriviallyDead(Operation *op) {
-  if (!op->isKnownNonTerminator())
+  if (op->mightHaveTrait<OpTrait::IsTerminator>())
     return false;
   return wouldOpBeTriviallyDeadImpl(op);
 }

mlir/lib/Parser/Parser.cpp

if (parseToken(Token::l_paren, "expected '(' to start operand list") ||
       parseToken(Token::r_paren, "expected ')' to end operand list")) {
     return nullptr;
   }
 
   // Parse the successor list.
   if (getToken().is(Token::l_square)) {
     // Check if the operation is a known terminator.
     const AbstractOperation *abstractOp = result.name.getAbstractOperation();
-    if (abstractOp && !abstractOp->hasProperty(OperationProperty::Terminator))
+    if (abstractOp && !abstractOp->hasTrait<OpTrait::IsTerminator>())
       return emitError("successors in non-terminator"), nullptr;
 
     SmallVector<Block *, 2> successors;
     if (parseSuccessors(successors))
       return nullptr;
     result.addSuccessors(successors);
   }
 
for (auto pair : llvm::zip(arguments, argTypes)) {
       Type type = std::get<1>(pair);
       OperationParser::SSAUseInfo operandInfo = {operand.name, operand.number,
                                                  operand.location};
       regionArguments.emplace_back(operandInfo, type);
     }
 
     // Try to parse the region.
     assert((!enableNameShadowing ||
-            opDefinition->hasProperty(OperationProperty::IsolatedFromAbove)) &&
+            opDefinition->hasTrait<OpTrait::IsIsolatedFromAbove>()) &&
            "name shadowing is only allowed on isolated regions");
     if (parser.parseRegion(region, regionArguments, enableNameShadowing))
       return failure();
     return success();
   }
 
   /// Parses a region if present.
   OptionalParseResult parseOptionalRegion(Region &region,

mlir/lib/Pass/Pass.cpp

 
 //===----------------------------------------------------------------------===//
 // OpToOpPassAdaptor
 //===----------------------------------------------------------------------===//
 
 LogicalResult OpToOpPassAdaptor::run(Pass *pass, Operation *op,
                                      AnalysisManager am, bool verifyPasses,
                                      unsigned parentInitGeneration) {
-  if (!op->getName().getAbstractOperation())
+  if (!op->isRegistered())
     return op->emitOpError()
            << "trying to schedule a pass on an unregistered operation";
-  if (!op->getName().getAbstractOperation()->hasProperty(
-          OperationProperty::IsolatedFromAbove))
+  if (!op->hasTrait<OpTrait::IsIsolatedFromAbove>())
     return op->emitOpError() << "trying to schedule a pass on an operation not "
                                 "marked as 'IsolatedFromAbove'";
 
   // Initialize the pass state with a callback for the pass to dynamically
   // execute a pipeline on the currently visited operation.
   PassInstrumentor *pi = am.getPassInstrumentor();
   PassInstrumentation::PipelineParentInfo parentInfo = {llvm::get_threadid(),
                                                         pass};

mlir/lib/Target/LLVMIR/ModuleTranslation.cpp

LogicalResult ModuleTranslation::convertOneFunction(LLVMFuncOp func) {
   // Finally, after all blocks have been traversed and values mapped, connect
   // the PHI nodes to the results of preceding blocks.
   connectPHINodes(func, valueMapping, blockMapping, branchMapping);
   return success();
 }
 
 LogicalResult ModuleTranslation::checkSupportedModuleOps(Operation *m) {
   for (Operation &o : getModuleBody(m).getOperations())
-    if (!isa<LLVM::LLVMFuncOp, LLVM::GlobalOp>(&o) && !o.isKnownTerminator())
+    if (!isa<LLVM::LLVMFuncOp, LLVM::GlobalOp>(&o) &&
+        !o.hasTrait<OpTrait::IsTerminator>())
       return o.emitOpError("unsupported module-level operation");
   return success();
 }
 
 LogicalResult ModuleTranslation::convertFunctionSignatures() {
   // Declare all functions first because there may be function calls that form a
   // call graph with cycles, or global initializers that reference functions.
   for (auto function : getModuleBody(mlirModule).getOps<LLVMFuncOp>()) {

mlir/lib/Transforms/CSE.cpp

private:
   /// Operations marked as dead and to be erased.
   std::vector<Operation *> opsToErase;
 };
 } // end anonymous namespace
 
 /// Attempt to eliminate a redundant operation.
 LogicalResult CSE::simplifyOperation(ScopedMapTy &knownValues, Operation *op) {
   // Don't simplify terminator operations.
-  if (op->isKnownTerminator())
+  if (op->hasTrait<OpTrait::IsTerminator>())
     return failure();
 
   // If the operation is already trivially dead just add it to the erase list.
   if (isOpTriviallyDead(op)) {
     opsToErase.push_back(op);
     ++numDCE;
     return success();
   }
void CSE::simplifyBlock(ScopedMapTy &knownValues, DominanceInfo &domInfo,
   for (auto &inst : *bb) {
     // If the operation is simplified, we don't process any held regions.
     if (succeeded(simplifyOperation(knownValues, &inst)))
       continue;
 
     // If this operation is isolated above, we can't process nested regions with
     // the given 'knownValues' map. This would cause the insertion of implicit
     // captures in explicit capture only regions.
-    if (!inst.isRegistered() || inst.isKnownIsolatedFromAbove()) {
+    if (inst.mightHaveTrait<OpTrait::IsIsolatedFromAbove>()) {
       ScopedMapTy nestedKnownValues;
       for (auto &region : inst.getRegions())
         simplifyRegion(nestedKnownValues, domInfo, region);
       continue;
     }
 
     // Otherwise, process nested regions normally.
     for (auto &region : inst.getRegions())

mlir/lib/Transforms/Inliner.cpp

struct Inliner : public InlinerInterface {
   SymbolTableCollection &symbolTable;
 };
 } // namespace
 
 /// Returns true if the given call should be inlined.
 static bool shouldInline(ResolvedCall &resolvedCall) {
   // Don't allow inlining terminator calls. We currently don't support this
   // case.
-  if (resolvedCall.call->isKnownTerminator())
+  if (resolvedCall.call->hasTrait<OpTrait::IsTerminator>())
     return false;
 
   // Don't allow inlining if the target is an ancestor of the call. This
   // prevents inlining recursively.
   if (resolvedCall.targetNode->getCallableRegion()->isAncestor(
           resolvedCall.call->getParentRegion()))
     return false;
 
for (auto *node : currentSCC) {
     // handling as we may remove the node during simplification. In the future,
     // we should be able to handle this case with proper node deletion tracking.
     if (node->hasChildren())
       continue;
 
     // We also won't apply simplifications to nodes that can't have passes
     // scheduled on them.
     auto *region = node->getCallableRegion();
-    if (!region->getParentOp()->isKnownIsolatedFromAbove())
+    if (!region->getParentOp()->hasTrait<OpTrait::IsIsolatedFromAbove>())
       continue;
     nodesToVisit.push_back(node);
   }
   if (nodesToVisit.empty())
     return success();
 
   // Optimize each of the nodes within the SCC in parallel.
   // NOTE: This is simple now, because we don't enable optimizing nodes within

mlir/lib/Transforms/SCCP.cpp

for (Value operand : op->getOperands()) {
     // Make sure all of the operands are resolved first.
     auto &operandLattice = latticeValues[operand];
     if (operandLattice.isUnknown())
       return;
     operandConstants.push_back(operandLattice.getConstant());
   }
 
   // If this is a terminator operation, process any control flow lattice state.
-  if (op->isKnownTerminator())
+  if (op->hasTrait<OpTrait::IsTerminator>())
     visitTerminatorOperation(op, operandConstants);
 
   // Process call operations. The call visitor processes result values, so we
   // can exit afterwards.
   if (CallOpInterface call = dyn_cast<CallOpInterface>(op))
     return visitCallOperation(call);
 
   // Process callable operations. These are specially handled region operations

mlir/lib/Transforms/Utils/FoldUtils.cpp

 static Region *
 getInsertionRegion(DialectInterfaceCollection<DialectFoldInterface> &interfaces,
                    Block *insertionBlock) {
   while (Region *region = insertionBlock->getParent()) {
     // Insert in this region for any of the following scenarios:
     //  * The parent is unregistered, or is known to be isolated from above.
     //  * The parent is a top-level operation.
     auto *parentOp = region->getParentOp();
-    if (!parentOp->isRegistered() || parentOp->isKnownIsolatedFromAbove() ||
+    if (parentOp->mightHaveTrait<OpTrait::IsIsolatedFromAbove>() ||
         !parentOp->getBlock())
       return region;
 
     // Otherwise, check if this region is a desired insertion region.
     auto *interface = interfaces.getInterfaceFor(parentOp);
     if (LLVM_UNLIKELY(interface && interface->shouldMaterializeInto(region)))
       return region;
 

 /// `results` with the results of the folding.
 LogicalResult OperationFolder::tryToFold(
     OpBuilder &builder, Operation *op, SmallVectorImpl<Value> &results,
     function_ref<void(Operation *)> processGeneratedConstants) {
   SmallVector<Attribute, 8> operandConstants;
   SmallVector<OpFoldResult, 8> foldResults;
 
   // If this is a commutative operation, move constants to be trailing operands.
-  if (op->getNumOperands() >= 2 && op->isCommutative()) {
+  if (op->getNumOperands() >= 2 && op->hasTrait<OpTrait::IsCommutative>()) {
     std::stable_partition(
         op->getOpOperands().begin(), op->getOpOperands().end(),
         [&](OpOperand &O) { return !matchPattern(O.get(), m_Constant()); });
   }
 
   // Check to see if any operands to the operation is constant and whether
   // the operation knows how to constant fold itself.
   operandConstants.assign(op->getNumOperands(), Attribute());

mlir/lib/Transforms/Utils/GreedyPatternRewriteDriver.cpp

mlir::applyPatternsAndFoldGreedily(MutableArrayRef<Region> regions,
                                    unsigned maxIterations) {
   if (regions.empty())
     return success();
 
   // The top-level operation must be known to be isolated from above to
   // prevent performing canonicalizations on operations defined at or above
   // the region containing 'op'.
   auto regionIsIsolated = [](Region &region) {
-    return region.getParentOp()->isKnownIsolatedFromAbove();
+    return region.getParentOp()->hasTrait<OpTrait::IsIsolatedFromAbove>();
   };
   (void)regionIsIsolated;
   assert(llvm::all_of(regions, regionIsIsolated) &&
          "patterns can only be applied to operations IsolatedFromAbove");
 
   // Start the pattern driver.
   GreedyPatternRewriteDriver driver(regions[0].getContext(), patterns);
   bool converged = driver.simplify(regions, maxIterations);

mlir/lib/Transforms/Utils/RegionUtils.cpp

static bool isUseSpeciallyKnownDead(OpOperand &use, LiveMap &liveMap) {
   // The reason for this is easiest to think about in terms of a classical phi
   // node based SSA IR, where each successor operand is really an operand to a
   // *separate* phi node, rather than all operands to the branch itself as with
   // the block argument representation that MLIR uses.
   //
   // And similarly, because each successor operand is really an operand to a phi
   // node, rather than to the terminator op itself, a terminator op can't e.g.
   // "print" the value of a successor operand.
-  if (owner->isKnownTerminator()) {
+  if (owner->hasTrait<OpTrait::IsTerminator>()) {
     if (BranchOpInterface branchInterface = dyn_cast<BranchOpInterface>(owner))
       if (auto arg = branchInterface.getSuccessorBlockArgument(operandIndex))
         return !liveMap.wasProvenLive(*arg);
     return false;
   }
   return false;
 }
 
 static void processValue(Value value, LiveMap &liveMap) {
   bool provedLive = llvm::any_of(value.getUses(), [&](OpOperand &use) {
     if (isUseSpeciallyKnownDead(use, liveMap))
       return false;
     return liveMap.wasProvenLive(use.getOwner());
   });
   if (provedLive)
     liveMap.setProvedLive(value);
 }
 
 static bool isOpIntrinsicallyLive(Operation *op) {
   // This pass doesn't modify the CFG, so terminators are never deleted.
-  if (!op->isKnownNonTerminator())
+  if (op->mightHaveTrait<OpTrait::IsTerminator>())
     return true;
   // If the op has a side effect, we treat it as live.
   // TODO: Properly handle region side effects.
   return !MemoryEffectOpInterface::hasNoEffect(op) || op->getNumRegions() != 0;
 }
 
 static void propagateLiveness(Region &region, LiveMap &liveMap);
 
static void propagateLiveness(Operation *op, LiveMap &liveMap) {
   // All Value's are either a block argument or an op result.
   // We call processValue on those cases.
 
   // Recurse on any regions the op has.
   for (Region &region : op->getRegions())
     propagateLiveness(region, liveMap);
 
   // Process terminator operations.
-  if (op->isKnownTerminator())
+  if (op->hasTrait<OpTrait::IsTerminator>())
     return propagateTerminatorLiveness(op, liveMap);
 
   // Process the op itself.
   if (isOpIntrinsicallyLive(op)) {
     liveMap.setProvedLive(op);
     return;
   }
   for (Value value : op->getResults())

mlir/test/lib/Dialect/Shape/TestShapeFunctions.cpp

 } // end anonymous namespace
 
 void ReportShapeFnPass::runOnOperation() {
   auto module = getOperation();
 
   // Report the shape function available to refine the op.
   auto shapeFnId = Identifier::get("shape.function", &getContext());
   auto remarkShapeFn = [&](shape::FunctionLibraryOp shapeFnLib, Operation *op) {
-    if (op->isKnownTerminator())
+    if (op->hasTrait<OpTrait::IsTerminator>())
       return true;
     if (auto typeInterface = dyn_cast<InferTypeOpInterface>(op)) {
       op->emitRemark() << "implements InferType op interface";
       return true;
     }
     if (auto fn = shapeFnLib.getShapeFunction(op)) {
       op->emitRemark() << "associated shape function: " << fn.getName();
       return true;

mlir/test/lib/Dialect/Test/TestPatterns.cpp

struct TestSelectiveOpReplacementPattern : public OpRewritePattern<TestCastOp> {
   LogicalResult matchAndRewrite(TestCastOp op,
                                 PatternRewriter &rewriter) const final {
     if (op.getNumOperands() != 2)
       return failure();
     OperandRange operands = op.getOperands();
 
     // Replace non-terminator uses with the first operand.
     rewriter.replaceOpWithIf(op, operands[0], [](OpOperand &operand) {
-      return operand.getOwner()->isKnownTerminator();
+      return operand.getOwner()->hasTrait<OpTrait::IsTerminator>();
     });
     // Replace everything else with the second operand if the operation isn't
     // dead.
     rewriter.replaceOp(op, op.getOperand(1));
     return success();
   }
 };
 

mlir/test/lib/Transforms/TestDynamicPipeline.cpp

if (runOnParent) {
         if (!failed(runPipeline(*pm, currentOp->getParentOp())))
           signalPassFailure();
       return;
     }
 
     if (runOnNestedOp) {
       llvm::errs() << "Run on nested op\n";
       currentOp->walk([&](Operation *op) {
-        if (op == currentOp || !op->isKnownIsolatedFromAbove() ||
+        if (op == currentOp || !op->hasTrait<OpTrait::IsIsolatedFromAbove>() ||
             op->getName() != currentOp->getName())
           return;
         llvm::errs() << "Run on " << *op << "\n";
         // Run on the current operation
         if (failed(runPipeline(*pm, op)))
           signalPassFailure();
       });
     } else {

mlir/test/lib/Transforms/TestOpaqueLoc.cpp

getOperation().walk([&](Operation *op) {
 
       Location loc = op->getLoc();
 
       /// Set opaque location without fallback location to test the
       /// corresponding get method.
       op->setLoc(
           OpaqueLoc::get<MyLocation *>(myLocs.back().get(), &getContext()));
 
-      if (isa<FuncOp>(op) || op->isKnownTerminator())
+      if (isa<FuncOp>(op) || op->hasTrait<OpTrait::IsTerminator>())
         return;
 
       OpBuilder builder(op);
 
       /// Add the same operation but with fallback location to test the
       /// corresponding get method and serialization.
       Operation *op_cloned_1 = builder.clone(*op);
       op_cloned_1->setLoc(