support prefix parsing of ! + add parsing test

Author: martin-luecke

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

@@ -225,7 +225,10 @@ void NodePrinter::printImpl(const AttributeExpr *expr) {
 void NodePrinter::printImpl(const CallExpr *expr) {
   os << "CallExpr " << expr << " Type<";
   print(expr->getType());
-  os << ">\n";
+  os << ">";
+  if (expr->getIsNegated())
+    os << " negated";
+  os << "\n";
   printChildren(expr->getCallableExpr());
   printChildren("Arguments", expr->getArguments());
 }

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

@@ -31,8 +31,8 @@
 #include "llvm/Support/ScopedPrinter.h"
 #include "llvm/TableGen/Error.h"
 #include "llvm/TableGen/Parser.h"
-#include <string>
 #include <optional>
+#include <string>
 
 using namespace mlir;
 using namespace mlir::pdll;
@@ -324,6 +324,7 @@ class Parser {
   FailureOr<ast::Expr *> parseInlineConstraintLambdaExpr();
   FailureOr<ast::Expr *> parseInlineRewriteLambdaExpr();
   FailureOr<ast::Expr *> parseMemberAccessExpr(ast::Expr *parentExpr);
+  FailureOr<ast::Expr *> parseNegatedExpr();
   FailureOr<ast::OpNameDecl *> parseOperationName(bool allowEmptyName = false);
   FailureOr<ast::OpNameDecl *> parseWrappedOperationName(bool allowEmptyName);
   FailureOr<ast::Expr *>
@@ -1830,6 +1831,9 @@ FailureOr<ast::Expr *> Parser::parseExpr() {
   case Token::l_square:
     lhsExpr = parseArrayAttrExpr();
     break;
+  case Token::exclam:
+    lhsExpr = parseNegatedExpr();
+    break;
   case Token::string_block:
     return emitError("expected expression. If you are trying to create an "
                      "ArrayAttr, use a space between `[` and `{`.");
@@ -1845,11 +1849,11 @@ FailureOr<ast::Expr *> Parser::parseExpr() {
     case Token::dot:
       lhsExpr = parseMemberAccessExpr(*lhsExpr);
       break;
-    case Token::exclam:
-      // TODO: Fx: This parses the "!" as suffix instead of prefix.
-      consumeToken(Token::exclam);
-      lhsExpr = parseCallExpr(*lhsExpr, /*isNegated = */ true);
-      break;
+    // case Token::exclam:
+    //   // TODO: Fx: This parses the "!" as suffix instead of prefix.
+    //   consumeToken(Token::exclam);
+    //   lhsExpr = parseCallExpr(*lhsExpr, /*isNegated = */ true);
+    //   break;
     case Token::l_paren:
       lhsExpr = parseCallExpr(*lhsExpr);
       break;
@@ -2068,6 +2072,16 @@ FailureOr<ast::Expr *> Parser::parseMemberAccessExpr(ast::Expr *parentExpr) {
   return createMemberAccessExpr(parentExpr, memberName, loc);
 }
 
+FailureOr<ast::Expr *> Parser::parseNegatedExpr() {
+  consumeToken(Token::exclam);
+  if (!curToken.is(Token::identifier))
+    return emitError("expected native constraint");
+  FailureOr<ast::Expr *> identifierExpr = parseIdentifierExpr();
+  if (failed(identifierExpr))
+    return failure();
+  return parseCallExpr(*identifierExpr, /*isNegated = */ true);
+}
+
 FailureOr<ast::OpNameDecl *> Parser::parseOperationName(bool allowEmptyName) {
   SMRange loc = curToken.getLoc();
 

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

@@ -77,6 +77,21 @@ Pattern {
 
 // -----
 
+// CHECK: Module {{.*}}
+// CHECK:  -UserConstraintDecl {{.*}} Name<checkOp> ResultType<Tuple<>>
+// CHECK: `-PatternDecl {{.*}}
+// CHECK:   -CallExpr {{.*}} Type<Tuple<>> negated
+// CHECK:     `-DeclRefExpr {{.*}} Type<Constraint>
+// CHECK:       `-UserConstraintDecl {{.*}} Name<checkOp> ResultType<Tuple<>>
+Constraint checkOp(op: Op);
+
+Pattern {
+  let inputOp = op<my_dialect.bar>;
+  !checkOp(inputOp);
+  erase inputOp;
+}
+// -----
+
 //===----------------------------------------------------------------------===//
 // MemberAccessExpr
 //===----------------------------------------------------------------------===//