[mlir] make structured transform ops use types

Types have been introduced a while ago and provide for better
readability and transform-time verification. Use them in the ops from
the structured transform dialect extension.

In most cases, the types are appended as trailing functional types or a
derived format of the functional type that allows for an empty right
hand size without the annoying `-> ()` syntax (similarly to `func.func`
declaration that may omit the arrow). When handles are used inside mixed
static/dynamic lists, such as tile sizes, types of those handles follow
them immediately as in `sizes [%0 : !transform.any_value, 42]`. This
allows for better readability than matching the trailing type.

Update code to remove hardcoded PDL dependencies and expunge PDL from
structured transform op code.

Reviewed By: nicolasvasilache

Differential Revision: https://reviews.llvm.org/D144515

Author: ftynse

mlir/include/mlir/Dialect/Linalg/TransformOps/LinalgTransformOps.td

@@ -0,0 +1,47 @@
+//===- Syntax.h - Custom syntax for Linalg transform ops --------*- C++ -*-===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef MLIR_DIALECT_LINALG_TRANSFORMOPS_SYNTAX_H
+#define MLIR_DIALECT_LINALG_TRANSFORMOPS_SYNTAX_H
+
+#include "mlir/Support/LLVM.h"
+
+namespace mlir {
+class ParseResult;
+class OpAsmParser;
+class OpAsmPrinter;
+class Type;
+class TypeRange;
+class Operation;
+
+/// Parses a single non-function type or a function type with at least one
+/// argument. This allows for the following syntax:
+///
+///   - type: just the argument type;
+///   - `(` type `)` `->` type: one argument and one result type;
+///   - `(` type `)` `->` `(` comma-separated-type-list `)`: one argument and
+///     multiple result types.
+///
+/// Unlike FunctionType, this allows and requires one to omit the parens around
+/// the argument type in absence of result types, and does not accept the
+/// trailing `-> ()` construct, which makes the syntax nicer for operations.
+ParseResult parseSemiFunctionType(OpAsmParser &parser, Type &argumentType,
+                                  Type &resultType);
+ParseResult parseSemiFunctionType(OpAsmParser &parser, Type &argumentType,
+                                  SmallVectorImpl<Type> &resultTypes);
+
+/// Prints argument and result types in a syntax similar to that of FunctionType
+/// but allowing and requiring one to omit the parens around the argument type
+/// in absence of result types, and without the trailing `-> ()`.
+void printSemiFunctionType(OpAsmPrinter &printer, Operation *op,
+                           Type argumentType, TypeRange resultType);
+void printSemiFunctionType(OpAsmPrinter &printer, Operation *op,
+                           Type argumentType, Type resultType);
+} // namespace mlir
+
+#endif // MLIR_DIALECT_LINALG_TRANSFORMOPS_SYNTAX_H

mlir/include/mlir/Dialect/Linalg/TransformOps/Syntax.h

@@ -22,28 +22,32 @@ class TransformState;
 
 /// Printer hook for custom directive in assemblyFormat.
 ///
-///   custom<PackedOrDynamicIndexList>($packed, $values, $integers)
+///   custom<PackedOrDynamicIndexList>($packed, type($packed), $values,
+///       type($values), $integers)
 ///
 /// where `values` are variadic Index values, `integers` is an `I64ArrayAttr`
 /// and `packed` is a single transform dialect handle who's mapped payload ops
 /// have a single Index result and represent the index list. Either `packed`
 /// or the other two parameters may be specified.
 ///
 /// This allows idiomatic printing of mixed value and integer attributes in a
-/// list or with a single handle. E.g., `[%arg0, 7, 42, %arg42]` or just `%h`.
+/// list or with a single handle. E.g., `[%arg0 : !transform.any_op, 7, 42,
+/// %arg42 : !transform.param<i64>]` or just `%h : !transform.any_op`.
 void printPackedOrDynamicIndexList(OpAsmPrinter &printer, Operation *op,
-                                   Value packed, OperandRange values,
+                                   Value packed, Type packedType,
+                                   OperandRange values, TypeRange valueTypes,
                                    ArrayRef<int64_t> integers);
 
-/// Pasrer hook for custom directive in assemblyFormat.
+/// Parser hook for custom directive in assemblyFormat.
 ///
-///   custom<PackedOrDynamicIndexList>($packed, $values, $integers)
+///   custom<PackedOrDynamicIndexList>($packed, type($packed), $values,
+///       type($values), $integers)
 ///
 /// See `printPackedOrDynamicIndexList` for details.
 ParseResult parsePackedOrDynamicIndexList(
     OpAsmParser &parser, std::optional<OpAsmParser::UnresolvedOperand> &packed,
-    SmallVectorImpl<OpAsmParser::UnresolvedOperand> &values,
-    DenseI64ArrayAttr &integers);
+    Type &packedType, SmallVectorImpl<OpAsmParser::UnresolvedOperand> &values,
+    SmallVectorImpl<Type> &valueTypes, DenseI64ArrayAttr &integers);
 } // namespace transform
 } // namespace mlir
 

mlir/include/mlir/Dialect/Transform/Utils/Utils.h

@@ -42,35 +42,49 @@ namespace mlir {
 /// Printer hook for custom directive in assemblyFormat.
 ///
 ///   custom<DynamicIndexList>($values, $integers)
+///   custom<DynamicIndexList>($values, $integers, type($values))
 ///
-/// where `values` is of ODS type `Variadic<Index>` and `integers` is of ODS
+/// where `values` is of ODS type `Variadic<*>` and `integers` is of ODS
 /// type `I64ArrayAttr`. Prints a list with either (1) the static integer value
-/// in `integers` is `dynVal` or (2) the next value otherwise. This allows
-/// idiomatic printing of mixed value and integer attributes in a list. E.g.
-/// `[%arg0, 7, 42, %arg42]`.
+/// in `integers` is `kDynamic` or (2) the next value otherwise. If `valueTypes`
+/// is non-empty, it is expected to contain as many elements as `values`
+/// indicating their types. This allows idiomatic printing of mixed value and
+/// integer attributes in a list. E.g.
+/// `[%arg0 : index, 7, 42, %arg42 : i32]`.
 void printDynamicIndexList(
     OpAsmPrinter &printer, Operation *op, OperandRange values,
-    ArrayRef<int64_t> integers,
+    ArrayRef<int64_t> integers, TypeRange valueTypes = TypeRange(),
     AsmParser::Delimiter delimiter = AsmParser::Delimiter::Square);
 
-/// Pasrer hook for custom directive in assemblyFormat.
+/// Parser hook for custom directive in assemblyFormat.
 ///
 ///   custom<DynamicIndexList>($values, $integers)
+///   custom<DynamicIndexList>($values, $integers, type($values))
 ///
-/// where `values` is of ODS type `Variadic<Index>` and `integers` is of ODS
+/// where `values` is of ODS type `Variadic<*>` and `integers` is of ODS
 /// type `I64ArrayAttr`. Parse a mixed list with either (1) static integer
 /// values or (2) SSA values. Fill `integers` with the integer ArrayAttr, where
-/// `dynVal` encodes the position of SSA values. Add the parsed SSA values
-/// to `values` in-order.
-//
-/// E.g. after parsing "[%arg0, 7, 42, %arg42]":
-///   1. `result` is filled with the i64 ArrayAttr "[`dynVal`, 7, 42, `dynVal`]"
+/// `kDynamic` encodes the position of SSA values. Add the parsed SSA values
+/// to `values` in-order. If `valueTypes` is non-null, fill it with types
+/// corresponding to values; otherwise the caller must handle the types.
+///
+/// E.g. after parsing "[%arg0 : index, 7, 42, %arg42 : i32]":
+///   1. `result` is filled with the i64 ArrayAttr "[`kDynamic`, 7, 42,
+///   `kDynamic`]"
 ///   2. `ssa` is filled with "[%arg0, %arg1]".
 ParseResult parseDynamicIndexList(
     OpAsmParser &parser,
     SmallVectorImpl<OpAsmParser::UnresolvedOperand> &values,
-    DenseI64ArrayAttr &integers,
+    DenseI64ArrayAttr &integers, SmallVectorImpl<Type> *valueTypes = nullptr,
     AsmParser::Delimiter delimiter = AsmParser::Delimiter::Square);
+inline ParseResult parseDynamicIndexList(
+    OpAsmParser &parser,
+    SmallVectorImpl<OpAsmParser::UnresolvedOperand> &values,
+    DenseI64ArrayAttr &integers, SmallVectorImpl<Type> &valueTypes,
+    AsmParser::Delimiter delimiter = AsmParser::Delimiter::Square) {
+  return parseDynamicIndexList(parser, values, integers, &valueTypes,
+                               delimiter);
+}
 
 /// Verify that a the `values` has as many elements as the number of entries in
 /// `attr` for which `isDynamic` evaluates to true.

mlir/include/mlir/Interfaces/ViewLikeInterface.h

@@ -2,6 +2,7 @@ add_mlir_dialect_library(MLIRLinalgTransformOps
   DialectExtension.cpp
   LinalgMatchOps.cpp
   LinalgTransformOps.cpp
+  Syntax.cpp
 
   ADDITIONAL_HEADER_DIRS
   ${MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect/Linalg/TransformOps
@@ -19,7 +20,6 @@ add_mlir_dialect_library(MLIRLinalgTransformOps
   MLIRLinalgDialect
   MLIRLinalgTransforms
   MLIRParser
-  MLIRPDLDialect
   MLIRSCFDialect
   MLIRSideEffectInterfaces
   MLIRTransformDialect

mlir/lib/Dialect/Linalg/TransformOps/CMakeLists.txt

@@ -13,7 +13,6 @@
 #include "mlir/Dialect/Linalg/IR/Linalg.h"
 #include "mlir/Dialect/Linalg/TransformOps/LinalgMatchOps.h"
 #include "mlir/Dialect/Linalg/TransformOps/LinalgTransformOps.h"
-#include "mlir/Dialect/PDL/IR/PDL.h"
 #include "mlir/Dialect/SCF/IR/SCF.h"
 #include "mlir/Dialect/Tensor/IR/Tensor.h"
 #include "mlir/Dialect/Transform/IR/TransformDialect.h"
@@ -31,7 +30,6 @@ class LinalgTransformDialectExtension
   using Base::Base;
 
   void init() {
-    declareDependentDialect<pdl::PDLDialect>();
     declareDependentDialect<linalg::LinalgDialect>();
 
     declareGeneratedDialect<affine::AffineDialect>();

mlir/lib/Dialect/Linalg/TransformOps/DialectExtension.cpp

@@ -9,6 +9,7 @@
 #include "mlir/Dialect/Linalg/TransformOps/LinalgMatchOps.h"
 #include "mlir/Analysis/SliceAnalysis.h"
 #include "mlir/Dialect/Linalg/IR/Linalg.h"
+#include "mlir/Dialect/Linalg/TransformOps/Syntax.h"
 #include "mlir/Dialect/Transform/IR/MatchInterfaces.h"
 #include "mlir/IR/BuiltinAttributes.h"
 #include "mlir/IR/FunctionImplementation.h"
@@ -745,82 +746,6 @@ static void printStructuredTransformDims(OpAsmPrinter &printer, Operation *op,
     printer << ")";
   }
 }
-/// Parses a single non-function type or a function type with at least one
-/// argument. This allows for the following syntax:
-///
-///   - type: just the argument type;
-///   - `(` type `)` `->` type: one argument and one result type;
-///   - `(` type `)` `->` `(` comma-separated-type-list `)`: one argument and
-///     multiple result types.
-///
-/// Unlike FunctionType, this allows and requires one to omit the parens around
-/// the argument type in absence of result types, and does not accept the
-/// trailing `-> ()` construct, which makes the syntax nicer for operations.
-static ParseResult parseSemiFunctionType(OpAsmParser &parser,
-                                         Type &argumentType, Type &resultType) {
-  argumentType = resultType = nullptr;
-  bool hasLParen = parser.parseOptionalLParen().succeeded();
-  if (parser.parseType(argumentType).failed())
-    return failure();
-  if (!hasLParen)
-    return success();
-
-  return failure(parser.parseRParen().failed() ||
-                 parser.parseArrow().failed() ||
-                 parser.parseType(resultType).failed());
-}
-static ParseResult parseSemiFunctionType(OpAsmParser &parser,
-                                         Type &argumentType,
-                                         SmallVectorImpl<Type> &resultTypes) {
-  argumentType = nullptr;
-  bool hasLParen = parser.parseOptionalLParen().succeeded();
-  if (parser.parseType(argumentType).failed())
-    return failure();
-  if (!hasLParen)
-    return success();
-
-  if (parser.parseRParen().failed() || parser.parseArrow().failed())
-    return failure();
-
-  if (parser.parseOptionalLParen().failed()) {
-    Type type;
-    if (parser.parseType(type).failed())
-      return failure();
-    resultTypes.push_back(type);
-    return success();
-  }
-  if (parser.parseTypeList(resultTypes).failed() ||
-      parser.parseRParen().failed()) {
-    resultTypes.clear();
-    return failure();
-  }
-  return success();
-}
-
-/// Prints argument and result types in a syntax similar to that of FunctionType
-/// but allowing and requiring one to omit the parens around the argument type
-/// in absence of result types, and without the trailing `-> ()`.
-static void printSemiFunctionType(OpAsmPrinter &printer, Operation *op,
-                                  Type argumentType, TypeRange resultType) {
-  if (!resultType.empty())
-    printer << "(";
-  printer << argumentType;
-  if (resultType.empty())
-    return;
-  printer << ") -> ";
-
-  if (resultType.size() > 1)
-    printer << "(";
-  llvm::interleaveComma(resultType, printer.getStream());
-  if (resultType.size() > 1)
-    printer << ")";
-}
-static void printSemiFunctionType(OpAsmPrinter &printer, Operation *op,
-                                  Type argumentType, Type resultType) {
-  return printSemiFunctionType(printer, op, argumentType,
-                               resultType ? TypeRange(resultType)
-                                          : TypeRange());
-}
 
 #define GET_OP_CLASSES
 #include "mlir/Dialect/Linalg/TransformOps/LinalgMatchOps.cpp.inc"