[mlir][NFC] Switched `interfaces` to a private member of SSANameState.

[izuk]

Summary

interfaces is passed through to the numberValuesIn* functions with exactly
the same value as when SSANameState is constructed. This just seems cleaner.

Also, a dependent PR adds printerFlags which follows similar code paths.

[mehdi_amini]

Please add a description to your commit message which includes the context/motivation for the change ( https://mlir.llvm.org/getting_started/Contributing/#commit-messages )

Also if this seems NFC? (tag the title)

[izuk]

Updated the PR description.

[mehdi_amini]

LGTM, let me know if you need someone to land this for you!

mlir/lib/IR/AsmPrinter.cpp

 
 /// This class implements a dummy OpAsmPrinter that doesn't print any output,
 /// and merely collects the attributes and types that *would* be printed in a
 /// normal print invocation so that we can generate proper aliases. This allows
 /// for us to generate aliases only for the attributes and types that would be
 /// in the output, and trims down unnecessary output.
 class DummyAliasOperationPrinter : private OpAsmPrinter {
 public:
-  explicit DummyAliasOperationPrinter(const OpPrintingFlags &flags,
+  explicit DummyAliasOperationPrinter(const OpPrintingFlags &printerFlags,
                                       AliasInitializer &initializer)
-      : printerFlags(flags), initializer(initializer) {}
+      : printerFlags(printerFlags), initializer(initializer) {}
 
   /// Print the given operation.
   void print(Operation *op) {
     // Visit the operation location.
     if (printerFlags.shouldPrintDebugInfo())
       initializer.visit(op->getLoc(), /*canBeDeferred=*/true);
 
     // If requested, always print the generic form.
public:
 
   /// Renumber the arguments for the specified region to the same names as the
   /// SSA values in namesToUse. See OperationPrinter::shadowRegionArgs for
   /// details.
   void shadowRegionArgs(Region &region, ValueRange namesToUse);
 
 private:
   /// Number the SSA values within the given IR unit.
-  void numberValuesInRegion(
-      Region &region,
-      DialectInterfaceCollection<OpAsmDialectInterface> &interfaces);
-  void numberValuesInBlock(
-      Block &block,
-      DialectInterfaceCollection<OpAsmDialectInterface> &interfaces);
-  void numberValuesInOp(
-      Operation &op,
-      DialectInterfaceCollection<OpAsmDialectInterface> &interfaces);
+  void numberValuesInRegion(Region &region);
+  void numberValuesInBlock(Block &block);
+  void numberValuesInOp(Operation &op);
 
   /// Given a result of an operation 'result', find the result group head
   /// 'lookupValue' and the result of 'result' within that group in
   /// 'lookupResultNo'. 'lookupResultNo' is only filled in if the result group
   /// has more than 1 result.
   void getResultIDAndNumber(OpResult result, Value &lookupValue,
                             Optional<int> &lookupResultNo) const;
 
private:
   llvm::BumpPtrAllocator usedNameAllocator;
 
   /// This is the next value ID to assign in numbering.
   unsigned nextValueID = 0;
   /// This is the next ID to assign to a region entry block argument.
   unsigned nextArgumentID = 0;
   /// This is the next ID to assign when a name conflict is detected.
   unsigned nextConflictID = 0;
+
+  DialectInterfaceCollection<OpAsmDialectInterface> &interfaces;
 };
 } // end anonymous namespace
 
 SSANameState::SSANameState(
     Operation *op,
-    DialectInterfaceCollection<OpAsmDialectInterface> &interfaces) {
+    DialectInterfaceCollection<OpAsmDialectInterface> &interfaces)
+    : interfaces(interfaces) {
   llvm::SaveAndRestore<unsigned> valueIDSaver(nextValueID);
   llvm::SaveAndRestore<unsigned> argumentIDSaver(nextArgumentID);
   llvm::SaveAndRestore<unsigned> conflictIDSaver(nextConflictID);
 
   // The naming context includes `nextValueID`, `nextArgumentID`,
   // `nextConflictID` and `usedNames` scoped HashTable. This information is
   // carried from the parent region.
   using UsedNamesScopeTy = llvm::ScopedHashTable<StringRef, char>::ScopeTy;
   using NamingContext =
       std::tuple<Region *, unsigned, unsigned, unsigned, UsedNamesScopeTy *>;
 
   // Allocator for UsedNamesScopeTy
   llvm::BumpPtrAllocator allocator;
 
   // Add a scope for the top level operation.
   auto *topLevelNamesScope =
       new (allocator.Allocate<UsedNamesScopeTy>()) UsedNamesScopeTy(usedNames);
 
   SmallVector<NamingContext, 8> nameContext;
   for (Region &region : op->getRegions())
     nameContext.push_back(std::make_tuple(&region, nextValueID, nextArgumentID,
                                           nextConflictID, topLevelNamesScope));
 
-  numberValuesInOp(*op, interfaces);
+  numberValuesInOp(*op);
 
   while (!nameContext.empty()) {
     Region *region;
     UsedNamesScopeTy *parentScope;
     std::tie(region, nextValueID, nextArgumentID, nextConflictID, parentScope) =
         nameContext.pop_back_val();
 
     // When we switch from one subtree to another, pop the scopes(needless)
     // until the parent scope.
     while (usedNames.getCurScope() != parentScope) {
       usedNames.getCurScope()->~UsedNamesScopeTy();
       assert((usedNames.getCurScope() != nullptr || parentScope == nullptr) &&
              "top level parentScope must be a nullptr");
     }
 
     // Add a scope for the current region.
     auto *curNamesScope = new (allocator.Allocate<UsedNamesScopeTy>())
         UsedNamesScopeTy(usedNames);
 
-    numberValuesInRegion(*region, interfaces);
+    numberValuesInRegion(*region);
 
     for (Operation &op : region->getOps())
       for (Region &region : op.getRegions())
         nameContext.push_back(std::make_tuple(&region, nextValueID,
                                               nextArgumentID, nextConflictID,
                                               curNamesScope));
   }
 
for (unsigned i = 0, e = namesToUse.size(); i != e; ++i) {
     // Use the name without the leading %.
     auto name = StringRef(nameStream.str()).drop_front();
 
     // Overwrite the name.
     valueNames[nameToReplace] = name.copy(usedNameAllocator);
   }
 }
 
-void SSANameState::numberValuesInRegion(
-    Region &region,
-    DialectInterfaceCollection<OpAsmDialectInterface> &interfaces) {
+void SSANameState::numberValuesInRegion(Region &region) {
   // Number the values within this region in a breadth-first order.
   unsigned nextBlockID = 0;
   for (auto &block : region) {
     // Each block gets a unique ID, and all of the operations within it get
     // numbered as well.
     blockIDs[&block] = nextBlockID++;
-    numberValuesInBlock(block, interfaces);
+    numberValuesInBlock(block);
   }
 }
 
-void SSANameState::numberValuesInBlock(
-    Block &block,
-    DialectInterfaceCollection<OpAsmDialectInterface> &interfaces) {
+void SSANameState::numberValuesInBlock(Block &block) {
   auto setArgNameFn = [&](Value arg, StringRef name) {
     assert(!valueIDs.count(arg) && "arg numbered multiple times");
     assert(arg.cast<BlockArgument>().getOwner() == &block &&
            "arg not defined in 'block'");
     setValueName(arg, name);
   };
 
   bool isEntryBlock = block.isEntryBlock();
if (isEntryBlock) {
       specialNameBuffer.resize(strlen("arg"));
       specialName << nextArgumentID++;
     }
     setValueName(arg, specialName.str());
   }
 
   // Number the operations in this block.
   for (auto &op : block)
-    numberValuesInOp(op, interfaces);
+    numberValuesInOp(op);
 }
 
-void SSANameState::numberValuesInOp(
-    Operation &op,
-    DialectInterfaceCollection<OpAsmDialectInterface> &interfaces) {
+void SSANameState::numberValuesInOp(Operation &op) {
   unsigned numResults = op.getNumResults();
   if (numResults == 0)
     return;
   Value resultBegin = op.getResult(0);
 
   // Function used to set the special result names for the operation.
   SmallVector<int, 2> resultGroups(/*Size=*/1, /*Value=*/0);
   auto setResultNameFn = [&](Value result, StringRef name) {
private:
   /// The state used for attribute and type aliases.
   AliasState aliasState;
 
   /// The state used for SSA value names.
   SSANameState nameState;
 
   /// An optional location map to be populated.
   AsmState::LocationMap *locationMap;
+
+  OpPrintingFlags printerFlags;
 };
 } // end namespace detail
 } // end namespace mlir
 
 AsmState::AsmState(Operation *op, LocationMap *locationMap)
     : impl(std::make_unique<AsmStateImpl>(op, locationMap)) {}
 AsmState::~AsmState() {}