[PDLL] Add support for tuple types and expressions

[rriddle]

Summary

Tuples are used to group multiple elements into a single
compound value. The values in a tuple can be of any type, and
do not need to be of the same type. There is also no limit to
the number of elements held by a tuple.

Tuples will be used to support multiple results from
Constraints and Rewrites (added in a followup), and will also
make it easier to support more complex primitives (such as
range based maps that can operate on multiple values).

Depends On D115296

[nicolasvasilache]

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

893

nl

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

1427

some error message for out-of-bounds rather than just crash?

[Mogball]

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

459

I'm seeing makeMutableArrayRef(...) and {...} used interchangeably throughout these patches. Should one be preferred for consistency?

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

423

llvm::to_string?

[jpienaar]

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

212

I don't see where it is verified that the names are unique.

213

I'm not clear on the value of this tuple/named map construct being added. I can see this from adding constraints/matching side, but as a standalone data entity not so clear.

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

1054

rm ?

1425

So no names can start with digit and there would be an error if this were true?

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

66

Could you add 2 more tests:

1. name starting with digit
2. repeated name use

[rriddle]

Update

[rriddle]

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

213

The tuple construct has various uses, outside of just multiple result constraint/rewrites. For one, the range based expressions use tuples to support application on multiple ranges; e.g.:

let range1: ValueRange;
let range2: ValueRange;
let range3: TypeRange;
map((range1, range2, range3), Rewrite(arg1: Value, arg2: Value, type: Type) {

});

IMO we need some struct/tuple like construct to support any kind of functional builtins. I don't think it has much use within a specific pattern/constraint/rewrite, but for enabling higher order builtin constructs (multi-result constraints/rewrites, functional builtins, etc.) it has various benefits.

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

1425

Yep, added a test to ensure it.

1427

There should be an error message already, the index < tupleType.size() handles the bounds check. This is tested in one of the tests:

let tuple = (result1 = value: Value, result2 = value);
let tuple2 = (tuple.0, tuple.2);
> invalid member access `2` on expression of type `Tuple<result1: Value, result2: Value>`

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

private:
   /// TrailingObject utilities.
   friend llvm::TrailingObjects<OperationExpr, Expr *, NamedAttributeDecl *>;
   size_t numTrailingObjects(OverloadToken<Expr *>) const {
     return numOperands + numResultTypes;
   }
 };
 
 //===----------------------------------------------------------------------===//
+// TupleExpr
+//===----------------------------------------------------------------------===//
+
+/// This expression builds a tuple from a set of element values.
+class TupleExpr final : public Node::NodeBase<TupleExpr, Expr>,
+                        private llvm::TrailingObjects<TupleExpr, Expr *> {
+public:
+  static TupleExpr *create(Context &ctx, llvm::SMRange loc,
+                           ArrayRef<Expr *> elements,
+                           ArrayRef<StringRef> elementNames);
+
+  /// Return the element expressions of this tuple.
+  MutableArrayRef<Expr *> getElements() {
+    return {getTrailingObjects<Expr *>(), getType().size()};
+  }
+  ArrayRef<Expr *> getElements() const {
+    return const_cast<TupleExpr *>(this)->getElements();
+  }
+
+  /// Return the tuple result type of this expression.
+  TupleType getType() const { return Base::getType().cast<TupleType>(); }
+
+private:
+  TupleExpr(llvm::SMRange loc, TupleType type) : Base(loc, type) {}
+
+  /// TrailingObject utilities.
+  friend class llvm::TrailingObjects<TupleExpr, Expr *>;
+};
+
+//===----------------------------------------------------------------------===//
 // 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);

 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, OperationExpr,
-             TypeExpr>(node);
+             TupleExpr, 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/include/mlir/Tools/PDLL/AST/Types.h

 namespace ast {
 class Context;
 
 namespace detail {
 struct AttributeTypeStorage;
 struct ConstraintTypeStorage;
 struct OperationTypeStorage;
 struct RangeTypeStorage;
+struct TupleTypeStorage;
 struct TypeTypeStorage;
 struct ValueTypeStorage;
 } // namespace detail
 
 //===----------------------------------------------------------------------===//
 // Type
 //===----------------------------------------------------------------------===//
 
public:
   /// Provide type casting support.
   static bool classof(Type type);
 
   /// Return an instance of the ValueRange type.
   static ValueRangeType get(Context &context);
 };
 
 //===----------------------------------------------------------------------===//
+// TupleType
+//===----------------------------------------------------------------------===//
+
+/// This class represents a PDLL tuple type, i.e. an ordered set of element
+/// types with optional names.
+class TupleType : public Type::TypeBase<detail::TupleTypeStorage> {
+public:
+  using Base::Base;
+
+  /// Return an instance of the Tuple type.
+  static TupleType get(Context &context, ArrayRef<Type> elementTypes,
+                       ArrayRef<StringRef> elementNames);
+  static TupleType get(Context &context,
+                       ArrayRef<Type> elementTypes = llvm::None);
+
+  /// Return the element types of this tuple.
+  ArrayRef<Type> getElementTypes() const;
+
+  /// Return the element names of this tuple.
+  ArrayRef<StringRef> getElementNames() const;
+
+  /// Return the number of elements within this tuple.
+  size_t size() const { return getElementTypes().size(); }
+
+  /// Return if the tuple has no elements.
+  bool empty() const { return size() == 0; }
+};
+
+//===----------------------------------------------------------------------===//
 // TypeType
 //===----------------------------------------------------------------------===//
 
 /// This class represents a PDLL type that corresponds to an mlir::Type.
 class TypeType : public Type::TypeBase<detail::TypeTypeStorage> {
 public:
   using Base::Base;
 

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

 Context::Context() {
   typeUniquer.registerSingletonStorageType<detail::AttributeTypeStorage>();
   typeUniquer.registerSingletonStorageType<detail::ConstraintTypeStorage>();
   typeUniquer.registerSingletonStorageType<detail::TypeTypeStorage>();
   typeUniquer.registerSingletonStorageType<detail::ValueTypeStorage>();
 
   typeUniquer.registerParametricStorageType<detail::OperationTypeStorage>();
   typeUniquer.registerParametricStorageType<detail::RangeTypeStorage>();
+  typeUniquer.registerParametricStorageType<detail::TupleTypeStorage>();
 }

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

private:
   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 TupleExpr *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);
TypeSwitch<Type>(type)
         os << "Op";
         if (Optional<StringRef> name = type.getName())
           os << "<" << *name << ">";
       })
       .Case([&](RangeType type) {
         print(type.getElementType());
         os << "Range";
       })
+      .Case([&](TupleType type) {
+        os << "Tuple<";
+        llvm::interleaveComma(
+            llvm::zip(type.getElementNames(), type.getElementTypes()), os,
+            [&](auto it) {
+              if (!std::get<0>(it).empty())
+                os << std::get<0>(it) << ": ";
+              this->print(std::get<1>(it));
+            });
+        os << ">";
+      })
       .Case([&](TypeType) { os << "Type"; })
       .Case([&](ValueType) { os << "Value"; })
       .Default([](Type) { llvm_unreachable("unknown AST type"); });
 }
 
 void NodePrinter::print(const Node *node) {
   printIndent();
   os << "-";
 
   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 OperationExpr, const TypeExpr,
+          const OperationExpr, const TupleExpr, const TypeExpr,
 
           // Decls.
           const AttrConstraintDecl, const OpConstraintDecl,
           const TypeConstraintDecl, const TypeRangeConstraintDecl,
           const ValueConstraintDecl, const ValueRangeConstraintDecl,
           const NamedAttributeDecl, const OpNameDecl, const PatternDecl,
           const VariableDecl,
 
void NodePrinter::printImpl(const OperationExpr *expr) {
   os << ">\n";
 
   printChildren(expr->getNameDecl());
   printChildren("Operands", expr->getOperands());
   printChildren("Result Types", expr->getResultTypes());
   printChildren("Attributes", expr->getAttributes());
 }
 
+void NodePrinter::printImpl(const TupleExpr *expr) {
+  os << "TupleExpr " << expr << " Type<";
+  print(expr->getType());
+  os << ">\n";
+
+  printChildren(expr->getElements());
+}
+
 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);

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

OperationExpr *OperationExpr::create(
   return opExpr;
 }
 
 Optional<StringRef> OperationExpr::getName() const {
   return getNameDecl()->getName();
 }
 
 //===----------------------------------------------------------------------===//
+// TupleExpr
+//===----------------------------------------------------------------------===//
+
+TupleExpr *TupleExpr::create(Context &ctx, llvm::SMRange loc,
+                             ArrayRef<Expr *> elements,
+                             ArrayRef<StringRef> names) {
+  unsigned allocSize = TupleExpr::totalSizeToAlloc<Expr *>(elements.size());
+  void *rawData = ctx.getAllocator().Allocate(allocSize, alignof(TupleExpr));
+
+  auto elementTypes = llvm::map_range(
+      elements, [](const Expr *expr) { return expr->getType(); });
+  TupleType type = TupleType::get(ctx, llvm::to_vector(elementTypes), names);
+
+  TupleExpr *expr = new (rawData) TupleExpr(loc, type);
+  std::uninitialized_copy(elements.begin(), elements.end(),
+                          expr->getElements().begin());
+  return expr;
+}
+
+//===----------------------------------------------------------------------===//
 // TypeExpr
 //===----------------------------------------------------------------------===//
 
 TypeExpr *TypeExpr::create(Context &ctx, llvm::SMRange loc, StringRef value) {
   return new (ctx.getAllocator().Allocate<TypeExpr>())
       TypeExpr(ctx, loc, copyStringWithNull(ctx, value));
 }
 

mlir/lib/Tools/PDLL/AST/TypeDetail.h

 // RangeType
 //===----------------------------------------------------------------------===//
 
 struct RangeTypeStorage : public TypeStorageBase<RangeTypeStorage, Type> {
   using Base::Base;
 };
 
 //===----------------------------------------------------------------------===//
+// TupleType
+//===----------------------------------------------------------------------===//
+
+struct TupleTypeStorage
+    : public TypeStorageBase<TupleTypeStorage,
+                             std::pair<ArrayRef<Type>, ArrayRef<StringRef>>> {
+  using Base::Base;
+
+  static TupleTypeStorage *
+  construct(StorageUniquer::StorageAllocator &alloc,
+            std::pair<ArrayRef<Type>, ArrayRef<StringRef>> key) {
+    SmallVector<StringRef> names = llvm::to_vector(llvm::map_range(
+        key.second, [&](StringRef name) { return alloc.copyInto(name); }));
+    return new (alloc.allocate<TupleTypeStorage>()) TupleTypeStorage(
+        std::make_pair(alloc.copyInto(key.first),
+                       alloc.copyInto(llvm::makeArrayRef(names))));
+  }
+};
+
+//===----------------------------------------------------------------------===//
 // TypeType
 //===----------------------------------------------------------------------===//
 
 struct TypeTypeStorage : public TypeStorageBase<TypeTypeStorage> {};
 
 //===----------------------------------------------------------------------===//
 // ValueType
 //===----------------------------------------------------------------------===//

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

 }
 
 ValueRangeType ValueRangeType::get(Context &context) {
   return RangeType::get(context, ValueType::get(context))
       .cast<ValueRangeType>();
 }
 
 //===----------------------------------------------------------------------===//
+// TupleType
+//===----------------------------------------------------------------------===//
+
+TupleType TupleType::get(Context &context, ArrayRef<Type> elementTypes,
+                         ArrayRef<StringRef> elementNames) {
+  assert(elementTypes.size() == elementNames.size());
+  return context.getTypeUniquer().get<ImplTy>(
+      /*initFn=*/function_ref<void(ImplTy *)>(), elementTypes, elementNames);
+}
+TupleType TupleType::get(Context &context, ArrayRef<Type> elementTypes) {
+  SmallVector<StringRef> elementNames(elementTypes.size());
+  return get(context, elementTypes, elementNames);
+}
+
+ArrayRef<Type> TupleType::getElementTypes() const {
+  return getImplAs<ImplTy>()->getValue().first;
+}
+
+ArrayRef<StringRef> TupleType::getElementNames() const {
+  return getImplAs<ImplTy>()->getValue().second;
+}
+
+//===----------------------------------------------------------------------===//
 // TypeType
 //===----------------------------------------------------------------------===//
 
 TypeType TypeType::get(Context &context) {
   return context.getTypeUniquer().get<ImplTy>();
 }
 
 //===----------------------------------------------------------------------===//
 // ValueType
 //===----------------------------------------------------------------------===//
 
 ValueType ValueType::get(Context &context) {
   return context.getTypeUniquer().get<ImplTy>();
 }

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

 //===- Parser.cpp ---------------------------------------------------------===//
 //
 // Part of the LLVM Project, 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/Tools/PDLL/Parser/Parser.h"
 #include "Lexer.h"
 #include "mlir/Support/LogicalResult.h"
 #include "mlir/Tools/PDLL/AST/Context.h"
 #include "mlir/Tools/PDLL/AST/Diagnostic.h"
 #include "mlir/Tools/PDLL/AST/Nodes.h"
 #include "mlir/Tools/PDLL/AST/Types.h"
+#include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/TypeSwitch.h"
 #include "llvm/Support/FormatVariadic.h"
 #include "llvm/Support/SaveAndRestore.h"
+#include "llvm/Support/ScopedPrinter.h"
 #include <string>
 
 using namespace mlir;
 using namespace mlir::pdll;
 
 //===----------------------------------------------------------------------===//
 // Parser
 //===----------------------------------------------------------------------===//
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 *> parseTupleExpr();
   FailureOr<ast::Expr *> parseTypeExpr();
   FailureOr<ast::Expr *> parseUnderscoreExpr();
 
   //===--------------------------------------------------------------------===//
   // Stmts
 
   FailureOr<ast::Stmt *> parseStmt(bool expectTerminalSemicolon = true);
   FailureOr<ast::CompoundStmt *> parseCompoundStmt();
private:
   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);
+  FailureOr<ast::TupleExpr *> createTupleExpr(llvm::SMRange loc,
+                                              ArrayRef<ast::Expr *> elements,
+                                              ArrayRef<StringRef> elementNames);
 
   //===--------------------------------------------------------------------===//
   // Stmts
 
   FailureOr<ast::EraseStmt *> createEraseStmt(llvm::SMRange loc,
                                               ast::Expr *rootOp);
 
   //===--------------------------------------------------------------------===//
LogicalResult Parser::convertExpressionTo(
   // figure out some way to support both.
   if ((exprType == valueTy || exprType == valueRangeTy) &&
       (type == valueTy || type == valueRangeTy))
     return success();
   if ((exprType == typeTy || exprType == typeRangeTy) &&
       (type == typeTy || type == typeRangeTy))
     return success();
 
+  // Handle tuple types.
+  if (auto exprTupleType = exprType.dyn_cast<ast::TupleType>()) {
+    auto tupleType = type.dyn_cast<ast::TupleType>();
+    if (!tupleType || tupleType.size() != exprTupleType.size())
+      return emitConvertError();
+
+    // Build a new tuple expression using each of the elements of the current
+    // tuple.
+    SmallVector<ast::Expr *> newExprs;
+    for (unsigned i = 0, e = exprTupleType.size(); i < e; ++i) {
+      newExprs.push_back(ast::MemberAccessExpr::create(
+          ctx, expr->getLoc(), expr, llvm::to_string(i),
+          exprTupleType.getElementTypes()[i]));
+
+      auto diagFn = [&](ast::Diagnostic &diag) {
+        diag.attachNote(llvm::formatv("when converting element #{0} of `{1}`",
+                                      i, exprTupleType));
+        if (noteAttachFn)
+          noteAttachFn(diag);
+      };
+      if (failed(convertExpressionTo(newExprs.back(),
+                                     tupleType.getElementTypes()[i], diagFn)))
+        return failure();
+    }
+    expr = ast::TupleExpr::create(ctx, expr->getLoc(), newExprs,
+                                  tupleType.getElementNames());
+    return success();
+  }
+
   return emitConvertError();
 }
 
 //===----------------------------------------------------------------------===//
 // Directives
 
 LogicalResult Parser::parseDirective(SmallVector<ast::Decl *> &decls) {
   StringRef directive = curToken.getSpelling();
case Token::identifier:
     lhsExpr = parseIdentifierExpr();
     break;
   case Token::kw_op:
     lhsExpr = parseOperationExpr();
     break;
   case Token::kw_type:
     lhsExpr = parseTypeExpr();
     break;
+  case Token::l_paren:
+    lhsExpr = parseTupleExpr();
+    break;
   default:
     return emitError("expected expression");
   }
   if (failed(lhsExpr))
     return failure();
 
   // Check for an operator expression.
   while (true) {
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::parseTupleExpr() {
+  llvm::SMRange loc = curToken.getLoc();
+  consumeToken(Token::l_paren);
+
+  DenseMap<StringRef, llvm::SMRange> usedNames;
+  SmallVector<StringRef> elementNames;
+  SmallVector<ast::Expr *> elements;
+  if (curToken.isNot(Token::r_paren)) {
+    do {
+      // Check for the optional element name assignment before the value.
+      StringRef elementName;
+      if (curToken.is(Token::identifier) || curToken.isDependentKeyword()) {
+        Token elementNameTok = curToken;
+        consumeToken();
+
+        // The element name is only present if followed by an `=`.
+        if (consumeIf(Token::equal)) {
+          elementName = elementNameTok.getSpelling();
+
+          // Check to see if this name is already used.
+          auto elementNameIt =
+              usedNames.try_emplace(elementName, elementNameTok.getLoc());
+          if (!elementNameIt.second) {
+            return emitErrorAndNote(
+                elementNameTok.getLoc(),
+                llvm::formatv("duplicate tuple element label `{0}`",
+                              elementName),
+                elementNameIt.first->getSecond(),
+                "see previous label use here");
+          }
+        } else {
+          // Otherwise, we treat this as part of an expression so reset the
+          // lexer.
+          resetToken(elementNameTok.getLoc());
+        }
+      }
+      elementNames.push_back(elementName);
+
+      // Parse the tuple element value.
+      FailureOr<ast::Expr *> element = parseExpr();
+      if (failed(element))
+        return failure();
+      elements.push_back(*element);
+    } while (consumeIf(Token::comma));
+  }
+  loc.End = curToken.getEndLoc();
+  if (failed(
+          parseToken(Token::r_paren, "expected `)` after tuple element list")))
+    return failure();
+  return createTupleExpr(loc, elements, elementNames);
+}
+
 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);

 
 FailureOr<ast::Type> Parser::validateMemberAccess(ast::Expr *parentExpr,
                                                   StringRef name,
                                                   llvm::SMRange loc) {
   ast::Type parentType = parentExpr->getType();
   if (parentType.isa<ast::OperationType>()) {
     if (name == ast::AllResultsMemberAccessExpr::getMemberName())
       return valueRangeTy;
+  } 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];
+    }
+
+    // Handle named results.
+    auto elementNames = tupleType.getElementNames();
+    auto it = llvm::find(elementNames, name);
+    if (it != elementNames.end())
+      return tupleType.getElementTypes()[it - elementNames.begin()];
   }
   return emitError(
       loc,
       llvm::formatv("invalid member access `{0}` on expression of type `{1}`",
                     name, parentType));
 }
 
 FailureOr<ast::OperationExpr *> Parser::createOperationExpr(
return emitError(
         valueExpr->getLoc(),
         llvm::formatv(
             "expected `{0}` or `{1}` convertible expression, but got `{2}`",
             singleTy, rangeTy, valueExprType));
   }
   return success();
 }
 
+FailureOr<ast::TupleExpr *>
+Parser::createTupleExpr(llvm::SMRange loc, ArrayRef<ast::Expr *> elements,
+                        ArrayRef<StringRef> elementNames) {
+  for (const ast::Expr *element : elements) {
+    ast::Type eleTy = element->getType();
+    if (eleTy.isa<ast::ConstraintType, ast::TupleType>()) {
+      return emitError(
+          element->getLoc(),
+          llvm::formatv("unable to build a tuple with `{0}` element", eleTy));
+    }
+  }
+  return ast::TupleExpr::create(ctx, loc, elements, elementNames);
+}
+
 //===----------------------------------------------------------------------===//
 // 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: invalid member access `unknown_result` on expression of type `Op`
   let root: Op;
   erase root.unknown_result;
 }
 
 // -----
 
+Pattern {
+  let tuple = (result1 = value: Value, result2 = value);
+
+  // CHECK: invalid member access `unknown_result` on expression of type `Tuple<result1: Value, result2: Value>`
+  let tuple2 = (tuple.result1, tuple.unknown_result);
+
+  erase op<>;
+}
+
+// -----
+
+Pattern {
+  let tuple = (result1 = value: Value, result2 = value);
+
+  // CHECK: invalid member access `2` on expression of type `Tuple<result1: Value, result2: Value>`
+  let tuple2 = (tuple.0, tuple.2);
+
+  erase op<>;
+}
+
+// -----
+
+//===----------------------------------------------------------------------===//
+// Tuple Expr
+//===----------------------------------------------------------------------===//
+
+Pattern {
+  // CHECK: expected `)` after tuple element list
+  let tuple = (value: Value, value;
+}
+
+// -----
+
+Pattern {
+  // CHECK: unable to build a tuple with `Tuple<Value, Value>` element
+  let tuple = (_: Value, _: Value);
+  let var = (tuple);
+  erase op<>;
+}
+
+// -----
+
+Pattern {
+  // CHECK: expected expression
+  let tuple = (10 = _: Value);
+  erase op<>;
+}
+
+// -----
+
+Pattern {
+  // CHECK: duplicate tuple element label `field`
+  // CHECK: see previous label use here
+  let tuple = (field = _: Value, field = _: Value);
+  erase op<>;
+}
+
+// -----
+
 //===----------------------------------------------------------------------===//
 // `attr` Expr
 //===----------------------------------------------------------------------===//
 
 Pattern {
   // CHECK: expected string literal containing MLIR attribute
   let foo = attr<foo>;
 }

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

Pattern {
   let attr = attr<"10: i32">;
 
   erase _: Op;
 }
 
 // -----
 
 //===----------------------------------------------------------------------===//
+// MemberAccessExpr
+//===----------------------------------------------------------------------===//
+
+// CHECK: Module
+// CHECK: `-VariableDecl {{.*}} Name<firstEltIndex> Type<Op>
+// CHECK:   `-MemberAccessExpr {{.*}} Member<0> Type<Op>
+// CHECK:     `-DeclRefExpr {{.*}} Type<Tuple<firstElt: Op>>
+// CHECK: `-VariableDecl {{.*}} Name<firstEltName> Type<Op>
+// CHECK:   `-MemberAccessExpr {{.*}} Member<firstElt> Type<Op>
+// CHECK:     `-DeclRefExpr {{.*}} Type<Tuple<firstElt: Op>>
+Pattern {
+  let tuple = (firstElt = _: Op);
+  let firstEltIndex = tuple.0;
+  let firstEltName = tuple.firstElt;
+
+  erase _: Op;
+}
+
+// -----
+
+//===----------------------------------------------------------------------===//
 // OperationExpr
 //===----------------------------------------------------------------------===//
 
 // CHECK: Module
 // CHECK: `-OperationExpr {{.*}} Type<Op>
 // CHECK:   `-OpNameDecl
 Pattern {
   erase op<>;

 // CHECK:     `-DeclRefExpr {{.*}} Type<Type>
 Pattern {
   erase op<> -> (_: Type, _: TypeRange, _: Type);
 }
 
 // -----
 
 //===----------------------------------------------------------------------===//
+// TupleExpr
+//===----------------------------------------------------------------------===//
+
+// CHECK: Module
+// CHECK: `-VariableDecl {{.*}} Name<emptyTuple>
+// CHECK:   `-TupleExpr {{.*}} Type<Tuple<>>
+// CHECK: `-VariableDecl {{.*}} Name<mixedTuple>
+// CHECK:   `-TupleExpr {{.*}} Type<Tuple<arg1: Attr, Value>>
+// CHECK:     |-DeclRefExpr {{.*}} Type<Attr>
+// CHECK:     `-DeclRefExpr {{.*}} Type<Value>
+Pattern {
+  let value: Value;
+
+  let emptyTuple = ();
+  let mixedTuple = (arg1 = _: Attr, value);
+
+  erase _: Op;
+}
+
+// -----
+
+//===----------------------------------------------------------------------===//
 // TypeExpr
 //===----------------------------------------------------------------------===//
 
 // CHECK: Module
 // CHECK: `-TypeExpr {{.*}} Value<"i64">
 Pattern {
   let type = type<"i64">;
 
   erase _: Op;
 }