[PDLL] Add support for `op` Operation expressions

[rriddle]

Summary

An operation expression in PDLL represents an MLIR operation. In
the match section of a pattern, this expression models one of
the input operations to the pattern. In the rewrite section of
a pattern, this expression models one of the operations to
create. The general structure of the operation expression is very
similar to that of the "generic form" of textual MLIR assembly:

let root = op<my_dialect.foo>(operands: ValueRange) {attr = attr: Attr} -> (resultTypes: TypeRange);

For now we only model the components that are within PDL, as PDL
gains support for blocks and regions so will this expression.

Depends On D115295

[nicolasvasilache]

LGTM once the test / op(op) doc is addressed.

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

355

can this be a named constexpr thing that is documented at point of definition instead of a magic string constant?

943

nit: somme comment that absence of a name means Operation* / apply to all ops?

1376

same re magic string constant

1383

same re magic string constant

1388

hmm unused group name ?
I imagine you'll connect this as a followup?

1409

I find this case not trivial and I don't think I see a test.
Could you add some pseudo-PDLL as a comment here as well as a test?

[Mogball]

mlir/include/mlir/Tools/PDLL/AST/Nodes.h

863

feels_vscode

[jpienaar]

LG with Nicolas's comments addressed

mlir/include/mlir/Tools/PDLL/AST/Nodes.h

354

s/the structural form to/an/ ? (think message is the same and feels cleaner)

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

936

we ?

952

(all of these are giving me strong RETURN_IF_ERROR, ASSIGN_OR_RETURN vibes)

[rriddle]

update

[rriddle]

rebase

mlir/include/mlir/Tools/PDLL/AST/Nodes.h

 #include "llvm/Support/TrailingObjects.h"
 
 namespace mlir {
 namespace pdll {
 namespace ast {
 class Context;
 class Decl;
 class Expr;
+class NamedAttributeDecl;
 class OpNameDecl;
 class VariableDecl;
 
 //===----------------------------------------------------------------------===//
 // Name
 //===----------------------------------------------------------------------===//
 
 /// This class provides a convenient API for interacting with source names. It
private:
   /// The parent expression of this access.
   const Expr *parentExpr;
 
   /// The name of the member being accessed from the parent.
   StringRef memberName;
 };
 
 //===----------------------------------------------------------------------===//
+// AllResultsMemberAccessExpr
+
+/// This class represents an instance of MemberAccessExpr that references all
+/// results of an operation.
+class AllResultsMemberAccessExpr : public MemberAccessExpr {
+public:
+  /// Return the member name used for the "all-results" access.
+  static StringRef getMemberName() { return "$results"; }
+
+  static AllResultsMemberAccessExpr *create(Context &ctx, llvm::SMRange loc,
+                                            const Expr *parentExpr, Type type) {
+    return cast<AllResultsMemberAccessExpr>(
+        MemberAccessExpr::create(ctx, loc, parentExpr, getMemberName(), type));
+  }
+
+  /// Provide type casting support.
+  static bool classof(const Node *node) {
+    const MemberAccessExpr *memAccess = dyn_cast<MemberAccessExpr>(node);
+    return memAccess && memAccess->getMemberName() == getMemberName();
+  }
+};
+
+//===----------------------------------------------------------------------===//
+// OperationExpr
+//===----------------------------------------------------------------------===//
+
+/// This expression represents the structural form of an MLIR Operation. It
+/// represents either an input operation to match, or an operation to create
+/// within a rewrite.
+class OperationExpr final
+    : public Node::NodeBase<OperationExpr, Expr>,
+      private llvm::TrailingObjects<OperationExpr, Expr *,
+                                    NamedAttributeDecl *> {
+public:
+  static OperationExpr *create(Context &ctx, llvm::SMRange loc,
+                               const OpNameDecl *nameDecl,
+                               ArrayRef<Expr *> operands,
+                               ArrayRef<Expr *> resultTypes,
+                               ArrayRef<NamedAttributeDecl *> attributes);
+
+  /// Return the name of the operation, or None if there isn't one.
+  Optional<StringRef> getName() const;
+
+  /// Return the declaration of the operation name.
+  const OpNameDecl *getNameDecl() const { return nameDecl; }
+
+  /// Return the location of the name of the operation expression, or an invalid
+  /// location if there isn't a name.
+  llvm::SMRange getNameLoc() const { return nameLoc; }
+
+  /// Return the operands of this operation.
+  MutableArrayRef<Expr *> getOperands() {
+    return {getTrailingObjects<Expr *>(), numOperands};
+  }
+  ArrayRef<Expr *> getOperands() const {
+    return const_cast<OperationExpr *>(this)->getOperands();
+  }
+
+  /// Return the result types of this operation.
+  MutableArrayRef<Expr *> getResultTypes() {
+    return {getTrailingObjects<Expr *>() + numOperands, numResultTypes};
+  }
+  MutableArrayRef<Expr *> getResultTypes() const {
+    return const_cast<OperationExpr *>(this)->getResultTypes();
+  }
+
+  /// Return the attributes of this operation.
+  MutableArrayRef<NamedAttributeDecl *> getAttributes() {
+    return {getTrailingObjects<NamedAttributeDecl *>(), numAttributes};
+  }
+  MutableArrayRef<NamedAttributeDecl *> getAttributes() const {
+    return const_cast<OperationExpr *>(this)->getAttributes();
+  }
+
+private:
+  OperationExpr(llvm::SMRange loc, Type type, const OpNameDecl *nameDecl,
+                unsigned numOperands, unsigned numResultTypes,
+                unsigned numAttributes, llvm::SMRange nameLoc)
+      : Base(loc, type), nameDecl(nameDecl), numOperands(numOperands),
+        numResultTypes(numResultTypes), numAttributes(numAttributes),
+        nameLoc(nameLoc) {}
+
+  /// The name decl of this expression.
+  const OpNameDecl *nameDecl;
+
+  /// The number of operands, result types, and attributes of the operation.
+  unsigned numOperands, numResultTypes, numAttributes;
+
+  /// The location of the operation name in the expression if it has a name.
+  llvm::SMRange nameLoc;
+
+  /// TrailingObject utilities.
+  friend llvm::TrailingObjects<OperationExpr, Expr *, NamedAttributeDecl *>;
+  size_t numTrailingObjects(OverloadToken<Expr *>) const {
+    return numOperands + numResultTypes;
+  }
+};
+
+//===----------------------------------------------------------------------===//
 // TypeExpr
 //===----------------------------------------------------------------------===//
 
 /// This expression represents a literal MLIR Type, and contains the textual
 /// assembly format of that type.
 class TypeExpr : public Node::NodeBase<TypeExpr, Expr> {
 public:
   static TypeExpr *create(Context &ctx, llvm::SMRange loc, StringRef value);
protected:
   ValueRangeConstraintDecl(llvm::SMRange loc, Expr *typeExpr)
       : Base(loc), typeExpr(typeExpr) {}
 
   /// An optional type that the value range is constrained to.
   Expr *typeExpr;
 };
 
 //===----------------------------------------------------------------------===//
+// NamedAttributeDecl
+//===----------------------------------------------------------------------===//
+
+/// This Decl represents a NamedAttribute, and contains a string name and
+/// attribute value.
+class NamedAttributeDecl : public Node::NodeBase<NamedAttributeDecl, Decl> {
+public:
+  static NamedAttributeDecl *create(Context &ctx, const Name &name,
+                                    Expr *value);
+
+  /// Return the name of the attribute.
+  const Name &getName() const { return *Decl::getName(); }
+
+  /// Return value of the attribute.
+  Expr *getValue() const { return value; }
+
+private:
+  NamedAttributeDecl(const Name &name, Expr *value)
+      : Base(name.getLoc(), &name), value(value) {}
+
+  /// The value of the attribute.
+  Expr *value;
+};
+
+//===----------------------------------------------------------------------===//
 // OpNameDecl
 //===----------------------------------------------------------------------===//
 
 /// This Decl represents an OperationName.
 class OpNameDecl : public Node::NodeBase<OpNameDecl, Decl> {
 public:
   static OpNameDecl *create(Context &ctx, const Name &name);
   static OpNameDecl *create(Context &ctx, llvm::SMRange loc);
private:
   friend llvm::TrailingObjects<Module, Decl *>;
 };
 
 //===----------------------------------------------------------------------===//
 // Defered Method Definitions
 //===----------------------------------------------------------------------===//
 
 inline bool Decl::classof(const Node *node) {
-  return isa<ConstraintDecl, OpNameDecl, PatternDecl, VariableDecl>(node);
+  return isa<ConstraintDecl, NamedAttributeDecl, OpNameDecl, PatternDecl,
+             VariableDecl>(node);
 }
 
 inline bool ConstraintDecl::classof(const Node *node) {
   return isa<CoreConstraintDecl>(node);
 }
 
 inline bool CoreConstraintDecl::classof(const Node *node) {
   return isa<AttrConstraintDecl, OpConstraintDecl, TypeConstraintDecl,
              TypeRangeConstraintDecl, ValueConstraintDecl,
              ValueRangeConstraintDecl>(node);
 }
 
 inline bool Expr::classof(const Node *node) {
-  return isa<AttributeExpr, DeclRefExpr, MemberAccessExpr, TypeExpr>(node);
+  return isa<AttributeExpr, DeclRefExpr, MemberAccessExpr, OperationExpr,
+             TypeExpr>(node);
 }
 
 inline bool OpRewriteStmt::classof(const Node *node) {
   return isa<EraseStmt>(node);
 }
 
 inline bool Stmt::classof(const Node *node) {
   return isa<CompoundStmt, LetStmt, OpRewriteStmt, Expr>(node);
 }
 
 } // namespace ast
 } // namespace pdll
 } // namespace mlir
 
 #endif // MLIR_TOOLS_PDLL_AST_NODES_H_

mlir/lib/Tools/PDLL/AST/NodePrinter.cpp

private:
   /// Print the given derived node to the stream.
   void printImpl(const CompoundStmt *stmt);
   void printImpl(const EraseStmt *stmt);
   void printImpl(const LetStmt *stmt);
 
   void printImpl(const AttributeExpr *expr);
   void printImpl(const DeclRefExpr *expr);
   void printImpl(const MemberAccessExpr *expr);
+  void printImpl(const OperationExpr *expr);
   void printImpl(const TypeExpr *expr);
 
   void printImpl(const AttrConstraintDecl *decl);
   void printImpl(const OpConstraintDecl *decl);
   void printImpl(const TypeConstraintDecl *decl);
   void printImpl(const TypeRangeConstraintDecl *decl);
   void printImpl(const ValueConstraintDecl *decl);
   void printImpl(const ValueRangeConstraintDecl *decl);
+  void printImpl(const NamedAttributeDecl *decl);
   void printImpl(const OpNameDecl *decl);
   void printImpl(const PatternDecl *decl);
   void printImpl(const VariableDecl *decl);
   void printImpl(const Module *module);
 
   /// Print the current indent stack.
   void printIndent() {
     if (elementIndentStack.empty())
void NodePrinter::print(const Node *node) {
   elementIndentStack.push_back(/*isLastElt*/ false);
   TypeSwitch<const Node *>(node)
       .Case<
           // Statements.
           const CompoundStmt, const EraseStmt, const LetStmt,
 
           // Expressions.
           const AttributeExpr, const DeclRefExpr, const MemberAccessExpr,
-          const TypeExpr,
+          const OperationExpr, const TypeExpr,
 
           // Decls.
           const AttrConstraintDecl, const OpConstraintDecl,
           const TypeConstraintDecl, const TypeRangeConstraintDecl,
           const ValueConstraintDecl, const ValueRangeConstraintDecl,
-          const OpNameDecl, const PatternDecl, const VariableDecl,
+          const NamedAttributeDecl, const OpNameDecl, const PatternDecl,
+          const VariableDecl,
 
           const Module>([&](auto derivedNode) { this->printImpl(derivedNode); })
       .Default([](const Node *) { llvm_unreachable("unknown AST node"); });
   elementIndentStack.pop_back();
 }
 
 void NodePrinter::printImpl(const CompoundStmt *stmt) {
   os << "CompoundStmt " << stmt << "\n";

 void NodePrinter::printImpl(const MemberAccessExpr *expr) {
   os << "MemberAccessExpr " << expr << " Member<" << expr->getMemberName()
      << "> Type<";
   print(expr->getType());
   os << ">\n";
   printChildren(expr->getParentExpr());
 }
 
+void NodePrinter::printImpl(const OperationExpr *expr) {
+  os << "OperationExpr " << expr << " Type<";
+  print(expr->getType());
+  os << ">\n";
+
+  printChildren(expr->getNameDecl());
+  printChildren("Operands", expr->getOperands());
+  printChildren("Result Types", expr->getResultTypes());
+  printChildren("Attributes", expr->getAttributes());
+}
+
 void NodePrinter::printImpl(const TypeExpr *expr) {
   os << "TypeExpr " << expr << " Value<\"" << expr->getValue() << "\">\n";
 }
 
 void NodePrinter::printImpl(const AttrConstraintDecl *decl) {
   os << "AttrConstraintDecl " << decl << "\n";
   if (const auto *typeExpr = decl->getTypeExpr())
     printChildren(typeExpr);

 }
 
 void NodePrinter::printImpl(const ValueRangeConstraintDecl *decl) {
   os << "ValueRangeConstraintDecl " << decl << "\n";
   if (const auto *typeExpr = decl->getTypeExpr())
     printChildren(typeExpr);
 }
 
+void NodePrinter::printImpl(const NamedAttributeDecl *decl) {
+  os << "NamedAttributeDecl " << decl << " Name<" << decl->getName().getName()
+     << ">\n";
+  printChildren(decl->getValue());
+}
+
 void NodePrinter::printImpl(const OpNameDecl *decl) {
   os << "OpNameDecl " << decl;
   if (Optional<StringRef> name = decl->getName())
     os << " Name<" << name << ">";
   os << "\n";
 }
 
 void NodePrinter::printImpl(const PatternDecl *decl) {

mlir/lib/Tools/PDLL/AST/Nodes.cpp

 MemberAccessExpr *MemberAccessExpr::create(Context &ctx, llvm::SMRange loc,
                                            const Expr *parentExpr,
                                            StringRef memberName, Type type) {
   return new (ctx.getAllocator().Allocate<MemberAccessExpr>()) MemberAccessExpr(
       loc, parentExpr, memberName.copy(ctx.getAllocator()), type);
 }
 
 //===----------------------------------------------------------------------===//
+// OperationExpr
+//===----------------------------------------------------------------------===//
+
+OperationExpr *
+OperationExpr::create(Context &ctx, llvm::SMRange loc, const OpNameDecl *name,
+                      ArrayRef<Expr *> operands, ArrayRef<Expr *> resultTypes,
+                      ArrayRef<NamedAttributeDecl *> attributes) {
+  unsigned allocSize =
+      OperationExpr::totalSizeToAlloc<Expr *, NamedAttributeDecl *>(
+          operands.size() + resultTypes.size(), attributes.size());
+  void *rawData =
+      ctx.getAllocator().Allocate(allocSize, alignof(OperationExpr));
+
+  Type resultType = OperationType::get(ctx, name->getName());
+  OperationExpr *opExpr = new (rawData)
+      OperationExpr(loc, resultType, name, operands.size(), resultTypes.size(),
+                    attributes.size(), name->getLoc());
+  std::uninitialized_copy(operands.begin(), operands.end(),
+                          opExpr->getOperands().begin());
+  std::uninitialized_copy(resultTypes.begin(), resultTypes.end(),
+                          opExpr->getResultTypes().begin());
+  std::uninitialized_copy(attributes.begin(), attributes.end(),
+                          opExpr->getAttributes().begin());
+  return opExpr;
+}
+
+Optional<StringRef> OperationExpr::getName() const {
+  return getNameDecl()->getName();
+}
+
+//===----------------------------------------------------------------------===//
 // TypeExpr
 //===----------------------------------------------------------------------===//
 
 TypeExpr *TypeExpr::create(Context &ctx, llvm::SMRange loc, StringRef value) {
   return new (ctx.getAllocator().Allocate<TypeExpr>())
       TypeExpr(ctx, loc, copyStringWithNull(ctx, value));
 }
 

 ValueRangeConstraintDecl *ValueRangeConstraintDecl::create(Context &ctx,
                                                            llvm::SMRange loc,
                                                            Expr *typeExpr) {
   return new (ctx.getAllocator().Allocate<ValueRangeConstraintDecl>())
       ValueRangeConstraintDecl(loc, typeExpr);
 }
 
 //===----------------------------------------------------------------------===//
+// NamedAttributeDecl
+//===----------------------------------------------------------------------===//
+
+NamedAttributeDecl *NamedAttributeDecl::create(Context &ctx, const Name &name,
+                                               Expr *value) {
+  return new (ctx.getAllocator().Allocate<NamedAttributeDecl>())
+      NamedAttributeDecl(name, value);
+}
+
+//===----------------------------------------------------------------------===//
 // OpNameDecl
 //===----------------------------------------------------------------------===//
 
 OpNameDecl *OpNameDecl::create(Context &ctx, const Name &name) {
   return new (ctx.getAllocator().Allocate<OpNameDecl>()) OpNameDecl(name);
 }
 OpNameDecl *OpNameDecl::create(Context &ctx, llvm::SMRange loc) {
   return new (ctx.getAllocator().Allocate<OpNameDecl>()) OpNameDecl(loc);

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

private:
   /// Try to convert the given expression to `type`. Returns failure and emits
   /// an error if a conversion is not viable. On failure, `noteAttachFn` is
   /// invoked to attach notes to the emitted error diagnostic. On success,
   /// `expr` is updated to the expression used to convert to `type`.
   LogicalResult convertExpressionTo(
       ast::Expr *&expr, ast::Type type,
       function_ref<void(ast::Diagnostic &diag)> noteAttachFn = {});
 
+  /// Given an operation expression, convert it to a Value or ValueRange
+  /// typed expression.
+  ast::Expr *convertOpToValue(const ast::Expr *opExpr);
+
   //===--------------------------------------------------------------------===//
   // Directives
 
   LogicalResult parseDirective(SmallVector<ast::Decl *> &decls);
   LogicalResult parseInclude(SmallVector<ast::Decl *> &decls);
 
   //===--------------------------------------------------------------------===//
   // Decls
 
   /// This structure contains the set of pattern metadata that may be parsed.
   struct ParsedPatternMetadata {
     Optional<uint16_t> benefit;
     bool hasBoundedRecursion = false;
   };
 
   FailureOr<ast::Decl *> parseTopLevelDecl();
+  FailureOr<ast::NamedAttributeDecl *> parseNamedAttributeDecl();
   FailureOr<ast::Decl *> parsePatternDecl();
   LogicalResult parsePatternDeclMetadata(ParsedPatternMetadata &metadata);
 
   /// Check to see if a decl has already been defined with the given name, if
   /// one has emit and error and return failure. Returns success otherwise.
   LogicalResult checkDefineNamedDecl(const ast::Name &name);
 
   /// Try to define a variable decl with the given components, returns the
private:
 
   /// Identifier expressions.
   FailureOr<ast::Expr *> parseAttributeExpr();
   FailureOr<ast::Expr *> parseDeclRefExpr(StringRef name, llvm::SMRange loc);
   FailureOr<ast::Expr *> parseIdentifierExpr();
   FailureOr<ast::Expr *> parseMemberAccessExpr(ast::Expr *parentExpr);
   FailureOr<ast::OpNameDecl *> parseOperationName();
   FailureOr<ast::OpNameDecl *> parseWrappedOperationName();
+  FailureOr<ast::Expr *> parseOperationExpr();
   FailureOr<ast::Expr *> parseTypeExpr();
   FailureOr<ast::Expr *> parseUnderscoreExpr();
 
   //===--------------------------------------------------------------------===//
   // Stmts
 
   FailureOr<ast::Stmt *> parseStmt(bool expectTerminalSemicolon = true);
   FailureOr<ast::CompoundStmt *> parseCompoundStmt();
private:
   FailureOr<ast::MemberAccessExpr *>
   createMemberAccessExpr(ast::Expr *parentExpr, StringRef name,
                          llvm::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, llvm::SMRange loc);
+  FailureOr<ast::OperationExpr *>
+  createOperationExpr(llvm::SMRange loc, const ast::OpNameDecl *name,
+                      MutableArrayRef<ast::Expr *> operands,
+                      MutableArrayRef<ast::NamedAttributeDecl *> attributes,
+                      MutableArrayRef<ast::Expr *> results);
+  LogicalResult
+  validateOperationOperands(llvm::SMRange loc, Optional<StringRef> name,
+                            MutableArrayRef<ast::Expr *> operands);
+  LogicalResult validateOperationResults(llvm::SMRange loc,
+                                         Optional<StringRef> name,
+                                         MutableArrayRef<ast::Expr *> results);
+  LogicalResult
+  validateOperationOperandsOrResults(llvm::SMRange loc,
+                                     Optional<StringRef> name,
+                                     MutableArrayRef<ast::Expr *> values,
+                                     ast::Type singleTy, ast::Type rangeTy);
 
   //===--------------------------------------------------------------------===//
   // Stmts
 
   FailureOr<ast::EraseStmt *> createEraseStmt(llvm::SMRange loc,
                                               ast::Expr *rootOp);
 
   //===--------------------------------------------------------------------===//
while (curToken.isNot(Token::eof)) {
     FailureOr<ast::Decl *> decl = parseTopLevelDecl();
     if (failed(decl))
       return failure();
     decls.push_back(*decl);
   }
   return success();
 }
 
+ast::Expr *Parser::convertOpToValue(const ast::Expr *opExpr) {
+  return ast::AllResultsMemberAccessExpr::create(ctx, opExpr->getLoc(), opExpr,
+                                                 valueRangeTy);
+}
+
 LogicalResult Parser::convertExpressionTo(
     ast::Expr *&expr, ast::Type type,
     function_ref<void(ast::Diagnostic &diag)> noteAttachFn) {
   ast::Type exprType = expr->getType();
   if (exprType == type)
     return success();
 
   auto emitConvertError = [&]() -> ast::InFlightDiagnostic {
if (auto exprOpType = exprType.dyn_cast<ast::OperationType>()) {
     if (auto opType = type.dyn_cast<ast::OperationType>()) {
       if (opType.getName())
         return emitConvertError();
       return success();
     }
 
     // An operation can always convert to a ValueRange.
     if (type == valueRangeTy) {
-      expr = ast::MemberAccessExpr::create(ctx, expr->getLoc(), expr,
-                                           "$results", valueRangeTy);
+      expr = ast::AllResultsMemberAccessExpr::create(ctx, expr->getLoc(), expr,
+                                                     valueRangeTy);
       return success();
     }
 
     // Allow conversion to a single value by constraining the result range.
     if (type == valueTy) {
-      expr = ast::MemberAccessExpr::create(ctx, expr->getLoc(), expr,
-                                           "$results", valueTy);
+      expr = ast::AllResultsMemberAccessExpr::create(ctx, expr->getLoc(), expr,
+                                                     valueTy);
       return success();
     }
     return emitConvertError();
   }
 
   // FIXME: Decide how to allow/support converting a single result to multiple,
   // and multiple to a single result. For now, we just allow Single->Range,
   // but this isn't something really supported in the PDL dialect. We should
FailureOr<ast::Decl *> Parser::parseTopLevelDecl() {
   if (const ast::Name *name = (*decl)->getName()) {
     if (failed(checkDefineNamedDecl(*name)))
       return failure();
     curDeclScope->add(*decl);
   }
   return decl;
 }
 
+FailureOr<ast::NamedAttributeDecl *> Parser::parseNamedAttributeDecl() {
+  std::string attrNameStr;
+  if (curToken.isString())
+    attrNameStr = curToken.getStringValue();
+  else if (curToken.is(Token::identifier) || curToken.isKeyword())
+    attrNameStr = curToken.getSpelling().str();
+  else
+    return emitError("expected identifier or string attribute name");
+  const auto &name = ast::Name::create(ctx, attrNameStr, curToken.getLoc());
+  consumeToken();
+
+  // Check for a value of the attribute.
+  ast::Expr *attrValue = nullptr;
+  if (consumeIf(Token::equal)) {
+    FailureOr<ast::Expr *> attrExpr = parseExpr();
+    if (failed(attrExpr))
+      return failure();
+    attrValue = *attrExpr;
+  } else {
+    // If there isn't a concrete value, create an expression representing a
+    // UnitAttr.
+    attrValue = ast::AttributeExpr::create(ctx, name.getLoc(), "unit");
+  }
+
+  return ast::NamedAttributeDecl::create(ctx, name, attrValue);
+}
+
 FailureOr<ast::Decl *> Parser::parsePatternDecl() {
   llvm::SMRange loc = curToken.getLoc();
   consumeToken(Token::kw_Pattern);
   llvm::SaveAndRestore<ParserContext> saveCtx(parserContext,
                                               ParserContext::PatternMatch);
 
   // Check for an optional identifier for the pattern name.
   const ast::Name *name = nullptr;
FailureOr<ast::Expr *> Parser::parseExpr() {
   FailureOr<ast::Expr *> lhsExpr;
   switch (curToken.getKind()) {
   case Token::kw_attr:
     lhsExpr = parseAttributeExpr();
     break;
   case Token::identifier:
     lhsExpr = parseIdentifierExpr();
     break;
+  case Token::kw_op:
+    lhsExpr = parseOperationExpr();
+    break;
   case Token::kw_type:
     lhsExpr = parseTypeExpr();
     break;
   default:
     return emitError("expected expression");
   }
   if (failed(lhsExpr))
     return failure();
FailureOr<ast::OpNameDecl *> Parser::parseWrappedOperationName() {
   if (failed(opNameDecl))
     return failure();
 
   if (failed(parseToken(Token::greater, "expected `>` after operation name")))
     return failure();
   return opNameDecl;
 }
 
+FailureOr<ast::Expr *> Parser::parseOperationExpr() {
+  llvm::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();
+  }
+
+  // Parse the operation name. The name may be elided, in which case the
+  // operation refers to "any" operation(i.e. a difference between `MyOp` and
+  // `Operation*`).
+  FailureOr<ast::OpNameDecl *> opNameDecl = parseWrappedOperationName();
+  if (failed(opNameDecl))
+    return failure();
+
+  // Check for the optional list of operands.
+  SmallVector<ast::Expr *> operands;
+  if (consumeIf(Token::l_paren)) {
+    do {
+      FailureOr<ast::Expr *> operand = parseExpr();
+      if (failed(operand))
+        return failure();
+      operands.push_back(*operand);
+    } while (consumeIf(Token::comma));
+
+    if (failed(parseToken(Token::r_paren,
+                          "expected `)` after operation operand list")))
+      return failure();
+  }
+
+  // Check for the optional list of attributes.
+  SmallVector<ast::NamedAttributeDecl *> attributes;
+  if (consumeIf(Token::l_brace)) {
+    do {
+      FailureOr<ast::NamedAttributeDecl *> decl = parseNamedAttributeDecl();
+      if (failed(decl))
+        return failure();
+      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.
+  SmallVector<ast::Expr *> resultTypes;
+  if (consumeIf(Token::arrow)) {
+    if (failed(parseToken(Token::l_paren,
+                          "expected `(` before operation result type list")))
+      return failure();
+
+    do {
+      FailureOr<ast::Expr *> resultTypeExpr = parseExpr();
+      if (failed(resultTypeExpr))
+        return failure();
+      resultTypes.push_back(*resultTypeExpr);
+    } while (consumeIf(Token::comma));
+
+    if (failed(parseToken(Token::r_paren,
+                          "expected `)` after operation result type list")))
+      return failure();
+  }
+
+  return createOperationExpr(loc, *opNameDecl, operands, attributes,
+                             resultTypes);
+}
+
 FailureOr<ast::Expr *> Parser::parseTypeExpr() {
   llvm::SMRange loc = curToken.getLoc();
   consumeToken(Token::kw_type);
 
   // If we aren't followed by a `<`, the `type` keyword is treated as a normal
   // identifier.
   if (!consumeIf(Token::less)) {
     resetToken(loc);
Parser::createMemberAccessExpr(ast::Expr *parentExpr, StringRef name,
 
   return ast::MemberAccessExpr::create(ctx, loc, parentExpr, name, *memberType);
 }
 
 FailureOr<ast::Type> Parser::validateMemberAccess(ast::Expr *parentExpr,
                                                   StringRef name,
                                                   llvm::SMRange loc) {
   ast::Type parentType = parentExpr->getType();
-  if (ast::OperationType opType = parentType.dyn_cast<ast::OperationType>()) {
-    // $results is a special member access representing all of the results.
-    // TODO: Should we have special AST expressions for these? How does the
-    // user reference these in the language itself?
-    if (name == "$results")
+  if (parentType.isa<ast::OperationType>()) {
+    if (name == ast::AllResultsMemberAccessExpr::getMemberName())
       return valueRangeTy;
   }
   return emitError(
       loc,
       llvm::formatv("invalid member access `{0}` on expression of type `{1}`",
                     name, parentType));
 }
 
+FailureOr<ast::OperationExpr *> Parser::createOperationExpr(
+    llvm::SMRange loc, const ast::OpNameDecl *name,
+    MutableArrayRef<ast::Expr *> operands,
+    MutableArrayRef<ast::NamedAttributeDecl *> attributes,
+    MutableArrayRef<ast::Expr *> results) {
+  Optional<StringRef> opNameRef = name->getName();
+
+  // Verify the inputs operands.
+  if (failed(validateOperationOperands(loc, opNameRef, 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.
+  if (failed(validateOperationResults(loc, opNameRef, results)))
+    return failure();
+
+  return ast::OperationExpr::create(ctx, loc, name, operands, results,
+                                    attributes);
+}
+
+LogicalResult
+Parser::validateOperationOperands(llvm::SMRange loc, Optional<StringRef> name,
+                                  MutableArrayRef<ast::Expr *> operands) {
+  return validateOperationOperandsOrResults(loc, name, operands, valueTy,
+                                            valueRangeTy);
+}
+
+LogicalResult
+Parser::validateOperationResults(llvm::SMRange loc, Optional<StringRef> name,
+                                 MutableArrayRef<ast::Expr *> results) {
+  return validateOperationOperandsOrResults(loc, name, results, typeTy,
+                                            typeRangeTy);
+}
+
+LogicalResult Parser::validateOperationOperandsOrResults(
+    llvm::SMRange loc, Optional<StringRef> name,
+    MutableArrayRef<ast::Expr *> values, ast::Type singleTy,
+    ast::Type rangeTy) {
+  // All operation types accept a single range parameter.
+  if (values.size() == 1) {
+    if (failed(convertExpressionTo(values[0], rangeTy)))
+      return failure();
+    return success();
+  }
+
+  // Otherwise, accept the value groups as they have been defined and just
+  // ensure they are one of the expected types.
+  for (ast::Expr *&valueExpr : values) {
+    ast::Type valueExprType = valueExpr->getType();
+
+    // Check if this is one of the expected types.
+    if (valueExprType == rangeTy || valueExprType == singleTy)
+      continue;
+
+    // If the operand is an Operation, allow converting to a Value or
+    // ValueRange. This situations arises quite often with nested operation
+    // expressions: `op<my_dialect.foo>(op<my_dialect.bar>)`
+    if (singleTy == valueTy) {
+      if (valueExprType.isa<ast::OperationType>()) {
+        valueExpr = convertOpToValue(valueExpr);
+        continue;
+      }
+    }
+
+    return emitError(
+        valueExpr->getLoc(),
+        llvm::formatv(
+            "expected `{0}` or `{1}` convertible expression, but got `{2}`",
+            singleTy, rangeTy, valueExprType));
+  }
+  return success();
+}
+
 //===----------------------------------------------------------------------===//
 // Stmts
 
 FailureOr<ast::EraseStmt *> Parser::createEraseStmt(llvm::SMRange loc,
                                                     ast::Expr *rootOp) {
   // Check that root is an Operation.
   ast::Type rootType = rootOp->getType();
   if (!rootType.isa<ast::OperationType>())

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

 Pattern {
   // CHECK: expected `>` after attribute literal
   let foo = attr<""<>;
 }
 
 // -----
 
 //===----------------------------------------------------------------------===//
+// `op` Expr
+//===----------------------------------------------------------------------===//
+
+Pattern {
+  // CHECK: expected `)` after operation operand list
+  let value: Value;
+  let foo = op<builtin.func>(value<;
+}
+
+// -----
+
+Pattern {
+  // CHECK: unable to convert expression of type `Attr` to the expected type of `ValueRange`
+  let attr: Attr;
+  let foo = op<builtin.func>(attr);
+}
+
+// -----
+
+Pattern {
+  // CHECK: expected `Value` or `ValueRange` convertible expression, but got `Type`
+  let foo = op<>(_: Type, _: TypeRange);
+}
+
+// -----
+
+Pattern {
+  // CHECK: expected identifier or string attribute name
+  let foo = op<> { 10;
+}
+
+// -----
+
+Pattern {
+  // CHECK: expected `Attr` expression, but got `Value`
+  let foo = op<> { foo = _: Value };
+}
+
+// -----
+
+Pattern {
+  // CHECK: expected `}` after operation attribute list
+  let foo = op<> { "foo" {;
+}
+
+// -----
+
+Pattern {
+  // CHECK: expected `(` before operation result type list
+  let foo = op<> -> );
+}
+
+// -----
+
+Pattern {
+  // CHECK: unable to convert expression of type `ValueRange` to the expected type of `TypeRange`
+  let foo = op<> -> (_: ValueRange);
+}
+
+// -----
+
+Pattern {
+  // CHECK: expected `Type` or `TypeRange` convertible expression, but got `Value`
+  let foo = op<> -> (_: Value, _: ValueRange);
+}
+
+// -----
+
+Pattern {
+  // CHECK: expected `)` after operation result type list
+  let value: TypeRange;
+  let foo = op<> -> (value<;
+}
+
+// -----
+
+//===----------------------------------------------------------------------===//
 // `type` Expr
 //===----------------------------------------------------------------------===//
 
 Pattern {
   // CHECK: expected string literal containing MLIR type
   let foo = type<foo;
 }
 
 // -----
 
 Pattern {
   // CHECK: expected `>` after type literal
   let foo = type<"";
 }

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

Pattern {
   let attr = attr<"10: i32">;
 
   erase _: Op;
 }
 
 // -----
 
 //===----------------------------------------------------------------------===//
+// OperationExpr
+//===----------------------------------------------------------------------===//
+
+// CHECK: Module
+// CHECK: `-OperationExpr {{.*}} Type<Op>
+// CHECK:   `-OpNameDecl
+Pattern {
+  erase op<>;
+}
+
+// -----
+
+// CHECK: Module
+// CHECK: `-OperationExpr {{.*}} Type<Op<my_dialect.foo>>
+// CHECK:   `-OpNameDecl {{.*}} Name<my_dialect.foo>
+Pattern {
+  erase op<my_dialect.foo>;
+}
+
+// -----
+
+// CHECK: Module
+// CHECK: `-OperationExpr {{.*}} Type<Op>
+// CHECK:   `-OpNameDecl
+// CHECK:   `Operands`
+// CHECK:     |-DeclRefExpr {{.*}} Type<Value>
+// CHECK:     |-DeclRefExpr {{.*}} Type<ValueRange>
+// CHECK:     `-DeclRefExpr {{.*}} Type<Value>
+Pattern {
+  erase op<>(_: Value, _: ValueRange, _: Value);
+}
+
+// -----
+
+// CHECK: Module
+// CHECK: `-OperationExpr {{.*}} Type<Op>
+// CHECK:   `-OpNameDecl
+// CHECK:   `Operands`
+// CHECK:     `-MemberAccessExpr {{.*}} Member<$results> Type<ValueRange>
+// CHECK:       `-OperationExpr {{.*}} Type<Op<my_dialect.bar>>
+// CHECK:         `-OpNameDecl {{.*}} Name<my_dialect.bar>
+Pattern {
+  erase op<>(op<my_dialect.bar>);
+}
+
+// -----
+
+// CHECK: Module
+// CHECK: `-OperationExpr {{.*}} Type<Op>
+// CHECK:   `-OpNameDecl
+// CHECK:   `Attributes`
+// CHECK:     |-NamedAttributeDecl {{.*}} Name<unitAttr>
+// CHECK:       `-AttributeExpr {{.*}} Value<"unit">
+// CHECK:     `-NamedAttributeDecl {{.*}} Name<normal$Attr>
+// CHECK:       `-DeclRefExpr {{.*}} Type<Attr>
+
+Pattern {
+  erase op<> {unitAttr, "normal$Attr" = _: Attr};
+}
+
+// -----
+
+// CHECK: Module
+// CHECK: `-OperationExpr {{.*}} Type<Op>
+// CHECK:   `-OpNameDecl
+// CHECK:   `Result Types`
+// CHECK:     |-DeclRefExpr {{.*}} Type<Type>
+// CHECK:     |-DeclRefExpr {{.*}} Type<TypeRange>
+// CHECK:     `-DeclRefExpr {{.*}} Type<Type>
+Pattern {
+  erase op<> -> (_: Type, _: TypeRange, _: Type);
+}
+
+// -----
+
+//===----------------------------------------------------------------------===//
 // TypeExpr
 //===----------------------------------------------------------------------===//
 
 // CHECK: Module
 // CHECK: `-TypeExpr {{.*}} Value<"i64">
 Pattern {
   let type = type<"i64">;
 
   erase _: Op;
 }