[mlir:PDLL] Add proper support for operation result type inference

[rriddle]

Summary

This allows for the results of operations to be inferred in certain contexts,
and matches the support in PDL for result type inference. The main two
initial circumstances are when used as a replacement of another operation,
or when the operation being created implements InferTypeOpInterface.

[jpienaar]

(first sweep, mostly looks good, just some clarifications)

mlir/docs/PDLL.md

729

Are the other contexts not bound types? E.g, isn't this the only inferred case and the others bound/provided?

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

83

What about Explicit, Replacement, Inferred ?

2063

Do we also need to check that the op implements the interface?

2776

For a replacement don't we need this too? Or perhaps stepping up: what verification is done here and why doesn't it apply for replacement?

2783

I'd make this fail: given this is an AOT tool, we could warn or fail here always rather than asserting, especially as this doesn't sound like an invariant.

2819

Runtime runtime? E.g., are you thinking about dynamically registered/injected interfaces?

2836

Why only check for variadic?

[rriddle]

mlir/docs/PDLL.md

729

Technically I suppose, it depends on the context of "inference". From PDLL perspective, it is inferring the types from somewhere (even if from the MLIR level, it's using bound/provided types). The use of "inference" in PDLL is when the user doesn't explicitly provide result types.

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

2063

We handle the related verification in createOperationExpr when creating the expression, the parser here tries not to inject any of that information (given that when templates are in the mix, we might not know what the operation is here).

2776

The replacement inference case only happens when there are no explicit results (we don't infer if results were explicitly provided), so we don't have anything to verify in that case. The verification here is that the structure of the result expressions matches the expected format (either single value range or matching the ODS definition).

2783

It's an assert right now because there isn't a code path that would exercise the error. We don't set inference if explicit values were provided. I avoided an error because that gives the expectation that the path is expected/tested/thought out, as opposed to something that can't happen. Reworked the assert to better capture this.

2819

Yes, I'm thinking of dynamically registered interfaces. We do have some instances of injecting type inference interfaces, though we could choose, I suppose, to require that the ODS definition has them. Right now we haven't been applying hard enforcement that ODS has everything defined.

2836

Purely variable length result operations can have zero results, and we allow elided results lists to imply zero results.

[jpienaar]

Looks good, thanks!

mlir/docs/PDLL.md

 
 // `root` could be an instance of any operation type.
 let root = op<>;
 ```
 
 #### Operands
 
 The operands section corresponds to the operands of the operation. This section
-of an operation expression may be elided, in which case the operands are not
-constrained in any way. When present, the operands of an operation expression
-are interpreted in the following ways:
+of an operation expression may be elided, which within a `match` section means
+that the operands are not constrained in any way. If elided within a `rewrite`
+section, the operation is treated as having no operands. When present, the
+operands of an operation expression are interpreted in the following ways:
 
 1) A single instance of type `ValueRange`:
 
 In this case, the single range is treated as all of the operands of the
 operation:
 
 ```pdll
 // Define an instance with single range of operands.

 We can match the operands as so:
 
 ```pdll
 let root = op<my_dialect.indirect_call>(call: Value, args: ValueRange);
 ```
 
 #### Results
 
-The results section corresponds to the result types of the operation. This
-section of an operation expression may be elided, in which case the result types
-are not constrained in any way. When present, the result types of an operation
-expression are interpreted in the following ways:
+The results section corresponds to the result types of the operation. This section
+of an operation expression may be elided, which within a `match` section means
+that the result types are not constrained in any way. If elided within a `rewrite`
+section, the results of the operation are [inferred](#inferred-results). When present,
+the result types of an operation expression are interpreted in the following ways:
 
 1) A single instance of type `TypeRange`:
 
 In this case, the single range is treated as all of the result types of the
 operation:
 
 ```pdll
 // Define an instance with single range of types.

 ```
 
 We can match the result types as so:
 
 ```pdll
 let root = op<my_dialect.op> -> (result: Type, otherResults: TypeRange);
 ```
 
+#### Inferred Results
+
+Within the `rewrite` section of a pattern, the result types of an
+operation are inferred if they are elided or otherwise not
+previously bound. The ["variable binding"](#variable-binding) section above
+discusses the concept of "binding" in more detail. Below are various examples
+that build upon this to help showcase how a result type may be "bound":
+
+* Binding to a [constant](#type-expression):
+
+```pdll
+op<my_dialect.op> -> (type<"i32">);
+```
+
+* Binding to types within the `match` section:
+
+```pdll
+Pattern {
+  replace op<dialect.inputOp> -> (resultTypes: TypeRange)
+    with op<dialect.outputOp> -> (resultTypes);
+}
+```
+
+* Binding to previously inferred types:
+
+```pdll
+Pattern {
+  rewrite root: Op with {
+    // `resultTypes` here is *not* yet bound, and will be inferred when
+    // creating `dialect.op`. Any uses of `resultTypes` after this expression,
+    // will use the types inferred when creating this operation.
+    op<dialect.op> -> (resultTypes: TypeRange);
+
+    // `resultTypes` here is bound to the types inferred when creating `dialect.op`.
+    op<dialect.bar> -> (resultTypes);
+  };
+}
+```
+
+* Binding to a [`Native Rewrite`](#native-rewriters) method result:
+
+```pdll
+Rewrite BuildTypes() -> TypeRange;
+
+Pattern {
+  rewrite root: Op with {
+    op<dialect.op> -> (BuildTypes());
+  };
+}
+```
+
+Below are the set of contexts in which result type inferrence is supported:
+
+##### Inferred Results of Replacement Operation
+
+Replacements have the invariant that the types of the replacement values must
+match the result types of the input operation. This means that when replacing
+one operation with another, the result types of the replacement operation may
+be inferred from the result types of the operation being replaced. For example,
+consider the following pattern:
+
+```pdll
+Pattern => replace op<dialect.inputOp> with op<dialect.outputOp>;
+```
+
+This pattern could be written in a more explicit way as:
+
+```pdll
+Pattern {
+  replace op<dialect.inputOp> -> (resultTypes: TypeRange)
+    with op<dialect.outputOp> -> (resultTypes);
+}
+```
+
+##### Inferred Results with InferTypeOpInterface
+
+`InferTypeOpInterface` is an interface that enables operations to infer its result
+types from its input attributes, operands, regions, etc. When the result types of
+an operation cannot be inferred from any other context, this interface is invoked
+to infer the result types of the operation.
+
 #### Attributes
 
 The attributes section of the operation expression corresponds to the attribute
 dictionary of the operation. This section of an operation expression may be
 elided, in which case the attributes are not constrained in any way. The
 composition of this component maps exactly to how attribute dictionaries are
 structured in the MLIR textual assembly format:
 

mlir/include/mlir/Tools/PDLL/ODS/Context.h

public:
   auto getDialects() const {
     return llvm::make_pointee_range(llvm::make_second_range(dialects));
   }
 
   /// Insert a new operation with the context. Returns the inserted operation,
   /// and a boolean indicating if the operation newly inserted (false if the
   /// operation already existed).
   std::pair<Operation *, bool>
-  insertOperation(StringRef name, StringRef summary, StringRef desc, SMLoc loc);
+  insertOperation(StringRef name, StringRef summary, StringRef desc,
+                  bool supportsResultTypeInferrence, SMLoc loc);
 
   /// Lookup an operation registered with the given name, or null if no
   /// operation with that name is registered.
   const Operation *lookupOperation(StringRef name) const;
 
   /// Print the contents of this context to the provided stream.
   void print(raw_ostream &os) const;
 

mlir/include/mlir/Tools/PDLL/ODS/Dialect.h

public:
 
   /// Return the name of this dialect.
   StringRef getName() const { return name; }
 
   /// Insert a new operation with the dialect. Returns the inserted operation,
   /// and a boolean indicating if the operation newly inserted (false if the
   /// operation already existed).
   std::pair<Operation *, bool>
-  insertOperation(StringRef name, StringRef summary, StringRef desc, SMLoc loc);
+  insertOperation(StringRef name, StringRef summary, StringRef desc,
+                  bool supportsResultTypeInferrence, SMLoc loc);
 
   /// Lookup an operation registered with the given name, or null if no
   /// operation with that name is registered.
   Operation *lookupOperation(StringRef name) const;
 
   /// Return a map of all of the operations registered to this dialect.
   const llvm::StringMap<std::unique_ptr<Operation>> &getOperations() const {
     return operations;

mlir/include/mlir/Tools/PDLL/ODS/Operation.h

 
 /// This class provides an ODS representation of a specific operation operand or
 /// result. This includes the name, variable length flags, and more.
 class OperandOrResult {
 public:
   /// Return the name of this value.
   StringRef getName() const { return name; }
 
+  /// Returns true if this value is variable length, i.e. if it is Variadic or
+  /// Optional.
+  bool isVariableLength() const {
+    return variableLengthKind != VariableLengthKind::Single;
+  }
+
   /// Returns true if this value is variadic (Note this is false if the value is
   /// Optional).
   bool isVariadic() const {
     return variableLengthKind == VariableLengthKind::Variadic;
   }
 
   /// Returns the variable length kind of this value.
   VariableLengthKind getVariableLengthKind() const {
public:
   ArrayRef<Attribute> getAttributes() const { return attributes; }
 
   /// Returns the operands of this operation.
   ArrayRef<OperandOrResult> getOperands() const { return operands; }
 
   /// Returns the results of this operation.
   ArrayRef<OperandOrResult> getResults() const { return results; }
 
+  /// Return if the operation is known to support result type inferrence.
+  bool hasResultTypeInferrence() const { return supportsTypeInferrence; }
+
 private:
-  Operation(StringRef name, StringRef summary, StringRef desc, SMLoc loc);
+  Operation(StringRef name, StringRef summary, StringRef desc,
+            bool supportsTypeInferrence, SMLoc loc);
 
   /// The name of the operation.
   std::string name;
 
   /// The documentation of the operation.
   std::string summary;
   std::string description;
 
+  /// Flag indicating if the operation is known to support type inferrence.
+  bool supportsTypeInferrence;
+
   /// The source location of this operation.
   SMRange location;
 
   /// The operands of the operation.
   SmallVector<OperandOrResult> operands;
 
   /// The results of the operation.
   SmallVector<OperandOrResult> results;

mlir/lib/Tools/PDLL/ODS/Context.cpp

Dialect &Context::insertDialect(StringRef name) {
   return *dialect;
 }
 
 const Dialect *Context::lookupDialect(StringRef name) const {
   auto it = dialects.find(name);
   return it == dialects.end() ? nullptr : &*it->second;
 }
 
-std::pair<Operation *, bool> Context::insertOperation(StringRef name,
-                                                      StringRef summary,
-                                                      StringRef desc,
-                                                      SMLoc loc) {
+std::pair<Operation *, bool>
+Context::insertOperation(StringRef name, StringRef summary, StringRef desc,
+                         bool supportsResultTypeInferrence, SMLoc loc) {
   std::pair<StringRef, StringRef> dialectAndName = name.split('.');
   return insertDialect(dialectAndName.first)
-      .insertOperation(name, summary, desc, loc);
+      .insertOperation(name, summary, desc, supportsResultTypeInferrence, loc);
 }
 
 const Operation *Context::lookupOperation(StringRef name) const {
   std::pair<StringRef, StringRef> dialectAndName = name.split('.');
   if (const Dialect *dialect = lookupDialect(dialectAndName.first))
     return dialect->lookupOperation(name);
   return nullptr;
 }

mlir/lib/Tools/PDLL/ODS/Dialect.cpp

 
 //===----------------------------------------------------------------------===//
 // Dialect
 //===----------------------------------------------------------------------===//
 
 Dialect::Dialect(StringRef name) : name(name.str()) {}
 Dialect::~Dialect() = default;
 
-std::pair<Operation *, bool> Dialect::insertOperation(StringRef name,
-                                                      StringRef summary,
-                                                      StringRef desc,
-                                                      llvm::SMLoc loc) {
+std::pair<Operation *, bool>
+Dialect::insertOperation(StringRef name, StringRef summary, StringRef desc,
+                         bool supportsResultTypeInferrence, llvm::SMLoc loc) {
   std::unique_ptr<Operation> &operation = operations[name];
   if (operation)
     return std::make_pair(&*operation, /*wasInserted*/ false);
 
-  operation.reset(new Operation(name, summary, desc, loc));
+  operation.reset(
+      new Operation(name, summary, desc, supportsResultTypeInferrence, loc));
   return std::make_pair(&*operation, /*wasInserted*/ true);
 }
 
 Operation *Dialect::lookupOperation(StringRef name) const {
   auto it = operations.find(name);
   return it != operations.end() ? it->second.get() : nullptr;
 }

mlir/lib/Tools/PDLL/ODS/Operation.cpp

 using namespace mlir;
 using namespace mlir::pdll::ods;
 
 //===----------------------------------------------------------------------===//
 // Operation
 //===----------------------------------------------------------------------===//
 
 Operation::Operation(StringRef name, StringRef summary, StringRef desc,
-                     llvm::SMLoc loc)
+                     bool supportsTypeInferrence, llvm::SMLoc loc)
     : name(name.str()), summary(summary.str()),
+      supportsTypeInferrence(supportsTypeInferrence),
       location(loc, llvm::SMLoc::getFromPointer(loc.getPointer() + 1)) {
   llvm::raw_string_ostream descOS(description);
   raw_indented_ostream(descOS).printReindented(desc.rtrim(" \t"));
 }

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

enum class ParserContext {
     /// is allows a terminal operation rewrite statement but no other rewrite
     /// transformations.
     PatternMatch,
     /// The parser is currently within a Rewrite, which disallows calls to
     /// constraints, requires operation expressions to have names, etc.
     Rewrite,
   };
 
+  /// The current specification context of an operations result type. This
+  /// indicates how the result types of an operation may be inferred.
+  enum class OpResultTypeContext {
+    /// The result types of the operation are not known to be inferred.
+    Explicit,
+    /// The result types of the operation are inferred from the root input of a
+    /// `replace` statement.
+    Replacement,
+    /// The result types of the operation are inferred by using the
+    /// `InferTypeOpInterface` interface provided by the operation.
+    Interface,
+  };
+
   //===--------------------------------------------------------------------===//
   // Parsing
   //===--------------------------------------------------------------------===//
 
   /// Push a new decl scope onto the lexer.
   ast::DeclScope *pushDeclScope() {
     ast::DeclScope *newScope =
         new (scopeAllocator.Allocate()) ast::DeclScope(curDeclScope);
private:
   FailureOr<ast::Expr *> parseCallExpr(ast::Expr *parentExpr);
   FailureOr<ast::Expr *> parseDeclRefExpr(StringRef name, SMRange loc);
   FailureOr<ast::Expr *> parseIdentifierExpr();
   FailureOr<ast::Expr *> parseInlineConstraintLambdaExpr();
   FailureOr<ast::Expr *> parseInlineRewriteLambdaExpr();
   FailureOr<ast::Expr *> parseMemberAccessExpr(ast::Expr *parentExpr);
   FailureOr<ast::OpNameDecl *> parseOperationName(bool allowEmptyName = false);
   FailureOr<ast::OpNameDecl *> parseWrappedOperationName(bool allowEmptyName);
-  FailureOr<ast::Expr *> parseOperationExpr();
+  FailureOr<ast::Expr *>
+  parseOperationExpr(OpResultTypeContext inputResultTypeContext =
+                         OpResultTypeContext::Explicit);
   FailureOr<ast::Expr *> parseTupleExpr();
   FailureOr<ast::Expr *> parseTypeExpr();
   FailureOr<ast::Expr *> parseUnderscoreExpr();
 
   //===--------------------------------------------------------------------===//
   // Stmts
 
   FailureOr<ast::Stmt *> parseStmt(bool expectTerminalSemicolon = true);
private:
   createMemberAccessExpr(ast::Expr *parentExpr, StringRef name, SMRange loc);
 
   /// Validate the member access `name` into the given parent expression. On
   /// success, this also returns the type of the member accessed.
   FailureOr<ast::Type> validateMemberAccess(ast::Expr *parentExpr,
                                             StringRef name, SMRange loc);
   FailureOr<ast::OperationExpr *>
   createOperationExpr(SMRange loc, const ast::OpNameDecl *name,
+                      OpResultTypeContext resultTypeContext,
                       MutableArrayRef<ast::Expr *> operands,
                       MutableArrayRef<ast::NamedAttributeDecl *> attributes,
                       MutableArrayRef<ast::Expr *> results);
   LogicalResult
   validateOperationOperands(SMRange loc, Optional<StringRef> name,
                             const ods::Operation *odsOp,
                             MutableArrayRef<ast::Expr *> operands);
   LogicalResult validateOperationResults(SMRange loc, Optional<StringRef> name,
                                          const ods::Operation *odsOp,
                                          MutableArrayRef<ast::Expr *> results);
+  void checkOperationResultTypeInferrence(SMRange loc, StringRef name,
+                                          const ods::Operation *odsOp);
   LogicalResult validateOperationOperandsOrResults(
       StringRef groupName, SMRange loc, Optional<SMRange> odsOpLoc,
       Optional<StringRef> name, MutableArrayRef<ast::Expr *> values,
       ArrayRef<ods::OperandOrResult> odsValues, ast::Type singleTy,
       ast::Type rangeTy);
   FailureOr<ast::TupleExpr *> createTupleExpr(SMRange loc,
                                               ArrayRef<ast::Expr *> elements,
                                               ArrayRef<StringRef> elementNames);
auto convertLocToRange = [&](llvm::SMLoc loc) -> llvm::SMRange {
     return {loc, llvm::SMLoc::getFromPointer(loc.getPointer() + 1)};
   };
 
   // Process the parsed tablegen records to build ODS information.
   /// Operations.
   for (llvm::Record *def : tdRecords.getAllDerivedDefinitions("Op")) {
     tblgen::Operator op(def);
 
+    // Check to see if this operation is known to support type inferrence.
+    bool supportsResultTypeInferrence =
+        op.getTrait("::mlir::InferTypeOpInterface::Trait");
+
     bool inserted = false;
     ods::Operation *odsOp = nullptr;
-    std::tie(odsOp, inserted) =
-        odsContext.insertOperation(op.getOperationName(), op.getSummary(),
-                                   op.getDescription(), op.getLoc().front());
+    std::tie(odsOp, inserted) = odsContext.insertOperation(
+        op.getOperationName(), op.getSummary(), op.getDescription(),
+        supportsResultTypeInferrence, op.getLoc().front());
 
     // Ignore operations that have already been added.
     if (!inserted)
       continue;
 
     for (const tblgen::NamedAttribute &attr : op.getAttributes()) {
       odsOp->appendAttribute(
           attr.name, attr.attr.isOptional(),
Parser::parseWrappedOperationName(bool allowEmptyName) {
   if (failed(opNameDecl))
     return failure();
 
   if (failed(parseToken(Token::greater, "expected `>` after operation name")))
     return failure();
   return opNameDecl;
 }
 
-FailureOr<ast::Expr *> Parser::parseOperationExpr() {
+FailureOr<ast::Expr *>
+Parser::parseOperationExpr(OpResultTypeContext inputResultTypeContext) {
   SMRange loc = curToken.getLoc();
   consumeToken(Token::kw_op);
 
   // If it isn't followed by a `<`, the `op` keyword is treated as a normal
   // identifier.
   if (curToken.isNot(Token::less)) {
     resetToken(loc);
     return parseIdentifierExpr();
do {
       attributes.emplace_back(*decl);
     } while (consumeIf(Token::comma));
 
     if (failed(parseToken(Token::r_brace,
                           "expected `}` after operation attribute list")))
       return failure();
   }
 
-  // Check for the optional list of result types.
+  // Handle the result types of the operation.
   SmallVector<ast::Expr *> resultTypes;
+  OpResultTypeContext resultTypeContext = inputResultTypeContext;
+
+  // Check for an explicit list of result types.
   if (consumeIf(Token::arrow)) {
     if (failed(parseToken(Token::l_paren,
                           "expected `(` before operation result type list")))
       return failure();
 
+    // If result types are provided, initially assume that the operation does
+    // not rely on type inferrence. We don't assert that it isn't, because we
+    // may be inferring the value of some type/type range variables, but given
+    // that these variables may be defined in calls we can't always discern when
+    // this is the case.
+    resultTypeContext = OpResultTypeContext::Explicit;
+
     // Handle the case of an empty result list.
     if (!consumeIf(Token::r_paren)) {
       do {
         // Check for result signature code completion.
         if (curToken.is(Token::code_complete)) {
           codeCompleteOperationResultsSignature(opName, resultTypes.size());
           return failure();
         }
if (consumeIf(Token::arrow)) {
     }
   } else if (parserContext != ParserContext::Rewrite) {
     // If the result list isn't specified and we are in a match context, define
     // an inplace unconstrained result range corresponding to all of the results
     // of the operation. This avoids treating zero results the same way as
     // "unconstrained results".
     resultTypes.push_back(createImplicitRangeVar(
         ast::TypeRangeConstraintDecl::create(ctx, loc), typeRangeTy));
+  } else if (resultTypeContext == OpResultTypeContext::Explicit) {
+    // If the result list isn't specified and we are in a rewrite, try to infer
+    // them at runtime instead.
+    resultTypeContext = OpResultTypeContext::Interface;
   }
 
-  return createOperationExpr(loc, *opNameDecl, operands, attributes,
-                             resultTypes);
+  return createOperationExpr(loc, *opNameDecl, resultTypeContext, operands,
+                             attributes, resultTypes);
 }
 
 FailureOr<ast::Expr *> Parser::parseTupleExpr() {
   SMRange loc = curToken.getLoc();
   consumeToken(Token::l_paren);
 
   DenseMap<StringRef, SMRange> usedNames;
   SmallVector<StringRef> elementNames;
do {
         return failure();
       replValues.emplace_back(*replExpr);
     } while (consumeIf(Token::comma));
 
     if (failed(parseToken(Token::r_paren,
                           "expected `)` after replacement values")))
       return failure();
   } else {
-    FailureOr<ast::Expr *> replExpr = parseExpr();
+    // Handle replacement with an operation uniquely, as the replacement
+    // operation supports type inferrence from the root operation.
+    FailureOr<ast::Expr *> replExpr;
+    if (curToken.is(Token::kw_op))
+      replExpr = parseOperationExpr(OpResultTypeContext::Replacement);
+    else
+      replExpr = parseExpr();
     if (failed(replExpr))
       return failure();
     replValues.emplace_back(*replExpr);
   }
 
   return createReplaceStmt(loc, *rootOp, replValues);
 }
 
FailureOr<ast::Type> Parser::validateMemberAccess(ast::Expr *parentExpr,
   return emitError(
       loc,
       llvm::formatv("invalid member access `{0}` on expression of type `{1}`",
                     name, parentType));
 }
 
 FailureOr<ast::OperationExpr *> Parser::createOperationExpr(
     SMRange loc, const ast::OpNameDecl *name,
+    OpResultTypeContext resultTypeContext,
     MutableArrayRef<ast::Expr *> operands,
     MutableArrayRef<ast::NamedAttributeDecl *> attributes,
     MutableArrayRef<ast::Expr *> results) {
   Optional<StringRef> opNameRef = name->getName();
   const ods::Operation *odsOp = lookupODSOperation(opNameRef);
 
   // Verify the inputs operands.
   if (failed(validateOperationOperands(loc, opNameRef, odsOp, operands)))
     return failure();
 
   // Verify the attribute list.
   for (ast::NamedAttributeDecl *attr : attributes) {
     // Check for an attribute type, or a type awaiting resolution.
     ast::Type attrType = attr->getValue()->getType();
     if (!attrType.isa<ast::AttributeType>()) {
       return emitError(
           attr->getValue()->getLoc(),
           llvm::formatv("expected `Attr` expression, but got `{0}`", attrType));
     }
   }
 
-  // Verify the result types.
+  assert(
+      (resultTypeContext == OpResultTypeContext::Explicit || results.empty()) &&
+      "unexpected inferrence when results were explicitly specified");
+
+  // If we aren't relying on type inferrence, or explicit results were provided,
+  // validate them.
+  if (resultTypeContext == OpResultTypeContext::Explicit) {
     if (failed(validateOperationResults(loc, opNameRef, odsOp, results)))
       return failure();
 
+    // Validate the use of interface based type inferrence for this operation.
+  } else if (resultTypeContext == OpResultTypeContext::Interface) {
+    assert(opNameRef &&
+           "expected valid operation name when inferring operation results");
+    checkOperationResultTypeInferrence(loc, *opNameRef, odsOp);
+  }
+
   return ast::OperationExpr::create(ctx, loc, name, operands, results,
                                     attributes);
 }
 
 LogicalResult
 Parser::validateOperationOperands(SMRange loc, Optional<StringRef> name,
                                   const ods::Operation *odsOp,
                                   MutableArrayRef<ast::Expr *> operands) {
   return validateOperationOperandsOrResults(
       "operand", loc, odsOp ? odsOp->getLoc() : Optional<SMRange>(), name,
       operands, odsOp ? odsOp->getOperands() : llvm::None, valueTy,
       valueRangeTy);
 }
 
 LogicalResult
 Parser::validateOperationResults(SMRange loc, Optional<StringRef> name,
                                  const ods::Operation *odsOp,
                                  MutableArrayRef<ast::Expr *> results) {
   return validateOperationOperandsOrResults(
       "result", loc, odsOp ? odsOp->getLoc() : Optional<SMRange>(), name,
       results, odsOp ? odsOp->getResults() : llvm::None, typeTy, typeRangeTy);
 }
 
+void Parser::checkOperationResultTypeInferrence(SMRange loc, StringRef opName,
+                                                const ods::Operation *odsOp) {
+  // If the operation might not have inferrence support, emit a warning to the
+  // user. We don't emit an error because the interface might be added to the
+  // operation at runtime. It's rare, but it could still happen. We emit a
+  // warning here instead.
+
+  // Handle inferrence warnings for unknown operations.
+  if (!odsOp) {
+    ctx.getDiagEngine().emitWarning(
+        loc, llvm::formatv(
+                 "operation result types are marked to be inferred, but "
+                 "`{0}` is unknown. Ensure that `{0}` supports zero "
+                 "results or implements `InferTypeOpInterface`. Include "
+                 "the ODS definition of this operation to remove this warning.",
+                 opName));
+    return;
+  }
+
+  // Handle inferrence warnings for known operations that expected at least one
+  // result, but don't have inference support. An elided results list can mean
+  // "zero-results", and we don't want to warn when that is the expected
+  // behavior.
+  bool requiresInferrence =
+      llvm::any_of(odsOp->getResults(), [](const ods::OperandOrResult &result) {
+        return !result.isVariableLength();
+      });
+  if (requiresInferrence && !odsOp->hasResultTypeInferrence()) {
+    ast::InFlightDiagnostic diag = ctx.getDiagEngine().emitWarning(
+        loc,
+        llvm::formatv("operation result types are marked to be inferred, but "
+                      "`{0}` does not provide an implementation of "
+                      "`InferTypeOpInterface`. Ensure that `{0}` attaches "
+                      "`InferTypeOpInterface` at runtime, or add support to "
+                      "the ODS definition to remove this warning.",
+                      opName));
+    diag->attachNote(llvm::formatv("see the definition of `{0}` here", opName),
+                     odsOp->getLoc());
+    return;
+  }
+}
+
 LogicalResult Parser::validateOperationOperandsOrResults(
     StringRef groupName, SMRange loc, Optional<SMRange> odsOpLoc,
     Optional<StringRef> name, MutableArrayRef<ast::Expr *> values,
     ArrayRef<ods::OperandOrResult> odsValues, ast::Type singleTy,
     ast::Type rangeTy) {
   // All operation types accept a single range parameter.
   if (values.size() == 1) {
     if (failed(convertExpressionTo(values[0], rangeTy)))

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

 Pattern {
   // CHECK: invalid number of result groups for `test.all_empty`; expected 0, but got 2
   // CHECK: see the definition of `test.all_empty` here
   let foo = op<test.all_empty> -> (result1: Type, result2: Type);
 }
 
 // -----
 
+Pattern {
+  // CHECK: warning: operation result types are marked to be inferred, but
+  // CHECK-SAME: `test.unknown_inferred_result_op` is unknown.
+  // CHECK-SAME: Ensure that `test.unknown_inferred_result_op` supports zero
+  // CHECK-SAME: results or implements `InferTypeOpInterface`.
+  // CHECK-SAME: Include the ODS definition of this operation to remove this
+  // CHECK-SAME: warning.
+  rewrite _: Op with {
+    op<test.unknown_inferred_result_op>;
+  };
+}
+
+// -----
+
+#include "include/ops.td"
+
+Pattern {
+  // CHECK: warning: operation result types are marked to be inferred, but
+  // CHECK-SAME: `test.multiple_single_result` does not provide an implementation
+  // CHECK-SAME: of `InferTypeOpInterface`. Ensure that `test.multiple_single_result`
+  // CHECK-SAME: attaches `InferTypeOpInterface` at runtime, or add support
+  // CHECK-SAME: to the ODS definition to remove this warning.
+  // CHECK: see the definition of `test.multiple_single_result` here
+  rewrite _: Op with {
+    op<test.multiple_single_result>;
+  };
+}
+
+// -----
+
 //===----------------------------------------------------------------------===//
 // `type` Expr
 //===----------------------------------------------------------------------===//
 
 Pattern {
   // CHECK: expected string literal containing MLIR type
   let foo = type<foo;
 }
 
 // -----
 
 Pattern {
   // CHECK: expected `>` after type literal
   let foo = type<"";
 }