[mlir][irdl] NFC: Ensure ops ends with `Op` suffix

[math-fehr]

Summary

IRDL operations were inconsistent in their naming. They now
all end with the Op suffix.

[jpienaar]

(I still want an ODS lint mode :))

[math-fehr]

core: Update to main

mlir/include/mlir/Dialect/IRDL/IR/IRDLOps.td

 // IRDL Constraint operations
 //===----------------------------------------------------------------------===//
 
 class IRDL_ConstraintOp<string mnemonic, list<Trait> traits = []>
     : IRDL_Op<mnemonic, [VerifyConstraintInterface,
         DeclareOpInterfaceMethods<VerifyConstraintInterface>] # traits> {
 }
 
-def IRDL_Is : IRDL_ConstraintOp<"is",
+def IRDL_IsOp : IRDL_ConstraintOp<"is",
     [ParentOneOf<["TypeOp", "AttributeOp", "OperationOp"]>, Pure]> {
   let summary = "Constraints an attribute/type to be a specific attribute instance";
   let description = [{
     `irdl.is` defines a constraint that only accepts a specific instance of a
     type or attribute.
 
     Example:
 
let description = [{
     that can only have a `i32` as its parameter.
   }];
 
   let arguments = (ins AnyAttr:$expected);
   let results = (outs IRDL_AttributeType:$output);
   let assemblyFormat = " $expected ` ` attr-dict ";
 }
 
-def IRDL_Parametric : IRDL_ConstraintOp<"parametric",
+def IRDL_ParametricOp : IRDL_ConstraintOp<"parametric",
     [ParentOneOf<["TypeOp", "AttributeOp", "OperationOp"]>, Pure]> {
   let summary = "Constraints an attribute/type base and its parameters";
   let description = [{
     `irdl.parametric` defines a constraint that accepts only a single type
     or attribute base. The attribute base is defined by a symbolic reference
     to the corresponding definition. It will additionally constraint the
     parameters of the type/attribute.
 
def IRDL_ParametricOp : IRDL_ConstraintOp<"parametric",
   }];
 
   let arguments = (ins SymbolRefAttr:$base_type,
                        Variadic<IRDL_AttributeType>:$args);
   let results = (outs IRDL_AttributeType:$output);
   let assemblyFormat = " $base_type `<` $args `>` ` ` attr-dict ";
 }
 
-def IRDL_Any : IRDL_ConstraintOp<"any",
+def IRDL_AnyOp : IRDL_ConstraintOp<"any",
     [ParentOneOf<["TypeOp", "AttributeOp", "OperationOp"]>]> {
   let summary = "Accept any type or attribute";
   let description = [{
     `irdl.any` defines a constraint that accepts any type or attribute.
 
     Example:
 
     ```mlir
     irdl.dialect @cmath {
       irdl.type @complex_flexible {
         %0 = irdl.any
         irdl.parameters(%0)
       }
     }
     ```
 
     The above program defines a type `complex_flexible` inside the dialect
     `cmath` that has a single parameter that can be any attribute.
   }];
 
   let results = (outs IRDL_AttributeType:$output);
   let assemblyFormat = " attr-dict ";
 }
 
-def IRDL_AnyOf : IRDL_ConstraintOp<"any_of",
+def IRDL_AnyOfOp : IRDL_ConstraintOp<"any_of",
                   [ParentOneOf<["TypeOp", "AttributeOp", "OperationOp"]>,
                    SameOperandsAndResultType]> {
   let summary = "Constraints to the union of the provided constraints";
   let description = [{
     `irdl.any_of` defines a constraint that accepts any type or attribute that
     satisfies at least one of its provided type constraints.
 
     Example:
let description = [{
     `f32`.
   }];
 
   let arguments = (ins Variadic<IRDL_AttributeType>:$args);
   let results = (outs IRDL_AttributeType:$output);
   let assemblyFormat = [{ `(` $args `)` ` ` attr-dict }];
 }
 
-def IRDL_AllOf : IRDL_ConstraintOp<"all_of",
+def IRDL_AllOfOp : IRDL_ConstraintOp<"all_of",
                  [ParentOneOf<["TypeOp", "AttributeOp", "OperationOp"]>,
                   SameOperandsAndResultType]> {
   let summary = "Constraints to the intersection of the provided constraints";
   let description = [{
     `irdl.all_of` defines a constraint that accepts any type or attribute that
     satisfies all of its provided constraints.
 
     Example:

mlir/lib/Dialect/IRDL/IR/IRDLOps.cpp

 //===- IRDLOps.cpp - IRDL dialect -------------------------------*- C++ -*-===//
 //
 // This file is licensed 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/Dialect/IRDL/IR/IRDL.h"
 
 using namespace mlir;
 using namespace mlir::irdl;
 
-std::unique_ptr<Constraint> Is::getVerifier(
+std::unique_ptr<Constraint> IsOp::getVerifier(
     ArrayRef<Value> valueToConstr,
     DenseMap<TypeOp, std::unique_ptr<DynamicTypeDefinition>> const &types,
     DenseMap<AttributeOp, std::unique_ptr<DynamicAttrDefinition>> const
         &attrs) {
   return std::make_unique<IsConstraint>(getExpectedAttr());
 }
 
-std::unique_ptr<Constraint> Parametric::getVerifier(
+std::unique_ptr<Constraint> ParametricOp::getVerifier(
     ArrayRef<Value> valueToConstr,
     DenseMap<TypeOp, std::unique_ptr<DynamicTypeDefinition>> const &types,
     DenseMap<AttributeOp, std::unique_ptr<DynamicAttrDefinition>> const
         &attrs) {
   SmallVector<unsigned> constraints;
   for (Value arg : getArgs()) {
     for (auto [i, value] : enumerate(valueToConstr)) {
       if (value == arg) {
std::unique_ptr<Constraint> ParametricOp::getVerifier(
   if (auto attrOp = dyn_cast<AttributeOp>(defOp))
     return std::make_unique<DynParametricAttrConstraint>(attrs.at(attrOp).get(),
                                                          constraints);
 
   llvm_unreachable("verifier should ensure that the referenced operation is "
                    "either a type or an attribute definition");
 }
 
-std::unique_ptr<Constraint> AnyOf::getVerifier(
+std::unique_ptr<Constraint> AnyOfOp::getVerifier(
     ArrayRef<Value> valueToConstr,
     DenseMap<TypeOp, std::unique_ptr<DynamicTypeDefinition>> const &types,
     DenseMap<AttributeOp, std::unique_ptr<DynamicAttrDefinition>> const
         &attrs) {
   SmallVector<unsigned> constraints;
   for (Value arg : getArgs()) {
     for (auto [i, value] : enumerate(valueToConstr)) {
       if (value == arg) {
         constraints.push_back(i);
         break;
       }
     }
   }
 
   return std::make_unique<AnyOfConstraint>(constraints);
 }
 
-std::unique_ptr<Constraint> AllOf::getVerifier(
+std::unique_ptr<Constraint> AllOfOp::getVerifier(
     ArrayRef<Value> valueToConstr,
     DenseMap<TypeOp, std::unique_ptr<DynamicTypeDefinition>> const &types,
     DenseMap<AttributeOp, std::unique_ptr<DynamicAttrDefinition>> const
         &attrs) {
   SmallVector<unsigned> constraints;
   for (Value arg : getArgs()) {
     for (auto [i, value] : enumerate(valueToConstr)) {
       if (value == arg) {
         constraints.push_back(i);
         break;
       }
     }
   }
 
   return std::make_unique<AllOfConstraint>(constraints);
 }
 
-std::unique_ptr<Constraint> Any::getVerifier(
+std::unique_ptr<Constraint> AnyOp::getVerifier(
     ArrayRef<Value> valueToConstr,
     DenseMap<TypeOp, std::unique_ptr<DynamicTypeDefinition>> const &types,
     DenseMap<AttributeOp, std::unique_ptr<DynamicAttrDefinition>> const
         &attrs) {
   return std::make_unique<AnyAttributeConstraint>();
 }

mlir/lib/Dialect/IRDL/IRDLLoading.cpp

 /// - `paramIds`: the set of type or attribute IDs that are used as bases.
 /// - `paramIrdlOps`: the set of IRDL operations that are used as bases.
 /// - `isIds`: the set of type or attribute IDs that are used in `irdl.is`
 ///   constraints.
 static bool getBases(Operation *op, SmallPtrSet<TypeID, 4> &paramIds,
                      SmallPtrSet<Operation *, 4> &paramIrdlOps,
                      SmallPtrSet<TypeID, 4> &isIds) {
   // For `irdl.any_of`, we get the bases from all its arguments.
-  if (auto anyOf = dyn_cast<AnyOf>(op)) {
+  if (auto anyOf = dyn_cast<AnyOfOp>(op)) {
     bool has_any = false;
     for (Value arg : anyOf.getArgs())
       has_any &= getBases(arg.getDefiningOp(), paramIds, paramIrdlOps, isIds);
     return has_any;
   }
 
   // For `irdl.all_of`, we get the bases from the first argument.
   // This is restrictive, but we can relax it later if needed.
-  if (auto allOf = dyn_cast<AllOf>(op))
+  if (auto allOf = dyn_cast<AllOfOp>(op))
     return getBases(allOf.getArgs()[0].getDefiningOp(), paramIds, paramIrdlOps,
                     isIds);
 
   // For `irdl.parametric`, we get directly the base from the operation.
-  if (auto params = dyn_cast<Parametric>(op)) {
+  if (auto params = dyn_cast<ParametricOp>(op)) {
     SymbolRefAttr symRef = params.getBaseType();
     Operation *defOp = SymbolTable::lookupNearestSymbolFrom(op, symRef);
     assert(defOp && "symbol reference should refer to an existing operation");
     paramIrdlOps.insert(defOp);
     return false;
   }
 
   // For `irdl.is`, we get the base TypeID directly.
-  if (auto is = dyn_cast<Is>(op)) {
+  if (auto is = dyn_cast<IsOp>(op)) {
     Attribute expected = is.getExpected();
     isIds.insert(expected.getTypeID());
     return false;
   }
 
   // For `irdl.any`, we return `false` since we can match any type or attribute
   // base.
-  if (auto isA = dyn_cast<Any>(op))
+  if (auto isA = dyn_cast<AnyOp>(op))
     return true;
 
   llvm_unreachable("unknown IRDL constraint");
 }
 
 /// Check that an any_of is in the subset IRDL can handle.
 /// IRDL uses a greedy algorithm to match constraints. This means that if we
 /// encounter an `any_of` with multiple constraints, we will match the first
 /// constraint that is satisfied. Thus, the order of constraints matter in
 /// `any_of` with our current algorithm.
 /// In order to make the order of constraints irrelevant, we require that
 /// all `any_of` constraint parameters are disjoint. For this, we check that
 /// the base parameters are all disjoints between `parametric` operations, and
 /// that they are disjoint between `parametric` and `is` operations.
 /// This restriction will be relaxed in the future, when we will change our
 /// algorithm to be non-greedy.
-static LogicalResult checkCorrectAnyOf(AnyOf anyOf) {
+static LogicalResult checkCorrectAnyOf(AnyOfOp anyOf) {
   SmallPtrSet<TypeID, 4> paramIds;
   SmallPtrSet<Operation *, 4> paramIrdlOps;
   SmallPtrSet<TypeID, 4> isIds;
 
   for (Value arg : anyOf.getArgs()) {
     Operation *argOp = arg.getDefiningOp();
     SmallPtrSet<TypeID, 4> argParamIds;
     SmallPtrSet<Operation *, 4> argParamIrdlOps;
op.walk([&](AttributeOp attrOp) {
     attrDefs.try_emplace(attrOp, std::move(attrDef));
   });
   return attrDefs;
 }
 
 LogicalResult mlir::irdl::loadDialects(ModuleOp op) {
   // First, check that all any_of constraints are in a correct form.
   // This is to ensure we can do the verification correctly.
-  WalkResult anyOfCorrects =
-      op.walk([](AnyOf anyOf) { return (WalkResult)checkCorrectAnyOf(anyOf); });
+  WalkResult anyOfCorrects = op.walk(
+      [](AnyOfOp anyOf) { return (WalkResult)checkCorrectAnyOf(anyOf); });
   if (anyOfCorrects.wasInterrupted())
     return op.emitError("any_of constraints are not in the correct form");
 
   // Preallocate all dialects, and type and attribute definitions.
   // In particular, this allocates TypeIDs so type and attributes can have
   // verifiers that refer to each other.
   DenseMap<DialectOp, ExtensibleDialect *> dialects = loadEmptyDialects(op);
   DenseMap<TypeOp, std::unique_ptr<DynamicTypeDefinition>> types =