[MLIR] Fix block label parsing bug

[bondhugula]

Summary

Fix bug in Block label parsing:
https://github.com/llvm/llvm-project/issues/54343

The parseOptionalBlockArgList method was doing the wrong thing
(contrary to its doc comment) and its calling context was also
incorrect. This led to a parse failure for something like "^bb0()".

Fixes #54343

[bondhugula]

Adjust parsing context.

[bondhugula]

clang-format and add an extra test case.

[mehdi_amini]

Note if you write it in the description as Fixes #54343 it'll reference the commit and close the issues (the full URL instead of #54343 may work as well)

[bondhugula]

Update commit summary to reference github issue.

[bondhugula]

Tweak summary.

mlir/lib/Parser/Parser.cpp

ParseResult OperationParser::parseBlock(Block *&block) {
 
   block = defineBlockNamed(name, nameLoc, block);
 
   // Fail if the block was already defined.
   if (!block)
     return emitError(nameLoc, "redefinition of block '") << name << "'";
 
   // If an argument list is present, parse it.
-  if (consumeIf(Token::l_paren)) {
-    if (parseOptionalBlockArgList(block) ||
-        parseToken(Token::r_paren, "expected ')' to end argument list"))
+  if (getToken().is(Token::l_paren))
+    if (parseOptionalBlockArgList(block))
       return failure();
-  }
 
   if (parseToken(Token::colon, "expected ':' after block name"))
     return failure();
 
   return parseBlockBody(block);
 }
 
 ParseResult OperationParser::parseBlockBody(Block *block) {
Block *OperationParser::defineBlockNamed(StringRef name, SMLoc loc,
 
   // Populate the high level assembly state if necessary.
   if (state.asmState)
     state.asmState->addDefinition(blockAndLoc.block, loc);
 
   return blockAndLoc.block;
 }
 
-/// Parse a (possibly empty) list of SSA operands with types as block arguments.
+/// Parse a (possibly empty) list of SSA operands with types as block arguments
+/// enclosed in parentheses.
 ///
-///   ssa-id-and-type-list ::= ssa-id-and-type (`,` ssa-id-and-type)*
+///   value-id-and-type-list ::= value-id-and-type (`,` ssa-id-and-type)*
+///   block-arg-list ::= `(` value-id-and-type-list? `)`
 ///
 ParseResult OperationParser::parseOptionalBlockArgList(Block *owner) {
   if (getToken().is(Token::r_brace))
     return success();
 
   // If the block already has arguments, then we're handling the entry block.
   // Parse and register the names for the arguments, but do not add them.
   bool definingExistingArgs = owner->getNumArguments() != 0;
   unsigned nextArgument = 0;
 
-  return parseCommaSeparatedList([&]() -> ParseResult {
+  return parseCommaSeparatedList(Delimiter::Paren, [&]() -> ParseResult {
     return parseSSADefOrUseAndType(
         [&](SSAUseInfo useInfo, Type type) -> ParseResult {
           BlockArgument arg;
 
           // If we are defining existing arguments, ensure that the argument
           // has already been created with the right type.
           if (definingExistingArgs) {
             // Otherwise, ensure that this argument has already been created.

mlir/test/IR/invalid.mlir

 ^bb41:
 ^bb42:
   return
 }
 
 // -----
 
 func @block_no_rparen() {
-^bb42 (%bb42 : i32: // expected-error {{expected ')' to end argument list}}
+^bb42 (%bb42 : i32: // expected-error {{expected ')'}}
   return
 }
 
 // -----
 
 func @block_arg_no_ssaid() {
 ^bb42 (i32): // expected-error {{expected SSA operand}}
   return

 
 func @no_terminator() {
   cf.br ^bb1
 ^bb1:
   %x = arith.constant 0 : i32
   %y = arith.constant 1 : i32  // expected-error {{block with no terminator}}
 }
 
+// -----
+
+func @no_block_arg_enclosing_parens() {
+^bb %x: i32 : // expected-error {{expected ':' after block name}}
+  return
+}
 
 // -----
 
 "       // expected-error {{expected}}
 "
 
 // -----
 

mlir/test/IR/parser.mlir

 ^bb42 (%arg0: i32, %f: i64):
   // CHECK: "bar"(%{{.*}}) : (i64) -> (i1, i1, i1)
   %2:3 = "bar"(%f) : (i64) -> (i1,i1,i1)
   // CHECK: return{{$}}
   return
 // CHECK: }
 }
 
+// CHECK-LABEL: func @block_label_empty_list
+func @block_label_empty_list() {
+^bb0():
+  return
+}
+
 // CHECK-LABEL: func @multiblock() {
 func @multiblock() {
   return     // CHECK:   return
 ^bb1:         // CHECK: ^bb1:   // no predecessors
   cf.br ^bb4     // CHECK:   cf.br ^bb3
 ^bb2:         // CHECK: ^bb2:   // pred: ^bb2
   cf.br ^bb2     // CHECK:   cf.br ^bb2
 ^bb4:         // CHECK: ^bb3:   // pred: ^bb1