[mlir][spirv] Clean up SPIRVOps.cpp. NFC.

[kuhar]

Summary

Resolve almost all clang tidy warnings in this file:

1. Clean up string constants.
2. Use consistent argument names across function declarations and definitions. Rename state - > result, which is consistent with the other dialects.
3. Remove misleading function parameter name comments (argTypes). This did not match the actual function argument (bool enableNameShadowing).
4. Simplify calls to is_splat.

[kuhar]

Rebased.

[antiagainst]

Cool, thanks for this!

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

1031

I actually think result is not the proper naming; state should be better. This is really building up the full state of the op, including operands, results, and attributes. Results is really just part of it. But I understand the consistency concerns here. So this is also fine to me.

[kuhar]

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

1031

My main concern here was that the parameter name did not match the argument name. But yes, the type is even called OperationState after all. If that makes sense globally, I think we should rename the argument name in parse and replace it in all dialects.

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

 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/bit.h"
 #include <numeric>
 
 using namespace mlir;
 
 // TODO: generate these strings using ODS.
-static constexpr const char kMemoryAccessAttrName[] = "memory_access";
-static constexpr const char kSourceMemoryAccessAttrName[] =
-    "source_memory_access";
-static constexpr const char kAlignmentAttrName[] = "alignment";
-static constexpr const char kSourceAlignmentAttrName[] = "source_alignment";
-static constexpr const char kBranchWeightAttrName[] = "branch_weights";
-static constexpr const char kCallee[] = "callee";
-static constexpr const char kClusterSize[] = "cluster_size";
-static constexpr const char kControl[] = "control";
-static constexpr const char kDefaultValueAttrName[] = "default_value";
-static constexpr const char kExecutionScopeAttrName[] = "execution_scope";
-static constexpr const char kEqualSemanticsAttrName[] = "equal_semantics";
-static constexpr const char kFnNameAttrName[] = "fn";
-static constexpr const char kGroupOperationAttrName[] = "group_operation";
-static constexpr const char kIndicesAttrName[] = "indices";
-static constexpr const char kInitializerAttrName[] = "initializer";
-static constexpr const char kInterfaceAttrName[] = "interface";
-static constexpr const char kMemoryScopeAttrName[] = "memory_scope";
-static constexpr const char kSemanticsAttrName[] = "semantics";
-static constexpr const char kSpecIdAttrName[] = "spec_id";
-static constexpr const char kTypeAttrName[] = "type";
-static constexpr const char kUnequalSemanticsAttrName[] = "unequal_semantics";
-static constexpr const char kValueAttrName[] = "value";
-static constexpr const char kValuesAttrName[] = "values";
-static constexpr const char kCompositeSpecConstituentsName[] = "constituents";
+constexpr char kMemoryAccessAttrName[] = "memory_access";
+constexpr char kSourceMemoryAccessAttrName[] = "source_memory_access";
+constexpr char kAlignmentAttrName[] = "alignment";
+constexpr char kSourceAlignmentAttrName[] = "source_alignment";
+constexpr char kBranchWeightAttrName[] = "branch_weights";
+constexpr char kCallee[] = "callee";
+constexpr char kClusterSize[] = "cluster_size";
+constexpr char kControl[] = "control";
+constexpr char kDefaultValueAttrName[] = "default_value";
+constexpr char kExecutionScopeAttrName[] = "execution_scope";
+constexpr char kEqualSemanticsAttrName[] = "equal_semantics";
+constexpr char kFnNameAttrName[] = "fn";
+constexpr char kGroupOperationAttrName[] = "group_operation";
+constexpr char kIndicesAttrName[] = "indices";
+constexpr char kInitializerAttrName[] = "initializer";
+constexpr char kInterfaceAttrName[] = "interface";
+constexpr char kMemoryScopeAttrName[] = "memory_scope";
+constexpr char kSemanticsAttrName[] = "semantics";
+constexpr char kSpecIdAttrName[] = "spec_id";
+constexpr char kTypeAttrName[] = "type";
+constexpr char kUnequalSemanticsAttrName[] = "unequal_semantics";
+constexpr char kValueAttrName[] = "value";
+constexpr char kValuesAttrName[] = "values";
+constexpr char kCompositeSpecConstituentsName[] = "constituents";
 
 //===----------------------------------------------------------------------===//
 // Common utility functions
 //===----------------------------------------------------------------------===//
 
 static ParseResult parseOneResultSameOperandTypeOp(OpAsmParser &parser,
                                                    OperationState &result) {
   SmallVector<OpAsmParser::UnresolvedOperand, 2> ops;

 void spirv::AccessChainOp::build(OpBuilder &builder, OperationState &state,
                                  Value basePtr, ValueRange indices) {
   auto type = getElementPtrType(basePtr.getType(), indices, state.location);
   assert(type && "Unable to deduce return type based on basePtr and indices");
   build(builder, state, type, basePtr, indices);
 }
 
 ParseResult spirv::AccessChainOp::parse(OpAsmParser &parser,
-                                        OperationState &state) {
+                                        OperationState &result) {
   OpAsmParser::UnresolvedOperand ptrInfo;
   SmallVector<OpAsmParser::UnresolvedOperand, 4> indicesInfo;
   Type type;
   auto loc = parser.getCurrentLocation();
   SmallVector<Type, 4> indicesTypes;
 
   if (parser.parseOperand(ptrInfo) ||
       parser.parseOperandList(indicesInfo, OpAsmParser::Delimiter::Square) ||
       parser.parseColonType(type) ||
-      parser.resolveOperand(ptrInfo, type, state.operands)) {
+      parser.resolveOperand(ptrInfo, type, result.operands)) {
     return failure();
   }
 
   // Check that the provided indices list is not empty before parsing their
   // type list.
   if (indicesInfo.empty()) {
-    return mlir::emitError(state.location, "'spv.AccessChain' op expected at "
+    return mlir::emitError(result.location, "'spv.AccessChain' op expected at "
                                             "least one index ");
   }
 
   if (parser.parseComma() || parser.parseTypeList(indicesTypes))
     return failure();
 
   // Check that the indices types list is not empty and that it has a one-to-one
   // mapping to the provided indices.
   if (indicesTypes.size() != indicesInfo.size()) {
-    return mlir::emitError(state.location,
+    return mlir::emitError(result.location,
                            "'spv.AccessChain' op indices types' count must be "
                            "equal to indices info count");
   }
 
-  if (parser.resolveOperands(indicesInfo, indicesTypes, loc, state.operands))
+  if (parser.resolveOperands(indicesInfo, indicesTypes, loc, result.operands))
     return failure();
 
   auto resultType = getElementPtrType(
-      type, llvm::makeArrayRef(state.operands).drop_front(), state.location);
+      type, llvm::makeArrayRef(result.operands).drop_front(), result.location);
   if (!resultType) {
     return failure();
   }
 
-  state.addTypes(resultType);
+  result.addTypes(resultType);
   return success();
 }
 
 template <typename Op>
 static void printAccessChain(Op op, ValueRange indices, OpAsmPrinter &printer) {
   printer << ' ' << op.base_ptr() << '[' << indices
           << "] : " << op.base_ptr().getType() << ", " << indices.getTypes();
 }

 
 void spirv::AtomicExchangeOp::print(OpAsmPrinter &printer) {
   printer << " \"" << stringifyScope(memory_scope()) << "\" \""
           << stringifyMemorySemantics(semantics()) << "\" " << getOperands()
           << " : " << pointer().getType();
 }
 
 ParseResult spirv::AtomicExchangeOp::parse(OpAsmParser &parser,
-                                           OperationState &state) {
+                                           OperationState &result) {
   spirv::Scope memoryScope;
   spirv::MemorySemantics semantics;
   SmallVector<OpAsmParser::UnresolvedOperand, 2> operandInfo;
   Type type;
-  if (parseEnumStrAttr(memoryScope, parser, state, kMemoryScopeAttrName) ||
-      parseEnumStrAttr(semantics, parser, state, kSemanticsAttrName) ||
+  if (parseEnumStrAttr(memoryScope, parser, result, kMemoryScopeAttrName) ||
+      parseEnumStrAttr(semantics, parser, result, kSemanticsAttrName) ||
       parser.parseOperandList(operandInfo, 2))
     return failure();
 
   auto loc = parser.getCurrentLocation();
   if (parser.parseColonType(type))
     return failure();
 
   auto ptrType = type.dyn_cast<spirv::PointerType>();
   if (!ptrType)
     return parser.emitError(loc, "expected pointer type");
 
   if (parser.resolveOperands(operandInfo, {ptrType, ptrType.getPointeeType()},
-                             parser.getNameLoc(), state.operands))
+                             parser.getNameLoc(), result.operands))
     return failure();
 
-  return parser.addTypeToList(ptrType.getPointeeType(), state.types);
+  return parser.addTypeToList(ptrType.getPointeeType(), result.types);
 }
 
 LogicalResult spirv::AtomicExchangeOp::verify() {
   if (getType() != value().getType())
     return emitOpError("value operand must have the same type as the op "
                        "result, but found ")
            << value().getType() << " vs " << getType();
 

 SuccessorOperands
 spirv::BranchConditionalOp::getSuccessorOperands(unsigned index) {
   assert(index < 2 && "invalid successor index");
   return SuccessorOperands(index == kTrueIndex ? trueTargetOperandsMutable()
                                                : falseTargetOperandsMutable());
 }
 
 ParseResult spirv::BranchConditionalOp::parse(OpAsmParser &parser,
-                                              OperationState &state) {
+                                              OperationState &result) {
   auto &builder = parser.getBuilder();
   OpAsmParser::UnresolvedOperand condInfo;
   Block *dest;
 
   // Parse the condition.
   Type boolTy = builder.getI1Type();
   if (parser.parseOperand(condInfo) ||
-      parser.resolveOperand(condInfo, boolTy, state.operands))
+      parser.resolveOperand(condInfo, boolTy, result.operands))
     return failure();
 
   // Parse the optional branch weights.
   if (succeeded(parser.parseOptionalLSquare())) {
     IntegerAttr trueWeight, falseWeight;
     NamedAttrList weights;
 
     auto i32Type = builder.getIntegerType(32);
     if (parser.parseAttribute(trueWeight, i32Type, "weight", weights) ||
         parser.parseComma() ||
         parser.parseAttribute(falseWeight, i32Type, "weight", weights) ||
         parser.parseRSquare())
       return failure();
 
-    state.addAttribute(kBranchWeightAttrName,
+    result.addAttribute(kBranchWeightAttrName,
                         builder.getArrayAttr({trueWeight, falseWeight}));
   }
 
   // Parse the true branch.
   SmallVector<Value, 4> trueOperands;
   if (parser.parseComma() ||
       parser.parseSuccessorAndUseList(dest, trueOperands))
     return failure();
-  state.addSuccessors(dest);
-  state.addOperands(trueOperands);
+  result.addSuccessors(dest);
+  result.addOperands(trueOperands);
 
   // Parse the false branch.
   SmallVector<Value, 4> falseOperands;
   if (parser.parseComma() ||
       parser.parseSuccessorAndUseList(dest, falseOperands))
     return failure();
-  state.addSuccessors(dest);
-  state.addOperands(falseOperands);
-  state.addAttribute(
+  result.addSuccessors(dest);
+  result.addOperands(falseOperands);
+  result.addAttribute(
       spirv::BranchConditionalOp::getOperandSegmentSizeAttr(),
       builder.getI32VectorAttr({1, static_cast<int32_t>(trueOperands.size()),
                                 static_cast<int32_t>(falseOperands.size())}));
 
   return success();
 }
 
 void spirv::BranchConditionalOp::print(OpAsmPrinter &printer) {
auto elementType =
       getElementType(composite.getType(), indexAttr, state.location);
   if (!elementType) {
     return;
   }
   build(builder, state, elementType, composite, indexAttr);
 }
 
 ParseResult spirv::CompositeExtractOp::parse(OpAsmParser &parser,
-                                             OperationState &state) {
+                                             OperationState &result) {
   OpAsmParser::UnresolvedOperand compositeInfo;
   Attribute indicesAttr;
   Type compositeType;
   SMLoc attrLocation;
 
   if (parser.parseOperand(compositeInfo) ||
       parser.getCurrentLocation(&attrLocation) ||
-      parser.parseAttribute(indicesAttr, kIndicesAttrName, state.attributes) ||
+      parser.parseAttribute(indicesAttr, kIndicesAttrName, result.attributes) ||
       parser.parseColonType(compositeType) ||
-      parser.resolveOperand(compositeInfo, compositeType, state.operands)) {
+      parser.resolveOperand(compositeInfo, compositeType, result.operands)) {
     return failure();
   }
 
   Type resultType =
       getElementType(compositeType, indicesAttr, parser, attrLocation);
   if (!resultType) {
     return failure();
   }
-  state.addTypes(resultType);
+  result.addTypes(resultType);
   return success();
 }
 
 void spirv::CompositeExtractOp::print(OpAsmPrinter &printer) {
   printer << ' ' << composite() << indices() << " : " << composite().getType();
 }
 
 LogicalResult spirv::CompositeExtractOp::verify() {

 void spirv::CompositeInsertOp::build(OpBuilder &builder, OperationState &state,
                                      Value object, Value composite,
                                      ArrayRef<int32_t> indices) {
   auto indexAttr = builder.getI32ArrayAttr(indices);
   build(builder, state, composite.getType(), object, composite, indexAttr);
 }
 
 ParseResult spirv::CompositeInsertOp::parse(OpAsmParser &parser,
-                                            OperationState &state) {
+                                            OperationState &result) {
   SmallVector<OpAsmParser::UnresolvedOperand, 2> operands;
   Type objectType, compositeType;
   Attribute indicesAttr;
   auto loc = parser.getCurrentLocation();
 
   return failure(
       parser.parseOperandList(operands, 2) ||
-      parser.parseAttribute(indicesAttr, kIndicesAttrName, state.attributes) ||
+      parser.parseAttribute(indicesAttr, kIndicesAttrName, result.attributes) ||
       parser.parseColonType(objectType) ||
       parser.parseKeywordType("into", compositeType) ||
       parser.resolveOperands(operands, {objectType, compositeType}, loc,
-                             state.operands) ||
-      parser.addTypesToList(compositeType, state.types));
+                             result.operands) ||
+      parser.addTypesToList(compositeType, result.types));
 }
 
 LogicalResult spirv::CompositeInsertOp::verify() {
   auto indicesArrayAttr = indices().dyn_cast<ArrayAttr>();
   auto objectType =
       getElementType(composite().getType(), indicesArrayAttr, getLoc());
   if (!objectType)
     return failure();
printer << " " << object() << ", " << composite() << indices() << " : "
           << object().getType() << " into " << composite().getType();
 }
 
 //===----------------------------------------------------------------------===//
 // spv.Constant
 //===----------------------------------------------------------------------===//
 
 ParseResult spirv::ConstantOp::parse(OpAsmParser &parser,
-                                     OperationState &state) {
+                                     OperationState &result) {
   Attribute value;
-  if (parser.parseAttribute(value, kValueAttrName, state.attributes))
+  if (parser.parseAttribute(value, kValueAttrName, result.attributes))
     return failure();
 
   Type type = NoneType::get(parser.getContext());
   if (auto typedAttr = value.dyn_cast<TypedAttr>())
     type = typedAttr.getType();
   if (type.isa<NoneType, TensorType>()) {
     if (parser.parseColonType(type))
       return failure();
   }
 
-  return parser.addTypeToList(type, state.types);
+  return parser.addTypeToList(type, result.types);
 }
 
 void spirv::ConstantOp::print(OpAsmPrinter &printer) {
   printer << ' ' << value();
   if (getType().isa<spirv::ArrayType>())
     printer << " : " << getType();
 }
 
void spirv::EntryPointOp::build(OpBuilder &builder, OperationState &state,
                                 spirv::FuncOp function,
                                 ArrayRef<Attribute> interfaceVars) {
   build(builder, state,
         spirv::ExecutionModelAttr::get(builder.getContext(), executionModel),
         SymbolRefAttr::get(function), builder.getArrayAttr(interfaceVars));
 }
 
 ParseResult spirv::EntryPointOp::parse(OpAsmParser &parser,
-                                       OperationState &state) {
+                                       OperationState &result) {
   spirv::ExecutionModel execModel;
   SmallVector<OpAsmParser::UnresolvedOperand, 0> identifiers;
   SmallVector<Type, 0> idTypes;
   SmallVector<Attribute, 4> interfaceVars;
 
   FlatSymbolRefAttr fn;
-  if (parseEnumStrAttr(execModel, parser, state) ||
-      parser.parseAttribute(fn, Type(), kFnNameAttrName, state.attributes)) {
+  if (parseEnumStrAttr(execModel, parser, result) ||
+      parser.parseAttribute(fn, Type(), kFnNameAttrName, result.attributes)) {
     return failure();
   }
 
   if (!parser.parseOptionalComma()) {
     // Parse the interface variables
     if (parser.parseCommaSeparatedList([&]() -> ParseResult {
           // The name of the interface variable attribute isnt important
           FlatSymbolRefAttr var;
           NamedAttrList attrs;
           if (parser.parseAttribute(var, Type(), "var_symbol", attrs))
             return failure();
           interfaceVars.push_back(var);
           return success();
         }))
       return failure();
   }
-  state.addAttribute(kInterfaceAttrName,
+  result.addAttribute(kInterfaceAttrName,
                       parser.getBuilder().getArrayAttr(interfaceVars));
   return success();
 }
 
 void spirv::EntryPointOp::print(OpAsmPrinter &printer) {
   printer << " \"" << stringifyExecutionModel(execution_model()) << "\" ";
   printer.printSymbolName(fn());
   auto interfaceVars = interface().getValue();
   if (!interfaceVars.empty()) {
void spirv::ExecutionModeOp::build(OpBuilder &builder, OperationState &state,
                                    spirv::ExecutionMode executionMode,
                                    ArrayRef<int32_t> params) {
   build(builder, state, SymbolRefAttr::get(function),
         spirv::ExecutionModeAttr::get(builder.getContext(), executionMode),
         builder.getI32ArrayAttr(params));
 }
 
 ParseResult spirv::ExecutionModeOp::parse(OpAsmParser &parser,
-                                          OperationState &state) {
+                                          OperationState &result) {
   spirv::ExecutionMode execMode;
   Attribute fn;
-  if (parser.parseAttribute(fn, kFnNameAttrName, state.attributes) ||
-      parseEnumStrAttr(execMode, parser, state)) {
+  if (parser.parseAttribute(fn, kFnNameAttrName, result.attributes) ||
+      parseEnumStrAttr(execMode, parser, result)) {
     return failure();
   }
 
   SmallVector<int32_t, 4> values;
   Type i32Type = parser.getBuilder().getIntegerType(32);
   while (!parser.parseOptionalComma()) {
     NamedAttrList attr;
     Attribute value;
     if (parser.parseAttribute(value, i32Type, "value", attr)) {
       return failure();
     }
     values.push_back(value.cast<IntegerAttr>().getInt());
   }
-  state.addAttribute(kValuesAttrName,
+  result.addAttribute(kValuesAttrName,
                       parser.getBuilder().getI32ArrayAttr(values));
   return success();
 }
 
 void spirv::ExecutionModeOp::print(OpAsmPrinter &printer) {
   printer << " ";
   printer.printSymbolName(fn());
   printer << " \"" << stringifyExecutionMode(execution_mode()) << "\"";
   auto values = this->values();

 LogicalResult spirv::UConvertOp::verify() {
   return verifyCastOp(*this, /*requireSameBitWidth=*/false);
 }
 
 //===----------------------------------------------------------------------===//
 // spv.func
 //===----------------------------------------------------------------------===//
 
-ParseResult spirv::FuncOp::parse(OpAsmParser &parser, OperationState &state) {
+ParseResult spirv::FuncOp::parse(OpAsmParser &parser, OperationState &result) {
   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))
+                             result.attributes))
     return failure();
 
   // Parse the function signature.
   bool isVariadic = false;
   if (function_interface_impl::parseFunctionSignature(
           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(),
+  result.addAttribute(FunctionOpInterface::getTypeAttrName(),
                       TypeAttr::get(fnType));
 
   // Parse the optional function control keyword.
   spirv::FunctionControl fnControl;
-  if (parseEnumStrAttr(fnControl, parser, state))
+  if (parseEnumStrAttr(fnControl, parser, result))
     return failure();
 
   // If additional attributes are present, parse them.
-  if (parser.parseOptionalAttrDictWithKeyword(state.attributes))
+  if (parser.parseOptionalAttrDictWithKeyword(result.attributes))
     return failure();
 
   // Add the attributes to the function arguments.
   assert(resultAttrs.size() == resultTypes.size());
-  function_interface_impl::addArgAndResultAttrs(builder, state, entryArgs,
+  function_interface_impl::addArgAndResultAttrs(builder, result, entryArgs,
                                                 resultAttrs);
 
   // Parse the optional function body.
-  auto *body = state.addRegion();
-  OptionalParseResult result = parser.parseOptionalRegion(*body, entryArgs);
-  return failure(result.has_value() && failed(*result));
+  auto *body = result.addRegion();
+  OptionalParseResult parseResult =
+      parser.parseOptionalRegion(*body, entryArgs);
+  return failure(parseResult.hasValue() && failed(*parseResult));
 }
 
 void spirv::FuncOp::print(OpAsmPrinter &printer) {
   // Print function name, signature, and control.
   printer << " ";
   printer.printSymbolName(sym_name());
   auto fnType = getFunctionType();
   function_interface_impl::printFunctionSignature(
void spirv::GlobalVariableOp::build(OpBuilder &builder, OperationState &state,
                                     spirv::BuiltIn builtin) {
   build(builder, state, TypeAttr::get(type), builder.getStringAttr(name));
   state.addAttribute(
       spirv::SPIRVDialect::getAttributeName(spirv::Decoration::BuiltIn),
       builder.getStringAttr(spirv::stringifyBuiltIn(builtin)));
 }
 
 ParseResult spirv::GlobalVariableOp::parse(OpAsmParser &parser,
-                                           OperationState &state) {
+                                           OperationState &result) {
   // Parse variable name.
   StringAttr nameAttr;
   if (parser.parseSymbolName(nameAttr, SymbolTable::getSymbolAttrName(),
-                             state.attributes)) {
+                             result.attributes)) {
     return failure();
   }
 
   // Parse optional initializer
   if (succeeded(parser.parseOptionalKeyword(kInitializerAttrName))) {
     FlatSymbolRefAttr initSymbol;
     if (parser.parseLParen() ||
         parser.parseAttribute(initSymbol, Type(), kInitializerAttrName,
-                              state.attributes) ||
+                              result.attributes) ||
         parser.parseRParen())
       return failure();
   }
 
-  if (parseVariableDecorations(parser, state)) {
+  if (parseVariableDecorations(parser, result)) {
     return failure();
   }
 
   Type type;
   auto loc = parser.getCurrentLocation();
   if (parser.parseColonType(type)) {
     return failure();
   }
   if (!type.isa<spirv::PointerType>()) {
     return parser.emitError(loc, "expected spv.ptr type");
   }
-  state.addAttribute(kTypeAttrName, TypeAttr::get(type));
+  result.addAttribute(kTypeAttrName, TypeAttr::get(type));
 
   return success();
 }
 
 void spirv::GlobalVariableOp::print(OpAsmPrinter &printer) {
   SmallVector<StringRef, 4> elidedAttrs{
       spirv::attributeName<spirv::StorageClass>()};
 
LogicalResult spirv::GroupNonUniformBroadcastOp::verify() {
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // spv.SubgroupBlockReadINTEL
 //===----------------------------------------------------------------------===//
 
 ParseResult spirv::SubgroupBlockReadINTELOp::parse(OpAsmParser &parser,
-                                                   OperationState &state) {
+                                                   OperationState &result) {
   // Parse the storage class specification
   spirv::StorageClass storageClass;
   OpAsmParser::UnresolvedOperand ptrInfo;
   Type elementType;
   if (parseEnumStrAttr(storageClass, parser) || parser.parseOperand(ptrInfo) ||
       parser.parseColon() || parser.parseType(elementType)) {
     return failure();
   }
 
   auto ptrType = spirv::PointerType::get(elementType, storageClass);
   if (auto valVecTy = elementType.dyn_cast<VectorType>())
     ptrType = spirv::PointerType::get(valVecTy.getElementType(), storageClass);
 
-  if (parser.resolveOperand(ptrInfo, ptrType, state.operands)) {
+  if (parser.resolveOperand(ptrInfo, ptrType, result.operands)) {
     return failure();
   }
 
-  state.addTypes(elementType);
+  result.addTypes(elementType);
   return success();
 }
 
 void spirv::SubgroupBlockReadINTELOp::print(OpAsmPrinter &printer) {
   printer << " " << ptr() << " : " << getType();
 }
 
 LogicalResult spirv::SubgroupBlockReadINTELOp::verify() {
   if (failed(verifyBlockReadWritePtrAndValTypes(*this, ptr(), value())))
     return failure();
 
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // spv.SubgroupBlockWriteINTEL
 //===----------------------------------------------------------------------===//
 
 ParseResult spirv::SubgroupBlockWriteINTELOp::parse(OpAsmParser &parser,
-                                                    OperationState &state) {
+                                                    OperationState &result) {
   // Parse the storage class specification
   spirv::StorageClass storageClass;
   SmallVector<OpAsmParser::UnresolvedOperand, 2> operandInfo;
   auto loc = parser.getCurrentLocation();
   Type elementType;
   if (parseEnumStrAttr(storageClass, parser) ||
       parser.parseOperandList(operandInfo, 2) || parser.parseColon() ||
       parser.parseType(elementType)) {
     return failure();
   }
 
   auto ptrType = spirv::PointerType::get(elementType, storageClass);
   if (auto valVecTy = elementType.dyn_cast<VectorType>())
     ptrType = spirv::PointerType::get(valVecTy.getElementType(), storageClass);
 
   if (parser.resolveOperands(operandInfo, {ptrType, elementType}, loc,
-                             state.operands)) {
+                             result.operands)) {
     return failure();
   }
   return success();
 }
 
 void spirv::SubgroupBlockWriteINTELOp::print(OpAsmPrinter &printer) {
   printer << " " << ptr() << ", " << value() << " : " << value().getType();
 }

 // spv.IAddCarryOp
 //===----------------------------------------------------------------------===//
 
 LogicalResult spirv::IAddCarryOp::verify() {
   auto resultType = getType().cast<spirv::StructType>();
   if (resultType.getNumElements() != 2)
     return emitOpError("expected result struct type containing two members");
 
-  if (!llvm::is_splat(llvm::makeArrayRef(
-          {operand1().getType(), operand2().getType(),
-           resultType.getElementType(0), resultType.getElementType(1)})))
+  if (!llvm::is_splat({operand1().getType(), operand2().getType(),
+                       resultType.getElementType(0),
+                       resultType.getElementType(1)}))
     return emitOpError(
         "expected all operand types and struct member types are the same");
 
   return success();
 }
 
 ParseResult spirv::IAddCarryOp::parse(OpAsmParser &parser,
                                       OperationState &result) {

 // spv.ISubBorrowOp
 //===----------------------------------------------------------------------===//
 
 LogicalResult spirv::ISubBorrowOp::verify() {
   auto resultType = getType().cast<spirv::StructType>();
   if (resultType.getNumElements() != 2)
     return emitOpError("expected result struct type containing two members");
 
-  if (!llvm::is_splat(llvm::makeArrayRef(
-          {operand1().getType(), operand2().getType(),
-           resultType.getElementType(0), resultType.getElementType(1)})))
+  if (!llvm::is_splat({operand1().getType(), operand2().getType(),
+                       resultType.getElementType(0),
+                       resultType.getElementType(1)}))
     return emitOpError(
         "expected all operand types and struct member types are the same");
 
   return success();
 }
 
 ParseResult spirv::ISubBorrowOp::parse(OpAsmParser &parser,
                                        OperationState &result) {

 void spirv::LoadOp::build(OpBuilder &builder, OperationState &state,
                           Value basePtr, MemoryAccessAttr memoryAccess,
                           IntegerAttr alignment) {
   auto ptrType = basePtr.getType().cast<spirv::PointerType>();
   build(builder, state, ptrType.getPointeeType(), basePtr, memoryAccess,
         alignment);
 }
 
-ParseResult spirv::LoadOp::parse(OpAsmParser &parser, OperationState &state) {
+ParseResult spirv::LoadOp::parse(OpAsmParser &parser, OperationState &result) {
   // Parse the storage class specification
   spirv::StorageClass storageClass;
   OpAsmParser::UnresolvedOperand ptrInfo;
   Type elementType;
   if (parseEnumStrAttr(storageClass, parser) || parser.parseOperand(ptrInfo) ||
-      parseMemoryAccessAttributes(parser, state) ||
-      parser.parseOptionalAttrDict(state.attributes) || parser.parseColon() ||
+      parseMemoryAccessAttributes(parser, result) ||
+      parser.parseOptionalAttrDict(result.attributes) || parser.parseColon() ||
       parser.parseType(elementType)) {
     return failure();
   }
 
   auto ptrType = spirv::PointerType::get(elementType, storageClass);
-  if (parser.resolveOperand(ptrInfo, ptrType, state.operands)) {
+  if (parser.resolveOperand(ptrInfo, ptrType, result.operands)) {
     return failure();
   }
 
-  state.addTypes(elementType);
+  result.addTypes(elementType);
   return success();
 }
 
 void spirv::LoadOp::print(OpAsmPrinter &printer) {
   SmallVector<StringRef, 4> elidedAttrs;
   StringRef sc = stringifyStorageClass(
       ptr().getType().cast<spirv::PointerType>().getStorageClass());
   printer << " \"" << sc << "\" " << ptr();

 
 void spirv::LoopOp::build(OpBuilder &builder, OperationState &state) {
   state.addAttribute("loop_control",
                      builder.getI32IntegerAttr(
                          static_cast<uint32_t>(spirv::LoopControl::None)));
   state.addRegion();
 }
 
-ParseResult spirv::LoopOp::parse(OpAsmParser &parser, OperationState &state) {
-  if (parseControlAttribute<spirv::LoopControl>(parser, state))
+ParseResult spirv::LoopOp::parse(OpAsmParser &parser, OperationState &result) {
+  if (parseControlAttribute<spirv::LoopControl>(parser, result))
     return failure();
-  return parser.parseRegion(*state.addRegion(), /*arguments=*/{},
-                            /*argTypes=*/{});
+  return parser.parseRegion(*result.addRegion(), /*arguments=*/{});
 }
 
 void spirv::LoopOp::print(OpAsmPrinter &printer) {
   auto control = loop_control();
   if (control != spirv::LoopControl::None)
     printer << " control(" << spirv::stringifyLoopControl(control) << ")";
   printer << ' ';
   printer.printRegion(getRegion(), /*printEntryBlockArgs=*/false,
void spirv::ModuleOp::build(OpBuilder &builder, OperationState &state,
   builder.createBlock(state.addRegion());
   if (vceTriple)
     state.addAttribute(getVCETripleAttrName(), *vceTriple);
   if (name)
     state.addAttribute(mlir::SymbolTable::getSymbolAttrName(),
                        builder.getStringAttr(*name));
 }
 
-ParseResult spirv::ModuleOp::parse(OpAsmParser &parser, OperationState &state) {
-  Region *body = state.addRegion();
+ParseResult spirv::ModuleOp::parse(OpAsmParser &parser,
+                                   OperationState &result) {
+  Region *body = result.addRegion();
 
   // If the name is present, parse it.
   StringAttr nameAttr;
   (void)parser.parseOptionalSymbolName(
-      nameAttr, mlir::SymbolTable::getSymbolAttrName(), state.attributes);
+      nameAttr, mlir::SymbolTable::getSymbolAttrName(), result.attributes);
 
   // Parse attributes
   spirv::AddressingModel addrModel;
   spirv::MemoryModel memoryModel;
-  if (::parseEnumKeywordAttr(addrModel, parser, state) ||
-      ::parseEnumKeywordAttr(memoryModel, parser, state))
+  if (::parseEnumKeywordAttr(addrModel, parser, result) ||
+      ::parseEnumKeywordAttr(memoryModel, parser, result))
     return failure();
 
   if (succeeded(parser.parseOptionalKeyword("requires"))) {
     spirv::VerCapExtAttr vceTriple;
     if (parser.parseAttribute(vceTriple,
                               spirv::ModuleOp::getVCETripleAttrName(),
-                              state.attributes))
+                              result.attributes))
       return failure();
   }
 
-  if (parser.parseOptionalAttrDictWithKeyword(state.attributes) ||
-      parser.parseRegion(*body, /*arguments=*/{}, /*argTypes=*/{}))
+  if (parser.parseOptionalAttrDictWithKeyword(result.attributes) ||
+      parser.parseRegion(*body, /*arguments=*/{}))
     return failure();
 
   // Make sure we have at least one block.
   if (body->empty())
     body->push_back(new Block());
 
   return success();
 }
LogicalResult spirv::SelectOp::verify() {
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // spv.mlir.selection
 //===----------------------------------------------------------------------===//
 
 ParseResult spirv::SelectionOp::parse(OpAsmParser &parser,
-                                      OperationState &state) {
-  if (parseControlAttribute<spirv::SelectionControl>(parser, state))
+                                      OperationState &result) {
+  if (parseControlAttribute<spirv::SelectionControl>(parser, result))
     return failure();
-  return parser.parseRegion(*state.addRegion(), /*arguments=*/{},
-                            /*argTypes=*/{});
+  return parser.parseRegion(*result.addRegion(), /*arguments=*/{});
 }
 
 void spirv::SelectionOp::print(OpAsmPrinter &printer) {
   auto control = selection_control();
   if (control != spirv::SelectionControl::None)
     printer << " control(" << spirv::stringifySelectionControl(control) << ")";
   printer << ' ';
   printer.printRegion(getRegion(), /*printEntryBlockArgs=*/false,
spirv::SelectionOp spirv::SelectionOp::createIfThen(
   return selectionOp;
 }
 
 //===----------------------------------------------------------------------===//
 // spv.SpecConstant
 //===----------------------------------------------------------------------===//
 
 ParseResult spirv::SpecConstantOp::parse(OpAsmParser &parser,
-                                         OperationState &state) {
+                                         OperationState &result) {
   StringAttr nameAttr;
   Attribute valueAttr;
 
   if (parser.parseSymbolName(nameAttr, SymbolTable::getSymbolAttrName(),
-                             state.attributes))
+                             result.attributes))
     return failure();
 
   // Parse optional spec_id.
   if (succeeded(parser.parseOptionalKeyword(kSpecIdAttrName))) {
     IntegerAttr specIdAttr;
     if (parser.parseLParen() ||
-        parser.parseAttribute(specIdAttr, kSpecIdAttrName, state.attributes) ||
+        parser.parseAttribute(specIdAttr, kSpecIdAttrName, result.attributes) ||
         parser.parseRParen())
       return failure();
   }
 
   if (parser.parseEqual() ||
-      parser.parseAttribute(valueAttr, kDefaultValueAttrName, state.attributes))
+      parser.parseAttribute(valueAttr, kDefaultValueAttrName,
+                            result.attributes))
     return failure();
 
   return success();
 }
 
 void spirv::SpecConstantOp::print(OpAsmPrinter &printer) {
   printer << ' ';
   printer.printSymbolName(sym_name());
LogicalResult spirv::SpecConstantOp::verify() {
   return emitOpError(
       "default value can only be a bool, integer, or float scalar");
 }
 
 //===----------------------------------------------------------------------===//
 // spv.StoreOp
 //===----------------------------------------------------------------------===//
 
-ParseResult spirv::StoreOp::parse(OpAsmParser &parser, OperationState &state) {
+ParseResult spirv::StoreOp::parse(OpAsmParser &parser, OperationState &result) {
   // Parse the storage class specification
   spirv::StorageClass storageClass;
   SmallVector<OpAsmParser::UnresolvedOperand, 2> operandInfo;
   auto loc = parser.getCurrentLocation();
   Type elementType;
   if (parseEnumStrAttr(storageClass, parser) ||
       parser.parseOperandList(operandInfo, 2) ||
-      parseMemoryAccessAttributes(parser, state) || parser.parseColon() ||
+      parseMemoryAccessAttributes(parser, result) || parser.parseColon() ||
       parser.parseType(elementType)) {
     return failure();
   }
 
   auto ptrType = spirv::PointerType::get(elementType, storageClass);
   if (parser.resolveOperands(operandInfo, {ptrType, elementType}, loc,
-                             state.operands)) {
+                             result.operands)) {
     return failure();
   }
   return success();
 }
 
 void spirv::StoreOp::print(OpAsmPrinter &printer) {
   SmallVector<StringRef, 4> elidedAttrs;
   StringRef sc = stringifyStorageClass(
LogicalResult spirv::UnreachableOp::verify() {
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // spv.Variable
 //===----------------------------------------------------------------------===//
 
 ParseResult spirv::VariableOp::parse(OpAsmParser &parser,
-                                     OperationState &state) {
+                                     OperationState &result) {
   // Parse optional initializer
   Optional<OpAsmParser::UnresolvedOperand> initInfo;
   if (succeeded(parser.parseOptionalKeyword("init"))) {
     initInfo = OpAsmParser::UnresolvedOperand();
     if (parser.parseLParen() || parser.parseOperand(*initInfo) ||
         parser.parseRParen())
       return failure();
   }
 
-  if (parseVariableDecorations(parser, state)) {
+  if (parseVariableDecorations(parser, result)) {
     return failure();
   }
 
   // Parse result pointer type
   Type type;
   if (parser.parseColon())
     return failure();
   auto loc = parser.getCurrentLocation();
   if (parser.parseType(type))
     return failure();
 
   auto ptrType = type.dyn_cast<spirv::PointerType>();
   if (!ptrType)
     return parser.emitError(loc, "expected spv.ptr type");
-  state.addTypes(ptrType);
+  result.addTypes(ptrType);
 
   // Resolve the initializer operand
   if (initInfo) {
     if (parser.resolveOperand(*initInfo, ptrType.getPointeeType(),
-                              state.operands))
+                              result.operands))
       return failure();
   }
 
   auto attr = parser.getBuilder().getI32IntegerAttr(
       llvm::bit_cast<int32_t>(ptrType.getStorageClass()));
-  state.addAttribute(spirv::attributeName<spirv::StorageClass>(), attr);
+  result.addAttribute(spirv::attributeName<spirv::StorageClass>(), attr);
 
   return success();
 }
 
 void spirv::VariableOp::print(OpAsmPrinter &printer) {
   SmallVector<StringRef, 4> elidedAttrs{
       spirv::attributeName<spirv::StorageClass>()};
   // Print optional initializer
LogicalResult spirv::VectorShuffleOp::verify() {
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // spv.CooperativeMatrixLoadNV
 //===----------------------------------------------------------------------===//
 
 ParseResult spirv::CooperativeMatrixLoadNVOp::parse(OpAsmParser &parser,
-                                                    OperationState &state) {
+                                                    OperationState &result) {
   SmallVector<OpAsmParser::UnresolvedOperand, 3> operandInfo;
   Type strideType = parser.getBuilder().getIntegerType(32);
   Type columnMajorType = parser.getBuilder().getIntegerType(1);
   Type ptrType;
   Type elementType;
   if (parser.parseOperandList(operandInfo, 3) ||
-      parseMemoryAccessAttributes(parser, state) || parser.parseColon() ||
+      parseMemoryAccessAttributes(parser, result) || parser.parseColon() ||
       parser.parseType(ptrType) || parser.parseKeywordType("as", elementType)) {
     return failure();
   }
   if (parser.resolveOperands(operandInfo,
                              {ptrType, strideType, columnMajorType},
-                             parser.getNameLoc(), state.operands)) {
+                             parser.getNameLoc(), result.operands)) {
     return failure();
   }
 
-  state.addTypes(elementType);
+  result.addTypes(elementType);
   return success();
 }
 
 void spirv::CooperativeMatrixLoadNVOp::print(OpAsmPrinter &printer) {
   printer << " " << pointer() << ", " << stride() << ", " << columnmajor();
   // Print optional memory access attribute.
   if (auto memAccess = memory_access())
     printer << " [\"" << stringifyMemoryAccess(*memAccess) << "\"]";
return verifyPointerAndCoopMatrixType(*this, pointer().getType(),
                                         result().getType());
 }
 
 //===----------------------------------------------------------------------===//
 // spv.CooperativeMatrixStoreNV
 //===----------------------------------------------------------------------===//
 
 ParseResult spirv::CooperativeMatrixStoreNVOp::parse(OpAsmParser &parser,
-                                                     OperationState &state) {
+                                                     OperationState &result) {
   SmallVector<OpAsmParser::UnresolvedOperand, 4> operandInfo;
   Type strideType = parser.getBuilder().getIntegerType(32);
   Type columnMajorType = parser.getBuilder().getIntegerType(1);
   Type ptrType;
   Type elementType;
   if (parser.parseOperandList(operandInfo, 4) ||
-      parseMemoryAccessAttributes(parser, state) || parser.parseColon() ||
+      parseMemoryAccessAttributes(parser, result) || parser.parseColon() ||
       parser.parseType(ptrType) || parser.parseComma() ||
       parser.parseType(elementType)) {
     return failure();
   }
   if (parser.resolveOperands(
           operandInfo, {ptrType, elementType, strideType, columnMajorType},
-          parser.getNameLoc(), state.operands)) {
+          parser.getNameLoc(), result.operands)) {
     return failure();
   }
 
   return success();
 }
 
 void spirv::CooperativeMatrixStoreNVOp::print(OpAsmPrinter &printer) {
   printer << " " << pointer() << ", " << object() << ", " << stride() << ", "
void spirv::CopyMemoryOp::print(OpAsmPrinter &printer) {
   printer.printOptionalAttrDict((*this)->getAttrs(), elidedAttrs);
 
   Type pointeeType =
       target().getType().cast<spirv::PointerType>().getPointeeType();
   printer << " : " << pointeeType;
 }
 
 ParseResult spirv::CopyMemoryOp::parse(OpAsmParser &parser,
-                                       OperationState &state) {
+                                       OperationState &result) {
   spirv::StorageClass targetStorageClass;
   OpAsmParser::UnresolvedOperand targetPtrInfo;
 
   spirv::StorageClass sourceStorageClass;
   OpAsmParser::UnresolvedOperand sourcePtrInfo;
 
   Type elementType;
 
   if (parseEnumStrAttr(targetStorageClass, parser) ||
       parser.parseOperand(targetPtrInfo) || parser.parseComma() ||
       parseEnumStrAttr(sourceStorageClass, parser) ||
       parser.parseOperand(sourcePtrInfo) ||
-      parseMemoryAccessAttributes(parser, state)) {
+      parseMemoryAccessAttributes(parser, result)) {
     return failure();
   }
 
   if (!parser.parseOptionalComma()) {
     // Parse 2nd memory access attributes.
-    if (parseSourceMemoryAccessAttributes(parser, state)) {
+    if (parseSourceMemoryAccessAttributes(parser, result)) {
       return failure();
     }
   }
 
   if (parser.parseColon() || parser.parseType(elementType))
     return failure();
 
-  if (parser.parseOptionalAttrDict(state.attributes))
+  if (parser.parseOptionalAttrDict(result.attributes))
     return failure();
 
   auto targetPtrType = spirv::PointerType::get(elementType, targetStorageClass);
   auto sourcePtrType = spirv::PointerType::get(elementType, sourceStorageClass);
 
-  if (parser.resolveOperand(targetPtrInfo, targetPtrType, state.operands) ||
-      parser.resolveOperand(sourcePtrInfo, sourcePtrType, state.operands)) {
+  if (parser.resolveOperand(targetPtrInfo, targetPtrType, result.operands) ||
+      parser.resolveOperand(sourcePtrInfo, sourcePtrType, result.operands)) {
     return failure();
   }
 
   return success();
 }
 
 LogicalResult spirv::CopyMemoryOp::verify() {
   Type targetType =
LogicalResult spirv::MatrixTimesMatrixOp::verify() {
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // spv.SpecConstantComposite
 //===----------------------------------------------------------------------===//
 
 ParseResult spirv::SpecConstantCompositeOp::parse(OpAsmParser &parser,
-                                                  OperationState &state) {
+                                                  OperationState &result) {
 
   StringAttr compositeName;
   if (parser.parseSymbolName(compositeName, SymbolTable::getSymbolAttrName(),
-                             state.attributes))
+                             result.attributes))
     return failure();
 
   if (parser.parseLParen())
     return failure();
 
   SmallVector<Attribute, 4> constituents;
 
   do {
     // The name of the constituent attribute isn't important
     const char *attrName = "spec_const";
     FlatSymbolRefAttr specConstRef;
     NamedAttrList attrs;
 
     if (parser.parseAttribute(specConstRef, Type(), attrName, attrs))
       return failure();
 
     constituents.push_back(specConstRef);
   } while (!parser.parseOptionalComma());
 
   if (parser.parseRParen())
     return failure();
 
-  state.addAttribute(kCompositeSpecConstituentsName,
+  result.addAttribute(kCompositeSpecConstituentsName,
                       parser.getBuilder().getArrayAttr(constituents));
 
   Type type;
   if (parser.parseColonType(type))
     return failure();
 
-  state.addAttribute(kTypeAttrName, TypeAttr::get(type));
+  result.addAttribute(kTypeAttrName, TypeAttr::get(type));
 
   return success();
 }
 
 void spirv::SpecConstantCompositeOp::print(OpAsmPrinter &printer) {
   printer << " ";
   printer.printSymbolName(sym_name());
   printer << " (";
LogicalResult spirv::SpecConstantCompositeOp::verify() {
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // spv.SpecConstantOperation
 //===----------------------------------------------------------------------===//
 
 ParseResult spirv::SpecConstantOperationOp::parse(OpAsmParser &parser,
-                                                  OperationState &state) {
-  Region *body = state.addRegion();
+                                                  OperationState &result) {
+  Region *body = result.addRegion();
 
   if (parser.parseKeyword("wraps"))
     return failure();
 
   body->push_back(new Block);
   Block &block = body->back();
   Operation *wrappedOp = parser.parseGenericOperation(&block, block.begin());
 
   if (!wrappedOp)
     return failure();
 
   OpBuilder builder(parser.getContext());
   builder.setInsertionPointToEnd(&block);
   builder.create<spirv::YieldOp>(wrappedOp->getLoc(), wrappedOp->getResult(0));
-  state.location = wrappedOp->getLoc();
+  result.location = wrappedOp->getLoc();
 
-  state.addTypes(wrappedOp->getResult(0).getType());
+  result.addTypes(wrappedOp->getResult(0).getType());
 
-  if (parser.parseOptionalAttrDict(state.attributes))
+  if (parser.parseOptionalAttrDict(result.attributes))
     return failure();
 
   return success();
 }
 
 void spirv::SpecConstantOperationOp::print(OpAsmPrinter &printer) {
   printer << " wraps ";
   printer.printGenericOp(&body().front().front());
void spirv::InBoundsPtrAccessChainOp::build(OpBuilder &builder,
                                             Value basePtr, Value element,
                                             ValueRange indices) {
   auto type = getElementPtrType(basePtr.getType(), indices, state.location);
   assert(type && "Unable to deduce return type based on basePtr and indices");
   build(builder, state, type, basePtr, element, indices);
 }
 
 ParseResult spirv::InBoundsPtrAccessChainOp::parse(OpAsmParser &parser,
-                                                   OperationState &state) {
+                                                   OperationState &result) {
   return parsePtrAccessChainOpImpl(
-      spirv::InBoundsPtrAccessChainOp::getOperationName(), parser, state);
+      spirv::InBoundsPtrAccessChainOp::getOperationName(), parser, result);
 }
 
 void spirv::InBoundsPtrAccessChainOp::print(OpAsmPrinter &printer) {
   printAccessChain(*this, concatElemAndIndices(*this), printer);
 }
 
 LogicalResult spirv::InBoundsPtrAccessChainOp::verify() {
   return verifyAccessChain(*this, indices());
 }
 
 //===----------------------------------------------------------------------===//
 // spv.PtrAccessChainOp
 //===----------------------------------------------------------------------===//
 
 void spirv::PtrAccessChainOp::build(OpBuilder &builder, OperationState &state,
                                     Value basePtr, Value element,
                                     ValueRange indices) {
   auto type = getElementPtrType(basePtr.getType(), indices, state.location);
   assert(type && "Unable to deduce return type based on basePtr and indices");
   build(builder, state, type, basePtr, element, indices);
 }
 
 ParseResult spirv::PtrAccessChainOp::parse(OpAsmParser &parser,
-                                           OperationState &state) {
+                                           OperationState &result) {
   return parsePtrAccessChainOpImpl(spirv::PtrAccessChainOp::getOperationName(),
-                                   parser, state);
+                                   parser, result);
 }
 
 void spirv::PtrAccessChainOp::print(OpAsmPrinter &printer) {
   printAccessChain(*this, concatElemAndIndices(*this), printer);
 }
 
 LogicalResult spirv::PtrAccessChainOp::verify() {
   return verifyAccessChain(*this, indices());