[mlir][ASM] Refactor how attribute/type aliases are specified.

[rriddle]

Summary

Previously they were separated into "instance" and "kind" aliases, and also required that the dialect know ahead of time all of the instances that would have a corresponding alias. This approach was very clunky and not ergonomic to interact with. The new approach is to provide the dialect with an instance of an attribute/type to provide an alias for, fully replacing the original split approach.

[jpienaar]

Looks good overall

mlir/include/mlir/IR/OpImplementation.h

804–814

So if not overridden this just does nothing? "getAlias" which then writes to raw_ostream feels weird ... What is it getting?

mlir/lib/IR/AsmPrinter.cpp

238

Why not match with the gets above and have this and below be printAttribute? Below you have the type in the visit member too - Could we have these all consistent?

369

Why -1 ?

[rriddle]

update comments

[rriddle]

Thanks for the review Jacques!

mlir/include/mlir/IR/OpImplementation.h

804–814

Switched to LogicalResult return.

mlir/lib/IR/AsmPrinter.cpp

369

This is what was used before to represent optionality(whew, this has been around for a while now), switched to Optional<int>.

[ftynse]

Looks great!

I have two requests:

• could we get tests that exercise sanization and name conflicts?
• (separate commit) could we get a way to control alias printing (even something like -mlir-ignore-type-alias would work for me, looking up affine maps 1k lines above their use is a pain).

mlir/lib/IR/AsmPrinter.cpp

326–328

Are user-specified names allowed to start with an underscore? If so, what do we do in case sanization creates conflicts?

[rriddle]

Resolve comments and add tests

[rriddle]

Thanks for the review Alex!

In D89354#2339127, @ftynse wrote:

Looks great!

I have two requests:

• could we get tests that exercise sanization and name conflicts?
• (separate commit) could we get a way to control alias printing (even something like -mlir-ignore-type-alias would work for me, looking up affine maps 1k lines above their use is a pain).

If you use mlir-print-local-scope it should avoid printing aliases.

[ftynse]

Thanks!

[stella.stamenova]

I haven't had a chance to debug this yet, but we are seeing failures in the mlir tests on Windows Debug that appear to be caused by this change. The failures are:

MLIR :: Dialect/Affine/canonicalize.mlir
MLIR :: Dialect/Affine/simplify-affine-structures.mlir
MLIR :: Transforms/loop-invariant-code-motion.mlir

The failure in each of the tests is in initializeAliases. Here's an example error log:

         ********************
         FAIL: MLIR :: Transforms/loop-invariant-code-motion.mlir (67347 of 72158)
         ******************** TEST 'MLIR :: Transforms/loop-invariant-code-motion.mlir' FAILED ********************
         Script:
         --
         : 'RUN: at line 1';   e:\agent\_work\37\b\llvm\debug\bin\mlir-opt.exe E:\agent\_work\37\llvm-project\mlir\test\Transforms\loop-invariant-code-motion.mlir  -split-input-file -loop-invariant-code-motion | e:\agent\_work\37\b\llvm\debug\bin\filecheck.exe E:\agent\_work\37\llvm-project\mlir\test\Transforms\loop-invariant-code-motion.mlir
         --
         Exit Code: 1
         
         Command Output (stdout):
         --
         $ ":" "RUN: at line 1"
         note: command had no output on stdout or stderr
         $ "e:\agent\_work\37\b\llvm\debug\bin\mlir-opt.exe" "E:\agent\_work\37\llvm-project\mlir\test\Transforms\loop-invariant-code-motion.mlir" "-split-input-file" "-loop-invariant-code-motion"
         # command stderr:
         PLEASE submit a bug report to https://bugs.llvm.org/ and include the crash backtrace.
         
         Stack dump:
		 
		  0.	Program arguments: e:\agent\_work\37\b\llvm\debug\bin\mlir-opt.exe E:\agent\_work\37\llvm-project\mlir\test\Transforms\loop-invariant-code-motion.mlir -split-input-file -loop-invariant-code-motion 
         
          #0 0x00007ff6737e151e std::_Vector_const_iterator<class std::_Vector_val<struct std::_Simple_types<class mlir::Attribute>>>::operator*(void) const c:\program files (x86)\microsoft visual studio\2017\community\vc\tools\msvc\14.16.27023\include\vector:51:0
         
          #1 0x00007ff6737e1818 std::_Vector_iterator<class std::_Vector_val<struct std::_Simple_types<class mlir::Attribute>>>::operator*(void) const c:\program files (x86)\microsoft visual studio\2017\community\vc\tools\msvc\14.16.27023\include\vector:259:0
         
          #2 0x00007ff6737f983f llvm::detail::result_pair<class std::vector<class mlir::Attribute, class std::allocator<class mlir::Attribute>> &>::value(void) e:\agent\_work\37\llvm-project\llvm\include\llvm\adt\stlextras.h:1825:0
         
          #3 0x00007ff6737bc0d7 initializeAliases<mlir::Attribute> e:\agent\_work\37\llvm-project\mlir\lib\ir\asmprinter.cpp:380:0
         
          #4 0x00007ff6737bb73f `anonymous namespace'::AliasState::AliasInitializer::initialize e:\agent\_work\37\llvm-project\mlir\lib\ir\asmprinter.cpp:407:0
         
          #5 0x00007ff6737bb25d `anonymous namespace'::AliasState::initialize e:\agent\_work\37\llvm-project\mlir\lib\ir\asmprinter.cpp:473:0
         
          #6 0x00007ff6737f57de mlir::detail::AsmStateImpl::initializeAliases(class mlir::Operation *) e:\agent\_work\37\llvm-project\mlir\lib\ir\asmprinter.cpp:878:0
         
          #7 0x00007ff6737baef9 mlir::ModuleOp::print(class llvm::raw_ostream &, class mlir::OpPrintingFlags) e:\agent\_work\37\llvm-project\mlir\lib\ir\asmprinter.cpp:2465:0
         
          #8 0x00007ff6734e3ecc performActions e:\agent\_work\37\llvm-project\mlir\lib\support\mliroptmain.cpp:74:0
		  
		  #9 0x00007ff6734e40e3 processBuffer e:\agent\_work\37\llvm-project\mlir\lib\support\mliroptmain.cpp:103:0
         
         #10 0x00007ff6734e6851 <lambda_cfae4fdf50565b622aa01f27d2c735fe>::operator() e:\agent\_work\37\llvm-project\mlir\lib\support\mliroptmain.cpp:133:0
         
         #11 0x00007ff6734e56c7 llvm::function_ref<(class std::unique_ptr<class llvm::MemoryBuffer, struct std::default_delete<class llvm::MemoryBuffer>>, class llvm::raw_ostream &)>::callback_fn<class <lambda_cfae4fdf50565b622aa01f27d2c735fe>>(__int64, class std::unique_ptr<class llvm::MemoryBuffer, struct std::default_delete<class llvm::MemoryBuffer>>, class llvm::raw_ostream &) e:\agent\_work\37\llvm-project\llvm\include\llvm\adt\stlextras.h:185:0
         
         #12 0x00007ff67375cbad llvm::function_ref<(class std::unique_ptr<class llvm::MemoryBuffer, struct std::default_delete<class llvm::MemoryBuffer>>, class llvm::raw_ostream &)>::operator()(class std::unique_ptr<class llvm::MemoryBuffer, struct std::default_delete<class llvm::MemoryBuffer>>, class llvm::raw_ostream &) const e:\agent\_work\37\llvm-project\llvm\include\llvm\adt\stlextras.h:209:0
         
         #13 0x00007ff67375c99d mlir::splitAndProcessBuffer(class std::unique_ptr<class llvm::MemoryBuffer, struct std::default_delete<class llvm::MemoryBuffer>>, class llvm::function_ref<(class std::unique_ptr<class llvm::MemoryBuffer, struct std::default_delete<class llvm::MemoryBuffer>>, class llvm::raw_ostream &)>, class llvm::raw_ostream &) e:\agent\_work\37\llvm-project\mlir\lib\support\toolutilities.cpp:42:0
         
         #14 0x00007ff6734e2e0c mlir::MlirOptMain(class llvm::raw_ostream &, class std::unique_ptr<class llvm::MemoryBuffer, struct std::default_delete<class llvm::MemoryBuffer>>, class mlir::PassPipelineCLParser const &, class mlir::DialectRegistry &, bool, bool, bool, bool, bool) e:\agent\_work\37\llvm-project\mlir\lib\support\mliroptmain.cpp:130:0
         
         #15 0x00007ff6734e3b9d mlir::MlirOptMain(int, char **, class llvm::StringRef, class mlir::DialectRegistry &, bool) e:\agent\_work\37\llvm-project\mlir\lib\support\mliroptmain.cpp:223:0
         
         #16 0x00007ff67115f230 main e:\agent\_work\37\llvm-project\mlir\tools\mlir-opt\mlir-opt.cpp:160:0
         
         #17 0x00007ff6739d86d4 invoke_main d:\agent\_work\2\s\src\vctools\crt\vcstartup\src\startup\exe_common.inl:79:0

[mehdi_amini]

I haven't had a chance to debug this yet, but we are seeing failures in the mlir tests on Windows Debug that appear to be caused by this change. The failures are:

If reverting the patch fixes it, please feel free to push a revert.

[rriddle]

In D89354#2366600, @stella.stamenova wrote:

I haven't had a chance to debug this yet, but we are seeing failures in the mlir tests on Windows Debug that appear to be caused by this change. The failures are:

Sorry about that. Should be fixed by 235dfcf70abca65dba5d80f1a42d1485bab8980c.

[stella.stamenova]

In D89354#2366718, @rriddle wrote:

In D89354#2366600, @stella.stamenova wrote:

I haven't had a chance to debug this yet, but we are seeing failures in the mlir tests on Windows Debug that appear to be caused by this change. The failures are:

Sorry about that. Should be fixed by 235dfcf70abca65dba5d80f1a42d1485bab8980c.

Thanks, all better now!

mlir/include/mlir/IR/OpImplementation.h

 /// operation. See 'getAsmResultNames' below for more details.
 using OpAsmSetValueNameFn = function_ref<void(Value, StringRef)>;
 
 class OpAsmDialectInterface
     : public DialectInterface::Base<OpAsmDialectInterface> {
 public:
   OpAsmDialectInterface(Dialect *dialect) : Base(dialect) {}
 
-  /// Hooks for getting identifier aliases for symbols. The identifier is used
-  /// in place of the symbol when printing textual IR.
-  ///
-  /// Hook for defining Attribute kind aliases. This will generate an alias for
-  /// all attributes of the given kind in the form : <alias>[0-9]+. These
-  /// aliases must not contain `.`.
-  virtual void getAttributeKindAliases(
-      SmallVectorImpl<std::pair<TypeID, StringRef>> &aliases) const {}
-  /// Hook for defining Attribute aliases. These aliases must not contain `.` or
-  /// end with a numeric digit([0-9]+).
-  virtual void getAttributeAliases(
-      SmallVectorImpl<std::pair<Attribute, StringRef>> &aliases) const {}
-  /// Hook for defining Type aliases.
-  virtual void
-  getTypeAliases(SmallVectorImpl<std::pair<Type, StringRef>> &aliases) const {}
+  /// Hooks for getting an alias identifier alias for a given symbol, that is
+  /// not necessarily a part of this dialect. The identifier is used in place of
+  /// the symbol when printing textual IR. These aliases must not contain `.` or
+  /// end with a numeric digit([0-9]+). Returns success if an alias was
+  /// provided, failure otherwise.
+  virtual LogicalResult getAlias(Attribute attr, raw_ostream &os) const {
+    return failure();
+  }
+  virtual LogicalResult getAlias(Type type, raw_ostream &os) const {
+    return failure();
+  }
 
   /// Get a special name to use when printing the given operation. See
   /// OpAsmInterface.td#getAsmResultNames for usage details and documentation.
   virtual void getAsmResultNames(Operation *op,
                                  OpAsmSetValueNameFn setNameFn) const {}
 
   /// Get a special name to use when printing the entry block arguments of the
   /// region contained by an operation in this dialect.

mlir/lib/IR/AsmPrinter.cpp

 /// This class manages the state for type and attribute aliases.
 class AliasState {
 public:
   // Initialize the internal aliases.
   void
   initialize(Operation *op,
              DialectInterfaceCollection<OpAsmDialectInterface> &interfaces);
 
-  /// Return a name used for an attribute alias, or empty if there is no alias.
-  Twine getAttributeAlias(Attribute attr) const;
+  /// Get an alias for the given attribute if it has one and print it in `os`.
+  /// Returns success if an alias was printed, failure otherwise.
+  LogicalResult getAlias(Attribute attr, raw_ostream &os) const;
 
   /// Print all of the referenced attribute aliases.
   void printAttributeAliases(raw_ostream &os, NewLineCounter &newLine) const;
 
-  /// Return a string to use as an alias for the given type, or empty if there
-  /// is no alias recorded.
-  StringRef getTypeAlias(Type ty) const;
+  /// Get an alias for the given type if it has one and print it in `os`.
+  /// Returns success if an alias was printed, failure otherwise.
+  LogicalResult getAlias(Type ty, raw_ostream &os) const;
 
   /// Print all of the referenced type aliases.
   void printTypeAliases(raw_ostream &os, NewLineCounter &newLine) const;
 
 private:
-  /// A special index constant used for non-kind attribute aliases.
-  enum { NonAttrKindAlias = -1 };
+  /// This class represents a utility that initializes the set of attribute and
+  /// type aliases, without the need to store the extra information within the
+  /// main AliasState class or pass it around via function arguments.
+  class AliasInitializer {
+  public:
+    AliasInitializer(
+        DialectInterfaceCollection<OpAsmDialectInterface> &interfaces,
+        llvm::BumpPtrAllocator &aliasAllocator)
+        : interfaces(interfaces), aliasAllocator(aliasAllocator),
+          aliasOS(aliasBuffer) {}
 
-  /// Record a reference to the given attribute.
-  void recordAttributeReference(Attribute attr);
+    void
+    initialize(Operation *op,
+               llvm::MapVector<Attribute, std::pair<StringRef, Optional<int>>>
+                   &attrToAlias,
+               llvm::MapVector<Type, std::pair<StringRef, Optional<int>>>
+                   &typeToAlias);
 
-  /// Record a reference to the given type.
-  void recordTypeReference(Type ty);
+  private:
+    void visit(Attribute attr);
+    void visit(Type type);
 
-  // Visit functions.
-  void visitOperation(Operation *op);
-  void visitType(Type type);
-  void visitAttribute(Attribute attr);
+    /// Try to generate an alias for the provided symbol. If an alias is
+    /// generated, the provided alias mapping and reverse mapping are updated.
+    template <typename T>
+    void
+    generateAlias(T symbol,
+                  llvm::MapVector<StringRef, std::vector<T>> &aliasToSymbol);
 
-  /// Set of attributes known to be used within the module.
-  llvm::SetVector<Attribute> usedAttributes;
+    /// The set of asm interfaces within the context.
+    DialectInterfaceCollection<OpAsmDialectInterface> &interfaces;
 
-  /// Mapping between attribute and a pair comprised of a base alias name and a
-  /// count suffix. If the suffix is set to -1, it is not displayed.
-  llvm::MapVector<Attribute, std::pair<StringRef, int>> attrToAlias;
+    /// Mapping between an alias and the set of symbols mapped to it.
+    llvm::MapVector<StringRef, std::vector<Attribute>> aliasToAttr;
+    llvm::MapVector<StringRef, std::vector<Type>> aliasToType;
+
+    /// An allocator used for alias names.
+    llvm::BumpPtrAllocator &aliasAllocator;
 
-  /// Mapping between attribute kind and a pair comprised of a base alias name
-  /// and a unique list of attributes belonging to this kind sorted by location
-  /// seen in the module.
-  llvm::MapVector<TypeID, std::pair<StringRef, std::vector<Attribute>>>
-      attrKindToAlias;
+    /// The set of visited attributes.
+    DenseSet<Attribute> visitedAttributes;
 
-  /// Set of types known to be used within the module.
-  llvm::SetVector<Type> usedTypes;
+    /// The set of visited types.
+    DenseSet<Type> visitedTypes;
 
-  /// A mapping between a type and a given alias.
-  DenseMap<Type, StringRef> typeToAlias;
+    /// Storage and stream used when generating an alias.
+    SmallString<32> aliasBuffer;
+    llvm::raw_svector_ostream aliasOS;
   };
-} // end anonymous namespace
 
-// Utility to generate a function to register a symbol alias.
-static bool canRegisterAlias(StringRef name, llvm::StringSet<> &usedAliases) {
-  assert(!name.empty() && "expected alias name to be non-empty");
-  // TODO: Assert that the provided alias name can be lexed as
-  // an identifier.
-
-  // Check that the alias doesn't contain a '.' character and the name is not
-  // already in use.
-  return !name.contains('.') && usedAliases.insert(name).second;
-}
+  /// Mapping between attribute and a pair comprised of a base alias name and a
+  /// count suffix. If the suffix is set to None, it is not displayed.
+  llvm::MapVector<Attribute, std::pair<StringRef, Optional<int>>> attrToAlias;
+  llvm::MapVector<Type, std::pair<StringRef, Optional<int>>> typeToAlias;
 
-void AliasState::initialize(
-    Operation *op,
-    DialectInterfaceCollection<OpAsmDialectInterface> &interfaces) {
-  // Track the identifiers in use for each symbol so that the same identifier
-  // isn't used twice.
-  llvm::StringSet<> usedAliases;
-
-  // Collect the set of aliases from each dialect.
-  SmallVector<std::pair<TypeID, StringRef>, 8> attributeKindAliases;
-  SmallVector<std::pair<Attribute, StringRef>, 8> attributeAliases;
-  SmallVector<std::pair<Type, StringRef>, 16> typeAliases;
-
-  // AffineMap/Integer set have specific kind aliases.
-  attributeKindAliases.emplace_back(AffineMapAttr::getTypeID(), "map");
-  attributeKindAliases.emplace_back(IntegerSetAttr::getTypeID(), "set");
+  /// An allocator used for alias names.
+  llvm::BumpPtrAllocator aliasAllocator;
+};
+} // end anonymous namespace
 
-  for (auto &interface : interfaces) {
-    interface.getAttributeKindAliases(attributeKindAliases);
-    interface.getAttributeAliases(attributeAliases);
-    interface.getTypeAliases(typeAliases);
-  }
-
-  // Setup the attribute kind aliases.
-  StringRef alias;
-  TypeID attrKind;
-  for (auto &attrAliasPair : attributeKindAliases) {
-    std::tie(attrKind, alias) = attrAliasPair;
-    assert(!alias.empty() && "expected non-empty alias string");
-    if (!usedAliases.count(alias) && !alias.contains('.'))
-      attrKindToAlias.insert({attrKind, {alias, {}}});
-  }
-
-  // Clear the set of used identifiers so that the attribute kind aliases are
-  // just a prefix and not the full alias, i.e. there may be some overlap.
-  usedAliases.clear();
-
-  // Register the attribute aliases.
-  // Create a regex for the attribute kind alias names, these have a prefix with
-  // a counter appended to the end. We prevent normal aliases from having these
-  // names to avoid collisions.
-  llvm::Regex reservedAttrNames("[0-9]+$");
-
-  // Attribute value aliases.
-  Attribute attr;
-  for (auto &attrAliasPair : attributeAliases) {
-    std::tie(attr, alias) = attrAliasPair;
-    if (!reservedAttrNames.match(alias) && canRegisterAlias(alias, usedAliases))
-      attrToAlias.insert({attr, {alias, NonAttrKindAlias}});
-  }
-
-  // Clear the set of used identifiers as types can have the same identifiers as
-  // affine structures.
-  usedAliases.clear();
-
-  // Type aliases.
-  for (auto &typeAliasPair : typeAliases)
-    if (canRegisterAlias(typeAliasPair.second, usedAliases))
-      typeToAlias.insert(typeAliasPair);
-
-  // Traverse the given IR to generate the set of used attributes/types.
-  op->walk([&](Operation *op) { visitOperation(op); });
-}
-
-/// Return a name used for an attribute alias, or empty if there is no alias.
-Twine AliasState::getAttributeAlias(Attribute attr) const {
-  auto alias = attrToAlias.find(attr);
-  if (alias == attrToAlias.end())
-    return Twine();
-
-  // Return the alias for this attribute, along with the index if this was
-  // generated by a kind alias.
-  int kindIndex = alias->second.second;
-  return alias->second.first +
-         (kindIndex == NonAttrKindAlias ? Twine() : Twine(kindIndex));
+/// Returns true if 'c' is an allowable punctuation character: [$._-]
+/// Returns false otherwise.
+static bool isPunct(char c) {
+  return c == '$' || c == '.' || c == '_' || c == '-';
 }
 
-/// Print all of the referenced attribute aliases.
-void AliasState::printAttributeAliases(raw_ostream &os,
-                                       NewLineCounter &newLine) const {
-  auto printAlias = [&](StringRef alias, Attribute attr, int index) {
-    os << '#' << alias;
-    if (index != NonAttrKindAlias)
-      os << index;
-    os << " = " << attr << newLine;
-  };
+/// Sanitize the given name such that it can be used as a valid identifier. If
+/// the string needs to be modified in any way, the provided buffer is used to
+/// store the new copy,
+static StringRef sanitizeIdentifier(StringRef name, SmallString<16> &buffer) {
+  assert(!name.empty() && "Shouldn't have an empty name here");
 
-  // Print all of the attribute kind aliases.
-  for (auto &kindAlias : attrKindToAlias) {
-    auto &aliasAttrsPair = kindAlias.second;
-    for (unsigned i = 0, e = aliasAttrsPair.second.size(); i != e; ++i)
-      printAlias(aliasAttrsPair.first, aliasAttrsPair.second[i], i);
-    os << newLine;
+  // Check to see if this name is valid. If it starts with a digit, then it
+  // could conflict with the autogenerated numeric ID's (we unique them in a
+  // different map), so add an underscore prefix to avoid problems.
+  if (isdigit(name[0])) {
+    buffer.push_back('_');
+    buffer.append(name);
+    return StringRef(buffer.data(), buffer.size());
   }
 
-  // In a second pass print all of the remaining attribute aliases that aren't
-  // kind aliases.
-  for (Attribute attr : usedAttributes) {
-    auto alias = attrToAlias.find(attr);
-    if (alias != attrToAlias.end() && alias->second.second == NonAttrKindAlias)
-      printAlias(alias->second.first, attr, alias->second.second);
+  // Check to see if the name consists of all-valid identifiers.  If not, we
+  // need to escape them.
+  for (char ch : name) {
+    if (isalpha(ch) || isPunct(ch) || isdigit(ch))
+      continue;
+
+    for (char ch : name) {
+      if (isalpha(ch) || isPunct(ch) || isdigit(ch))
+        buffer.push_back(ch);
+      else if (ch == ' ')
+        buffer.push_back('_');
+      else
+        buffer.append(llvm::utohexstr((unsigned char)ch));
     }
+    return buffer;
   }
 
-/// Return a string to use as an alias for the given type, or empty if there
-/// is no alias recorded.
-StringRef AliasState::getTypeAlias(Type ty) const {
-  return typeToAlias.lookup(ty);
+  // Otherwise, return the original name.
+  return name;
 }
 
-/// Print all of the referenced type aliases.
-void AliasState::printTypeAliases(raw_ostream &os,
-                                  NewLineCounter &newLine) const {
-  for (Type type : usedTypes) {
-    auto alias = typeToAlias.find(type);
-    if (alias != typeToAlias.end())
-      os << '!' << alias->second << " = type " << type << newLine;
+/// Given a collection of aliases and symbols, initialize a mapping from a
+/// symbol to a given alias.
+template <typename T>
+static void initializeAliases(
+    llvm::MapVector<StringRef, std::vector<T>> &aliasToSymbol,
+    llvm::MapVector<T, std::pair<StringRef, Optional<int>>> &symbolToAlias) {
+  std::vector<std::pair<StringRef, std::vector<T>>> aliases =
+      aliasToSymbol.takeVector();
+  llvm::array_pod_sort(aliases.begin(), aliases.end(),
+                       [](const auto *lhs, const auto *rhs) {
+                         return lhs->first.compare(rhs->first);
+                       });
+
+  for (auto &it : aliases) {
+    // If there is only one instance for this alias, use the name directly.
+    if (it.second.size() == 1) {
+      symbolToAlias.insert({it.second.front(), {it.first, llvm::None}});
+      continue;
+    }
+    // Otherwise, add the index to the name.
+    for (auto &symbolIt : llvm::enumerate(it.second))
+      symbolToAlias.insert({symbolIt.value(), {it.first, symbolIt.index()}});
   }
 }
 
-/// Record a reference to the given attribute.
-void AliasState::recordAttributeReference(Attribute attr) {
-  // Don't recheck attributes that have already been seen or those that
-  // already have an alias.
-  if (!usedAttributes.insert(attr) || attrToAlias.count(attr))
-    return;
+void AliasState::AliasInitializer::initialize(
+    Operation *op,
+    llvm::MapVector<Attribute, std::pair<StringRef, Optional<int>>>
+        &attrToAlias,
+    llvm::MapVector<Type, std::pair<StringRef, Optional<int>>> &typeToAlias) {
+  op->walk([&](Operation *op) {
+    // Visit all the types used in the operation.
+    for (auto type : op->getOperandTypes())
+      visit(type);
+    for (auto type : op->getResultTypes())
+      visit(type);
+    for (auto &region : op->getRegions())
+      for (auto &block : region)
+        for (auto arg : block.getArguments())
+          visit(arg.getType());
+
+    // Visit each of the attributes.
+    for (auto elt : op->getAttrs())
+      visit(elt.second);
+  });
+
+  // Initialize the aliases sorted by name.
+  initializeAliases(aliasToAttr, attrToAlias);
+  initializeAliases(aliasToType, typeToAlias);
+}
 
-  // If this attribute kind has an alias, then record one for this attribute.
-  auto alias = attrKindToAlias.find(attr.getTypeID());
-  if (alias == attrKindToAlias.end())
+void AliasState::AliasInitializer::visit(Attribute attr) {
+  if (!visitedAttributes.insert(attr).second)
     return;
-  std::pair<StringRef, int> attrAlias(alias->second.first,
-                                      alias->second.second.size());
-  attrToAlias.insert({attr, attrAlias});
-  alias->second.second.push_back(attr);
+
+  if (auto arrayAttr = attr.dyn_cast<ArrayAttr>()) {
+    for (Attribute element : arrayAttr.getValue())
+      visit(element);
+  } else if (auto typeAttr = attr.dyn_cast<TypeAttr>()) {
+    visit(typeAttr.getValue());
   }
 
-/// Record a reference to the given type.
-void AliasState::recordTypeReference(Type ty) { usedTypes.insert(ty); }
+  // Try to generate an alias for this attribute.
+  generateAlias(attr, aliasToAttr);
+}
 
-// TODO: Support visiting other types/operations when implemented.
-void AliasState::visitType(Type type) {
-  recordTypeReference(type);
+void AliasState::AliasInitializer::visit(Type type) {
+  if (!visitedTypes.insert(type).second)
+    return;
 
+  // Visit several subtypes that contain types or atttributes.
   if (auto funcType = type.dyn_cast<FunctionType>()) {
     // Visit input and result types for functions.
     for (auto input : funcType.getInputs())
-      visitType(input);
+      visit(input);
     for (auto result : funcType.getResults())
-      visitType(result);
+      visit(result);
   } else if (auto shapedType = type.dyn_cast<ShapedType>()) {
-    visitType(shapedType.getElementType());
+    visit(shapedType.getElementType());
 
     // Visit affine maps in memref type.
     if (auto memref = type.dyn_cast<MemRefType>())
       for (auto map : memref.getAffineMaps())
-        recordAttributeReference(AffineMapAttr::get(map));
+        visit(AffineMapAttr::get(map));
   }
+
+  // Try to generate an alias for this type.
+  generateAlias(type, aliasToType);
 }
 
-void AliasState::visitAttribute(Attribute attr) {
-  recordAttributeReference(attr);
+template <typename T>
+void AliasState::AliasInitializer::generateAlias(
+    T symbol, llvm::MapVector<StringRef, std::vector<T>> &aliasToSymbol) {
+  SmallString<16> tempBuffer;
+  for (auto &interface : interfaces) {
+    interface.getAlias(symbol, aliasOS);
+    StringRef name = aliasOS.str();
+    if (name.empty())
+      continue;
+    name = sanitizeIdentifier(name, tempBuffer);
+    name = name.copy(aliasAllocator);
 
-  if (auto arrayAttr = attr.dyn_cast<ArrayAttr>()) {
-    for (auto elt : arrayAttr.getValue())
-      visitAttribute(elt);
-  } else if (auto typeAttr = attr.dyn_cast<TypeAttr>()) {
-    visitType(typeAttr.getValue());
+    aliasToSymbol[name].push_back(symbol);
+    aliasBuffer.clear();
+    break;
   }
 }
 
-void AliasState::visitOperation(Operation *op) {
-  // Visit all the types used in the operation.
-  for (auto type : op->getOperandTypes())
-    visitType(type);
-  for (auto type : op->getResultTypes())
-    visitType(type);
-  for (auto &region : op->getRegions())
-    for (auto &block : region)
-      for (auto arg : block.getArguments())
-        visitType(arg.getType());
+void AliasState::initialize(
+    Operation *op,
+    DialectInterfaceCollection<OpAsmDialectInterface> &interfaces) {
+  AliasInitializer initializer(interfaces, aliasAllocator);
+  initializer.initialize(op, attrToAlias, typeToAlias);
+}
 
-  // Visit each of the attributes.
-  for (auto elt : op->getAttrs())
-    visitAttribute(elt.second);
+static void printAlias(raw_ostream &os,
+                       const std::pair<StringRef, Optional<int>> &alias,
+                       char prefix) {
+  os << prefix << alias.first;
+  if (alias.second)
+    os << *alias.second;
+}
+
+LogicalResult AliasState::getAlias(Attribute attr, raw_ostream &os) const {
+  auto it = attrToAlias.find(attr);
+  if (it == attrToAlias.end())
+    return failure();
+
+  printAlias(os, it->second, '#');
+  return success();
+}
+
+void AliasState::printAttributeAliases(raw_ostream &os,
+                                       NewLineCounter &newLine) const {
+  for (const auto &it : attrToAlias) {
+    printAlias(os, it.second, '#');
+    os << " = " << it.first << newLine;
+  }
+}
+
+LogicalResult AliasState::getAlias(Type ty, raw_ostream &os) const {
+  auto it = typeToAlias.find(ty);
+  if (it == typeToAlias.end())
+    return failure();
+
+  printAlias(os, it->second, '!');
+  return success();
+}
+
+void AliasState::printTypeAliases(raw_ostream &os,
+                                  NewLineCounter &newLine) const {
+  for (const auto &it : typeToAlias) {
+    printAlias(os, it.second, '!');
+    os << " = " << it.first << newLine;
+  }
 }
 
 //===----------------------------------------------------------------------===//
 // SSANameState
 //===----------------------------------------------------------------------===//
 
 namespace {
 /// This class manages the state of SSA value names.
if (name.empty()) {
     valueIDs[value] = nextValueID++;
     return;
   }
 
   valueIDs[value] = NameSentinel;
   valueNames[value] = uniqueValueName(name);
 }
 
-/// Returns true if 'c' is an allowable punctuation character: [$._-]
-/// Returns false otherwise.
-static bool isPunct(char c) {
-  return c == '$' || c == '.' || c == '_' || c == '-';
-}
-
 StringRef SSANameState::uniqueValueName(StringRef name) {
-  assert(!name.empty() && "Shouldn't have an empty name here");
-
-  // Check to see if this name is valid.  If it starts with a digit, then it
-  // could conflict with the autogenerated numeric ID's (we unique them in a
-  // different map), so add an underscore prefix to avoid problems.
-  if (isdigit(name[0])) {
-    SmallString<16> tmpName("_");
-    tmpName += name;
-    return uniqueValueName(tmpName);
-  }
-
-  // Check to see if the name consists of all-valid identifiers.  If not, we
-  // need to escape them.
-  for (char ch : name) {
-    if (isalpha(ch) || isPunct(ch) || isdigit(ch))
-      continue;
-
-    SmallString<16> tmpName;
-    for (char ch : name) {
-      if (isalpha(ch) || isPunct(ch) || isdigit(ch))
-        tmpName += ch;
-      else if (ch == ' ')
-        tmpName += '_';
-      else {
-        tmpName += llvm::utohexstr((unsigned char)ch);
-      }
-    }
-    return uniqueValueName(tmpName);
-  }
+  SmallString<16> tmpBuffer;
+  name = sanitizeIdentifier(name, tmpBuffer);
 
   // Check to see if this name is already unique.
   if (!usedNames.count(name)) {
     name = name.copy(usedNameAllocator);
   } else {
     // Otherwise, we had a conflict - probe until we find a unique name. This
     // is guaranteed to terminate (and usually in a single iteration) because it
     // generates new names by incrementing nextConflictID.
     SmallString<64> probeName(name);
     probeName.push_back('_');
     while (true) {
-      probeName.resize(name.size() + 1);
       probeName += llvm::utostr(nextConflictID++);
       if (!usedNames.count(probeName)) {
         name = StringRef(probeName).copy(usedNameAllocator);
         break;
       }
+      probeName.resize(name.size() + 1);
     }
   }
 
   usedNames.insert(name, char());
   return name;
 }
 
 //===----------------------------------------------------------------------===//

 
 void ModulePrinter::printAttribute(Attribute attr,
                                    AttrTypeElision typeElision) {
   if (!attr) {
     os << "<<NULL ATTRIBUTE>>";
     return;
   }
 
-  // Check for an alias for this attribute.
-  if (state) {
-    Twine alias = state->getAliasState().getAttributeAlias(attr);
-    if (!alias.isTriviallyEmpty()) {
-      os << '#' << alias;
-      return;
-    }
-  }
+  // Try to print an alias for this attribute.
+  if (state && succeeded(state->getAliasState().getAlias(attr, os)))
 
   auto attrType = attr.getType();
   if (auto opaqueAttr = attr.dyn_cast<OpaqueAttr>()) {
     printDialectSymbol(os, "#", opaqueAttr.getDialectNamespace(),
                        opaqueAttr.getAttrData());
   } else if (attr.isa<UnitAttr>()) {
     os << "unit";
     return;

 }
 
 void ModulePrinter::printType(Type type) {
   if (!type) {
     os << "<<NULL TYPE>>";
     return;
   }
 
-  // Check for an alias for this type.
-  if (state) {
-    StringRef alias = state->getAliasState().getTypeAlias(type);
-    if (!alias.empty()) {
-      os << '!' << alias;
-      return;
-    }
-  }
+  // Try to print an alias for this type.
+  if (state && succeeded(state->getAliasState().getAlias(type, os)))
 
   TypeSwitch<Type>(type)
       .Case<OpaqueType>([&](OpaqueType opaqueTy) {
         printDialectSymbol(os, "!", opaqueTy.getDialectNamespace(),
                            opaqueTy.getTypeData());
       })
       .Case<IndexType>([&](Type) { os << "index"; })
       .Case<BFloat16Type>([&](Type) { os << "bf16"; })

mlir/lib/IR/MLIRContext.cpp

 #include "mlir/IR/Attributes.h"
 #include "mlir/IR/Diagnostics.h"
 #include "mlir/IR/Dialect.h"
 #include "mlir/IR/Function.h"
 #include "mlir/IR/Identifier.h"
 #include "mlir/IR/IntegerSet.h"
 #include "mlir/IR/Location.h"
 #include "mlir/IR/Module.h"
+#include "mlir/IR/OpImplementation.h"
 #include "mlir/IR/Types.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/DenseSet.h"
 #include "llvm/ADT/SetVector.h"
 #include "llvm/ADT/StringSet.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/Support/Allocator.h"
 #include "llvm/Support/CommandLine.h"
void mlir::registerMLIRContextCLOptions() {
   *clOptions;
 }
 
 //===----------------------------------------------------------------------===//
 // Builtin Dialect
 //===----------------------------------------------------------------------===//
 
 namespace {
+struct BuiltinOpAsmDialectInterface : public OpAsmDialectInterface {
+  using OpAsmDialectInterface::OpAsmDialectInterface;
+
+  LogicalResult getAlias(Attribute attr, raw_ostream &os) const override {
+    if (attr.isa<AffineMapAttr>()) {
+      os << "map";
+      return success();
+    }
+    if (attr.isa<IntegerSetAttr>()) {
+      os << "set";
+      return success();
+    }
+    return failure();
+  }
+};
+
 /// A builtin dialect to define types/etc that are necessary for the validity of
 /// the IR.
 struct BuiltinDialect : public Dialect {
   BuiltinDialect(MLIRContext *context)
       : Dialect(/*name=*/"", context, TypeID::get<BuiltinDialect>()) {
     addTypes<ComplexType, BFloat16Type, Float16Type, Float32Type, Float64Type,
              FunctionType, IndexType, IntegerType, MemRefType,
              UnrankedMemRefType, NoneType, OpaqueType, RankedTensorType,
              TupleType, UnrankedTensorType, VectorType>();
     addAttributes<AffineMapAttr, ArrayAttr, DenseIntOrFPElementsAttr,
                   DenseStringElementsAttr, DictionaryAttr, FloatAttr,
                   SymbolRefAttr, IntegerAttr, IntegerSetAttr, OpaqueAttr,
                   OpaqueElementsAttr, SparseElementsAttr, StringAttr, TypeAttr,
                   UnitAttr>();
     addAttributes<CallSiteLoc, FileLineColLoc, FusedLoc, NameLoc, OpaqueLoc,
                   UnknownLoc>();
+    addInterfaces<BuiltinOpAsmDialectInterface>();
 
     // TODO: These operations should be moved to a different dialect when they
     // have been fully decoupled from the core.
     addOperations<FuncOp, ModuleOp, ModuleTerminatorOp>();
   }
   static StringRef getDialectNamespace() { return ""; }
 };
 } // end anonymous namespace.

mlir/test/Dialect/Affine/affine-loop-invariant-code-motion.mlir

affine.for %arg0 = 0 to 10 {
 
     }
   }
 
   // CHECK: %0 = alloc() : memref<10xf32>
   // CHECK-NEXT: %cst = constant 8.000000e+00 : f32
   // CHECK-NEXT: affine.for %arg0 = 0 to 10 {
   // CHECK-NEXT: %1 = affine.apply #map{{[0-9]+}}(%arg0)
-  // CHECK-NEXT: affine.if #set0(%arg0, %1) {
+  // CHECK-NEXT: affine.if #set(%arg0, %1) {
   // CHECK-NEXT: %2 = addf %cst, %cst : f32
   // CHECK-NEXT: affine.store %2, %0[%arg0] : memref<10xf32>
   // CHECK-NEXT: }
 
 
   return
 }
 
affine.for %arg1 = 0 to 10 {
 
       }
     }
   }
 
   // CHECK: %0 = alloc() : memref<10xf32>
   // CHECK-NEXT: %cst = constant 8.000000e+00 : f32
   // CHECK-NEXT: affine.for %arg0 = 0 to 10 {
-  // CHECK-NEXT: affine.if #set0(%arg0, %arg0) {
+  // CHECK-NEXT: affine.if #set(%arg0, %arg0) {
   // CHECK-NEXT: %1 = addf %cst, %cst : f32
   // CHECK-NEXT: affine.store %1, %0[%arg0] : memref<10xf32>
   // CHECK-NEXT: }
 
 
   return
 }
 
affine.for %arg1 = 0 to 10 {
       }
     }
   }
 
   // CHECK: %0 = alloc() : memref<10xf32>
   // CHECK-NEXT: %cst = constant 8.000000e+00 : f32
   // CHECK-NEXT: affine.for %arg0 = 0 to 10 {
   // CHECK-NEXT: affine.for %arg1 = 0 to 10 {
-  // CHECK-NEXT: affine.if #set0(%arg0, %arg0) {
+  // CHECK-NEXT: affine.if #set(%arg0, %arg0) {
   // CHECK-NEXT: %1 = addf %cst, %cst : f32
   // CHECK-NEXT: affine.store %1, %0[%arg1] : memref<10xf32>
   // CHECK-NEXT: }
   // CHECK-NEXT: }
 
 
   return
 }
affine.for %arg1 = 0 to 10 {
       }
     }
   }
 
   // CHECK: %0 = alloc() : memref<10xf32>
   // CHECK-NEXT: %cst = constant 8.000000e+00 : f32
   // CHECK-NEXT: affine.for %arg0 = 0 to 10 {
   // CHECK-NEXT: affine.for %arg1 = 0 to 10 {
-  // CHECK-NEXT: affine.if #set0(%arg0, %arg0) {
+  // CHECK-NEXT: affine.if #set(%arg0, %arg0) {
   // CHECK-NEXT: %1 = addf %cst, %cst : f32
   // CHECK-NEXT: affine.store %1, %0[%arg0] : memref<10xf32>
-  // CHECK-NEXT: affine.if #set0(%arg0, %arg0) {
+  // CHECK-NEXT: affine.if #set(%arg0, %arg0) {
   // CHECK-NEXT: affine.store %1, %0[%arg1] : memref<10xf32>
   // CHECK-NEXT: }
   // CHECK-NEXT: }
   // CHECK-NEXT: }
 
 
   return
 }
affine.for %arg1 = 0 to 10 {
       }
     }
   }
 
   // CHECK: %0 = alloc() : memref<10xf32>
   // CHECK-NEXT: %cst = constant 8.000000e+00 : f32
   // CHECK-NEXT: affine.for %arg0 = 0 to 10 {
   // CHECK-NEXT: affine.for %arg1 = 0 to 10 {
-  // CHECK-NEXT: affine.if #set0(%arg0, %arg0) {
+  // CHECK-NEXT: affine.if #set(%arg0, %arg0) {
   // CHECK-NEXT: %1 = addf %cst, %cst : f32
   // CHECK-NEXT: affine.store %1, %0[%arg0] : memref<10xf32>
-  // CHECK-NEXT: affine.if #set0(%arg0, %arg0) {
+  // CHECK-NEXT: affine.if #set(%arg0, %arg0) {
   // CHECK-NEXT: affine.store %1, %0[%arg0] : memref<10xf32>
   // CHECK-NEXT: } else {
   // CHECK-NEXT: affine.store %1, %0[%arg1] : memref<10xf32>
   // CHECK-NEXT: }
   // CHECK-NEXT: }
   // CHECK-NEXT: }
 
 
affine.for %arg1 = 0 to 10 {
       }
     }
   }
 
   // CHECK: %0 = alloc() : memref<10xf32>
   // CHECK-NEXT: %1 = alloc() : memref<10xf32>
   // CHECK-NEXT: %cst = constant 8.000000e+00 : f32
   // CHECK-NEXT: affine.for %arg0 = 0 to 10 {
-  // CHECK-NEXT: affine.if #set0(%arg0, %arg0) {
+  // CHECK-NEXT: affine.if #set(%arg0, %arg0) {
   // CHECK-NEXT: %2 = addf %cst, %cst : f32
   // CHECK-NEXT: %3 = affine.load %0[%arg0] : memref<10xf32>
-  // CHECK-NEXT: affine.if #set0(%arg0, %arg0) {
+  // CHECK-NEXT: affine.if #set(%arg0, %arg0) {
   // CHECK-NEXT: affine.store %2, %1[%arg0] : memref<10xf32>
   // CHECK-NEXT: } else {
   // CHECK-NEXT: %4 = affine.load %0[%arg0] : memref<10xf32>
   // CHECK-NEXT: }
   // CHECK-NEXT: }
 
 
   return
affine.for %arg1 = 0 to 10 {
           }
       }
     }
   }
 
   // CHECK: %0 = alloc() : memref<10xf32>
   // CHECK-NEXT: %cst = constant 8.000000e+00 : f32
   // CHECK-NEXT: affine.for %arg0 = 0 to 10 {
-  // CHECK-NEXT: affine.if #set0(%arg0, %arg0) {
+  // CHECK-NEXT: affine.if #set(%arg0, %arg0) {
   // CHECK-NEXT: %1 = addf %cst, %cst : f32
   // CHECK-NEXT: %2 = affine.load %0[%arg0] : memref<10xf32>
-  // CHECK-NEXT: affine.if #set0(%arg0, %arg0) {
+  // CHECK-NEXT: affine.if #set(%arg0, %arg0) {
   // CHECK-NEXT: %3 = affine.load %0[%arg0] : memref<10xf32>
   // CHECK-NEXT: }
   // CHECK-NEXT: }
 
 
   return
 }
 
affine.for %arg1 = 0 to 10 {
       }
     }
   }
 
   // CHECK: %0 = alloc() : memref<10xf32>
   // CHECK-NEXT: %cst = constant 8.000000e+00 : f32
   // CHECK-NEXT: affine.for %arg0 = 0 to 10 {
   // CHECK-NEXT: affine.for %arg1 = 0 to 10 {
-  // CHECK-NEXT: affine.if #set0(%arg0, %arg0) {
+  // CHECK-NEXT: affine.if #set(%arg0, %arg0) {
   // CHECK-NEXT: %1 = addf %cst, %cst : f32
   // CHECK-NEXT: affine.store %1, %0[%arg0] : memref<10xf32>
   // CHECK-NEXT: affine.for %arg2 = 0 to 10 {
   // CHECK-NEXT: affine.store %1, %0[%arg2] : memref<10xf32>
   // CHECK-NEXT: }
   // CHECK-NEXT: }
   // CHECK-NEXT: }
 

mlir/test/Dialect/Affine/canonicalize.mlir

func @fold_empty_loop() {
   affine.for %i = 0 to 10 {
   }
   return
 }
 // CHECK: return
 
 // -----
 
-// CHECK-DAG: [[$SET:#set[0-9]+]] = affine_set<(d0, d1)[s0] : (d0 >= 0, -d0 + 1022 >= 0, d1 >= 0, -d1 + s0 - 2 >= 0)>
+// CHECK-DAG: [[$SET:#set[0-9]*]] = affine_set<(d0, d1)[s0] : (d0 >= 0, -d0 + 1022 >= 0, d1 >= 0, -d1 + s0 - 2 >= 0)>
 
 // CHECK-LABEL: func @canonicalize_affine_if
 // CHECK-SAME: [[M:%.*]]: index,
 // CHECK-SAME: [[N:%.*]]: index)
 func @canonicalize_affine_if(%M : index, %N : index) {
   %c1022 = constant 1022 : index
   // Drop unused operand %M, propagate %c1022, and promote %N to symbolic.
   affine.for %i = 0 to 1024 {

mlir/test/Dialect/Affine/ops.mlir

%sum_next = affine.if #set(%i) -> (f32) {
       affine.yield %sum_iter : f32
     }
     affine.yield %sum_next : f32
   }
   return %res : f32
 }
 // CHECK:      %[[const_0:.*]] = constant 0.000000e+00 : f32
 // CHECK-NEXT: %[[output:.*]] = affine.for %{{.*}} = 0 to 10 step 2 iter_args(%{{.*}} = %[[const_0]]) -> (f32) {
-// CHECK:        affine.if #set0(%{{.*}}) -> f32 {
+// CHECK:        affine.if #set(%{{.*}}) -> f32 {
 // CHECK:          affine.yield %{{.*}} : f32
 // CHECK-NEXT:   } else {
 // CHECK-NEXT:     affine.yield %{{.*}} : f32
 // CHECK-NEXT:   }
 // CHECK-NEXT:   affine.yield %{{.*}} : f32
 // CHECK-NEXT: }
 // CHECK-NEXT: return %[[output]] : f32
 

mlir/test/Dialect/SCF/for-loop-specialization.mlir

func @for(%outer: index, %A: memref<?xf32>, %B: memref<?xf32>,
   return
 }
 
 // CHECK-LABEL:   func @for(
 // CHECK-SAME:              [[ARG0:%.*]]: index, [[ARG1:%.*]]: memref<?xf32>, [[ARG2:%.*]]: memref<?xf32>, [[ARG3:%.*]]: memref<?xf32>, [[ARG4:%.*]]: memref<?xf32>) {
 // CHECK:           [[CST_0:%.*]] = constant 0 : index
 // CHECK:           [[CST_1:%.*]] = constant 1 : index
 // CHECK:           [[DIM_0:%.*]] = dim [[ARG1]], [[CST_0]] : memref<?xf32>
-// CHECK:           [[MIN:%.*]] = affine.min #map0(){{\[}}[[DIM_0]], [[ARG0]]]
+// CHECK:           [[MIN:%.*]] = affine.min #map(){{\[}}[[DIM_0]], [[ARG0]]]
 // CHECK:           [[CST_1024:%.*]] = constant 1024 : index
 // CHECK:           [[PRED:%.*]] = cmpi "eq", [[MIN]], [[CST_1024]] : index
 // CHECK:           scf.if [[PRED]] {
 // CHECK:             scf.for [[IDX0:%.*]] = [[CST_0]] to [[CST_1024]] step [[CST_1]] {
 // CHECK:               store
 // CHECK:             }
 // CHECK:           } else {
 // CHECK:             scf.for [[IDX0:%.*]] = [[CST_0]] to [[MIN]] step [[CST_1]] {
 // CHECK:               store
 // CHECK:             }
 // CHECK:           }
 // CHECK:           return
 // CHECK:         }

mlir/test/Dialect/SCF/parallel-loop-tiling.mlir

 // RUN: mlir-opt %s -pass-pipeline='func(parallel-loop-tiling{parallel-loop-tile-sizes=1,4})' -split-input-file | FileCheck %s
 
 func @parallel_loop(%arg0 : index, %arg1 : index, %arg2 : index,
                     %arg3 : index, %arg4 : index, %arg5 : index,
         %A: memref<?x?xf32>, %B: memref<?x?xf32>,
                     %C: memref<?x?xf32>, %result: memref<?x?xf32>) {
   scf.parallel (%i0, %i1) = (%arg0, %arg1) to (%arg2, %arg3) step (%arg4, %arg5) {
     %B_elem = load %B[%i0, %i1] : memref<?x?xf32>
     %C_elem = load %C[%i0, %i1] : memref<?x?xf32>
     %sum_elem = addf %B_elem, %C_elem : f32
     store %sum_elem, %result[%i0, %i1] : memref<?x?xf32>
   }
   return
 }
 
-// CHECK:       #map0 = affine_map<(d0, d1, d2) -> (d0, d1 - d2)>
+// CHECK:       #map = affine_map<(d0, d1, d2) -> (d0, d1 - d2)>
 // CHECK-LABEL:   func @parallel_loop(
 // CHECK-SAME:                        [[ARG1:%.*]]: index, [[ARG2:%.*]]: index, [[ARG3:%.*]]: index, [[ARG4:%.*]]: index, [[ARG5:%.*]]: index, [[ARG6:%.*]]: index, [[ARG7:%.*]]: memref<?x?xf32>, [[ARG8:%.*]]: memref<?x?xf32>, [[ARG9:%.*]]: memref<?x?xf32>, [[ARG10:%.*]]: memref<?x?xf32>) {
 // CHECK:           [[C0:%.*]] = constant 0 : index
 // CHECK:           [[C1:%.*]] = constant 1 : index
 // CHECK:           [[C4:%.*]] = constant 4 : index
 // CHECK:           [[V1:%.*]] = muli [[ARG5]], [[C1]] : index
 // CHECK:           [[V2:%.*]] = muli [[ARG6]], [[C4]] : index
 // CHECK:           scf.parallel ([[V3:%.*]], [[V4:%.*]]) = ([[ARG1]], [[ARG2]]) to ([[ARG3]], [[ARG4]]) step ([[V1]], [[V2]]) {
-// CHECK:             [[V5:%.*]] = affine.min #map0([[V1]], [[ARG3]], [[V3]])
-// CHECK:             [[V6:%.*]] = affine.min #map0([[V2]], [[ARG4]], [[V4]])
+// CHECK:             [[V5:%.*]] = affine.min #map([[V1]], [[ARG3]], [[V3]])
+// CHECK:             [[V6:%.*]] = affine.min #map([[V2]], [[ARG4]], [[V4]])
 // CHECK:             scf.parallel ([[V7:%.*]], [[V8:%.*]]) = ([[C0]], [[C0]]) to ([[V5]], [[V6]]) step ([[ARG5]], [[ARG6]]) {
 // CHECK:               [[V9:%.*]] = addi [[V7]], [[V3]] : index
 // CHECK:               [[V10:%.*]] = addi [[V8]], [[V4]] : index
 // CHECK:               [[V11:%.*]] = load [[ARG8]]{{\[}}[[V9]], [[V10]]] : memref<?x?xf32>
 // CHECK:               [[V12:%.*]] = load [[ARG9]]{{\[}}[[V9]], [[V10]]] : memref<?x?xf32>
 // CHECK:               [[V13:%.*]] = addf [[V11]], [[V12]] : f32
 // CHECK:               store [[V13]], [[ARG10]]{{\[}}[[V9]], [[V10]]] : memref<?x?xf32>
 // CHECK:             }

 // CHECK:           [[C1:%.*]] = constant 1 : index
 // CHECK:           scf.parallel ([[V1:%.*]], [[V2:%.*]]) = ([[C0]], [[C0]]) to ([[C2]], [[C2]]) step ([[C1]], [[C1]]) {
 // CHECK:             [[C0_1:%.*]] = constant 0 : index
 // CHECK:             [[C1_1:%.*]] = constant 1 : index
 // CHECK:             [[C4:%.*]] = constant 4 : index
 // CHECK:             [[V3:%.*]] = muli [[C1]], [[C1_1]] : index
 // CHECK:             [[V4:%.*]] = muli [[C1]], [[C4]] : index
 // CHECK:             scf.parallel ([[V5:%.*]], [[V6:%.*]]) = ([[C0]], [[C0]]) to ([[C2]], [[C2]]) step ([[V3]], [[V4]]) {
-// CHECK:               [[V7:%.*]] = affine.min #map0([[V4]], [[C2]], [[V6]])
+// CHECK:               [[V7:%.*]] = affine.min #map([[V4]], [[C2]], [[V6]])
 // CHECK:               scf.parallel ([[V8:%.*]], [[V9:%.*]]) = ([[C0_1]], [[C0_1]]) to ([[V3]], [[V7]]) step ([[C1]], [[C1]]) {
 // CHECK:                 = addi [[V8]], [[V5]] : index
 // CHECK:                 = addi [[V9]], [[V6]] : index
 // CHECK:               }
 // CHECK:             }
 // CHECK:           }
 // CHECK:           [[C0_2:%.*]] = constant 0 : index
 // CHECK:           [[C1_2:%.*]] = constant 1 : index
 // CHECK:           [[C4_1:%.*]] = constant 4 : index
 // CHECK:           [[V10:%.*]] = muli [[C1]], [[C1_2]] : index
 // CHECK:           [[V11:%.*]] = muli [[C1]], [[C4_1]] : index
 // CHECK:           scf.parallel ([[V12:%.*]], [[V13:%.*]]) = ([[C0]], [[C0]]) to ([[C2]], [[C2]]) step ([[V10]], [[V11]]) {
-// CHECK:             [[V14:%.*]] = affine.min #map0([[V11]], [[C2]], [[V13]])
+// CHECK:             [[V14:%.*]] = affine.min #map([[V11]], [[C2]], [[V13]])
 // CHECK:             scf.parallel ([[V15:%.*]], [[V16:%.*]]) = ([[C0_2]], [[C0_2]]) to ([[V10]], [[V14]]) step ([[C1]], [[C1]]) {
 // CHECK:               = addi [[V15]], [[V12]] : index
 // CHECK:               = addi [[V16]], [[V13]] : index
 // CHECK:             }
 // CHECK:           }
 // CHECK:           return
 // CHECK:         }

mlir/test/IR/memory-ops.mlir

 // RUN: mlir-opt %s | FileCheck %s
 
-// CHECK: #map0 = affine_map<(d0, d1)[s0] -> (d0 + s0, d1)>
+// CHECK: #map = affine_map<(d0, d1)[s0] -> (d0 + s0, d1)>
 
 // CHECK-LABEL: func @alloc() {
 func @alloc() {
 ^bb0:
   // Test simple alloc.
   // CHECK: %0 = alloc() : memref<1024x64xf32, 1>
   %0 = alloc() : memref<1024x64xf32, affine_map<(d0, d1) -> (d0, d1)>, 1>
 
   %c0 = "std.constant"() {value = 0: index} : () -> index
   %c1 = "std.constant"() {value = 1: index} : () -> index
 
   // Test alloc with dynamic dimensions.
   // CHECK: %1 = alloc(%c0, %c1) : memref<?x?xf32, 1>
   %1 = alloc(%c0, %c1) : memref<?x?xf32, affine_map<(d0, d1) -> (d0, d1)>, 1>
 
   // Test alloc with no dynamic dimensions and one symbol.
-  // CHECK: %2 = alloc()[%c0] : memref<2x4xf32, #map0, 1>
+  // CHECK: %2 = alloc()[%c0] : memref<2x4xf32, #map, 1>
   %2 = alloc()[%c0] : memref<2x4xf32, affine_map<(d0, d1)[s0] -> ((d0 + s0), d1)>, 1>
 
   // Test alloc with dynamic dimensions and one symbol.
-  // CHECK: %3 = alloc(%c1)[%c0] : memref<2x?xf32, #map0, 1>
+  // CHECK: %3 = alloc(%c1)[%c0] : memref<2x?xf32, #map, 1>
   %3 = alloc(%c1)[%c0] : memref<2x?xf32, affine_map<(d0, d1)[s0] -> (d0 + s0, d1)>, 1>
 
   // Alloc with no mappings.
   // b/116054838 Parser crash while parsing ill-formed AllocOp
   // CHECK: %4 = alloc() : memref<2xi32>
   %4 = alloc() : memref<2 x i32>
 
   // CHECK:   return
^bb0:
   %c0 = "std.constant"() {value = 0: index} : () -> index
   %c1 = "std.constant"() {value = 1: index} : () -> index
 
   // Test alloca with dynamic dimensions.
   // CHECK: %1 = alloca(%c0, %c1) : memref<?x?xf32, 1>
   %1 = alloca(%c0, %c1) : memref<?x?xf32, affine_map<(d0, d1) -> (d0, d1)>, 1>
 
   // Test alloca with no dynamic dimensions and one symbol.
-  // CHECK: %2 = alloca()[%c0] : memref<2x4xf32, #map0, 1>
+  // CHECK: %2 = alloca()[%c0] : memref<2x4xf32, #map, 1>
   %2 = alloca()[%c0] : memref<2x4xf32, affine_map<(d0, d1)[s0] -> ((d0 + s0), d1)>, 1>
 
   // Test alloca with dynamic dimensions and one symbol.
-  // CHECK: %3 = alloca(%c1)[%c0] : memref<2x?xf32, #map0, 1>
+  // CHECK: %3 = alloca(%c1)[%c0] : memref<2x?xf32, #map, 1>
   %3 = alloca(%c1)[%c0] : memref<2x?xf32, affine_map<(d0, d1)[s0] -> (d0 + s0, d1)>, 1>
 
   // Alloca with no mappings, but with alignment.
   // CHECK: %4 = alloca() {alignment = 64 : i64} : memref<2xi32>
   %4 = alloca() {alignment = 64} : memref<2 x i32>
 
   return
 }

mlir/test/Transforms/loop-fusion.mlir

affine.for %i1 = 0 to 10 {
     %v0 = affine.load %m[%i1] : memref<10xf32>
   }
 
   // IfOp in ForInst should prevent fusion.
   // CHECK:      affine.for %{{.*}} = 0 to 10 {
   // CHECK-NEXT:   affine.store %{{.*}}, %{{.*}}[%{{.*}}] : memref<10xf32>
   // CHECK-NEXT: }
   // CHECK:      affine.for %{{.*}} = 0 to 10 {
-  // CHECK-NEXT:   affine.if #set0(%{{.*}}) {
+  // CHECK-NEXT:   affine.if #set(%{{.*}}) {
   // CHECK-NEXT:   }
   // CHECK-NEXT:   affine.load %{{.*}}[%{{.*}}] : memref<10xf32>
   // CHECK-NEXT: }
   return
 }
 
 // -----
 

mlir/test/Transforms/loop-invariant-code-motion.mlir

affine.for %arg0 = 0 to 10 {
 
     }
   }
 
   // CHECK: %0 = alloc() : memref<10xf32>
   // CHECK-NEXT: %cst = constant 8.000000e+00 : f32
   // CHECK-NEXT: affine.for %arg0 = 0 to 10 {
   // CHECK-NEXT: %1 = affine.apply #map0(%arg0)
-  // CHECK-NEXT: affine.if #set0(%arg0, %1) {
+  // CHECK-NEXT: affine.if #set(%arg0, %1) {
   // CHECK-NEXT: %2 = addf %cst, %cst : f32
   // CHECK-NEXT: affine.store %2, %0[%arg0] : memref<10xf32>
   // CHECK-NEXT: }
 
 
   return
 }
 
affine.for %arg0 = 0 to 10 {
     }
   }
 
   // CHECK: %0 = alloc() : memref<10xf32>
   // CHECK-NEXT: %[[CST:.*]] = constant 8.000000e+00 : f32
   // CHECK-NEXT: affine.for %[[ARG:.*]] = 0 to 10 {
   // CHECK-NEXT: }
   // CHECK-NEXT: affine.for %[[ARG:.*]] = 0 to 10 {
-  // CHECK-NEXT: affine.if #set0(%[[ARG]], %[[ARG]]) {
+  // CHECK-NEXT: affine.if #set(%[[ARG]], %[[ARG]]) {
   // CHECK-NEXT: addf %[[CST]], %[[CST]] : f32
   // CHECK-NEXT: }
 
   return
 }
 
 // -----