WIP enforce alias printing for distinct attributes

[gysit]

Summary

This revision is a work in progress commit that tries
to use the alias printing mechanism to number the
distinct attribute during printing. It therefore
tries to enforce that distinct attributes are always
printed as aliases.

There are two main cases to handle

• Ignore the -mlir-print-local-scope flag
• Print aliases even if the user dumps a non top-level operation.

Dumping a non top-level operation looks as follows:

#distinct = distinct<42 : i32>
%0 = test.my_op { distinct_attr = #distinct }

Depends on D153360

mlir/lib/AsmParser/AttributeParser.cpp

 ///                      (tensor-type | vector-type)
 ///                    | `sparse` `<` attribute-value `,` attribute-value `>`
 ///                      `:` (tensor-type | vector-type)
 ///                    | `strided` `<` `[` comma-separated-int-or-question `]`
 ///                      (`,` `offset` `:` integer-literal)? `>`
 ///                    | distinct-attribute
 ///                    | extended-attribute
 ///
-Attribute Parser::parseAttribute(Type type) {
+Attribute Parser::parseAttribute(Type type, bool isAliasDef) {
   switch (getToken().getKind()) {
   // Parse an AffineMap or IntegerSet attribute.
   case Token::kw_affine_map: {
     consumeToken(Token::kw_affine_map);
 
     AffineMap map;
     if (parseToken(Token::less, "expected '<' in affine map") ||
         parseAffineMapReference(map) ||
Attribute Parser::parseAttribute(Type type, bool isAliasDef) {
   case Token::kw_sparse:
     return parseSparseElementsAttr(type);
 
   // Parse a strided layout attribute.
   case Token::kw_strided:
     return parseStridedLayoutAttr();
 
   // Parse a distinct attribute.
-  case Token::kw_distinct:
+  case Token::kw_distinct: {
+    if (isAliasDef)
       return parseDistinctAttr(type);
 
+    return (emitWrongTokenError("distinct attribute cannot be defined inline"),
+            nullptr);
+  }
+
   // Parse a string attribute.
   case Token::string: {
     auto val = getToken().getStringValue();
     consumeToken(Token::string);
     // Parse the optional trailing colon type if one wasn't explicitly provided.
     if (!type && consumeIf(Token::colon) && !(type = parseType()))
       return Attribute();
 

 
 /// Parse a distinct attribute.
 ///
 ///  distinct-attribute ::= `distinct`
 ///                         `[` integer-literal `]<` attribute-value `>`
 ///
 Attribute Parser::parseDistinctAttr(Type type) {
   consumeToken(Token::kw_distinct);
-  if (parseToken(Token::l_square, "expected '[' after 'distinct'"))
-    return {};
-
-  // Parse the distinct integer identifier.
-  Token token = getToken();
-  if (parseToken(Token::integer, "expected distinct Id"))
-    return {};
-  std::optional<uint64_t> value = token.getUInt64IntegerValue();
-  if (!value) {
-    emitError("expected an unsigned 64-bit integer");
-    return {};
-  }
-
-  // Parse the referenced attribute.
-  if (parseToken(Token::r_square, "expected ']' to close distinct Id") ||
-      parseToken(Token::less, "expected '<' after distinct Id"))
+  if (parseToken(Token::less, "expected '<' after 'distinct'"))
     return {};
   Attribute referencedAttr = parseAttribute(type);
   if (!referencedAttr) {
     emitError("expected attribute");
     return {};
   }
-
-  // Add the distinct attribute to the parser state, if it has not been parsed
-  // before. Otherwise, check if the parsed reference attribute matches the one
-  // found in the parser state.
-  DenseMap<uint64_t, DistinctAttr> &distinctAttrs =
-      state.symbols.distinctAttributes;
-  auto it = distinctAttrs.find(*value);
-  if (it == distinctAttrs.end()) {
-    DistinctAttr distinctAttr = DistinctAttr::create(referencedAttr);
-    it = distinctAttrs.try_emplace(*value, distinctAttr).first;
-  } else if (it->getSecond().getReferencedAttr() != referencedAttr) {
-    emitError("referenced attribute does not match previous definition");
-    return {};
-  }
-
   if (parseToken(Token::greater, "expected '>' to close distinct attribute"))
     return {};
-
-  return it->getSecond();
+  return DistinctAttr::create(referencedAttr);
 }

mlir/lib/AsmParser/Parser.h

public:
   ParseResult parseIntegerInDimensionList(int64_t &value);
   ParseResult parseXInDimensionList();
 
   //===--------------------------------------------------------------------===//
   // Attribute Parsing
   //===--------------------------------------------------------------------===//
 
   /// Parse an arbitrary attribute with an optional type.
-  Attribute parseAttribute(Type type = {});
+  Attribute parseAttribute(Type type = {}, bool isAliasDef = false);
 
   /// Parse an optional attribute with the provided type.
   OptionalParseResult parseOptionalAttribute(Attribute &attribute,
                                              Type type = {});
   OptionalParseResult parseOptionalAttribute(ArrayAttr &attribute, Type type);
   OptionalParseResult parseOptionalAttribute(StringAttr &attribute, Type type);
   OptionalParseResult parseOptionalAttribute(SymbolRefAttr &result, Type type);
 

mlir/lib/AsmParser/Parser.cpp

ParseResult TopLevelOperationParser::parseAttributeAliasDef() {
 
   consumeToken(Token::hash_identifier);
 
   // Parse the '='.
   if (parseToken(Token::equal, "expected '=' in attribute alias definition"))
     return failure();
 
   // Parse the attribute value.
-  Attribute attr = parseAttribute();
+  Attribute attr = parseAttribute(/*type=*/{}, /*isAliasDef=*/true);
   if (!attr)
     return failure();
 
   state.symbols.attributeAliasDefinitions[aliasName] = attr;
   return success();
 }
 
 ParseResult TopLevelOperationParser::parseTypeAliasDef() {

mlir/lib/AsmParser/ParserState.h

struct SymbolState {
   /// A map from type alias identifier to Type.
   llvm::StringMap<Type> typeAliasDefinitions;
 
   /// A map of dialect resource keys to the resolved resource name and handle
   /// to use during parsing.
   DenseMap<const OpAsmDialectInterface *,
            llvm::StringMap<std::pair<std::string, AsmDialectResourceHandle>>>
       dialectResources;
-
-  /// A map from unique integer identifier to DistinctAttr.
-  DenseMap<uint64_t, DistinctAttr> distinctAttributes;
 };
 
 //===----------------------------------------------------------------------===//
 // ParserState
 //===----------------------------------------------------------------------===//
 
 /// This class refers to all of the state maintained globally by the parser,
 /// such as the current lexer position etc.

mlir/lib/IR/AsmPrinter.cpp

 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/IR/AffineExpr.h"
 #include "mlir/IR/AffineMap.h"
 #include "mlir/IR/AsmState.h"
 #include "mlir/IR/Attributes.h"
 #include "mlir/IR/Builders.h"
+#include "mlir/IR/BuiltinAttributes.h"
 #include "mlir/IR/BuiltinDialect.h"
 #include "mlir/IR/BuiltinTypes.h"
 #include "mlir/IR/Dialect.h"
 #include "mlir/IR/DialectImplementation.h"
 #include "mlir/IR/DialectResourceBlobManager.h"
 #include "mlir/IR/IntegerSet.h"
 #include "mlir/IR/MLIRContext.h"
 #include "mlir/IR/OpImplementation.h"
void AliasInitializer::initialize(
     Operation *op, const OpPrintingFlags &printerFlags,
     llvm::MapVector<const void *, SymbolAlias> &attrTypeToAlias) {
   // Use a dummy printer when walking the IR so that we can collect the
   // attributes/types that will actually be used during printing when
   // considering aliases.
   DummyAliasOperationPrinter aliasPrinter(printerFlags, *this);
   aliasPrinter.printCustomOrGenericOp(op);
 
+  // Drop all aliases except for distinct attribute aliases if the operation is
+  // not a top-level operation or if the use local scope flag is set.
+  if (printerFlags.shouldUseLocalScope() || op->getParentOp()) {
+    aliases.remove_if([](const auto &aliasIt) {
+      const auto &[opaqueSymbol, alias] = aliasIt;
+      if (alias.isType)
+        return true;
+      Attribute attr = Attribute::getFromOpaquePointer(opaqueSymbol);
+      return !isa<DistinctAttr>(attr);
+    });
+  }
+
   // Initialize the aliases.
   initializeAliases(aliases, attrTypeToAlias);
 }
 
 template <typename T, typename... PrintArgs>
 std::pair<size_t, size_t> AliasInitializer::visitImpl(
     T value, llvm::MapVector<const void *, InProgressAliasInfo> &aliases,
     bool canBeDeferred, PrintArgs &&...printArgs) {
LogicalResult AliasState::getAlias(Type ty, raw_ostream &os) const {
   return success();
 }
 
 void AliasState::printAliases(AsmPrinter::Impl &p, NewLineCounter &newLine,
                               bool isDeferred) {
   auto filterFn = [=](const auto &aliasIt) {
     return aliasIt.second.canBeDeferred() == isDeferred;
   };
-  for (auto &[opaqueSymbol, alias] :
-       llvm::make_filter_range(attrTypeToAlias, filterFn)) {
+  auto aliasRange = llvm::make_filter_range(attrTypeToAlias, filterFn);
+  if (isDeferred && !aliasRange.empty())
+    p.getStream() << newLine;
+  for (auto &[opaqueSymbol, alias] : aliasRange) {
     alias.print(p.getStream());
     p.getStream() << " = ";
 
     if (alias.isTypeAlias()) {
       // TODO: Support nested aliases in mutable types.
       Type type = Type::getFromOpaquePointer(opaqueSymbol);
       if (type.hasTrait<TypeTrait::IsMutable>())
         p.getStream() << type;
if (!usedNames.count(name)) {
     }
   }
 
   usedNames.insert(name, char());
   return name;
 }
 
 //===----------------------------------------------------------------------===//
-// DistinctState
-//===----------------------------------------------------------------------===//
-
-namespace {
-/// This class manages the state for distinct attributes.
-class DistinctState {
-public:
-  /// Returns a unique identifier for the given distinct attribute.
-  uint64_t getId(DistinctAttr distinctAttr);
-
-private:
-  uint64_t distinctCounter = 0;
-  DenseMap<DistinctAttr, uint64_t> distinctAttrMap;
-};
-} // namespace
-
-uint64_t DistinctState::getId(DistinctAttr distinctAttr) {
-  auto [it, inserted] =
-      distinctAttrMap.try_emplace(distinctAttr, distinctCounter);
-  if (inserted)
-    distinctCounter++;
-  return it->getSecond();
-}
-
-//===----------------------------------------------------------------------===//
 // Resources
 //===----------------------------------------------------------------------===//
 
 AsmParsedResourceEntry::~AsmParsedResourceEntry() = default;
 AsmResourceBuilder::~AsmResourceBuilder() = default;
 AsmResourceParser::~AsmResourceParser() = default;
 AsmResourcePrinter::~AsmResourcePrinter() = default;
 
public:
   }
 
   /// Get the state used for aliases.
   AliasState &getAliasState() { return aliasState; }
 
   /// Get the state used for SSA names.
   SSANameState &getSSANameState() { return nameState; }
 
-  /// Get the state used for distinct attribute identifiers.
-  DistinctState &getDistinctState() { return distinctState; }
-
   /// Return the dialects within the context that implement
   /// OpAsmDialectInterface.
   DialectInterfaceCollection<OpAsmDialectInterface> &getDialectInterfaces() {
     return interfaces;
   }
 
   /// Return the non-dialect resource printers.
   auto getResourcePrinters() {
private:
   DenseMap<Dialect *, SetVector<AsmDialectResourceHandle>> dialectResources;
 
   /// The state used for attribute and type aliases.
   AliasState aliasState;
 
   /// The state used for SSA value names.
   SSANameState nameState;
 
-  /// The state used for distinct attribute identifiers.
-  DistinctState distinctState;
-
   /// Flags that control op output.
   OpPrintingFlags printerFlags;
 
   /// An optional location map to be populated.
   AsmState::LocationMap *locationMap;
 
   // Allow direct access to the impl fields.
   friend AsmState;
if (!isa<BuiltinDialect>(attr.getDialect())) {
     printDialectAttribute(attr);
   } else if (auto opaqueAttr = llvm::dyn_cast<OpaqueAttr>(attr)) {
     printDialectSymbol(os, "#", opaqueAttr.getDialectNamespace(),
                        opaqueAttr.getAttrData());
   } else if (llvm::isa<UnitAttr>(attr)) {
     os << "unit";
     return;
   } else if (auto distinctAttr = llvm::dyn_cast<DistinctAttr>(attr)) {
-    os << "distinct[" << state.getDistinctState().getId(distinctAttr) << "]<";
+    os << "distinct<";
     printAttribute(distinctAttr.getReferencedAttr());
     os << '>';
     return;
   } else if (auto dictAttr = llvm::dyn_cast<DictionaryAttr>(attr)) {
     os << '{';
     interleaveComma(dictAttr.getValue(),
                     [&](NamedAttribute attr) { printNamedAttribute(attr); });
     os << '}';

 class OperationPrinter : public AsmPrinter::Impl, private OpAsmPrinter {
 public:
   using Impl = AsmPrinter::Impl;
   using Impl::printType;
 
   explicit OperationPrinter(raw_ostream &os, AsmStateImpl &state)
       : Impl(os, state), OpAsmPrinter(static_cast<Impl &>(*this)) {}
 
-  /// Print the given top-level operation.
-  void printTopLevelOperation(Operation *op);
+  /// Print the given operation, including its left-hand side and its right-hand
+  /// side, with its indent, location, and required aliases.
+  void printFullOpWithIdentLocAndAliases(Operation *op);
 
   /// Print the given operation, including its left-hand side and its right-hand
   /// side, with its indent and location.
   void printFullOpWithIndentAndLoc(Operation *op);
   /// Print the given operation, including its left-hand side and its right-hand
   /// side, but not including indentation and location.
   void printFullOp(Operation *op);
   /// Print the right-hand size of the given operation in the custom or generic
private:
   /// The number of spaces used for indenting nested operations.
   const static unsigned indentWidth = 2;
 
   // This is the current indentation level for nested structures.
   unsigned currentIndent = 0;
 };
 } // namespace
 
-void OperationPrinter::printTopLevelOperation(Operation *op) {
+void OperationPrinter::printFullOpWithIdentLocAndAliases(Operation *op) {
   // Output the aliases at the top level that can't be deferred.
   state.getAliasState().printNonDeferredAliases(*this, newLine);
 
   // Print the module.
   printFullOpWithIndentAndLoc(op);
-  os << newLine;
 
   // Output the aliases at the top level that can be deferred.
   state.getAliasState().printDeferredAliases(*this, newLine);
-
   // Output any file level metadata.
   printFileMetadataDictionary(op);
 }
 
 void OperationPrinter::printFileMetadataDictionary(Operation *op) {
   bool sawMetadataEntry = false;
   auto checkAddMetadataDict = [&] {
     if (!std::exchange(sawMetadataEntry, true))

 void Operation::print(raw_ostream &os, const OpPrintingFlags &printerFlags) {
   // Find the operation to number from based upon the provided flags.
   Operation *op = findParent(this, printerFlags.shouldUseLocalScope());
   AsmState state(op, printerFlags);
   print(os, state);
 }
 void Operation::print(raw_ostream &os, AsmState &state) {
   OperationPrinter printer(os, state.getImpl());
-  if (!getParent() && !state.getPrinterFlags().shouldUseLocalScope()) {
-    state.getImpl().initializeAliases(this);
-    printer.printTopLevelOperation(this);
-  } else {
-    printer.printFullOpWithIndentAndLoc(this);
-  }
+  printer.printFullOpWithIdentLocAndAliases(this);
 }
 
 void Operation::dump() {
   print(llvm::errs(), OpPrintingFlags().useLocalScope());
   llvm::errs() << "\n";
 }
 
 void Block::print(raw_ostream &os) {

mlir/test/Dialect/Builtin/Bytecode/attrs.mlir

 // RUN: mlir-opt -emit-bytecode -allow-unregistered-dialect %s | mlir-opt -allow-unregistered-dialect -mlir-print-local-scope | FileCheck %s
 
 // Bytecode currently does not support big-endian platforms
 // UNSUPPORTED: target=s390x-{{.*}}
 
+
+//===----------------------------------------------------------------------===//
+// DistinctAttr
+//===----------------------------------------------------------------------===//
+
+// CHECK: #[[$DIST0:.*]] = distinct<42 : i32>
+// CHECK: #[[$DIST1:.*]] = distinct<42 : i32>
+#distinct = distinct<42 : i32>
+#distinct1 = distinct<42 : i32>
+
+// CHECK-LABEL: @TestDistinct
+module @TestDistinct attributes {
+  // CHECK: bytecode.distinct = #[[$DIST0]]
+  // CHECK: bytecode.distinct2 = #[[$DIST0]]
+  // CHECK: bytecode.distinct3 = #[[$DIST1]]
+  bytecode.distinct = #distinct,
+  bytecode.distinct2 = #distinct,
+  bytecode.distinct3 = #distinct1
+} {}
+
 //===----------------------------------------------------------------------===//
 // ArrayAttr
 //===----------------------------------------------------------------------===//
 
 // CHECK-LABEL: @TestArray
 module @TestArray attributes {
   // CHECK: bytecode.array = [unit]
   bytecode.array = [unit]

 
 // CHECK-LABEL: @TestType
 module @TestType attributes {
   // CHECK: bytecode.type = i178
   bytecode.type = i178
 } {}
 
 //===----------------------------------------------------------------------===//
-// DistinctAttr
-//===----------------------------------------------------------------------===//
-
-// CHECK-LABEL: @TestDistinct
-module @TestDistinct attributes {
-  // CHECK: bytecode.distinct = distinct[0]<42 : i32>
-  // CHECK: bytecode.distinct2 = distinct[0]<42 : i32>
-  // CHECK: bytecode.distinct3 = distinct[1]<42 : i32>
-  bytecode.distinct = distinct[0]<42 : i32>,
-  bytecode.distinct2 = distinct[0]<42 : i32>,
-  bytecode.distinct3 = distinct[1]<42 : i32>
-} {}
-
-//===----------------------------------------------------------------------===//
 // CallSiteLoc
 //===----------------------------------------------------------------------===//
 
 // CHECK-LABEL: @TestLocCallSite
 module @TestLocCallSite attributes {
   // CHECK: bytecode.loc = loc(callsite("foo" at "mysource.cc":10:8))
   bytecode.loc = loc(callsite("foo" at "mysource.cc":10:8))
 } {}

mlir/test/IR/distinct-attr.mlir

 // RUN: mlir-opt -allow-unregistered-dialect %s | FileCheck %s
-// RUN: mlir-opt -allow-unregistered-dialect -mlir-print-local-scope %s | FileCheck %s --check-prefix=CHECK-GENERIC
 
-// CHECK: #[[DISTINCT0:.*]] = distinct[0]<42 : i32>
-// CHECK: #[[DISTINCT1:.*]] = distinct[1]<array<i32: 10, 42>>
-// CHECK: #[[DISTINCT2:.*]] = distinct[2]<42 : i32>
+// CHECK: #[[DISTINCT0:.*]] = distinct<42 : i32>
+#distinct = distinct<42 : i32>
+// CHECK: #[[DISTINCT1:.*]] = distinct<array<i32: 10, 42>>
+#distinct1 = distinct<array<i32: 10, 42>>
+// CHECK: #[[DISTINCT2:.*]] = distinct<42 : i32>
+#distinct2 = distinct<42 : i32>
 
 // CHECK:         distinct.attr = #[[DISTINCT0]]
-// CHECK-GENERIC: distinct.attr = distinct[0]<42 : i32>
-"foo.op"() {distinct.attr = distinct[0]<42 : i32>} : () -> ()
+"foo.op"() {distinct.attr = #distinct} : () -> ()
 
 // CHECK:         distinct.attr = #[[DISTINCT1]]
-// CHECK-GENERIC: distinct.attr = distinct[1]<array<i32: 10, 42>>
-"foo.op"() {distinct.attr = distinct[1]<array<i32: 10, 42>>} : () -> ()
+"foo.op"() {distinct.attr = #distinct1} : () -> ()
 
 // CHECK:         distinct.attr = #[[DISTINCT0]]
-// CHECK-GENERIC: distinct.attr = distinct[0]<42 : i32>
-"foo.op"() {distinct.attr = distinct[0]<42 : i32>} : () -> ()
+"foo.op"() {distinct.attr = #distinct} : () -> ()
 
 // CHECK:         distinct.attr = #[[DISTINCT2]]
-// CHECK-GENERIC: distinct.attr = distinct[2]<42 : i32>
-"foo.op"() {distinct.attr = distinct[42]<42 : i32>} : () -> ()
+"foo.op"() {distinct.attr = #distinct2} : () -> ()

mlir/test/IR/invalid-builtin-attributes.mlir

 
 // -----
 
 // expected-error@below {{expected '>' to close an array attribute}}
 #attr = array<i8: 1)
 
 // -----
 
-// expected-error@below {{expected '[' after 'distinct'}}
-#attr = distinct<
-
-// -----
-
-// expected-error@below {{expected distinct Id}}
-#attr = distinct[i8
-
-// -----
-
-// expected-error@below {{expected an unsigned 64-bit integer}}
-#attr = distinct[0xAAAABBBBEEEEFFFF1]
-
-// -----
-
-// expected-error@below {{expected ']' to close distinct Id}}
-#attr = distinct[8)
-
-// -----
-
-// expected-error@below {{expected '<' after distinct Id}}
-#attr = distinct[8](
+// expected-error@below {{expected '<' after 'distinct'}}
+#attr = distinct[
 
 // -----
 
 // expected-error@below {{expected attribute}}
-#attr = distinct[8]<attribute
+#attr = distinct<attribute
 
 // -----
 
 // expected-error@below {{expected '>' to close distinct attribute}}
-#attr = distinct[8]<@foo]
+#attr = distinct<@foo]
 
 // -----
 
-#attr = distinct[0]<42 : i32>
-// expected-error@below {{referenced attribute does not match previous definition}}
-#attr1 = distinct[0]<43 : i32>
+func.func @inline_distinct() -> () {
+  "foo"(){bar = distinct<42 : i32>} : () -> () // expected-error {{distinct attribute cannot be defined inline}}
+}

mlir/test/IR/test-builtin-distinct-attrs.mlir

 // RUN: mlir-opt -allow-unregistered-dialect %s -test-distinct-attrs | FileCheck %s
 
-// CHECK: #[[DIST0:.*]] = distinct[0]<42 : i32>
-// CHECK: #[[DIST1:.*]] = distinct[1]<42 : i32>
-#distinct = distinct[0]<42 : i32>
-// CHECK: #[[DIST2:.*]] = distinct[2]<42 : i32>
-// CHECK: #[[DIST3:.*]] = distinct[3]<42 : i32>
-#distinct1 = distinct[1]<42 : i32>
-// CHECK: #[[DIST4:.*]] = distinct[4]<43 : i32>
-// CHECK: #[[DIST5:.*]] = distinct[5]<43 : i32>
-#distinct2 = distinct[2]<43 : i32>
-// CHECK: #[[DIST6:.*]] = distinct[6]<@foo_1>
-// CHECK: #[[DIST7:.*]] = distinct[7]<@foo_1>
-#distinct3 = distinct[3]<@foo_1>
+// CHECK: #[[DIST0:.*]] = distinct<42 : i32>
+// CHECK: #[[DIST1:.*]] = distinct<42 : i32>
+#distinct = distinct<42 : i32>
+// CHECK: #[[DIST2:.*]] = distinct<42 : i32>
+// CHECK: #[[DIST3:.*]] = distinct<42 : i32>
+#distinct1 = distinct<42 : i32>
+// CHECK: #[[DIST4:.*]] = distinct<43 : i32>
+// CHECK: #[[DIST5:.*]] = distinct<43 : i32>
+#distinct2 = distinct<43 : i32>
+// CHECK: #[[DIST6:.*]] = distinct<@foo_1>
+// CHECK: #[[DIST7:.*]] = distinct<@foo_1>
+#distinct3 = distinct<@foo_1>
 
 // Copies made for foo_2
-// CHECK: #[[DIST8:.*]] = distinct[8]<42 : i32>
-// CHECK: #[[DIST9:.*]] = distinct[9]<42 : i32>
-// CHECK: #[[DIST10:.*]] = distinct[10]<43 : i32>
-// CHECK: #[[DIST11:.*]] = distinct[11]<@foo_1>
+// CHECK: #[[DIST8:.*]] = distinct<42 : i32>
+// CHECK: #[[DIST9:.*]] = distinct<42 : i32>
+// CHECK: #[[DIST10:.*]] = distinct<43 : i32>
+// CHECK: #[[DIST11:.*]] = distinct<@foo_1>
 
 // Copies made for foo_3
-// CHECK: #[[DIST12:.*]] = distinct[12]<42 : i32>
-// CHECK: #[[DIST13:.*]] = distinct[13]<42 : i32>
-// CHECK: #[[DIST14:.*]] = distinct[14]<43 : i32>
-// CHECK: #[[DIST15:.*]] = distinct[15]<@foo_1>
+// CHECK: #[[DIST12:.*]] = distinct<42 : i32>
+// CHECK: #[[DIST13:.*]] = distinct<42 : i32>
+// CHECK: #[[DIST14:.*]] = distinct<43 : i32>
+// CHECK: #[[DIST15:.*]] = distinct<@foo_1>
 
 // Copies made for foo_4
-// CHECK: #[[DIST16:.*]] = distinct[16]<42 : i32>
-// CHECK: #[[DIST17:.*]] = distinct[17]<42 : i32>
-// CHECK: #[[DIST18:.*]] = distinct[18]<43 : i32>
-// CHECK: #[[DIST19:.*]] = distinct[19]<@foo_1>
+// CHECK: #[[DIST16:.*]] = distinct<42 : i32>
+// CHECK: #[[DIST17:.*]] = distinct<42 : i32>
+// CHECK: #[[DIST18:.*]] = distinct<43 : i32>
+// CHECK: #[[DIST19:.*]] = distinct<@foo_1>
 
 // CHECK: @foo_1
 func.func @foo_1() {
   // CHECK: "foo.op"() {distinct.input = #[[DIST0]], distinct.output = #[[DIST1]]}
   "foo.op"() {distinct.input = #distinct} : () -> ()
   // CHECK: "foo.op"() {distinct.input = #[[DIST2]], distinct.output = #[[DIST3]]}
   "foo.op"() {distinct.input = #distinct1} : () -> ()
   // CHECK: "foo.op"() {distinct.input = #[[DIST4]], distinct.output = #[[DIST5]]}

mlir/test/IR/test-symbol-rauw.mlir

module {
   func.func private @failed_repl() attributes {sym.new_name = "replaced_name" }
 
   "foo.possibly_unknown_symbol_table"() ({
   }) : () -> ()
 }
 
 // -----
 
+// CHECK: #[[DIST:.*]] = distinct<@replaced_foo>
+#distinct = distinct<@symbol_foo>
+
 // Check that replacement works in any implementations of SubElements.
 module {
     // CHECK: func private @replaced_foo
     func.func private @symbol_foo() attributes {sym.new_name = "replaced_foo" }
 
     // CHECK: func @symbol_bar
     func.func @symbol_bar() {
       // CHECK: foo.op
       // CHECK-SAME: non_symbol_attr,
-      // CHECK-SAME: use = [#test.sub_elements_access<[@replaced_foo], @symbol_bar, @replaced_foo>, distinct[0]<@replaced_foo>],
+      // CHECK-SAME: use = [#test.sub_elements_access<[@replaced_foo], @symbol_bar, @replaced_foo>, #[[DIST]]],
       // CHECK-SAME: z_non_symbol_attr_3
       "foo.op"() {
         non_symbol_attr,
-        use = [#test.sub_elements_access<[@symbol_foo],@symbol_bar,@symbol_foo>, distinct[0]<@symbol_foo>],
+        use = [#test.sub_elements_access<[@symbol_foo],@symbol_bar,@symbol_foo>, #distinct],
         z_non_symbol_attr_3
       } : () -> ()
     }
 }
 
 // -----
 
 module {

mlir/test/IR/test-symbol-uses.mlir

 // RUN: mlir-opt -allow-unregistered-dialect %s -test-symbol-uses -split-input-file -verify-diagnostics
 
+#distinct = distinct<@symbol_foo>
+
 // Symbol references to the module itself don't affect uses of symbols within
 // its table.
 // expected-remark@below {{symbol_removable function successfully erased}}
 module attributes {sym.outside_use = @symbol_foo } {
   // expected-remark@+1 {{symbol has 3 uses}}
   func.func private @symbol_foo()
 
   // expected-remark@below {{symbol has no uses}}
   // expected-remark@below {{found use of symbol : @symbol_foo}}
   // expected-remark@below {{symbol contains 3 nested references}}
   func.func @symbol_bar() attributes {sym.use = @symbol_foo} {
     // expected-remark@+1 {{found use of symbol : @symbol_foo}}
     "foo.op"() {
       non_symbol_attr,
       use = [{nested_symbol = [@symbol_foo]}],
       z_other_non_symbol_attr
     } : () -> ()
     // expected-remark@+1 {{found use of symbol : @symbol_foo}}
-    "foo.op"() { use = distinct[0]<@symbol_foo> } : () -> ()
+    "foo.op"() { use = #distinct } : () -> ()
   }
 
   // expected-remark@below {{symbol has no uses}}
   func.func private @symbol_removable()
 
   // expected-remark@+1 {{symbol has 1 use}}
   func.func private @symbol_baz()
 

mlir/unittests/IR/OpPropertiesTest.cpp

TEST(OpPropertiesTest, Properties) {
   {
     std::string output;
     llvm::raw_string_ostream os(output);
     opWithProp.print(os);
     ASSERT_STREQ("\"test_op_properties.op_with_properties\"() "
                  "<{a = -42 : i32, "
                  "array = array<i64: 40, 41>, "
                  "b = -4.200000e+01 : f32, "
-                 "label = \"bar foo\"}> : () -> ()\n",
+                 "label = \"bar foo\"}> : () -> ()",
                  os.str().c_str());
   }
   // Get a mutable reference to the properties for this operation and modify it
   // in place one member at a time.
   TestProperties &prop = opWithProp.getProperties();
   prop.a = 42;
   {
     std::string output;