[AsmParser] Introduce a new "Argument" abstraction + supporting logic

[lattner]

Summary

MLIR has a common pattern for "arguments" that uses syntax
like %x : i32 {attrs} loc("sourceloc") which is implemented
in adhoc ways throughout the codebase. The approach this uses
is verbose (because it is implemented with parallel arrays) and
inconsistent (e.g. lots of things drop source location info).

Solve this by introducing OpAsmParser::Argument and make addRegion
(which sets up BlockArguments for the region) take it. Convert the
world to propagating this down. This means that we correctly
capture and propagate source location information in a lot more
cases (e.g. see the affine.for testcase example), and it also
simplifies much code.

[lattner]

This also fixes the source location parsing bug that @mehdi_amini mentioned a couple days ago.

[lattner]

Remove now-constant argument.

[rriddle]

mlir/include/mlir/IR/OpImplementation.h

1226

1234

1238

I understand the intention of how these defaults are chosen, but right now it feels like the current uses overwhelmingly skew the other way (i.e. false).

mlir/lib/Dialect/Affine/IR/AffineOps.cpp

1479

mlir/lib/Dialect/GPU/IR/GPUDialect.cpp

779

mlir/lib/Dialect/SCF/SCF.cpp

407–408

[lattner]

Update flang

[lattner]

Incorporate improvements from River, still need to confirm sense of the bools in parseArgument

[lattner]

mlir/include/mlir/IR/OpImplementation.h

1238

Perhaps. I could totally swap their sense to default to false, and that would give a more "opt into the behavior you want" mode which would avoid an error of omission. Do you think that's the right call?

mlir/lib/Dialect/Affine/IR/AffineOps.cpp

1479

Nice, I tried llvm::drop_front and that didn't work, this did the trick thanks!

[lattner]

Two other minor comment changes I missed from River's review.

[rriddle]

mlir/include/mlir/IR/OpImplementation.h

1238

Given that every use we have so far wants at least one of these to be false, feels like that is the right "default". That being said, we have so few of these in general, it doesn't matter much to me. I can see pros/cons to either, I'll leave the final call up to you.

[lattner]

Yep, you're right, it is also much less common to have attributes, and no one wants attributes without a type. I'll flip it, thanks for the suggestion!

[lattner]

Flip the default on allowType/allowAttr

This cleans up most of the callsites in a very nice way, and
is more "opt in" rather than "opt out". Thanks to River for
the suggestion!

[tpopp]

Hello, why were parseOptionalAssignmentListWithTypesand parseAssignmentListWithTypes removed? This seems to be a common pattern in MLIR where functionality is provided but untested and unused inside of core and then freely removed while breaking users. If this is the intended progression of the API, a deprecation would be appreciated, so people can raise concerns that used functionality is being deleted. If this being freely removed because users of the code outside of the LLVM repository don't impact this decision, it really indicates that MLIR core needs to start providing some form of a stable API that people can rely on rather than the current (small) chaos caused by many changes.

[lattner]

Hello, why were parseOptionalAssignmentListWithTypesand parseAssignmentListWithTypes removed?

This was simply dead code in the tree. I'm sorry I didn't realize other people were using it, I didn't mean to break anyone intentionally. There is a simple replacement with parseArgument and parse comma separated list, though we could add back if it would help with your internal build and integration for awhile.

-Chris

[tpopp]

In D124649#3486240, @lattner wrote:

Hello, why were parseOptionalAssignmentListWithTypesand parseAssignmentListWithTypes removed?

This was simply dead code in the tree. I'm sorry I didn't realize other people were using it, I didn't mean to break anyone intentionally. There is a simple replacement with parseArgument and parse comma separated list, though we could add back if it would help with your internal build and integration for awhile.

-Chris

There were no large worries for our internal work. I essentially copied the code to the one user which was mlir-hlo's gml.st_loop: https://github.com/tensorflow/mlir-hlo/blob/master/tests/Dialect/gml_st/ops.mlir#L71

My comment was largely to push for a stricter process with seemingly dead code by commenting on commits when I see it.

Regarding the assignment list with types, I have only one example of this use case currently, so it is debatable if it deserves to be in core. I would argue for keeping such functionality, as I think the format in gml.st_loop will be more common with upstream users that represent large structured pieces of code for novel machine learning related hardware, but I don't think it's crucial due to being only a single use currently. Do you have any thoughts on the matter?

[lattner]

I don't think it should exist in core if it only has one user. In fact, I'd like to see the AsmParser stuff significantly refactored to be more modular and orthogonal. Most of this stuff exists because we didn't have parseCommaSeparatedList which defines away the majority of the utility of these macro helpers in the first place. See e.g. this patch:
https://reviews.llvm.org/D124791

flang/lib/Optimizer/Dialect/FIROps.cpp

mlir::ParseResult fir::GlobalOp::parse(mlir::OpAsmParser &parser,
 
   result.addAttribute(fir::GlobalOp::getTypeAttrName(result.name),
                       mlir::TypeAttr::get(globalType));
 
   if (simpleInitializer) {
     result.addRegion();
   } else {
     // Parse the optional initializer body.
-    auto parseResult = parser.parseOptionalRegion(
-        *result.addRegion(), /*arguments=*/llvm::None, /*argTypes=*/llvm::None);
+    auto parseResult =
+        parser.parseOptionalRegion(*result.addRegion(), /*arguments=*/{});
     if (parseResult.hasValue() && mlir::failed(*parseResult))
       return mlir::failure();
   }
   return mlir::success();
 }
 
 void fir::GlobalOp::print(mlir::OpAsmPrinter &p) {
   if (getLinkName().hasValue())
bodyRegion->front().addArguments(
       iterArgs.getTypes(),
       llvm::SmallVector<mlir::Location>(iterArgs.size(), result.location));
   result.addAttributes(attributes);
 }
 
 mlir::ParseResult fir::IterWhileOp::parse(mlir::OpAsmParser &parser,
                                           mlir::OperationState &result) {
   auto &builder = parser.getBuilder();
-  mlir::OpAsmParser::UnresolvedOperand inductionVariable, lb, ub, step;
-  if (parser.parseLParen() ||
-      parser.parseOperand(inductionVariable, /*allowResultNumber=*/false) ||
+  mlir::OpAsmParser::Argument inductionVariable, iterateVar;
+  mlir::OpAsmParser::UnresolvedOperand lb, ub, step, iterateInput;
+  if (parser.parseLParen() || parser.parseArgument(inductionVariable) ||
       parser.parseEqual())
     return mlir::failure();
 
   // Parse loop bounds.
   auto indexType = builder.getIndexType();
   auto i1Type = builder.getIntegerType(1);
   if (parser.parseOperand(lb) ||
       parser.resolveOperand(lb, indexType, result.operands) ||
       parser.parseKeyword("to") || parser.parseOperand(ub) ||
       parser.resolveOperand(ub, indexType, result.operands) ||
       parser.parseKeyword("step") || parser.parseOperand(step) ||
       parser.parseRParen() ||
-      parser.resolveOperand(step, indexType, result.operands))
-    return mlir::failure();
-
-  mlir::OpAsmParser::UnresolvedOperand iterateVar, iterateInput;
-  if (parser.parseKeyword("and") || parser.parseLParen() ||
-      parser.parseOperand(iterateVar, /*allowResultNumber=*/false) ||
-      parser.parseEqual() || parser.parseOperand(iterateInput) ||
-      parser.parseRParen() ||
+      parser.resolveOperand(step, indexType, result.operands) ||
+      parser.parseKeyword("and") || parser.parseLParen() ||
+      parser.parseArgument(iterateVar) || parser.parseEqual() ||
+      parser.parseOperand(iterateInput) || parser.parseRParen() ||
       parser.resolveOperand(iterateInput, i1Type, result.operands))
     return mlir::failure();
 
   // Parse the initial iteration arguments.
-  llvm::SmallVector<mlir::OpAsmParser::UnresolvedOperand> regionArgs;
   auto prependCount = false;
 
   // Induction variable.
+  llvm::SmallVector<mlir::OpAsmParser::Argument> regionArgs;
   regionArgs.push_back(inductionVariable);
   regionArgs.push_back(iterateVar);
 
   if (succeeded(parser.parseOptionalKeyword("iter_args"))) {
     llvm::SmallVector<mlir::OpAsmParser::UnresolvedOperand> operands;
     llvm::SmallVector<mlir::Type> regionTypes;
     // Parse assignment list and results type list.
     if (parser.parseAssignmentList(regionArgs, operands) ||
mlir::ParseResult fir::IterWhileOp::parse(mlir::OpAsmParser &parser,
   argTypes.append(result.types.begin(), result.types.end());
   // Parse the body region.
   auto *body = result.addRegion();
   if (regionArgs.size() != argTypes.size())
     return parser.emitError(
         parser.getNameLoc(),
         "mismatch in number of loop-carried values and defined values");
 
-  if (parser.parseRegion(*body, regionArgs, argTypes))
+  for (size_t i = 0, e = regionArgs.size(); i != e; ++i)
+    regionArgs[i].type = argTypes[i];
+
+  if (parser.parseRegion(*body, regionArgs))
     return mlir::failure();
 
   fir::IterWhileOp::ensureTerminator(*body, builder, result.location);
   return mlir::success();
 }
 
 mlir::LogicalResult fir::IterWhileOp::verify() {
   // Check that the body defines as single block argument for the induction
if (unordered)
     result.addAttribute(getUnorderedAttrName(result.name),
                         builder.getUnitAttr());
   result.addAttributes(attributes);
 }
 
 mlir::ParseResult fir::DoLoopOp::parse(mlir::OpAsmParser &parser,
                                        mlir::OperationState &result) {
   auto &builder = parser.getBuilder();
-  mlir::OpAsmParser::UnresolvedOperand inductionVariable, lb, ub, step;
+  mlir::OpAsmParser::Argument inductionVariable;
+  mlir::OpAsmParser::UnresolvedOperand lb, ub, step;
   // Parse the induction variable followed by '='.
-  if (parser.parseOperand(inductionVariable, /*allowResultNumber=*/false) ||
-      parser.parseEqual())
+  if (parser.parseArgument(inductionVariable) || parser.parseEqual())
     return mlir::failure();
 
   // Parse loop bounds.
   auto indexType = builder.getIndexType();
   if (parser.parseOperand(lb) ||
       parser.resolveOperand(lb, indexType, result.operands) ||
       parser.parseKeyword("to") || parser.parseOperand(ub) ||
       parser.resolveOperand(ub, indexType, result.operands) ||
       parser.parseKeyword("step") || parser.parseOperand(step) ||
       parser.resolveOperand(step, indexType, result.operands))
     return mlir::failure();
 
   if (mlir::succeeded(parser.parseOptionalKeyword("unordered")))
     result.addAttribute("unordered", builder.getUnitAttr());
 
   // Parse the optional initial iteration arguments.
-  llvm::SmallVector<mlir::OpAsmParser::UnresolvedOperand> regionArgs, operands;
+  llvm::SmallVector<mlir::OpAsmParser::Argument> regionArgs;
+  llvm::SmallVector<mlir::OpAsmParser::UnresolvedOperand> operands;
   llvm::SmallVector<mlir::Type> argTypes;
   bool prependCount = false;
   regionArgs.push_back(inductionVariable);
 
   if (succeeded(parser.parseOptionalKeyword("iter_args"))) {
     // Parse assignment list and results type list.
     if (parser.parseAssignmentList(regionArgs, operands) ||
         parser.parseArrowTypeList(result.types))
mlir::ParseResult fir::DoLoopOp::parse(mlir::OpAsmParser &parser,
   // Loop carried variables
   argTypes.append(result.types.begin(), result.types.end());
   // Parse the body region.
   auto *body = result.addRegion();
   if (regionArgs.size() != argTypes.size())
     return parser.emitError(
         parser.getNameLoc(),
         "mismatch in number of loop-carried values and defined values");
+  for (size_t i = 0, e = regionArgs.size(); i != e; ++i)
+    regionArgs[i].type = argTypes[i];
 
-  if (parser.parseRegion(*body, regionArgs, argTypes))
+  if (parser.parseRegion(*body, regionArgs))
     return mlir::failure();
 
   DoLoopOp::ensureTerminator(*body, builder, result.location);
 
   return mlir::success();
 }
 
 fir::DoLoopOp fir::getForInductionVarOwner(mlir::Value val) {

mlir/include/mlir/IR/FunctionImplementation.h

 /// Adds argument and result attributes, provided as `argAttrs` and
 /// `resultAttrs` arguments, to the list of operation attributes in `result`.
 /// Internally, argument and result attributes are stored as dict attributes
 /// with special names given by getResultAttrName, getArgumentAttrName.
 void addArgAndResultAttrs(Builder &builder, OperationState &result,
                           ArrayRef<DictionaryAttr> argAttrs,
                           ArrayRef<DictionaryAttr> resultAttrs);
 void addArgAndResultAttrs(Builder &builder, OperationState &result,
-                          ArrayRef<NamedAttrList> argAttrs,
-                          ArrayRef<NamedAttrList> resultAttrs);
+                          ArrayRef<OpAsmParser::Argument> argAttrs,
+                          ArrayRef<DictionaryAttr> resultAttrs);
 
 /// Callback type for `parseFunctionOp`, the callback should produce the
 /// type that will be associated with a function-like operation from lists of
 /// function arguments and results, VariadicFlag indicates whether the function
 /// should have variadic arguments; in case of error, it may populate the last
 /// argument with a message.
 using FuncTypeBuilder = function_ref<Type(
     Builder &, ArrayRef<Type>, ArrayRef<Type>, VariadicFlag, std::string &)>;
 
-/// Parses function arguments using `parser`. The `allowVariadic` argument
-/// indicates whether functions with variadic arguments are supported. The
-/// trailing arguments are populated by this function with names, types,
-/// attributes and locations of the arguments.
-ParseResult parseFunctionArgumentList(
-    OpAsmParser &parser, bool allowAttributes, bool allowVariadic,
-    SmallVectorImpl<OpAsmParser::UnresolvedOperand> &argNames,
-    SmallVectorImpl<Type> &argTypes, SmallVectorImpl<NamedAttrList> &argAttrs,
-    bool &isVariadic);
-
 /// Parses a function signature using `parser`. The `allowVariadic` argument
 /// indicates whether functions with variadic arguments are supported. The
 /// trailing arguments are populated by this function with names, types,
 /// attributes and locations of the arguments and those of the results.
-ParseResult parseFunctionSignature(
-    OpAsmParser &parser, bool allowVariadic,
-    SmallVectorImpl<OpAsmParser::UnresolvedOperand> &argNames,
-    SmallVectorImpl<Type> &argTypes, SmallVectorImpl<NamedAttrList> &argAttrs,
+ParseResult
+parseFunctionSignature(OpAsmParser &parser, bool allowVariadic,
+                       SmallVectorImpl<OpAsmParser::Argument> &arguments,
                        bool &isVariadic, SmallVectorImpl<Type> &resultTypes,
-    SmallVectorImpl<NamedAttrList> &resultAttrs);
+                       SmallVectorImpl<DictionaryAttr> &resultAttrs);
+
+/// Get a function type corresponding to an array of arguments (which have
+/// types) and a set of result types.
+Type getFunctionType(Builder &builder, ArrayRef<OpAsmParser::Argument> argAttrs,
+                     ArrayRef<Type> resultTypes);
 
 /// Parser implementation for function-like operations.  Uses
 /// `funcTypeBuilder` to construct the custom function type given lists of
 /// input and output types.  If `allowVariadic` is set, the parser will accept
 /// trailing ellipsis in the function signature and indicate to the builder
 /// whether the function is variadic.  If the builder returns a null type,
 /// `result` will not contain the `type` attribute.  The caller can then add a
 /// type, report the error or delegate the reporting to the op's verifier.

mlir/include/mlir/IR/OpImplementation.h

public:
   // Attribute/Type Parsing
   //===--------------------------------------------------------------------===//
 
   /// Invoke the `getChecked` method of the given Attribute or Type class, using
   /// the provided location to emit errors in the case of failure. Note that
   /// unlike `OpBuilder::getType`, this method does not implicitly insert a
   /// context parameter.
   template <typename T, typename... ParamsT>
-  T getChecked(SMLoc loc, ParamsT &&... params) {
+  T getChecked(SMLoc loc, ParamsT &&...params) {
     return T::getChecked([&] { return emitError(loc); },
                          std::forward<ParamsT>(params)...);
   }
   /// A variant of `getChecked` that uses the result of `getNameLoc` to emit
   /// errors.
   template <typename T, typename... ParamsT>
-  T getChecked(ParamsT &&... params) {
+  T getChecked(ParamsT &&...params) {
     return T::getChecked([&] { return emitError(getNameLoc()); },
                          std::forward<ParamsT>(params)...);
   }
 
   //===--------------------------------------------------------------------===//
   // Attribute Parsing
   //===--------------------------------------------------------------------===//
 
public:
   // Operand Parsing
   //===--------------------------------------------------------------------===//
 
   /// This is the representation of an operand reference.
   struct UnresolvedOperand {
     SMLoc location;  // Location of the token.
     StringRef name;  // Value name, e.g. %42 or %abc
     unsigned number; // Number, e.g. 12 for an operand like %xyz#12
-    Optional<Location> sourceLoc; // Source location specifier if present.
   };
 
   /// Parse different components, viz., use-info of operand(s), successor(s),
   /// region(s), attribute(s) and function-type, of the generic form of an
   /// operation instance and populate the input operation-state 'result' with
   /// those components. If any of the components is explicitly provided, then
   /// skip parsing that component.
   virtual ParseResult parseGenericOperationAfterOpName(
public:
   /// Operand values must come from single-result sources, and be valid
   /// dimensions/symbol identifiers according to mlir::isValidDim/Symbol.
   virtual ParseResult
   parseAffineExprOfSSAIds(SmallVectorImpl<UnresolvedOperand> &dimOperands,
                           SmallVectorImpl<UnresolvedOperand> &symbOperands,
                           AffineExpr &expr) = 0;
 
   //===--------------------------------------------------------------------===//
+  // Argument Parsing
+  //===--------------------------------------------------------------------===//
+
+  struct Argument {
+    UnresolvedOperand ssaName;    // SourceLoc, SSA name, result #.
+    Type type;                    // Type.
+    DictionaryAttr attrs;         // Attributes if present.
+    Optional<Location> sourceLoc; // Source location specifier if present.
+  };
+
+  /// Parse a single argument with the following syntax:
+  ///
+  ///   `%ssaName : !type { optionalAttrDict} loc(optionalSourceLoc)`
+  ///
+  /// If `allowType` is false or `allowAttrs` are false then the respective
+  /// parts of the grammar are not parsed.
+  virtual ParseResult parseArgument(Argument &result, bool allowType = false,
+                                    bool allowAttrs = false) = 0;
+
+  /// Parse a single argument if present.
+  virtual OptionalParseResult
+  parseOptionalArgument(Argument &result, bool allowType = false,
+                        bool allowAttrs = false) = 0;
+
+  /// Parse zero or more arguments with a specified surrounding delimiter.
+  virtual ParseResult parseArgumentList(SmallVectorImpl<Argument> &result,
+                                        Delimiter delimiter = Delimiter::None,
+                                        bool allowType = false,
+                                        bool allowAttrs = false) = 0;
+
+  //===--------------------------------------------------------------------===//
   // Region Parsing
   //===--------------------------------------------------------------------===//
 
   /// Parses a region. Any parsed blocks are appended to 'region' and must be
   /// moved to the op regions after the op is created. The first block of the
-  /// region takes 'arguments' of types 'argTypes'.  If 'enableNameShadowing' is
-  /// set to true, the argument names are allowed to shadow the names of other
-  /// existing SSA values defined above the region scope. 'enableNameShadowing'
-  /// can only be set to true for regions attached to operations that are
-  /// 'IsolatedFromAbove'.
+  /// region takes 'arguments'.
+  ///
+  /// If 'enableNameShadowing' is set to true, the argument names are allowed to
+  /// shadow the names of other existing SSA values defined above the region
+  /// scope. 'enableNameShadowing' can only be set to true for regions attached
+  /// to operations that are 'IsolatedFromAbove'.
   virtual ParseResult parseRegion(Region &region,
-                                  ArrayRef<UnresolvedOperand> arguments = {},
-                                  ArrayRef<Type> argTypes = {},
+                                  ArrayRef<Argument> arguments = {},
                                   bool enableNameShadowing = false) = 0;
 
   /// Parses a region if present.
-  virtual OptionalParseResult parseOptionalRegion(
-      Region &region, ArrayRef<UnresolvedOperand> arguments = {},
-      ArrayRef<Type> argTypes = {}, bool enableNameShadowing = false) = 0;
+  virtual OptionalParseResult
+  parseOptionalRegion(Region &region, ArrayRef<Argument> arguments = {},
+                      bool enableNameShadowing = false) = 0;
 
   /// Parses a region if present. If the region is present, a new region is
   /// allocated and placed in `region`. If no region is present or on failure,
   /// `region` remains untouched.
   virtual OptionalParseResult
   parseOptionalRegion(std::unique_ptr<Region> &region,
-                      ArrayRef<UnresolvedOperand> arguments = {},
-                      ArrayRef<Type> argTypes = {},
+                      ArrayRef<Argument> arguments = {},
                       bool enableNameShadowing = false) = 0;
 
   //===--------------------------------------------------------------------===//
   // Successor Parsing
   //===--------------------------------------------------------------------===//
 
   /// Parse a single operation successor.
   virtual ParseResult parseSuccessor(Block *&dest) = 0;
 
   /// Parse an optional operation successor.
   virtual OptionalParseResult parseOptionalSuccessor(Block *&dest) = 0;
 
   /// Parse a single operation successor and its operand list.
   virtual ParseResult
   parseSuccessorAndUseList(Block *&dest, SmallVectorImpl<Value> &operands) = 0;
 
   //===--------------------------------------------------------------------===//
   // Type Parsing
   //===--------------------------------------------------------------------===//
 
   /// Parse a list of assignments of the form
   ///   (%x1 = %y1, %x2 = %y2, ...)
-  ParseResult parseAssignmentList(SmallVectorImpl<UnresolvedOperand> &lhs,
+  ParseResult parseAssignmentList(SmallVectorImpl<Argument> &lhs,
                                   SmallVectorImpl<UnresolvedOperand> &rhs) {
     OptionalParseResult result = parseOptionalAssignmentList(lhs, rhs);
     if (!result.hasValue())
       return emitError(getCurrentLocation(), "expected '('");
     return result.getValue();
   }
 
   virtual OptionalParseResult
-  parseOptionalAssignmentList(SmallVectorImpl<UnresolvedOperand> &lhs,
+  parseOptionalAssignmentList(SmallVectorImpl<Argument> &lhs,
                               SmallVectorImpl<UnresolvedOperand> &rhs) = 0;
-
-  /// Parse a list of assignments of the form
-  ///   (%x1 = %y1 : type1, %x2 = %y2 : type2, ...)
-  ParseResult
-  parseAssignmentListWithTypes(SmallVectorImpl<UnresolvedOperand> &lhs,
-                               SmallVectorImpl<UnresolvedOperand> &rhs,
-                               SmallVectorImpl<Type> &types) {
-    OptionalParseResult result =
-        parseOptionalAssignmentListWithTypes(lhs, rhs, types);
-    if (!result.hasValue())
-      return emitError(getCurrentLocation(), "expected '('");
-    return result.getValue();
-  }
-
-  virtual OptionalParseResult
-  parseOptionalAssignmentListWithTypes(SmallVectorImpl<UnresolvedOperand> &lhs,
-                                       SmallVectorImpl<UnresolvedOperand> &rhs,
-                                       SmallVectorImpl<Type> &types) = 0;
 };
 
 //===--------------------------------------------------------------------===//
 // Dialect OpAsm interface.
 //===--------------------------------------------------------------------===//
 
 /// A functor used to set the name of the start of a result group of an
 /// operation. See 'getAsmResultNames' below for more details.
public:
   /// the symbol when printing textual IR. These aliases must not contain `.` or
   /// end with a numeric digit([0-9]+).
   virtual AliasResult getAlias(Attribute attr, raw_ostream &os) const {
     return AliasResult::NoAlias;
   }
   virtual AliasResult getAlias(Type type, raw_ostream &os) const {
     return AliasResult::NoAlias;
   }
-
 };
 } // namespace mlir
 
 //===--------------------------------------------------------------------===//
 // Operation OpAsm interface.
 //===--------------------------------------------------------------------===//
 
 /// The OpAsmOpInterface, see OpAsmInterface.td for more details.
 #include "mlir/IR/OpAsmInterface.h.inc"
 
 #endif

mlir/lib/Dialect/Affine/IR/AffineOps.cpp

static ParseResult parseBound(bool isLower, OperationState &result,
 
   return p.emitError(
       p.getNameLoc(),
       "expected valid affine map representation for loop bounds");
 }
 
 ParseResult AffineForOp::parse(OpAsmParser &parser, OperationState &result) {
   auto &builder = parser.getBuilder();
-  OpAsmParser::UnresolvedOperand inductionVariable;
+  OpAsmParser::Argument inductionVariable;
+  inductionVariable.type = builder.getIndexType();
   // Parse the induction variable followed by '='.
-  if (parser.parseOperand(inductionVariable, /*allowResultNumber=*/false) ||
-      parser.parseEqual())
+  if (parser.parseArgument(inductionVariable) || parser.parseEqual())
     return failure();
 
   // Parse loop bounds.
   if (parseBound(/*isLower=*/true, result, parser) ||
       parser.parseKeyword("to", " between bounds") ||
       parseBound(/*isLower=*/false, result, parser))
     return failure();
 
if (parser.parseOptionalKeyword("step")) {
 
     if (stepAttr.getValue().getSExtValue() < 0)
       return parser.emitError(
           stepLoc,
           "expected step to be representable as a positive signed integer");
   }
 
   // Parse the optional initial iteration arguments.
-  SmallVector<OpAsmParser::UnresolvedOperand, 4> regionArgs, operands;
-  SmallVector<Type, 4> argTypes;
+  SmallVector<OpAsmParser::Argument, 4> regionArgs;
+  SmallVector<OpAsmParser::UnresolvedOperand, 4> operands;
+
+  // Induction variable.
   regionArgs.push_back(inductionVariable);
 
   if (succeeded(parser.parseOptionalKeyword("iter_args"))) {
     // Parse assignment list and results type list.
     if (parser.parseAssignmentList(regionArgs, operands) ||
         parser.parseArrowTypeList(result.types))
       return failure();
     // Resolve input operands.
-    for (auto operandType : llvm::zip(operands, result.types))
-      if (parser.resolveOperand(std::get<0>(operandType),
-                                std::get<1>(operandType), result.operands))
+    for (auto argOperandType :
+         llvm::zip(llvm::drop_begin(regionArgs), operands, result.types)) {
+      Type type = std::get<2>(argOperandType);
+      std::get<0>(argOperandType).type = type;
+      if (parser.resolveOperand(std::get<1>(argOperandType), type,
+                                result.operands))
         return failure();
     }
-  // Induction variable.
-  Type indexType = builder.getIndexType();
-  argTypes.push_back(indexType);
-  // Loop carried variables.
-  argTypes.append(result.types.begin(), result.types.end());
+  }
+
   // Parse the body region.
   Region *body = result.addRegion();
-  if (regionArgs.size() != argTypes.size())
+  if (regionArgs.size() != result.types.size() + 1)
     return parser.emitError(
         parser.getNameLoc(),
         "mismatch between the number of loop-carried values and results");
-  if (parser.parseRegion(*body, regionArgs, argTypes))
+  if (parser.parseRegion(*body, regionArgs))
     return failure();
 
   AffineForOp::ensureTerminator(*body, builder, result.location);
 
   // Parse the optional attribute list.
   return parser.parseOptionalAttrDict(result.attributes);
 }
 
unsigned AffineForOp::getNumIterOperands() {
   AffineMap lbMap = getLowerBoundMapAttr().getValue();
   AffineMap ubMap = getUpperBoundMapAttr().getValue();
 
   return getNumOperands() - lbMap.getNumInputs() - ubMap.getNumInputs();
 }
 
 void AffineForOp::print(OpAsmPrinter &p) {
   p << ' ';
-  p.printOperand(getBody()->getArgument(0));
+  p.printRegionArgument(getBody()->getArgument(0), /*argAtrs=*/{},
+                        /*omitType=*/true);
   p << " = ";
   printBound(getLowerBoundMapAttr(), getLowerBoundOperands(), "max", p);
   p << " to ";
   printBound(getUpperBoundMapAttr(), getUpperBoundOperands(), "min", p);
 
   if (getStep() != 1)
     p << " step " << getStep();
 

 // operation ::= `affine.parallel` `(` ssa-ids `)` `=` parallel-bound
 //               `to` parallel-bound steps? region attr-dict?
 // steps     ::= `steps` `(` integer-literals `)`
 //
 ParseResult AffineParallelOp::parse(OpAsmParser &parser,
                                     OperationState &result) {
   auto &builder = parser.getBuilder();
   auto indexType = builder.getIndexType();
-  SmallVector<OpAsmParser::UnresolvedOperand, 4> ivs;
-  if (parser.parseOperandList(ivs, OpAsmParser::Delimiter::Paren,
-                              /*allowResultNumber=*/false) ||
+  SmallVector<OpAsmParser::Argument, 4> ivs;
+  if (parser.parseArgumentList(ivs, OpAsmParser::Delimiter::Paren) ||
       parser.parseEqual() ||
       parseAffineMapWithMinMax(parser, result, MinMaxKind::Max) ||
       parser.parseKeyword("to") ||
       parseAffineMapWithMinMax(parser, result, MinMaxKind::Min))
     return failure();
 
   AffineMapAttr stepsMapAttr;
   NamedAttrList stepsAttrs;
result.addAttribute(AffineParallelOp::getReductionsAttrName(),
                       builder.getArrayAttr(reductions));
 
   // Parse return types of reductions (if any)
   if (parser.parseOptionalArrowTypeList(result.types))
     return failure();
 
   // Now parse the body.
   Region *body = result.addRegion();
-  SmallVector<Type, 4> types(ivs.size(), indexType);
-  if (parser.parseRegion(*body, ivs, types) ||
+  for (auto &iv : ivs)
+    iv.type = indexType;
+  if (parser.parseRegion(*body, ivs) ||
       parser.parseOptionalAttrDict(result.attributes))
     return failure();
 
   // Add a terminator if none was parsed.
   AffineParallelOp::ensureTerminator(*body, builder, result.location);
   return success();
 }
 

mlir/lib/Dialect/Async/IR/Async.cpp

if (parser.parseOperandList(tokenArgs) ||
         parser.parseRSquare())
       return failure();
 
     numDependencies = tokenArgs.size();
   }
 
   // Parse async value operands (%value as %unwrapped : !async.value<!type>).
   SmallVector<OpAsmParser::UnresolvedOperand, 4> valueArgs;
-  SmallVector<OpAsmParser::UnresolvedOperand, 4> unwrappedArgs;
+  SmallVector<OpAsmParser::Argument, 4> unwrappedArgs;
   SmallVector<Type, 4> valueTypes;
-  SmallVector<Type, 4> unwrappedTypes;
 
   // Parse a single instance of `%value as %unwrapped : !async.value<!type>`.
   auto parseAsyncValueArg = [&]() -> ParseResult {
     if (parser.parseOperand(valueArgs.emplace_back()) ||
         parser.parseKeyword("as") ||
-        parser.parseOperand(unwrappedArgs.emplace_back()) ||
+        parser.parseArgument(unwrappedArgs.emplace_back()) ||
         parser.parseColonType(valueTypes.emplace_back()))
       return failure();
 
     auto valueTy = valueTypes.back().dyn_cast<ValueType>();
-    unwrappedTypes.emplace_back(valueTy ? valueTy.getValueType() : Type());
-
+    unwrappedArgs.back().type = valueTy ? valueTy.getValueType() : Type();
     return success();
   };
 
   auto argsLoc = parser.getCurrentLocation();
   if (parser.parseCommaSeparatedList(OpAsmParser::Delimiter::OptionalParen,
                                      parseAsyncValueArg) ||
       parser.resolveOperands(valueArgs, valueTypes, argsLoc, result.operands))
     return failure();
ParseResult ExecuteOp::parse(OpAsmParser &parser, OperationState &result) {
   // Parse operation attributes.
   NamedAttrList attrs;
   if (parser.parseOptionalAttrDictWithKeyword(attrs))
     return failure();
   result.addAttributes(attrs);
 
   // Parse asynchronous region.
   Region *body = result.addRegion();
-  if (parser.parseRegion(*body, /*arguments=*/{unwrappedArgs},
-                         /*argTypes=*/{unwrappedTypes},
-                         /*enableNameShadowing=*/false))
-    return failure();
-
-  return success();
+  return parser.parseRegion(*body, /*arguments=*/unwrappedArgs);
 }
 
 LogicalResult ExecuteOp::verifyRegions() {
   // Unwrap async.execute value operands types.
   auto unwrappedTypes = llvm::map_range(operands(), [](Value operand) {
     return operand.getType().cast<ValueType>().getValueType();
   });
 

mlir/lib/Dialect/GPU/IR/GPUDialect.cpp

ParseResult LaunchOp::parse(OpAsmParser &parser, OperationState &result) {
   }
 
   // Introduce the body region and parse it. The region has
   // kNumConfigRegionAttributes arguments that correspond to
   // block/thread identifiers and grid/block sizes, all of the `index` type.
   Type index = parser.getBuilder().getIndexType();
   SmallVector<Type, LaunchOp::kNumConfigRegionAttributes> dataTypes(
       LaunchOp::kNumConfigRegionAttributes, index);
+
+  SmallVector<OpAsmParser::Argument> regionArguments;
+  for (auto ssaValueAndType : llvm::zip(regionArgs, dataTypes)) {
+    OpAsmParser::Argument arg;
+    arg.ssaName = std::get<0>(ssaValueAndType);
+    arg.type = std::get<1>(ssaValueAndType);
+    regionArguments.push_back(arg);
+  }
+
   Region *body = result.addRegion();
-  if (parser.parseRegion(*body, regionArgs, dataTypes) ||
+  if (parser.parseRegion(*body, regionArguments) ||
       parser.parseOptionalAttrDict(result.attributes))
     return failure();
 
   SmallVector<int32_t, 8> segmentSizes(8, 1);
   segmentSizes.front() = asyncDependencies.size();
   segmentSizes.back() = hasDynamicSharedMemorySize ? 1 : 0;
   result.addAttribute(LaunchOp::getOperandSegmentSizeAttr(),
                       parser.getBuilder().getI32VectorAttr(segmentSizes));

 }
 
 static ParseResult parseLaunchFuncOperands(
     OpAsmParser &parser,
     SmallVectorImpl<OpAsmParser::UnresolvedOperand> &argNames,
     SmallVectorImpl<Type> &argTypes) {
   if (parser.parseOptionalKeyword("args"))
     return success();
-  SmallVector<NamedAttrList> argAttrs;
-  bool isVariadic = false;
-  return function_interface_impl::parseFunctionArgumentList(
-      parser, /*allowAttributes=*/false,
-      /*allowVariadic=*/false, argNames, argTypes, argAttrs, isVariadic);
+
+  SmallVector<OpAsmParser::Argument> args;
+  if (parser.parseArgumentList(args, OpAsmParser::Delimiter::Paren,
+                               /*allowType=*/true))
+    return failure();
+  for (auto &arg : args) {
+    argNames.push_back(arg.ssaName);
+    argTypes.push_back(arg.type);
+  }
+  return success();
 }
 
 static void printLaunchFuncOperands(OpAsmPrinter &printer, Operation *,
                                     OperandRange operands, TypeRange types) {
   if (operands.empty())
     return;
   printer << "args(";
   llvm::interleaveComma(llvm::zip(operands, types), printer,
                         [&](const auto &pair) {
                           printer.printOperand(std::get<0>(pair));
                           printer << " : ";
                           printer.printType(std::get<1>(pair));
                         });
   printer << ")";
 }
 
-//
-
 //===----------------------------------------------------------------------===//
 // ShuffleOp
 //===----------------------------------------------------------------------===//
 
 void ShuffleOp::build(OpBuilder &builder, OperationState &result, Value value,
                       int32_t offset, int32_t width, ShuffleMode mode) {
   build(builder, result, value,
         builder.create<arith::ConstantOp>(result.location,

 ///
 /// memory-attribution ::= (`workgroup` `(` ssa-id-and-type-list `)`)?
 ///                        (`private` `(` ssa-id-and-type-list `)`)?
 ///
 /// Note that this function parses only one of the two similar parts, with the
 /// keyword provided as argument.
 static ParseResult
 parseAttributions(OpAsmParser &parser, StringRef keyword,
-                  SmallVectorImpl<OpAsmParser::UnresolvedOperand> &args,
-                  SmallVectorImpl<Type> &argTypes) {
+                  SmallVectorImpl<OpAsmParser::Argument> &args) {
   // If we could not parse the keyword, just assume empty list and succeed.
   if (failed(parser.parseOptionalKeyword(keyword)))
     return success();
 
-  if (failed(parser.parseLParen()))
-    return failure();
-
-  // Early exit for an empty list.
-  if (succeeded(parser.parseOptionalRParen()))
-    return success();
-
-  do {
-    OpAsmParser::UnresolvedOperand arg;
-    Type type;
-
-    if (parser.parseOperand(arg, /*allowResultNumber=*/false) ||
-        parser.parseColonType(type))
-      return failure();
-
-    args.push_back(arg);
-    argTypes.push_back(type);
-  } while (succeeded(parser.parseOptionalComma()));
-
-  return parser.parseRParen();
+  return parser.parseArgumentList(args, OpAsmParser::Delimiter::Paren,
+                                  /*allowType=*/true);
 }
 
 /// Parses a GPU function.
 ///
 /// <operation> ::= `gpu.func` symbol-ref-id `(` argument-list `)`
 ///                 (`->` function-result-list)? memory-attribution `kernel`?
 ///                 function-attributes? region
 ParseResult GPUFuncOp::parse(OpAsmParser &parser, OperationState &result) {
-  SmallVector<OpAsmParser::UnresolvedOperand> entryArgs;
-  SmallVector<NamedAttrList> argAttrs;
-  SmallVector<NamedAttrList> resultAttrs;
-  SmallVector<Type> argTypes;
+  SmallVector<OpAsmParser::Argument> entryArgs;
+  SmallVector<DictionaryAttr> resultAttrs;
   SmallVector<Type> resultTypes;
   bool isVariadic;
 
   // Parse the function name.
   StringAttr nameAttr;
   if (parser.parseSymbolName(nameAttr, ::mlir::SymbolTable::getSymbolAttrName(),
                              result.attributes))
     return failure();
 
   auto signatureLocation = parser.getCurrentLocation();
   if (failed(function_interface_impl::parseFunctionSignature(
-          parser, /*allowVariadic=*/false, entryArgs, argTypes, argAttrs,
-          isVariadic, resultTypes, resultAttrs)))
+          parser, /*allowVariadic=*/false, entryArgs, isVariadic, resultTypes,
+          resultAttrs)))
     return failure();
 
-  if (entryArgs.empty() && !argTypes.empty())
+  if (!entryArgs.empty() && entryArgs[0].ssaName.name.empty())
     return parser.emitError(signatureLocation)
            << "gpu.func requires named arguments";
 
   // Construct the function type. More types will be added to the region, but
   // not to the function type.
   Builder &builder = parser.getBuilder();
+
+  SmallVector<Type> argTypes;
+  for (auto &arg : entryArgs)
+    argTypes.push_back(arg.type);
   auto type = builder.getFunctionType(argTypes, resultTypes);
   result.addAttribute(GPUFuncOp::getTypeAttrName(), TypeAttr::get(type));
 
+  function_interface_impl::addArgAndResultAttrs(builder, result, entryArgs,
+                                                resultAttrs);
+
   // Parse workgroup memory attributions.
   if (failed(parseAttributions(parser, GPUFuncOp::getWorkgroupKeyword(),
-                               entryArgs, argTypes)))
+                               entryArgs)))
     return failure();
 
   // Store the number of operands we just parsed as the number of workgroup
   // memory attributions.
-  unsigned numWorkgroupAttrs = argTypes.size() - type.getNumInputs();
+  unsigned numWorkgroupAttrs = entryArgs.size() - type.getNumInputs();
   result.addAttribute(GPUFuncOp::getNumWorkgroupAttributionsAttrName(),
                       builder.getI64IntegerAttr(numWorkgroupAttrs));
 
   // Parse private memory attributions.
-  if (failed(parseAttributions(parser, GPUFuncOp::getPrivateKeyword(),
-                               entryArgs, argTypes)))
+  if (failed(
+          parseAttributions(parser, GPUFuncOp::getPrivateKeyword(), entryArgs)))
     return failure();
 
   // Parse the kernel attribute if present.
   if (succeeded(parser.parseOptionalKeyword(GPUFuncOp::getKernelKeyword())))
     result.addAttribute(GPUDialect::getKernelFuncAttrName(),
                         builder.getUnitAttr());
 
   // Parse attributes.
   if (failed(parser.parseOptionalAttrDictWithKeyword(result.attributes)))
     return failure();
-  function_interface_impl::addArgAndResultAttrs(builder, result, argAttrs,
-                                                resultAttrs);
 
   // Parse the region. If no argument names were provided, take all names
   // (including those of attributions) from the entry block.
   auto *body = result.addRegion();
-  return parser.parseRegion(*body, entryArgs, argTypes);
+  return parser.parseRegion(*body, entryArgs);
 }
 
 static void printAttributions(OpAsmPrinter &p, StringRef keyword,
                               ArrayRef<BlockArgument> values) {
   if (values.empty())
     return;
 
   p << ' ' << keyword << '(';
void GPUModuleOp::build(OpBuilder &builder, OperationState &result,
   ensureTerminator(*result.addRegion(), builder, result.location);
   result.attributes.push_back(builder.getNamedAttr(
       ::mlir::SymbolTable::getSymbolAttrName(), builder.getStringAttr(name)));
 }
 
 ParseResult GPUModuleOp::parse(OpAsmParser &parser, OperationState &result) {
   StringAttr nameAttr;
   if (parser.parseSymbolName(nameAttr, mlir::SymbolTable::getSymbolAttrName(),
-                             result.attributes))
-    return failure();
-
+                             result.attributes) ||
       // If module attributes are present, parse them.
-  if (parser.parseOptionalAttrDictWithKeyword(result.attributes))
+      parser.parseOptionalAttrDictWithKeyword(result.attributes))
     return failure();
 
   // Parse the module body.
   auto *body = result.addRegion();
-  if (parser.parseRegion(*body, None, None))
+  if (parser.parseRegion(*body, {}))
     return failure();
 
   // Ensure that this module has a valid terminator.
   GPUModuleOp::ensureTerminator(*body, parser.getBuilder(), result.location);
   return success();
 }
 
 void GPUModuleOp::print(OpAsmPrinter &p) {

mlir/lib/Dialect/LLVMIR/IR/LLVMDialect.cpp

ParseResult LLVMFuncOp::parse(OpAsmParser &parser, OperationState &result) {
   // Default to external linkage if no keyword is provided.
   result.addAttribute(
       getLinkageAttrName(result.name),
       LinkageAttr::get(parser.getContext(),
                        parseOptionalLLVMKeyword<Linkage>(
                            parser, result, LLVM::Linkage::External)));
 
   StringAttr nameAttr;
-  SmallVector<OpAsmParser::UnresolvedOperand> entryArgs;
-  SmallVector<NamedAttrList> argAttrs;
-  SmallVector<NamedAttrList> resultAttrs;
-  SmallVector<Type> argTypes;
+  SmallVector<OpAsmParser::Argument> entryArgs;
+  SmallVector<DictionaryAttr> resultAttrs;
   SmallVector<Type> resultTypes;
   bool isVariadic;
 
   auto signatureLocation = parser.getCurrentLocation();
   if (parser.parseSymbolName(nameAttr, SymbolTable::getSymbolAttrName(),
                              result.attributes) ||
       function_interface_impl::parseFunctionSignature(
-          parser, /*allowVariadic=*/true, entryArgs, argTypes, argAttrs,
-          isVariadic, resultTypes, resultAttrs))
+          parser, /*allowVariadic=*/true, entryArgs, isVariadic, resultTypes,
+          resultAttrs))
     return failure();
 
+  SmallVector<Type> argTypes;
+  for (auto &arg : entryArgs)
+    argTypes.push_back(arg.type);
   auto type =
       buildLLVMFunctionType(parser, signatureLocation, argTypes, resultTypes,
                             function_interface_impl::VariadicFlag(isVariadic));
   if (!type)
     return failure();
   result.addAttribute(FunctionOpInterface::getTypeAttrName(),
                       TypeAttr::get(type));
 
   if (failed(parser.parseOptionalAttrDictWithKeyword(result.attributes)))
     return failure();
   function_interface_impl::addArgAndResultAttrs(parser.getBuilder(), result,
-                                                argAttrs, resultAttrs);
+                                                entryArgs, resultAttrs);
 
   auto *body = result.addRegion();
-  OptionalParseResult parseResult = parser.parseOptionalRegion(
-      *body, entryArgs, entryArgs.empty() ? ArrayRef<Type>() : argTypes);
+  OptionalParseResult parseResult =
+      parser.parseOptionalRegion(*body, entryArgs);
   return failure(parseResult.hasValue() && failed(*parseResult));
 }
 
 // Print the LLVMFuncOp. Collects argument and result types and passes them to
 // helper functions. Drops "void" result since it cannot be parsed back. Skips
 // the external linkage since it is the default value.
 void LLVMFuncOp::print(OpAsmPrinter &p) {
   p << ' ';

mlir/lib/Dialect/Linalg/IR/LinalgOps.cpp

if (parseCommonStructuredOpParts(parser, result, inputTypes, outputTypes))
     return failure();
 
   // Optional attributes may be added.
   if (succeeded(parser.parseOptionalKeyword("attrs")))
     if (failed(parser.parseEqual()) ||
         failed(parser.parseOptionalAttrDict(result.attributes)))
       return failure();
 
-  SmallVector<OpAsmParser::UnresolvedOperand, 8> regionOperands;
   std::unique_ptr<Region> region = std::make_unique<Region>();
-  SmallVector<Type, 8> operandTypes, regionTypes;
-  if (parser.parseRegion(*region, regionOperands, regionTypes))
+  if (parser.parseRegion(*region, {}))
     return failure();
   result.addRegion(std::move(region));
 
   // Generic ops may specify that a subset of its outputs are tensors. Such
   // outputs are specified in the result type.
   // TODO: may need to move output parsing before region parsing.
   // Need to wait for declarative assembly resolution to decide.
   SmallVector<Type, 1> outputTensorsTypes;

mlir/lib/Dialect/MemRef/IR/MemRefOps.cpp

ParseResult AllocaScopeOp::parse(OpAsmParser &parser, OperationState &result) {
   result.regions.reserve(1);
   Region *bodyRegion = result.addRegion();
 
   // Parse optional results type list.
   if (parser.parseOptionalArrowTypeList(result.types))
     return failure();
 
   // Parse the body region.
-  if (parser.parseRegion(*bodyRegion, /*arguments=*/{}, /*argTypes=*/{}))
+  if (parser.parseRegion(*bodyRegion, /*arguments=*/{}))
     return failure();
   AllocaScopeOp::ensureTerminator(*bodyRegion, parser.getBuilder(),
                                   result.location);
 
   // Parse the optional attribute list.
   if (parser.parseOptionalAttrDict(result.attributes))
     return failure();
 
ParseResult GenericAtomicRMWOp::parse(OpAsmParser &parser,
   if (parser.parseOperand(memref) ||
       parser.parseOperandList(ivs, OpAsmParser::Delimiter::Square) ||
       parser.parseColonType(memrefType) ||
       parser.resolveOperand(memref, memrefType, result.operands) ||
       parser.resolveOperands(ivs, indexType, result.operands))
     return failure();
 
   Region *body = result.addRegion();
-  if (parser.parseRegion(*body, llvm::None, llvm::None) ||
+  if (parser.parseRegion(*body, {}) ||
       parser.parseOptionalAttrDict(result.attributes))
     return failure();
   result.types.push_back(memrefType.cast<MemRefType>().getElementType());
   return success();
 }
 
 void GenericAtomicRMWOp::print(OpAsmPrinter &p) {
   p << ' ' << memref() << "[" << indices() << "] : " << memref().getType()

mlir/lib/Dialect/OpenMP/IR/OpenMPDialect.cpp

 /// steps := `step` `(`ssa-id-list`)`
 ParseResult
 parseWsLoopControl(OpAsmParser &parser, Region &region,
                    SmallVectorImpl<OpAsmParser::UnresolvedOperand> &lowerBound,
                    SmallVectorImpl<OpAsmParser::UnresolvedOperand> &upperBound,
                    SmallVectorImpl<OpAsmParser::UnresolvedOperand> &steps,
                    SmallVectorImpl<Type> &loopVarTypes, UnitAttr &inclusive) {
   // Parse an opening `(` followed by induction variables followed by `)`
-  SmallVector<OpAsmParser::UnresolvedOperand> ivs;
-  if (parser.parseOperandList(ivs, OpAsmParser::Delimiter::Paren,
-                              /*allowResultNumber=*/false))
-    return failure();
-
-  size_t numIVs = ivs.size();
+  SmallVector<OpAsmParser::Argument> ivs;
   Type loopVarType;
-  if (parser.parseColonType(loopVarType) ||
+  if (parser.parseArgumentList(ivs, OpAsmParser::Delimiter::Paren) ||
+      parser.parseColonType(loopVarType) ||
       // Parse loop bounds.
       parser.parseEqual() ||
-      parser.parseOperandList(lowerBound, numIVs,
+      parser.parseOperandList(lowerBound, ivs.size(),
                               OpAsmParser::Delimiter::Paren) ||
       parser.parseKeyword("to") ||
-      parser.parseOperandList(upperBound, numIVs,
+      parser.parseOperandList(upperBound, ivs.size(),
                               OpAsmParser::Delimiter::Paren))
     return failure();
 
   if (succeeded(parser.parseOptionalKeyword("inclusive")))
     inclusive = UnitAttr::get(parser.getBuilder().getContext());
 
   // Parse step values.
   if (parser.parseKeyword("step") ||
-      parser.parseOperandList(steps, numIVs, OpAsmParser::Delimiter::Paren))
+      parser.parseOperandList(steps, ivs.size(), OpAsmParser::Delimiter::Paren))
     return failure();
 
   // Now parse the body.
-  loopVarTypes = SmallVector<Type>(numIVs, loopVarType);
-  SmallVector<OpAsmParser::UnresolvedOperand> blockArgs(ivs);
-  if (parser.parseRegion(region, blockArgs, loopVarTypes))
-    return failure();
-  return success();
+  loopVarTypes = SmallVector<Type>(ivs.size(), loopVarType);
+  for (auto &iv : ivs)
+    iv.type = loopVarType;
+  return parser.parseRegion(region, ivs);
 }
 
 void printWsLoopControl(OpAsmPrinter &p, Operation *op, Region &region,
                         ValueRange lowerBound, ValueRange upperBound,
                         ValueRange steps, TypeRange loopVarTypes,
                         UnitAttr inclusive) {
   auto args = region.front().getArguments();
   p << " (" << args << ") : " << args[0].getType() << " = (" << lowerBound

 /// simdloop ::= `omp.simdloop` loop-control clause-list
 /// loop-control ::= `(` ssa-id-list `)` `:` type `=`  loop-bounds
 /// loop-bounds := `(` ssa-id-list `)` to `(` ssa-id-list `)` steps
 /// steps := `step` `(`ssa-id-list`)`
 /// clause-list ::= clause clause-list | empty
 /// clause ::= TODO
 ParseResult SimdLoopOp::parse(OpAsmParser &parser, OperationState &result) {
   // Parse an opening `(` followed by induction variables followed by `)`
-  SmallVector<OpAsmParser::UnresolvedOperand> ivs;
-  if (parser.parseOperandList(ivs, OpAsmParser::Delimiter::Paren,
-                              /*allowResultNumber=*/false))
-    return failure();
-  int numIVs = static_cast<int>(ivs.size());
+  SmallVector<OpAsmParser::Argument> ivs;
   Type loopVarType;
-  if (parser.parseColonType(loopVarType))
-    return failure();
+  SmallVector<OpAsmParser::UnresolvedOperand> lower, upper, steps;
+  if (parser.parseArgumentList(ivs, OpAsmParser::Delimiter::Paren) ||
+      parser.parseColonType(loopVarType) ||
       // Parse loop bounds.
-  SmallVector<OpAsmParser::UnresolvedOperand> lower;
-  if (parser.parseEqual() ||
-      parser.parseOperandList(lower, numIVs, OpAsmParser::Delimiter::Paren) ||
-      parser.resolveOperands(lower, loopVarType, result.operands))
-    return failure();
-  SmallVector<OpAsmParser::UnresolvedOperand> upper;
-  if (parser.parseKeyword("to") ||
-      parser.parseOperandList(upper, numIVs, OpAsmParser::Delimiter::Paren) ||
-      parser.resolveOperands(upper, loopVarType, result.operands))
-    return failure();
-
+      parser.parseEqual() ||
+      parser.parseOperandList(lower, ivs.size(),
+                              OpAsmParser::Delimiter::Paren) ||
+      parser.resolveOperands(lower, loopVarType, result.operands) ||
+      parser.parseKeyword("to") ||
+      parser.parseOperandList(upper, ivs.size(),
+                              OpAsmParser::Delimiter::Paren) ||
+      parser.resolveOperands(upper, loopVarType, result.operands) ||
       // Parse step values.
-  SmallVector<OpAsmParser::UnresolvedOperand> steps;
-  if (parser.parseKeyword("step") ||
-      parser.parseOperandList(steps, numIVs, OpAsmParser::Delimiter::Paren) ||
+      parser.parseKeyword("step") ||
+      parser.parseOperandList(steps, ivs.size(),
+                              OpAsmParser::Delimiter::Paren) ||
       parser.resolveOperands(steps, loopVarType, result.operands))
     return failure();
 
+  int numIVs = static_cast<int>(ivs.size());
   SmallVector<int> segments{numIVs, numIVs, numIVs};
   // TODO: Add parseClauses() when we support clauses
   result.addAttribute("operand_segment_sizes",
                       parser.getBuilder().getI32VectorAttr(segments));
 
   // Now parse the body.
   Region *body = result.addRegion();
-  SmallVector<Type> ivTypes(numIVs, loopVarType);
-  SmallVector<OpAsmParser::UnresolvedOperand> blockArgs(ivs);
-  if (parser.parseRegion(*body, blockArgs, ivTypes))
-    return failure();
-  return success();
+  for (auto &iv : ivs)
+    iv.type = loopVarType;
+  return parser.parseRegion(*body, ivs);
 }
 
 void SimdLoopOp::print(OpAsmPrinter &p) {
   auto args = getRegion().front().getArguments();
   p << " (" << args << ") : " << args[0].getType() << " = (" << lowerBound()
     << ") to (" << upperBound() << ") ";
   p << "step (" << step() << ") ";
 

mlir/lib/Dialect/PDLInterp/IR/PDLInterp.cpp

if (initLoop) {
     state.regions.front()->emplaceBlock();
     state.regions.front()->addArgument(rangeType.getElementType(),
                                        state.location);
   }
 }
 
 ParseResult ForEachOp::parse(OpAsmParser &parser, OperationState &result) {
   // Parse the loop variable followed by type.
-  OpAsmParser::UnresolvedOperand loopVariable;
-  Type loopVariableType;
-  if (parser.parseOperand(loopVariable, /*allowResultNumber=*/false) ||
-      parser.parseColonType(loopVariableType))
-    return failure();
-
-  // Parse the "in" keyword.
-  if (parser.parseKeyword("in", " after loop variable"))
-    return failure();
-
-  // Parse the operand (value range).
+  OpAsmParser::Argument loopVariable;
   OpAsmParser::UnresolvedOperand operandInfo;
-  if (parser.parseOperand(operandInfo))
+  if (parser.parseArgument(loopVariable, /*allowType=*/true) ||
+      parser.parseKeyword("in", " after loop variable") ||
+      // Parse the operand (value range).
+      parser.parseOperand(operandInfo))
     return failure();
 
   // Resolve the operand.
-  Type rangeType = pdl::RangeType::get(loopVariableType);
+  Type rangeType = pdl::RangeType::get(loopVariable.type);
   if (parser.resolveOperand(operandInfo, rangeType, result.operands))
     return failure();
 
   // Parse the body region.
   Region *body = result.addRegion();
-  if (parser.parseRegion(*body, {loopVariable}, {loopVariableType}))
-    return failure();
-
-  // Parse the attribute dictionary.
-  if (parser.parseOptionalAttrDict(result.attributes))
-    return failure();
-
-  // Parse the successor.
   Block *successor;
-  if (parser.parseArrow() || parser.parseSuccessor(successor))
+  if (parser.parseRegion(*body, loopVariable) ||
+      parser.parseOptionalAttrDict(result.attributes) ||
+      // Parse the successor.
+      parser.parseArrow() || parser.parseSuccessor(successor))
     return failure();
-  result.addSuccessors(successor);
 
+  result.addSuccessors(successor);
   return success();
 }
 
 void ForEachOp::print(OpAsmPrinter &p) {
   BlockArgument arg = getLoopVariable();
   p << ' ' << arg << " : " << arg.getType() << " in " << getValues() << ' ';
   p.printRegion(getRegion(), /*printEntryBlockArgs=*/false);
   p.printOptionalAttrDict((*this)->getAttrs());

mlir/lib/Dialect/SCF/SCF.cpp

void ForOp::print(OpAsmPrinter &p) {
   p.printRegion(getRegion(),
                 /*printEntryBlockArgs=*/false,
                 /*printBlockTerminators=*/hasIterOperands());
   p.printOptionalAttrDict((*this)->getAttrs());
 }
 
 ParseResult ForOp::parse(OpAsmParser &parser, OperationState &result) {
   auto &builder = parser.getBuilder();
-  OpAsmParser::UnresolvedOperand inductionVariable, lb, ub, step;
-  // Parse the induction variable followed by '='.
-  if (parser.parseOperand(inductionVariable, /*allowResultNumber=*/false) ||
-      parser.parseEqual())
-    return failure();
+  Type indexType = builder.getIndexType();
+
+  OpAsmParser::Argument inductionVariable;
+  inductionVariable.type = indexType;
+  OpAsmParser::UnresolvedOperand lb, ub, step;
 
+  // Parse the induction variable followed by '='.
+  if (parser.parseArgument(inductionVariable) || parser.parseEqual() ||
       // Parse loop bounds.
-  Type indexType = builder.getIndexType();
-  if (parser.parseOperand(lb) ||
+      parser.parseOperand(lb) ||
       parser.resolveOperand(lb, indexType, result.operands) ||
       parser.parseKeyword("to") || parser.parseOperand(ub) ||
       parser.resolveOperand(ub, indexType, result.operands) ||
       parser.parseKeyword("step") || parser.parseOperand(step) ||
       parser.resolveOperand(step, indexType, result.operands))
     return failure();
 
   // Parse the optional initial iteration arguments.
-  SmallVector<OpAsmParser::UnresolvedOperand, 4> regionArgs, operands;
-  SmallVector<Type, 4> argTypes;
+  SmallVector<OpAsmParser::Argument, 4> regionArgs;
+  SmallVector<OpAsmParser::UnresolvedOperand, 4> operands;
   regionArgs.push_back(inductionVariable);
 
   if (succeeded(parser.parseOptionalKeyword("iter_args"))) {
     // Parse assignment list and results type list.
     if (parser.parseAssignmentList(regionArgs, operands) ||
         parser.parseArrowTypeList(result.types))
       return failure();
+
     // Resolve input operands.
-    for (auto operandType : llvm::zip(operands, result.types))
-      if (parser.resolveOperand(std::get<0>(operandType),
-                                std::get<1>(operandType), result.operands))
+    for (auto argOperandType :
+         llvm::zip(llvm::drop_begin(regionArgs), operands, result.types)) {
+      Type type = std::get<2>(argOperandType);
+      std::get<0>(argOperandType).type = type;
+      if (parser.resolveOperand(std::get<1>(argOperandType), type,
+                                result.operands))
         return failure();
     }
-  // Induction variable.
-  argTypes.push_back(indexType);
-  // Loop carried variables
-  argTypes.append(result.types.begin(), result.types.end());
-  // Parse the body region.
-  Region *body = result.addRegion();
-  if (regionArgs.size() != argTypes.size())
+  }
+
+  if (regionArgs.size() != result.types.size() + 1)
     return parser.emitError(
         parser.getNameLoc(),
         "mismatch in number of loop-carried values and defined values");
 
-  if (parser.parseRegion(*body, regionArgs, argTypes))
+  // Parse the body region.
+  Region *body = result.addRegion();
+  if (parser.parseRegion(*body, regionArgs))
     return failure();
 
   ForOp::ensureTerminator(*body, builder, result.location);
 
   // Parse the optional attribute list.
   if (parser.parseOptionalAttrDict(result.attributes))
     return failure();
 
if (resultType != reduceType)
              << " to be the same as result type: " << resultType;
   }
   return success();
 }
 
 ParseResult ParallelOp::parse(OpAsmParser &parser, OperationState &result) {
   auto &builder = parser.getBuilder();
   // Parse an opening `(` followed by induction variables followed by `)`
-  SmallVector<OpAsmParser::UnresolvedOperand, 4> ivs;
-  if (parser.parseOperandList(ivs, OpAsmParser::Delimiter::Paren,
-                              /*allowResultNumber=*/false))
+  SmallVector<OpAsmParser::Argument, 4> ivs;
+  if (parser.parseArgumentList(ivs, OpAsmParser::Delimiter::Paren))
     return failure();
 
   // Parse loop bounds.
   SmallVector<OpAsmParser::UnresolvedOperand, 4> lower;
   if (parser.parseEqual() ||
       parser.parseOperandList(lower, ivs.size(),
                               OpAsmParser::Delimiter::Paren) ||
       parser.resolveOperands(lower, builder.getIndexType(), result.operands))
ParseResult ParallelOp::parse(OpAsmParser &parser, OperationState &result) {
   }
 
   // Parse optional results in case there is a reduce.
   if (parser.parseOptionalArrowTypeList(result.types))
     return failure();
 
   // Now parse the body.
   Region *body = result.addRegion();
-  SmallVector<Type, 4> types(ivs.size(), builder.getIndexType());
-  if (parser.parseRegion(*body, ivs, types))
+  for (auto &iv : ivs)
+    iv.type = builder.getIndexType();
+  if (parser.parseRegion(*body, ivs))
     return failure();
 
   // Set `operand_segment_sizes` attribute.
   result.addAttribute(
       ParallelOp::getOperandSegmentSizeAttr(),
       builder.getI32VectorAttr({static_cast<int32_t>(lower.size()),
                                 static_cast<int32_t>(upper.size()),
                                 static_cast<int32_t>(steps.size()),

 /// Parses a `while` op.
 ///
 /// op ::= `scf.while` assignments `:` function-type region `do` region
 ///         `attributes` attribute-dict
 /// initializer ::= /* empty */ | `(` assignment-list `)`
 /// assignment-list ::= assignment | assignment `,` assignment-list
 /// assignment ::= ssa-value `=` ssa-value
 ParseResult scf::WhileOp::parse(OpAsmParser &parser, OperationState &result) {
-  SmallVector<OpAsmParser::UnresolvedOperand, 4> regionArgs, operands;
+  SmallVector<OpAsmParser::Argument, 4> regionArgs;
+  SmallVector<OpAsmParser::UnresolvedOperand, 4> operands;
   Region *before = result.addRegion();
   Region *after = result.addRegion();
 
   OptionalParseResult listResult =
       parser.parseOptionalAssignmentList(regionArgs, operands);
   if (listResult.hasValue() && failed(listResult.getValue()))
     return failure();
 
ParseResult scf::WhileOp::parse(OpAsmParser &parser, OperationState &result) {
   }
 
   // Resolve input operands.
   if (failed(parser.resolveOperands(operands, functionType.getInputs(),
                                     parser.getCurrentLocation(),
                                     result.operands)))
     return failure();
 
-  return failure(
-      parser.parseRegion(*before, regionArgs, functionType.getInputs()) ||
+  // Propagate the types into the region arguments.
+  for (size_t i = 0, e = regionArgs.size(); i != e; ++i)
+    regionArgs[i].type = functionType.getInput(i);
+
+  return failure(parser.parseRegion(*before, regionArgs) ||
                  parser.parseKeyword("do") || parser.parseRegion(*after) ||
                  parser.parseOptionalAttrDictWithKeyword(result.attributes));
 }
 
 /// Prints a `while` op.
 void scf::WhileOp::print(OpAsmPrinter &p) {
   printInitializationList(p, getBefore().front().getArguments(), getInits(),
                           " ");
   p << " : ";
   p.printFunctionalType(getInits().getTypes(), getResults().getTypes());

mlir/lib/Dialect/SPIRV/IR/SPIRVOps.cpp

LogicalResult spirv::UConvertOp::verify() {
   return verifyCastOp(*this, /*requireSameBitWidth=*/false);
 }
 
 //===----------------------------------------------------------------------===//
 // spv.func
 //===----------------------------------------------------------------------===//
 
 ParseResult spirv::FuncOp::parse(OpAsmParser &parser, OperationState &state) {
-  SmallVector<OpAsmParser::UnresolvedOperand> entryArgs;
-  SmallVector<NamedAttrList> argAttrs;
-  SmallVector<NamedAttrList> resultAttrs;
-  SmallVector<Type> argTypes;
+  SmallVector<OpAsmParser::Argument> entryArgs;
+  SmallVector<DictionaryAttr> resultAttrs;
   SmallVector<Type> resultTypes;
   auto &builder = parser.getBuilder();
 
   // Parse the name as a symbol.
   StringAttr nameAttr;
   if (parser.parseSymbolName(nameAttr, SymbolTable::getSymbolAttrName(),
                              state.attributes))
     return failure();
 
   // Parse the function signature.
   bool isVariadic = false;
   if (function_interface_impl::parseFunctionSignature(
-          parser, /*allowVariadic=*/false, entryArgs, argTypes, argAttrs,
-          isVariadic, resultTypes, resultAttrs))
+          parser, /*allowVariadic=*/false, entryArgs, isVariadic, resultTypes,
+          resultAttrs))
     return failure();
 
+  SmallVector<Type> argTypes;
+  for (auto &arg : entryArgs)
+    argTypes.push_back(arg.type);
   auto fnType = builder.getFunctionType(argTypes, resultTypes);
   state.addAttribute(FunctionOpInterface::getTypeAttrName(),
                      TypeAttr::get(fnType));
 
   // Parse the optional function control keyword.
   spirv::FunctionControl fnControl;
   if (parseEnumStrAttr(fnControl, parser, state))
     return failure();
 
   // If additional attributes are present, parse them.
   if (parser.parseOptionalAttrDictWithKeyword(state.attributes))
     return failure();
 
   // Add the attributes to the function arguments.
-  assert(argAttrs.size() == argTypes.size());
   assert(resultAttrs.size() == resultTypes.size());
-  function_interface_impl::addArgAndResultAttrs(builder, state, argAttrs,
+  function_interface_impl::addArgAndResultAttrs(builder, state, entryArgs,
                                                 resultAttrs);
 
   // Parse the optional function body.
   auto *body = state.addRegion();
-  OptionalParseResult result = parser.parseOptionalRegion(
-      *body, entryArgs, entryArgs.empty() ? ArrayRef<Type>() : argTypes);
+  OptionalParseResult result = parser.parseOptionalRegion(*body, entryArgs);
   return failure(result.hasValue() && failed(*result));
 }
 
 void spirv::FuncOp::print(OpAsmPrinter &printer) {
   // Print function name, signature, and control.
   printer << " ";
   printer.printSymbolName(sym_name());
   auto fnType = getFunctionType();

mlir/lib/IR/FunctionImplementation.cpp

 //===- FunctionImplementation.cpp - Utilities for function-like ops -------===//
 //
 // 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/IR/FunctionImplementation.h"
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/FunctionInterfaces.h"
 #include "mlir/IR/SymbolTable.h"
 
 using namespace mlir;
 
-ParseResult mlir::function_interface_impl::parseFunctionArgumentList(
-    OpAsmParser &parser, bool allowAttributes, bool allowVariadic,
-    SmallVectorImpl<OpAsmParser::UnresolvedOperand> &argNames,
-    SmallVectorImpl<Type> &argTypes, SmallVectorImpl<NamedAttrList> &argAttrs,
+static ParseResult
+parseFunctionArgumentList(OpAsmParser &parser, bool allowVariadic,
+                          SmallVectorImpl<OpAsmParser::Argument> &arguments,
                           bool &isVariadic) {
-  if (parser.parseLParen())
-    return failure();
-
-  // The argument list either has to consistently have ssa-id's followed by
-  // types, or just be a type list.  It isn't ok to sometimes have SSA ID's and
-  // sometimes not.
-  auto parseArgument = [&]() -> ParseResult {
-    SMLoc loc = parser.getCurrentLocation();
 
-    // Parse argument name if present.
-    OpAsmParser::UnresolvedOperand argument;
-    Type argumentType;
-    auto hadSSAValue = parser.parseOptionalOperand(argument,
-                                                   /*allowResultNumber=*/false);
-    if (hadSSAValue.hasValue()) {
-      if (failed(hadSSAValue.getValue()))
-        return failure(); // Argument was present but malformed.
+  // Parse the function arguments.  The argument list either has to consistently
+  // have ssa-id's followed by types, or just be a type list.  It isn't ok to
+  // sometimes have SSA ID's and sometimes not.
+  isVariadic = false;
 
-      // Reject this if the preceding argument was missing a name.
-      if (argNames.empty() && !argTypes.empty())
-        return parser.emitError(loc, "expected type instead of SSA identifier");
+  return parser.parseCommaSeparatedList(
+      OpAsmParser::Delimiter::Paren, [&]() -> ParseResult {
+        // Ellipsis must be at end of the list.
+        if (isVariadic)
+          return parser.emitError(
+              parser.getCurrentLocation(),
+              "variadic arguments must be in the end of the argument list");
 
-      // Parse required type.
-      if (parser.parseColonType(argumentType))
-        return failure();
-    } else if (allowVariadic && succeeded(parser.parseOptionalEllipsis())) {
+        // Handle ellipsis as a special case.
+        if (allowVariadic && succeeded(parser.parseOptionalEllipsis())) {
+          // This is a variadic designator.
           isVariadic = true;
-      return success();
-    } else if (!argNames.empty()) {
-      // Reject this if the preceding argument had a name.
-      return parser.emitError(loc, "expected SSA identifier");
-    } else if (parser.parseType(argumentType)) {
-      return failure();
+          return success(); // Stop parsing arguments.
         }
+        // Parse argument name if present.
+        OpAsmParser::Argument argument;
+        auto argPresent = parser.parseOptionalArgument(
+            argument, /*allowType=*/true, /*allowAttrs=*/true);
+        if (argPresent.hasValue()) {
+          if (failed(argPresent.getValue()))
+            return failure(); // Present but malformed.
 
-    // Add the argument type.
-    argTypes.push_back(argumentType);
+          // Reject this if the preceding argument was missing a name.
+          if (!arguments.empty() && arguments.back().ssaName.name.empty())
+            return parser.emitError(argument.ssaName.location,
+                                    "expected type instead of SSA identifier");
+
+        } else {
+          argument.ssaName.location = parser.getCurrentLocation();
+          // Otherwise we just have a type list without SSA names.  Reject
+          // this if the preceding argument had a name.
+          if (!arguments.empty() && !arguments.back().ssaName.name.empty())
+            return parser.emitError(argument.ssaName.location,
+                                    "expected SSA identifier");
 
-    // Parse any argument attributes and source location information.
           NamedAttrList attrs;
-    if (parser.parseOptionalAttrDict(attrs) ||
+          if (parser.parseType(argument.type) ||
+              parser.parseOptionalAttrDict(attrs) ||
               parser.parseOptionalLocationSpecifier(argument.sourceLoc))
             return failure();
-         
-    if (!allowAttributes && !attrs.empty())
-      return parser.emitError(loc, "expected arguments without attributes");
-    argAttrs.push_back(attrs);
-
-    // If we had an argument name, then remember the parsed argument.
-    if (!argument.name.empty())
-      argNames.push_back(argument);
-    return success();
-  };
-
-  // Parse the function arguments.
-  isVariadic = false;
-  if (failed(parser.parseOptionalRParen())) {
-    do {
-      unsigned numTypedArguments = argTypes.size();
-      if (parseArgument())
-        return failure();
-
-      SMLoc loc = parser.getCurrentLocation();
-      if (argTypes.size() == numTypedArguments &&
-          succeeded(parser.parseOptionalComma()))
-        return parser.emitError(
-            loc, "variadic arguments must be in the end of the argument list");
-    } while (succeeded(parser.parseOptionalComma()));
-    parser.parseRParen();
+          argument.attrs = attrs.getDictionary(parser.getContext());
         }
-
+        arguments.push_back(argument);
         return success();
+      });
 }
 
 /// Parse a function result list.
 ///
 ///   function-result-list ::= function-result-list-parens
 ///                          | non-function-type
 ///   function-result-list-parens ::= `(` `)`
 ///                                 | `(` function-result-list-no-parens `)`
 ///   function-result-list-no-parens ::= function-result (`,` function-result)*
 ///   function-result ::= type attribute-dict?
 ///
 static ParseResult
 parseFunctionResultList(OpAsmParser &parser, SmallVectorImpl<Type> &resultTypes,
-                        SmallVectorImpl<NamedAttrList> &resultAttrs) {
+                        SmallVectorImpl<DictionaryAttr> &resultAttrs) {
   if (failed(parser.parseOptionalLParen())) {
     // We already know that there is no `(`, so parse a type.
     // Because there is no `(`, it cannot be a function type.
     Type ty;
     if (parser.parseType(ty))
       return failure();
     resultTypes.push_back(ty);
     resultAttrs.emplace_back();
     return success();
   }
 
   // Special case for an empty set of parens.
   if (succeeded(parser.parseOptionalRParen()))
     return success();
 
   // Parse individual function results.
-  do {
+  if (parser.parseCommaSeparatedList([&]() -> ParseResult {
         resultTypes.emplace_back();
         resultAttrs.emplace_back();
+        NamedAttrList attrs;
         if (parser.parseType(resultTypes.back()) ||
-        parser.parseOptionalAttrDict(resultAttrs.back())) {
+            parser.parseOptionalAttrDict(attrs))
           return failure();
-    }
-  } while (succeeded(parser.parseOptionalComma()));
+        resultAttrs.back() = attrs.getDictionary(parser.getContext());
+        return success();
+      }))
+    return failure();
+
   return parser.parseRParen();
 }
 
 ParseResult mlir::function_interface_impl::parseFunctionSignature(
     OpAsmParser &parser, bool allowVariadic,
-    SmallVectorImpl<OpAsmParser::UnresolvedOperand> &argNames,
-    SmallVectorImpl<Type> &argTypes, SmallVectorImpl<NamedAttrList> &argAttrs,
-    bool &isVariadic, SmallVectorImpl<Type> &resultTypes,
-    SmallVectorImpl<NamedAttrList> &resultAttrs) {
-  bool allowArgAttrs = true;
-  if (parseFunctionArgumentList(parser, allowArgAttrs, allowVariadic, argNames,
-                                argTypes, argAttrs, isVariadic))
+    SmallVectorImpl<OpAsmParser::Argument> &arguments, bool &isVariadic,
+    SmallVectorImpl<Type> &resultTypes,
+    SmallVectorImpl<DictionaryAttr> &resultAttrs) {
+  if (parseFunctionArgumentList(parser, allowVariadic, arguments, isVariadic))
     return failure();
   if (succeeded(parser.parseOptionalArrow()))
     return parseFunctionResultList(parser, resultTypes, resultAttrs);
   return success();
 }
 
-/// Implementation of `addArgAndResultAttrs` that is attribute list type
-/// agnostic.
-template <typename AttrListT, typename AttrArrayBuildFnT>
-static void addArgAndResultAttrsImpl(Builder &builder, OperationState &result,
-                                     ArrayRef<AttrListT> argAttrs,
-                                     ArrayRef<AttrListT> resultAttrs,
-                                     AttrArrayBuildFnT &&buildAttrArrayFn) {
-  auto nonEmptyAttrsFn = [](const AttrListT &attrs) { return !attrs.empty(); };
+void mlir::function_interface_impl::addArgAndResultAttrs(
+    Builder &builder, OperationState &result, ArrayRef<DictionaryAttr> argAttrs,
+    ArrayRef<DictionaryAttr> resultAttrs) {
+  auto nonEmptyAttrsFn = [](DictionaryAttr attrs) {
+    return attrs && !attrs.empty();
+  };
+  // Convert the specified array of dictionary attrs (which may have null
+  // entries) to an ArrayAttr of dictionaries.
+  auto getArrayAttr = [&](ArrayRef<DictionaryAttr> dictAttrs) {
+    SmallVector<Attribute> attrs;
+    for (auto &dict : dictAttrs)
+      attrs.push_back(dict ? dict : builder.getDictionaryAttr({}));
+    return builder.getArrayAttr(attrs);
+  };
 
   // Add the attributes to the function arguments.
-  if (!argAttrs.empty() && llvm::any_of(argAttrs, nonEmptyAttrsFn)) {
-    ArrayAttr attrDicts = builder.getArrayAttr(buildAttrArrayFn(argAttrs));
+  if (llvm::any_of(argAttrs, nonEmptyAttrsFn))
     result.addAttribute(function_interface_impl::getArgDictAttrName(),
-                        attrDicts);
-  }
+                        getArrayAttr(argAttrs));
+
   // Add the attributes to the function results.
-  if (!resultAttrs.empty() && llvm::any_of(resultAttrs, nonEmptyAttrsFn)) {
-    ArrayAttr attrDicts = builder.getArrayAttr(buildAttrArrayFn(resultAttrs));
+  if (llvm::any_of(resultAttrs, nonEmptyAttrsFn))
     result.addAttribute(function_interface_impl::getResultDictAttrName(),
-                        attrDicts);
-  }
+                        getArrayAttr(resultAttrs));
 }
 
 void mlir::function_interface_impl::addArgAndResultAttrs(
-    Builder &builder, OperationState &result, ArrayRef<DictionaryAttr> argAttrs,
+    Builder &builder, OperationState &result,
+    ArrayRef<OpAsmParser::Argument> args,
     ArrayRef<DictionaryAttr> resultAttrs) {
-  auto buildFn = [](ArrayRef<DictionaryAttr> attrs) {
-    return ArrayRef<Attribute>(attrs.data(), attrs.size());
-  };
-  addArgAndResultAttrsImpl(builder, result, argAttrs, resultAttrs, buildFn);
-}
-void mlir::function_interface_impl::addArgAndResultAttrs(
-    Builder &builder, OperationState &result, ArrayRef<NamedAttrList> argAttrs,
-    ArrayRef<NamedAttrList> resultAttrs) {
-  MLIRContext *context = builder.getContext();
-  auto buildFn = [=](ArrayRef<NamedAttrList> attrs) {
-    return llvm::to_vector<8>(
-        llvm::map_range(attrs, [=](const NamedAttrList &attrList) -> Attribute {
-          return attrList.getDictionary(context);
-        }));
-  };
-  addArgAndResultAttrsImpl(builder, result, argAttrs, resultAttrs, buildFn);
+  SmallVector<DictionaryAttr> argAttrs;
+  for (const auto &arg : args)
+    argAttrs.push_back(arg.attrs);
+  addArgAndResultAttrs(builder, result, argAttrs, resultAttrs);
 }
 
 ParseResult mlir::function_interface_impl::parseFunctionOp(
     OpAsmParser &parser, OperationState &result, bool allowVariadic,
     FuncTypeBuilder funcTypeBuilder) {
-  SmallVector<OpAsmParser::UnresolvedOperand> entryArgs;
-  SmallVector<NamedAttrList> argAttrs;
-  SmallVector<NamedAttrList> resultAttrs;
-  SmallVector<Type> argTypes;
+  SmallVector<OpAsmParser::Argument> entryArgs;
+  SmallVector<DictionaryAttr> resultAttrs;
   SmallVector<Type> resultTypes;
   auto &builder = parser.getBuilder();
 
   // Parse visibility.
   impl::parseOptionalVisibilityKeyword(parser, result.attributes);
 
   // Parse the name as a symbol.
   StringAttr nameAttr;
   if (parser.parseSymbolName(nameAttr, SymbolTable::getSymbolAttrName(),
                              result.attributes))
     return failure();
 
   // Parse the function signature.
   SMLoc signatureLocation = parser.getCurrentLocation();
   bool isVariadic = false;
-  if (parseFunctionSignature(parser, allowVariadic, entryArgs, argTypes,
-                             argAttrs, isVariadic, resultTypes, resultAttrs))
+  if (parseFunctionSignature(parser, allowVariadic, entryArgs, isVariadic,
+                             resultTypes, resultAttrs))
     return failure();
 
   std::string errorMessage;
+  SmallVector<Type> argTypes;
+  argTypes.reserve(entryArgs.size());
+  for (auto &arg : entryArgs)
+    argTypes.push_back(arg.type);
   Type type = funcTypeBuilder(builder, argTypes, resultTypes,
                               VariadicFlag(isVariadic), errorMessage);
   if (!type) {
     return parser.emitError(signatureLocation)
            << "failed to construct function type"
            << (errorMessage.empty() ? "" : ": ") << errorMessage;
   }
   result.addAttribute(getTypeAttrName(), TypeAttr::get(type));
if (parsedAttributes.get(disallowed))
       return parser.emitError(attributeDictLocation, "'")
              << disallowed
              << "' is an inferred attribute and should not be specified in the "
                 "explicit attribute dictionary";
   }
   result.attributes.append(parsedAttributes);
 
   // Add the attributes to the function arguments.
-  assert(argAttrs.size() == argTypes.size());
   assert(resultAttrs.size() == resultTypes.size());
-  addArgAndResultAttrs(builder, result, argAttrs, resultAttrs);
+  addArgAndResultAttrs(builder, result, entryArgs, resultAttrs);
 
   // Parse the optional function body. The printer will not print the body if
   // its empty, so disallow parsing of empty body in the parser.
   auto *body = result.addRegion();
   SMLoc loc = parser.getCurrentLocation();
-  OptionalParseResult parseResult = parser.parseOptionalRegion(
-      *body, entryArgs, entryArgs.empty() ? ArrayRef<Type>() : argTypes,
+  OptionalParseResult parseResult =
+      parser.parseOptionalRegion(*body, entryArgs,
                                  /*enableNameShadowing=*/false);
   if (parseResult.hasValue()) {
     if (failed(*parseResult))
       return failure();
     // Function body was parsed, make sure its not empty.
     if (body->empty())
       return parser.emitError(loc, "expected non-empty function body");
   }
   return success();

mlir/lib/Parser/AttributeParser.cpp

auto parseElt = [&]() -> ParseResult {
 
     auto attr = parseAttribute();
     if (!attr)
       return failure();
     attributes.push_back({*nameId, attr});
     return success();
   };
 
-  if (parseCommaSeparatedList(Delimiter::Braces, parseElt,
-                              " in attribute dictionary"))
-    return failure();
-
-  return success();
+  return parseCommaSeparatedList(Delimiter::Braces, parseElt,
+                                 " in attribute dictionary");
 }
 
 /// Parse a float attribute.
 Attribute Parser::parseFloatAttr(Type type, bool isNegative) {
   auto val = getToken().getFloatingPointValue();
   if (!val.hasValue())
     return (emitError("floating point value too large for attribute"), nullptr);
   consumeToken(Token::floatliteral);

mlir/lib/Parser/Parser.cpp

public:
   /// are any remaining issues.
   ParseResult finalize();
 
   //===--------------------------------------------------------------------===//
   // SSA Value Handling
   //===--------------------------------------------------------------------===//
 
   using UnresolvedOperand = OpAsmParser::UnresolvedOperand;
+  using Argument = OpAsmParser::Argument;
 
   struct DeferredLocInfo {
     SMLoc loc;
     StringRef identifier;
   };
 
   /// Push a new SSA name scope to the parser.
   void pushSSANameScope(bool isIsolated);
public:
 
   //===--------------------------------------------------------------------===//
   // Region Parsing
   //===--------------------------------------------------------------------===//
 
   /// Parse a region into 'region' with the provided entry block arguments.
   /// 'isIsolatedNameScope' indicates if the naming scope of this region is
   /// isolated from those above.
-  ParseResult
-  parseRegion(Region &region,
-              ArrayRef<std::pair<UnresolvedOperand, Type>> entryArguments,
+  ParseResult parseRegion(Region &region, ArrayRef<Argument> entryArguments,
                           bool isIsolatedNameScope = false);
 
   /// Parse a region body into 'region'.
-  ParseResult
-  parseRegionBody(Region &region, SMLoc startLoc,
-                  ArrayRef<std::pair<UnresolvedOperand, Type>> entryArguments,
+  ParseResult parseRegionBody(Region &region, SMLoc startLoc,
+                              ArrayRef<Argument> entryArguments,
                               bool isIsolatedNameScope);
 
   //===--------------------------------------------------------------------===//
   // Block Parsing
   //===--------------------------------------------------------------------===//
 
   /// Parse a new block into 'block'.
   ParseResult parseBlock(Block *&block);
 
if (state.asmState) {
           op, nameTok.getLocRange(), /*endLoc=*/getToken().getLoc(),
           asmResultGroups);
     }
 
     // Add definitions for each of the result groups.
     unsigned opResI = 0;
     for (ResultRecord &resIt : resultIDs) {
       for (unsigned subRes : llvm::seq<unsigned>(0, std::get<1>(resIt))) {
-        if (addDefinition({std::get<2>(resIt), std::get<0>(resIt), subRes, {}},
+        if (addDefinition({std::get<2>(resIt), std::get<0>(resIt), subRes},
                           op->getResult(opResI++)))
           return failure();
       }
     }
 
     // Add this operation to the assembly state if it was provided to populate.
   } else if (state.asmState) {
     state.asmState->finalizeOperationDefinition(op, nameTok.getLocRange(),
public:
 
   /// Parse a single operand.
   ParseResult parseOperand(UnresolvedOperand &result,
                            bool allowResultNumber = true) override {
     OperationParser::UnresolvedOperand useInfo;
     if (parser.parseSSAUse(useInfo, allowResultNumber))
       return failure();
 
-    result = {useInfo.location, useInfo.name, useInfo.number, {}};
-
-    // Parse a source locator on the operand if present.
-    return parseOptionalLocationSpecifier(result.sourceLoc);
+    result = {useInfo.location, useInfo.name, useInfo.number};
+    return success();
   }
 
   /// Parse a single operand if present.
   OptionalParseResult
   parseOptionalOperand(UnresolvedOperand &result,
                        bool allowResultNumber = true) override {
     if (parser.getToken().is(Token::percent_identifier))
       return parseOperand(result, allowResultNumber);
if (delimiter == Delimiter::None) {
         if (parser.getToken().is(Token::l_paren) ||
             parser.getToken().is(Token::l_square))
           return emitError(startLoc, "unexpected delimiter");
         return emitError(startLoc, "invalid operand");
       }
     }
 
     auto parseOneOperand = [&]() -> ParseResult {
-      UnresolvedOperand operandOrArg;
-      if (parseOperand(operandOrArg, allowResultNumber))
-        return failure();
-      result.push_back(operandOrArg);
-      return success();
+      return parseOperand(result.emplace_back(), allowResultNumber);
     };
 
     if (parseCommaSeparatedList(delimiter, parseOneOperand, " in operand list"))
       return failure();
 
     // Check that we got the expected # of elements.
     if (requiredOperandCount != -1 &&
         result.size() != static_cast<size_t>(requiredOperandCount))
auto parseElement = [&](bool isSymbol) -> ParseResult {
         dimOperands.push_back(operand);
       return success();
     };
 
     return parser.parseAffineExprOfSSAIds(expr, parseElement);
   }
 
   //===--------------------------------------------------------------------===//
+  // Argument Parsing
+  //===--------------------------------------------------------------------===//
+
+  /// Parse a single argument with the following syntax:
+  ///
+  ///   `%ssaname : !type { optionalAttrDict} loc(optionalSourceLoc)`
+  ///
+  /// If `allowType` is false or `allowAttrs` are false then the respective
+  /// parts of the grammar are not parsed.
+  ParseResult parseArgument(Argument &result, bool allowType = false,
+                            bool allowAttrs = false) override {
+    NamedAttrList attrs;
+    if (parseOperand(result.ssaName, /*allowResultNumber=*/false) ||
+        (allowType && parseColonType(result.type)) ||
+        (allowAttrs && parseOptionalAttrDict(attrs)) ||
+        parseOptionalLocationSpecifier(result.sourceLoc))
+      return failure();
+    result.attrs = attrs.getDictionary(getContext());
+    return success();
+  }
+
+  /// Parse a single argument if present.
+  OptionalParseResult parseOptionalArgument(Argument &result, bool allowType,
+                                            bool allowAttrs) override {
+    if (parser.getToken().is(Token::percent_identifier))
+      return parseArgument(result, allowType, allowAttrs);
+    return llvm::None;
+  }
+
+  ParseResult parseArgumentList(SmallVectorImpl<Argument> &result,
+                                Delimiter delimiter, bool allowType,
+                                bool allowAttrs) override {
+    // The no-delimiter case has some special handling for the empty case.
+    if (delimiter == Delimiter::None &&
+        parser.getToken().isNot(Token::percent_identifier))
+      return success();
+
+    auto parseOneArgument = [&]() -> ParseResult {
+      return parseArgument(result.emplace_back(), allowType, allowAttrs);
+    };
+    return parseCommaSeparatedList(delimiter, parseOneArgument,
+                                   " in argument list");
+  }
+
+  //===--------------------------------------------------------------------===//
   // Region Parsing
   //===--------------------------------------------------------------------===//
 
   /// Parse a region that takes `arguments` of `argTypes` types.  This
   /// effectively defines the SSA values of `arguments` and assigns their type.
-  ParseResult parseRegion(Region &region, ArrayRef<UnresolvedOperand> arguments,
-                          ArrayRef<Type> argTypes,
+  ParseResult parseRegion(Region &region, ArrayRef<Argument> arguments,
                           bool enableNameShadowing) override {
-    assert(arguments.size() == argTypes.size() &&
-           "mismatching number of arguments and types");
-
-    SmallVector<std::pair<OperationParser::UnresolvedOperand, Type>, 2>
-        regionArguments;
-    for (auto pair : llvm::zip(arguments, argTypes))
-      regionArguments.emplace_back(std::get<0>(pair), std::get<1>(pair));
-
     // Try to parse the region.
     (void)isIsolatedFromAbove;
     assert((!enableNameShadowing || isIsolatedFromAbove) &&
            "name shadowing is only allowed on isolated regions");
-    if (parser.parseRegion(region, regionArguments, enableNameShadowing))
+    if (parser.parseRegion(region, arguments, enableNameShadowing))
       return failure();
     return success();
   }
 
   /// Parses a region if present.
   OptionalParseResult parseOptionalRegion(Region &region,
-                                          ArrayRef<UnresolvedOperand> arguments,
-                                          ArrayRef<Type> argTypes,
+                                          ArrayRef<Argument> arguments,
                                           bool enableNameShadowing) override {
     if (parser.getToken().isNot(Token::l_brace))
       return llvm::None;
-    return parseRegion(region, arguments, argTypes, enableNameShadowing);
+    return parseRegion(region, arguments, enableNameShadowing);
   }
 
   /// Parses a region if present. If the region is present, a new region is
   /// allocated and placed in `region`. If no region is present, `region`
   /// remains untouched.
-  OptionalParseResult parseOptionalRegion(
-      std::unique_ptr<Region> &region, ArrayRef<UnresolvedOperand> arguments,
-      ArrayRef<Type> argTypes, bool enableNameShadowing = false) override {
+  OptionalParseResult
+  parseOptionalRegion(std::unique_ptr<Region> &region,
+                      ArrayRef<Argument> arguments,
+                      bool enableNameShadowing = false) override {
     if (parser.getToken().isNot(Token::l_brace))
       return llvm::None;
     std::unique_ptr<Region> newRegion = std::make_unique<Region>();
-    if (parseRegion(*newRegion, arguments, argTypes, enableNameShadowing))
+    if (parseRegion(*newRegion, arguments, enableNameShadowing))
       return failure();
 
     region = std::move(newRegion);
     return success();
   }
 
   //===--------------------------------------------------------------------===//
   // Successor Parsing
public:
 
   //===--------------------------------------------------------------------===//
   // Type Parsing
   //===--------------------------------------------------------------------===//
 
   /// Parse a list of assignments of the form
   ///   (%x1 = %y1, %x2 = %y2, ...).
   OptionalParseResult parseOptionalAssignmentList(
-      SmallVectorImpl<UnresolvedOperand> &lhs,
+      SmallVectorImpl<Argument> &lhs,
       SmallVectorImpl<UnresolvedOperand> &rhs) override {
     if (failed(parseOptionalLParen()))
       return llvm::None;
 
     auto parseElt = [&]() -> ParseResult {
-      UnresolvedOperand regionArg, operand;
-      if (parseOperand(regionArg, /*allowResultNumber=*/false) ||
-          parseEqual() || parseOperand(operand))
+      if (parseArgument(lhs.emplace_back()) || parseEqual() ||
+          parseOperand(rhs.emplace_back()))
         return failure();
-      lhs.push_back(regionArg);
-      rhs.push_back(operand);
-      return success();
-    };
-    return parser.parseCommaSeparatedListUntil(Token::r_paren, parseElt);
-  }
-
-  /// Parse a list of assignments of the form
-  ///   (%x1 = %y1 : type1, %x2 = %y2 : type2, ...).
-  OptionalParseResult
-  parseOptionalAssignmentListWithTypes(SmallVectorImpl<UnresolvedOperand> &lhs,
-                                       SmallVectorImpl<UnresolvedOperand> &rhs,
-                                       SmallVectorImpl<Type> &types) override {
-    if (failed(parseOptionalLParen()))
-      return llvm::None;
-
-    auto parseElt = [&]() -> ParseResult {
-      UnresolvedOperand regionArg, operand;
-      Type type;
-      if (parseOperand(regionArg, /*allowResultNumber=*/false) ||
-          parseEqual() || parseOperand(operand) || parseColon() ||
-          parseType(type))
-        return failure();
-      lhs.push_back(regionArg);
-      rhs.push_back(operand);
-      types.push_back(type);
       return success();
     };
     return parser.parseCommaSeparatedListUntil(Token::r_paren, parseElt);
   }
 
   /// Parse a loc(...) specifier if present, filling in result if so.
   ParseResult
   parseOptionalLocationSpecifier(Optional<Location> &result) override {
else
     opOrArgument.get<BlockArgument>().setLoc(directLoc);
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // Region Parsing
 //===----------------------------------------------------------------------===//
 
-ParseResult OperationParser::parseRegion(
-    Region &region,
-    ArrayRef<std::pair<OperationParser::UnresolvedOperand, Type>>
-        entryArguments,
+ParseResult OperationParser::parseRegion(Region &region,
+                                         ArrayRef<Argument> entryArguments,
                                          bool isIsolatedNameScope) {
   // Parse the '{'.
   Token lBraceTok = getToken();
   if (parseToken(Token::l_brace, "expected '{' to begin a region"))
     return failure();
 
   // If we are populating the parser state, start a new region definition.
   if (state.asmState)
     state.asmState->startRegionDefinition();
 
   // Parse the region body.
   if ((!entryArguments.empty() || getToken().isNot(Token::r_brace)) &&
       parseRegionBody(region, lBraceTok.getLoc(), entryArguments,
                       isIsolatedNameScope)) {
     return failure();
   }
   consumeToken(Token::r_brace);
 
   // If we are populating the parser state, finalize this region.
   if (state.asmState)
     state.asmState->finalizeRegionDefinition();
 
   return success();
 }
 
-ParseResult OperationParser::parseRegionBody(
-    Region &region, SMLoc startLoc,
-    ArrayRef<std::pair<OperationParser::UnresolvedOperand, Type>>
-        entryArguments,
+ParseResult OperationParser::parseRegionBody(Region &region, SMLoc startLoc,
+                                             ArrayRef<Argument> entryArguments,
                                              bool isIsolatedNameScope) {
   auto currentPt = opBuilder.saveInsertionPoint();
 
   // Push a new named value scope.
   pushSSANameScope(isIsolatedNameScope);
 
   // Parse the first block directly to allow for it to be unnamed.
   auto owningBlock = std::make_unique<Block>();
   Block *block = owningBlock.get();
 
   // If this block is not defined in the source file, add a definition for it
   // now in the assembly state. Blocks with a name will be defined when the name
   // is parsed.
   if (state.asmState && getToken().isNot(Token::caret_identifier))
     state.asmState->addDefinition(block, startLoc);
 
-  // Add arguments to the entry block.
-  if (!entryArguments.empty()) {
+  // Add arguments to the entry block if we had the form with explicit names.
+  if (!entryArguments.empty() && !entryArguments[0].ssaName.name.empty()) {
     // If we had named arguments, then don't allow a block name.
     if (getToken().is(Token::caret_identifier))
       return emitError("invalid block name in region with named arguments");
 
-    for (auto &placeholderArgPair : entryArguments) {
-      auto &argInfo = placeholderArgPair.first;
+    for (auto &entryArg : entryArguments) {
+      auto &argInfo = entryArg.ssaName;
 
       // Ensure that the argument was not already defined.
       if (auto defLoc = getReferenceLoc(argInfo.name, argInfo.number)) {
         return emitError(argInfo.location, "region entry argument '" +
                                                argInfo.name +
                                                "' is already in use")
                    .attachNote(getEncodedSourceLocation(*defLoc))
                << "previously referenced here";
       }
-      Location loc = argInfo.sourceLoc.hasValue()
-                         ? argInfo.sourceLoc.getValue()
+      Location loc = entryArg.sourceLoc.hasValue()
+                         ? entryArg.sourceLoc.getValue()
                          : getEncodedSourceLocation(argInfo.location);
-      BlockArgument arg = block->addArgument(placeholderArgPair.second, loc);
+      BlockArgument arg = block->addArgument(entryArg.type, loc);
 
       // Add a definition of this arg to the assembly state if provided.
       if (state.asmState)
         state.asmState->addDefinition(arg, argInfo.location);
 
       // Record the definition for this argument.
       if (addDefinition(argInfo, arg))
         return failure();

mlir/test/Dialect/GPU/invalid.mlir

func.func @launch_func_kernel_operand_types(%sz : index, %arg : f32) {
     return
   }
 }
 
 // -----
 
 module attributes {gpu.container_module} {
   func.func @launch_func_kernel_operand_attr(%sz : index) {
-    // expected-error@+1 {{expected arguments without attributes}}
+    // expected-error@+1 {{expected ')' in argument list}}
     gpu.launch_func @foo::@bar blocks in (%sz, %sz, %sz) threads in (%sz, %sz, %sz) args(%sz : index {foo})
     return
   }
 }
 
 // -----
 
 func.func @reduce_no_op_no_body(%arg0 : f32) {

mlir/test/IR/locations.mlir

 // RUN: mlir-opt -allow-unregistered-dialect %s -mlir-print-debuginfo -mlir-print-local-scope | FileCheck %s
 // RUN: mlir-opt -allow-unregistered-dialect %s -mlir-print-debuginfo | FileCheck %s --check-prefix=CHECK-ALIAS
 // RUN: mlir-opt -allow-unregistered-dialect %s -mlir-print-debuginfo | mlir-opt -allow-unregistered-dialect -mlir-print-debuginfo | FileCheck %s --check-prefix=CHECK-ALIAS
 // This test verifies that debug locations are round-trippable.
 
 #set0 = affine_set<(d0) : (1 == 0)>
 
 // CHECK-LABEL: func @inline_notation
 func.func @inline_notation() -> i32 {
   // CHECK: -> i32 loc("foo")
   %1 = "foo"() : () -> i32 loc("foo")
 
   // CHECK: arith.constant 4 : index loc(callsite("foo" at "mysource.cc":10:8))
   %2 = arith.constant 4 : index loc(callsite("foo" at "mysource.cc":10:8))
 
+  // CHECK: affine.for %arg0 loc("IVlocation") = 0 to 8 {
   // CHECK: } loc(fused["foo", "mysource.cc":10:8])
-  affine.for %i0 = 0 to 8 {
+  affine.for %i0 loc("IVlocation") = 0 to 8 {
   } loc(fused["foo", "mysource.cc":10:8])
 
   // CHECK: } loc(fused<"myPass">["foo", "foo2"])
   affine.if #set0(%2) {
   } loc(fused<"myPass">["foo", "foo2"])
 
   // CHECK: } loc(fused<"myPass">["foo"])
   affine.if #set0(%2) {

mlir/test/lib/Dialect/Test/TestDialect.cpp

 }
 
 //===----------------------------------------------------------------------===//
 // Test IsolatedRegionOp - parse passthrough region arguments.
 //===----------------------------------------------------------------------===//
 
 ParseResult IsolatedRegionOp::parse(OpAsmParser &parser,
                                     OperationState &result) {
-  OpAsmParser::UnresolvedOperand argInfo;
-  Type argType = parser.getBuilder().getIndexType();
-
   // Parse the input operand.
-  if (parser.parseOperand(argInfo) ||
-      parser.resolveOperand(argInfo, argType, result.operands))
+  OpAsmParser::Argument argInfo;
+  argInfo.type = parser.getBuilder().getIndexType();
+  if (parser.parseOperand(argInfo.ssaName) ||
+      parser.resolveOperand(argInfo.ssaName, argInfo.type, result.operands))
     return failure();
 
   // Parse the body region, and reuse the operand info as the argument info.
   Region *body = result.addRegion();
-  return parser.parseRegion(*body, argInfo, argType,
-                            /*enableNameShadowing=*/true);
+  return parser.parseRegion(*body, argInfo, /*enableNameShadowing=*/true);
 }
 
 void IsolatedRegionOp::print(OpAsmPrinter &p) {
   p << "test.isolated_region ";
   p.printOperand(getOperand());
   p.shadowRegionArgs(getRegion(), getOperand());
   p << ' ';
   p.printRegion(getRegion(), /*printEntryBlockArgs=*/false);
void PrettyPrintedRegionOp::print(OpAsmPrinter &p) {
   p.printFunctionalType(*this);
 }
 
 //===----------------------------------------------------------------------===//
 // Test PolyForOp - parse list of region arguments.
 //===----------------------------------------------------------------------===//
 
 ParseResult PolyForOp::parse(OpAsmParser &parser, OperationState &result) {
-  SmallVector<OpAsmParser::UnresolvedOperand, 4> ivsInfo;
+  SmallVector<OpAsmParser::Argument, 4> ivsInfo;
   // Parse list of region arguments without a delimiter.
-  if (parser.parseOperandList(ivsInfo, OpAsmParser::Delimiter::None,
-                              /*allowResultNumber=*/false))
+  if (parser.parseArgumentList(ivsInfo, OpAsmParser::Delimiter::None))
     return failure();
 
   // Parse the body region.
   Region *body = result.addRegion();
-  auto &builder = parser.getBuilder();
-  SmallVector<Type, 4> argTypes(ivsInfo.size(), builder.getIndexType());
-  return parser.parseRegion(*body, ivsInfo, argTypes);
+  for (auto &iv : ivsInfo)
+    iv.type = parser.getBuilder().getIndexType();
+  return parser.parseRegion(*body, ivsInfo);
 }
 
 void PolyForOp::print(OpAsmPrinter &p) { p.printGenericOp(*this); }
 
 void PolyForOp::getAsmBlockArgumentNames(Region &region,
                                          OpAsmSetValueNameFn setNameFn) {
   auto arrayAttr = getOperation()->getAttrOfType<ArrayAttr>("arg_names");
   if (!arrayAttr)