[mlir][PDLL] Allow numeric result indexing for unregistered op

[Chia-hungDuan]

Summary

If we don't specify the result index while matching operand with the
result of certain operation, it's supposed to match all the results of
the operation with the operand. For registered op, it's easy to do that
by either indexing with number or name. For unregistered op, this commit
enables the numeric result indexing for this use case.

[Mogball]

mlir/lib/Tools/PDLL/Parser/Parser.cpp

2687–2688

"Allow unchecked numeric indexing of the results of unregistered operations. It returns a single value."

[rriddle]

Given that we can't know the "result groups" of an unregistered operation, I think defaulting to individual results is fine. That being said, we'll definitely want to document this behavior (given that it means we'll treat registered operations differently from registered). Can you document the handling for unregistered operations in the Accessing Operation Results section of PDLL.md?

mlir/lib/Tools/PDLL/CodeGen/MLIRGen.cpp

448

I don't think sharing this variable is useful given that the branches don't converge, can we just duplicate? Otherwise, I have to follow the control flow to make sure it isn't used in an uninitialized context.

[Chia-hungDuan]

Address review comment and update the op name in the test

mlir/lib/Tools/PDLL/CodeGen/MLIRGen.cpp

448

Yep, that's weird. was changing the structure at the last moment and forgot it. Done

[rriddle]

mlir/docs/PDLL.md

703

Can you have a dedicated sub-section for unregistered operations?

#### Unregistered Operations

...

Just want to make sure this gets the callout that it deserves, so that it isn't potentially lost inside of another paragraph.

[Chia-hungDuan]

Address review comment

mlir/docs/PDLL.md

703

Done, let me know if the description is fine.

[rriddle]

LG, nice.

mlir/docs/PDLL.md

721–722

[Chia-hungDuan]

address review comment

mlir/docs/PDLL.md

 // the first result group of `resultOp`.
 // Note: If we elide the result types section within the match section, it means
 //       they aren't constrained, not that the operation has no results.
 let resultOp = op<my_dialect.result_op>;
 let inputOp = op<my_dialect.input_op>(resultOp.result, resultOp.0);
 ```
 
 Along with result name access, variables of `Op` type may implicitly convert to
-`Value` or `ValueRange`. These variables are converted to `Value` when they are
-known (via ODS) to only have one result, in all other cases they convert to
-`ValueRange`:
+`Value` or `ValueRange`. If these variables are registered (has ODS entry), they
+are converted to `Value` when they are known to only have one result, otherwise
+they will be converted to `ValueRange`. If they are unregistered variables (Note
+that the numeric result indexing is still avaiable on them), given that we don't
+have the knowledge of its result group, it'll always be converted to `Value`.
 
 ```pdll
 // `resultOp` may also convert implicitly to a Value for use in `inputOp`:
 let resultOp = op<my_dialect.result_op>;
 let inputOp = op<my_dialect.input_op>(resultOp);
 
 // We could also inline `resultOp` directly:
 let inputOp = op<my_dialect.input_op>(op<my_dialect.result_op>);
 ```
 
 ### Attribute Expression
 
 An attribute expression represents a literal MLIR attribute. It allows for
 statically specifying an MLIR attribute to use, by specifying the textual form
 of that attribute.
 
 ```pdll
 let trueConstant = op<arith.constant> {value = attr<"true">};
 
 let applyResult = op<affine.apply>(args: ValueRange) {map = attr<"affine_map<(d0, d1) -> (d1 - 3)>">}
 ```
 
 ### Type Expression

mlir/lib/Tools/PDLL/CodeGen/MLIRGen.cpp

if (isa<ast::AllResultsMemberAccessExpr>(expr)) {
       if (mlirType.isa<pdl::ValueType>())
         return builder.create<pdl::ResultOp>(loc, mlirType, parentExprs[0],
                                              builder.getI32IntegerAttr(0));
       return builder.create<pdl::ResultsOp>(loc, mlirType, parentExprs[0]);
     }
 
     assert(opType.getName() && "expected valid operation name");
     const ods::Operation *odsOp = odsContext.lookupOperation(*opType.getName());
-    assert(odsOp && "expected valid ODS operation information");
+
+    if (!odsOp) {
+      assert(llvm::isDigit(name[0]) && "unregistered op only allows numeric indexing");
+      unsigned resultIndex;
+      name.getAsInteger(/*Radix=*/10, resultIndex);
+      IntegerAttr index = builder.getI32IntegerAttr(resultIndex);
+      return builder.create<pdl::ResultOp>(loc, genType(expr->getType()),
+                                            parentExprs[0], index);
+    }
 
     // Find the result with the member name or by index.
     ArrayRef<ods::OperandOrResult> results = odsOp->getResults();
     unsigned resultIndex = results.size();
     if (llvm::isDigit(name[0])) {
       name.getAsInteger(/*Radix=*/10, resultIndex);
     } else {
       auto findFn = [&](const ods::OperandOrResult &result) {

mlir/lib/Tools/PDLL/Parser/Parser.cpp

if (const ods::Operation *odsOp = lookupODSOperation(opType.getName())) {
       }
 
       // Handle named results.
       const auto *it = llvm::find_if(results, [&](const auto &result) {
         return result.getName() == name;
       });
       if (it != results.end())
         return it->isVariadic() ? valueRangeTy : valueTy;
+    } else if (llvm::isDigit(name[0])) {
+      // Allow unchecked numeric indexing of the results of unregistered
+      // operations. It returns a single value.
+      return valueTy;
     }
-
   } else if (auto tupleType = parentType.dyn_cast<ast::TupleType>()) {
     // Handle indexed results.
     unsigned index = 0;
     if (llvm::isDigit(name[0]) && !name.getAsInteger(/*Radix=*/10, index) &&
         index < tupleType.size()) {
       return tupleType.getElementTypes()[index];
     }
 

mlir/test/mlir-pdll/CodeGen/MLIR/expr.pdll

 Pattern OpAllResultMemberAccess {
   let singleVar: Value = op<>;
   let rangeVar: ValueRange = op<>;
   erase op<>(singleVar, rangeVar);
 }
 
 // -----
 
+// Handle result indexing on unregistered op.
+// CHECK: pdl.pattern @UnregisteredOpResultIndexing
+// CHECK: %[[BAR_OP:.*]] = operation "my_dialect.unregisteredBar"
+// CHECK: %[[BAR_RES:.*]] = result 0 of %[[BAR_OP]]
+// CHECK: operation "my_dialect.unregisteredFoo"(%[[BAR_RES]] : !pdl.value)
+Pattern UnregisteredOpResultIndexing {
+  let bar : Op<my_dialect.unregisteredBar>;
+  let op = op<my_dialect.unregisteredFoo>(bar.0);
+  erase op;
+}
+
+// -----
+
 // Handle implicit "named" operation results access.
 
 #include "include/ops.td"
 
 // CHECK: pdl.pattern @OpResultMemberAccess
 // CHECK: %[[OP0:.*]] = operation
 // CHECK: %[[RES:.*]] = results 0 of %[[OP0]] -> !pdl.value
 // CHECK: %[[RES1:.*]] = results 0 of %[[OP0]] -> !pdl.value

mlir/test/mlir-pdll/Parser/expr.pdll

Pattern {
   let firstEltIndex = op.0;
   let firstEltName = op.result;
 
   erase op;
 }
 
 // -----
 
+// CHECK: Module
+// CHECK: `-VariableDecl {{.*}} Name<op> Type<Op<my_dialect.unregisteredFoo>>
+// CHECK:   `-OperationExpr {{.*}} Type<Op<my_dialect.unregisteredFoo>>
+// CHECK:     `-OpNameDecl {{.*}} Name<my_dialect.unregisteredFoo>
+// CHECK:     `Operands`
+// CHECK:       `-MemberAccessExpr {{.*}} Member<0> Type<Value>
+// CHECK:         `-OperationExpr {{.*}} Type<Op<my_dialect.unregisteredBar>>
+// CHECK:           `-OpNameDecl {{.*}} Name<my_dialect.unregisteredBar>
+// CHECK:           `Operands`
+// CHECK:             `-DeclRefExpr {{.*}} Type<ValueRange>
+// CHECK:               `-VariableDecl {{.*}} Name<_> Type<ValueRange>
+// CHECK:                 `Constraints`
+// CHECK:                   `-ValueRangeConstraintDecl
+Pattern {
+  let op = op<my_dialect.unregisteredFoo>(op<my_dialect.unregisteredBar>.0);
+  erase op;
+}
+
+// -----
+
 //===----------------------------------------------------------------------===//
 // OperationExpr
 //===----------------------------------------------------------------------===//
 
 // Test a non-constrained operation expression, and ensure that we don't treat
 // unconstrained as "not present"(e.g. zero operands).
 
 // CHECK: Module