[mlir][pdl] Some ops are missing `NoSideEffect`

[Mogball]

Summary

Querying or building constraints on types, operands, results, and attributes are side-effect free in both the matcher and rewriter. The ops should be marked as such.

mlir/include/mlir/Dialect/PDL/IR/PDLOps.td

let assemblyFormat = [{
     (`:` type($results)^)? attr-dict
   }];
 }
 
 //===----------------------------------------------------------------------===//
 // pdl::AttributeOp
 //===----------------------------------------------------------------------===//
 
-def PDL_AttributeOp : PDL_Op<"attribute"> {
+def PDL_AttributeOp : PDL_Op<"attribute", [NoSideEffect]> {
   let summary = "Define an input attribute in a pattern";
   let description = [{
     `pdl.attribute` operations capture named attribute edges into an operation.
     Instances of this operation define, and partially constrain, attributes of a
     given operation. A `pdl.attribute` may partially constrain the input by
     specifying an expected attribute value type (via a `pdl.type` operation), or
     a constant value for the attribute (via `val`). Only one of these may be set
     for a given input, as the type of the constant value provides the type. When
def PDL_EraseOp : PDL_Op<"erase", [HasParent<"pdl::RewriteOp">]> {
   let assemblyFormat = "$operation attr-dict";
   let verifier = ?;
 }
 
 //===----------------------------------------------------------------------===//
 // pdl::OperandOp
 //===----------------------------------------------------------------------===//
 
-def PDL_OperandOp : PDL_Op<"operand", [HasParent<"pdl::PatternOp">]> {
+def PDL_OperandOp
+    : PDL_Op<"operand", [HasParent<"pdl::PatternOp">, NoSideEffect]> {
   let summary = "Define an external input operand in a pattern";
   let description = [{
     `pdl.operand` operations capture external operand edges into an operation
     node that originate from operations or block arguments not otherwise
     specified within the pattern (i.e. via `pdl.result` or `pdl.results`). These
     operations define individual operands of a given operation. A `pdl.operand`
     may partially constrain an operand by specifying an expected value type
     (via a `pdl.type` operation).
let builders = [
     }]>,
   ];
 }
 
 //===----------------------------------------------------------------------===//
 // pdl::OperandsOp
 //===----------------------------------------------------------------------===//
 
-def PDL_OperandsOp : PDL_Op<"operands", [HasParent<"pdl::PatternOp">]> {
+def PDL_OperandsOp
+    : PDL_Op<"operands", [HasParent<"pdl::PatternOp">, NoSideEffect]> {
   let summary = "Define a range of input operands in a pattern";
   let description = [{
     `pdl.operands` operations capture external operand range edges into an
     operation node that originate from operations or block arguments not
     otherwise specified within the pattern (i.e. via `pdl.result` or
     `pdl.results`). These operations define groups of input operands into a
     given operation. A `pdl.operands` may partially constrain a set of input
     operands by specifying expected value types (via `pdl.types` operations).
let assemblyFormat = [{
     ($replOperation^)? attr-dict
   }];
 }
 
 //===----------------------------------------------------------------------===//
 // pdl::ResultOp
 //===----------------------------------------------------------------------===//
 
-def PDL_ResultOp : PDL_Op<"result"> {
+def PDL_ResultOp : PDL_Op<"result", [NoSideEffect]> {
   let summary = "Extract a result from an operation";
   let description = [{
     `pdl.result` operations extract result edges from an operation node within
     a pattern or rewrite region. The provided index is zero-based, and
     represents the concrete result to extract, i.e. this is not the result index
     as defined by the ODS definition of the operation.
 
     Example:
def PDL_ResultOp : PDL_Op<"result", [NoSideEffect]> {
   let assemblyFormat = "$index `of` $parent attr-dict";
   let verifier = ?;
 }
 
 //===----------------------------------------------------------------------===//
 // pdl::ResultsOp
 //===----------------------------------------------------------------------===//
 
-def PDL_ResultsOp : PDL_Op<"results"> {
+def PDL_ResultsOp : PDL_Op<"results", [NoSideEffect]> {
   let summary = "Extract a result group from an operation";
   let description = [{
     `pdl.results` operations extract a result group from an operation within a
     pattern or rewrite region. If an index is provided, this operation extracts
     a result group as defined by the ODS definition of the operation. In this
     case the result of this operation may be either a single `pdl.value` or
     a `pdl.range<value>`, depending on the constraint of the result in ODS. If
     no index is provided, this operation extracts the full result range of the
let assemblyFormat = [{
     attr-dict-with-keyword
   }];
 }
 
 //===----------------------------------------------------------------------===//
 // pdl::TypeOp
 //===----------------------------------------------------------------------===//
 
-def PDL_TypeOp : PDL_Op<"type"> {
+def PDL_TypeOp : PDL_Op<"type", [NoSideEffect]> {
   let summary = "Define a type handle within a pattern";
   let description = [{
     `pdl.type` operations capture result type constraints of `Attributes`,
     `Values`, and `Operations`. Instances of this operation define, and
     partially constrain, results types of a given entity. A `pdl.type` may
     partially constrain the result by specifying a constant `Type`.
 
     Example:
def PDL_TypeOp : PDL_Op<"type", [NoSideEffect]> {
   let results = (outs PDL_Type:$result);
   let assemblyFormat = "attr-dict (`:` $type^)?";
 }
 
 //===----------------------------------------------------------------------===//
 // pdl::TypesOp
 //===----------------------------------------------------------------------===//
 
-def PDL_TypesOp : PDL_Op<"types"> {
+def PDL_TypesOp : PDL_Op<"types", [NoSideEffect]> {
   let summary = "Define a range of type handles within a pattern";
   let description = [{
     `pdl.types` operations capture result type constraints of `Value`s, and
     `Operation`s. Instances of this operation define results types of a given
     entity. A `pdl.types` may partially constrain the results by specifying
     an array of `Type`s.
 
     Example: