[mlir] Add `parseEllipsis`

[Mogball]

Summary

To AsmParser and also to the assembly format

mlir/include/mlir/IR/OpImplementation.h

public:
   virtual ParseResult parseOptionalLSquare() = 0;
 
   /// Parse a `]` token.
   virtual ParseResult parseRSquare() = 0;
 
   /// Parse a `]` token if present.
   virtual ParseResult parseOptionalRSquare() = 0;
 
+  /// Parse a `...` token.
+  virtual ParseResult parseEllipsis() = 0;
+
   /// Parse a `...` token if present;
   virtual ParseResult parseOptionalEllipsis() = 0;
 
   /// Parse a floating point value from the stream.
   virtual ParseResult parseFloat(double &result) = 0;
 
   /// Parse an integer value from the stream.
   template <typename IntT>

mlir/lib/AsmParser/AsmParserImpl.h

ParseResult parseComma() override {
     return parser.parseToken(Token::comma, "expected ','");
   }
 
   /// Parse a `,` token if present.
   ParseResult parseOptionalComma() override {
     return success(parser.consumeIf(Token::comma));
   }
 
+  /// Parses a `...`.
+  ParseResult parseEllipsis() override {
+    return parser.parseToken(Token::ellipsis, "expected '...'");
+  }
+
   /// Parses a `...` if present.
   ParseResult parseOptionalEllipsis() override {
     return success(parser.consumeIf(Token::ellipsis));
   }
 
   /// Parse a `=` token.
   ParseResult parseEqual() override {
     return parser.parseToken(Token::equal, "expected '='");

mlir/test/lib/Dialect/Test/TestOps.td

 }
 
 def OIListAllowedLiteral : TEST_Op<"oilist_allowed_literal"> {
   let assemblyFormat = [{
     oilist( `foo` | `bar` ) `buzz` attr-dict
   }];
 }
 
+def TestEllipsisOp : TEST_Op<"ellipsis"> {
+  let arguments = (ins Variadic<AnyType>:$operands, UnitAttr:$variadic);
+  let assemblyFormat = [{
+    `(` $operands (`...` $variadic^)? `)` attr-dict `:` type($operands) `...`
+  }];
+}
+
 def ElseAnchorOp : TEST_Op<"else_anchor"> {
   let arguments = (ins Optional<AnyType>:$a);
   let assemblyFormat = "`(` (`?`) : (`` $a^ `:` type($a))? `)` attr-dict";
 }
 
 // This is used to test encoding of a string attribute into an SSA name of a
 // pretty printed value name.
 def StringAttrPrettyNameOp

mlir/test/mlir-tblgen/op-format.mlir

 
 ^bb2:
   return
 }
 
 // CHECK: test.format_literal_following_optional_group(5 : i32) : i32 {a}
 test.format_literal_following_optional_group(5 : i32) : i32 {a}
 
+func.func @variadic(%a: i32) {
+  // CHECK: test.ellipsis(%{{.*}} ...) : i32 ...
+  test.ellipsis(%a ...) : i32 ...
+  return
+}
+
 //===----------------------------------------------------------------------===//
 // Format trait type inference
 //===----------------------------------------------------------------------===//
 
 // CHECK: test.format_infer_variadic_type_from_non_variadic %[[I64]], %[[I64]] : i64
 test.format_infer_variadic_type_from_non_variadic %i64, %i64 : i64
 
 //===----------------------------------------------------------------------===//

mlir/tools/mlir-tblgen/AttrOrTypeFormatGen.cpp

os << StringSwitch<StringRef>(value)
               .Case("}", "RBrace")
               .Case("(", "LParen")
               .Case(")", "RParen")
               .Case("[", "LSquare")
               .Case("]", "RSquare")
               .Case("?", "Question")
               .Case("+", "Plus")
               .Case("*", "Star")
+              .Case("...", "Ellipsis")
        << "()";
   }
   if (isOptional) {
     // Leave the `if` unclosed to guard optional groups.
     return;
   }
   // Parser will emit an error
   os << ") return {};\n";

mlir/tools/mlir-tblgen/FormatGen.cpp

if (value.size() == 1) {
     if (emitError)
       emitError("single character literal must be a letter or one of '" + bare +
                 "'");
     return false;
   }
   // Check the punctuation that are larger than a single character.
   if (value == "->")
     return true;
+  if (value == "...")
+    return true;
 
   // Otherwise, this must be an identifier.
   return canFormatStringAsKeyword(value, emitError);
 }
 
 //===----------------------------------------------------------------------===//
 // Commandline Options
 //===----------------------------------------------------------------------===//
 
 llvm::cl::opt<bool> mlir::tblgen::formatErrorIsFatal(
     "asmformat-error-is-fatal",
     llvm::cl::desc("Emit a fatal error if format parsing fails"),
     llvm::cl::init(true));

mlir/tools/mlir-tblgen/OpFormatGen.cpp

body << (StringRef)StringSwitch<StringRef>(value)
               .Case("{", "LBrace()")
               .Case("}", "RBrace()")
               .Case("(", "LParen()")
               .Case(")", "RParen()")
               .Case("[", "LSquare()")
               .Case("]", "RSquare()")
               .Case("?", "Question()")
               .Case("+", "Plus()")
-              .Case("*", "Star()");
+              .Case("*", "Star()")
+              .Case("...", "Ellipsis()");
 }
 
 /// Generate the storage code required for parsing the given element.
 static void genElementParserStorage(FormatElement *element, const Operator &op,
                                     MethodBody &body) {
   if (auto *optional = dyn_cast<OptionalElement>(element)) {
     ArrayRef<FormatElement *> elements = optional->getThenElements();