[mlir][ods] Store the pointer to the anchor element (NFC)

[Mogball]

Summary

Instead of its index. There is no benefit to storing the index instead
of the pointer.

[Mogball]

clang-format

mlir/tools/mlir-tblgen/AttrOrTypeFormatGen.cpp

 protected:
   /// Verify the parsed elements.
   LogicalResult verify(SMLoc loc, ArrayRef<FormatElement *> elements) override;
   /// Verify the elements of a custom directive.
   LogicalResult
   verifyCustomDirectiveArguments(SMLoc loc,
                                  ArrayRef<FormatElement *> arguments) override;
   /// Verify the elements of an optional group.
-  LogicalResult
-  verifyOptionalGroupElements(SMLoc loc, ArrayRef<FormatElement *> elements,
-                              Optional<unsigned> anchorIndex) override;
+  LogicalResult verifyOptionalGroupElements(SMLoc loc,
+                                            ArrayRef<FormatElement *> elements,
+                                            FormatElement *anchor) override;
 
   /// Parse an attribute or type variable.
   FailureOr<FormatElement *> parseVariableImpl(SMLoc loc, StringRef name,
                                                Context ctx) override;
   /// Parse an attribute or type format directive.
   FailureOr<FormatElement *>
   parseDirectiveImpl(SMLoc loc, FormatToken::Kind kind, Context ctx) override;
 
LogicalResult DefFormatParser::verifyCustomDirectiveArguments(
     SMLoc loc, ArrayRef<FormatElement *> arguments) {
   // Arguments are fully verified by the parser context.
   return success();
 }
 
 LogicalResult
 DefFormatParser::verifyOptionalGroupElements(llvm::SMLoc loc,
                                              ArrayRef<FormatElement *> elements,
-                                             Optional<unsigned> anchorIndex) {
+                                             FormatElement *anchor) {
   // `params` and `struct` directives are allowed only if all the contained
   // parameters are optional.
   for (FormatElement *el : elements) {
     if (auto *param = dyn_cast<ParameterElement>(el)) {
       if (!param->isOptional()) {
         return emitError(loc,
                          "parameters in an optional group must be optional");
       }
     } else if (auto *params = dyn_cast<ParamsDirective>(el)) {
       if (llvm::any_of(params->getParams(), paramNotOptional)) {
         return emitError(loc, "`params` directive allowed in optional group "
                               "only if all parameters are optional");
       }
     } else if (auto *strct = dyn_cast<StructDirective>(el)) {
       if (llvm::any_of(strct->getParams(), paramNotOptional)) {
         return emitError(loc, "`struct` is only allowed in an optional group "
                               "if all captured parameters are optional");
       }
     }
   }
   // The anchor must be a parameter or one of the aforementioned directives.
-  if (anchorIndex && !isa<ParameterElement, ParamsDirective, StructDirective>(
-                         elements[*anchorIndex])) {
+  if (anchor &&
+      !isa<ParameterElement, ParamsDirective, StructDirective>(anchor)) {
     return emitError(loc,
                      "optional group anchor must be a parameter or directive");
   }
   return success();
 }
 
 FailureOr<DefFormat> DefFormatParser::parse() {
   FailureOr<std::vector<FormatElement *>> elements = FormatParser::parse();

mlir/tools/mlir-tblgen/FormatGen.h

 /// This class represents a group of elements that are optionally emitted based
 /// on an optional variable "anchor" and a group of elements that are emitted
 /// when the anchor element is not present.
 class OptionalElement : public FormatElementBase<FormatElement::Optional> {
 public:
   /// Create an optional group with the given child elements.
   OptionalElement(std::vector<FormatElement *> &&thenElements,
                   std::vector<FormatElement *> &&elseElements,
-                  unsigned anchorIndex, unsigned parseStart)
+                  FormatElement *anchor, unsigned parseStart)
       : thenElements(std::move(thenElements)),
-        elseElements(std::move(elseElements)), anchorIndex(anchorIndex),
+        elseElements(std::move(elseElements)), anchor(anchor),
         parseStart(parseStart) {}
 
   /// Return the `then` elements of the optional group.
   ArrayRef<FormatElement *> getThenElements() const { return thenElements; }
 
   /// Return the `else` elements of the optional group.
   ArrayRef<FormatElement *> getElseElements() const { return elseElements; }
 
   /// Return the anchor of the optional group.
-  FormatElement *getAnchor() const { return thenElements[anchorIndex]; }
+  FormatElement *getAnchor() const { return anchor; }
 
   /// Return the index of the first element to be parsed.
   unsigned getParseStart() const { return parseStart; }
 
 private:
   /// The child elements emitted when the anchor is present.
   std::vector<FormatElement *> thenElements;
   /// The child elements emitted when the anchor is not present.
   std::vector<FormatElement *> elseElements;
-  /// The index of the anchor element of the optional group within
-  /// `thenElements`.
-  unsigned anchorIndex;
+  /// The anchor element of the optional group.
+  FormatElement *anchor;
   /// The index of the first element that is parsed in `thenElements`. That is,
   /// the first non-whitespace element.
   unsigned parseStart;
 };
 
 //===----------------------------------------------------------------------===//
 // FormatParserBase
 //===----------------------------------------------------------------------===//
protected:
   /// Verify the arguments to a custom directive.
   virtual LogicalResult
   verifyCustomDirectiveArguments(llvm::SMLoc loc,
                                  ArrayRef<FormatElement *> arguments) = 0;
   /// Verify the elements of an optional group.
   virtual LogicalResult
   verifyOptionalGroupElements(llvm::SMLoc loc,
                               ArrayRef<FormatElement *> elements,
-                              Optional<unsigned> anchorIndex) = 0;
+                              FormatElement *anchor) = 0;
 
   //===--------------------------------------------------------------------===//
   // Lexer Utilities
 
   /// Emit an error at the given location.
   LogicalResult emitError(llvm::SMLoc loc, const Twine &msg) {
     lexer.emitError(loc, msg);
     return failure();

mlir/tools/mlir-tblgen/FormatGen.cpp

FailureOr<FormatElement *> FormatParser::parseOptionalGroup(Context ctx) {
   consumeToken();
   if (ctx != TopLevelContext) {
     return emitError(loc,
                      "optional groups can only be used as top-level elements");
   }
 
   // Parse the child elements for this optional group.
   std::vector<FormatElement *> thenElements, elseElements;
-  Optional<unsigned> anchorIndex;
+  FormatElement *anchor = nullptr;
   do {
     FailureOr<FormatElement *> element = parseElement(TopLevelContext);
     if (failed(element))
       return failure();
     // Check for an anchor.
     if (curToken.is(FormatToken::caret)) {
-      if (anchorIndex)
+      if (anchor)
         return emitError(curToken.getLoc(), "only one element can be marked as "
                                             "the anchor of an optional group");
-      anchorIndex = thenElements.size();
+      anchor = *element;
       consumeToken();
     }
     thenElements.push_back(*element);
   } while (!curToken.is(FormatToken::r_paren));
   consumeToken();
 
   // Parse the `else` elements of this optional group.
   if (curToken.is(FormatToken::colon)) {
if (curToken.is(FormatToken::colon)) {
     } while (!curToken.is(FormatToken::r_paren));
     consumeToken();
   }
   if (failed(parseToken(FormatToken::question,
                         "expected '?' after optional group")))
     return failure();
 
   // The optional group is required to have an anchor.
-  if (!anchorIndex)
+  if (!anchor)
     return emitError(loc, "optional group has no anchor element");
 
   // Verify the child elements.
-  if (failed(verifyOptionalGroupElements(loc, thenElements, anchorIndex)) ||
-      failed(verifyOptionalGroupElements(loc, elseElements, llvm::None)))
+  if (failed(verifyOptionalGroupElements(loc, thenElements, anchor)) ||
+      failed(verifyOptionalGroupElements(loc, elseElements, nullptr)))
     return failure();
 
   // Get the first parsable element. It must be an element that can be
   // optionally-parsed.
   auto parseBegin = llvm::find_if_not(thenElements, [](FormatElement *element) {
     return isa<WhitespaceElement>(element);
   });
   if (!isa<LiteralElement, VariableElement>(*parseBegin)) {
     return emitError(loc, "first parsable element of an optional group must be "
                           "a literal or variable");
   }
 
   unsigned parseStart = std::distance(thenElements.begin(), parseBegin);
   return create<OptionalElement>(std::move(thenElements),
-                                 std::move(elseElements), *anchorIndex,
-                                 parseStart);
+                                 std::move(elseElements), anchor, parseStart);
 }
 
 FailureOr<FormatElement *> FormatParser::parseCustomDirective(SMLoc loc,
                                                               Context ctx) {
   if (ctx != TopLevelContext)
     return emitError(loc, "'custom' is only valid as a top-level directive");
 
   FailureOr<FormatToken> nameTok;

mlir/tools/mlir-tblgen/OpFormatGen.cpp

 protected:
   /// Verify the format elements.
   LogicalResult verify(SMLoc loc, ArrayRef<FormatElement *> elements) override;
   /// Verify the arguments to a custom directive.
   LogicalResult
   verifyCustomDirectiveArguments(SMLoc loc,
                                  ArrayRef<FormatElement *> arguments) override;
   /// Verify the elements of an optional group.
-  LogicalResult
-  verifyOptionalGroupElements(SMLoc loc, ArrayRef<FormatElement *> elements,
-                              Optional<unsigned> anchorIndex) override;
+  LogicalResult verifyOptionalGroupElements(SMLoc loc,
+                                            ArrayRef<FormatElement *> elements,
+                                            FormatElement *anchor) override;
   LogicalResult verifyOptionalGroupElement(SMLoc loc, FormatElement *element,
                                            bool isAnchor);
 
   /// Parse an operation variable.
   FailureOr<FormatElement *> parseVariableImpl(SMLoc loc, StringRef name,
                                                Context ctx) override;
   /// Parse an operation format directive.
   FailureOr<FormatElement *>
if (isRefChild && !fmt.allResultTypes)
                             "'type' directive");
     fmt.allResultTypes = true;
   } else {
     return emitError(loc, "invalid argument to 'type' directive");
   }
   return element;
 }
 
-LogicalResult
-OpFormatParser::verifyOptionalGroupElements(SMLoc loc,
-                                            ArrayRef<FormatElement *> elements,
-                                            Optional<unsigned> anchorIndex) {
-  for (auto &it : llvm::enumerate(elements)) {
-    if (failed(verifyOptionalGroupElement(
-            loc, it.value(), anchorIndex && *anchorIndex == it.index())))
+LogicalResult OpFormatParser::verifyOptionalGroupElements(
+    SMLoc loc, ArrayRef<FormatElement *> elements, FormatElement *anchor) {
+  for (FormatElement *element : elements) {
+    if (failed(verifyOptionalGroupElement(loc, element, element == anchor)))
       return failure();
   }
   return success();
 }
 
 LogicalResult OpFormatParser::verifyOptionalGroupElement(SMLoc loc,
                                                          FormatElement *element,
                                                          bool isAnchor) {