Per-Fusion name counters fix duplicate TV names after copy

Move val/expr name counters from IrContainer to Fusion so each Fusion
independently tracks name assignment. This fixes CI failures where
Fusion::copy left the dest counter at N (number of cloned vals) instead
of max(name)+1 when source names were non-sequential, causing newly
created TVs to collide with existing names.

The fix adds val_type_name_map_ and expr_name_counter_ to Fusion, and
updates registerVal/registerExpr to use the Fusion-level counters.
Fusion::copy syncs counters from source to dest after cloning.
Fusion::swap exchanges counters. Fusion::clear resets them.

Author: mdavis36

csrc/fusion.cpp

@@ -157,6 +157,8 @@ void Fusion::swap(Fusion& a, Fusion& b) noexcept {
   std::swap(a.magic_zero_val_, b.magic_zero_val_);
   std::swap(a.axioms_, b.axioms_);
   std::swap(a.metadata_, b.metadata_);
+  std::swap(a.val_type_name_map_, b.val_type_name_map_);
+  std::swap(a.expr_name_counter_, b.expr_name_counter_);
 
   // Update Statement::ir_container_ pointers: a's old statements now belong
   // to b, and b's old statements now belong to a
@@ -208,6 +210,16 @@ IrCloner Fusion::copy(const Fusion* from, Fusion* to) {
     ir_cloner.clone(val);
   }
 
+  // Sync per-Fusion name counters from source to dest.
+  // During cloning, registerVal increments the dest Fusion's counter for each
+  // val, then IrBuilder::clone overrides the name with setName(src->name()).
+  // If source names are non-sequential (e.g., {0..10, 22..27} from segmenter
+  // creating intermediate TVs), the dest counter ends up at N (number of vals)
+  // instead of max(name)+1. Copying the source's counter state ensures new
+  // vals created post-copy won't collide with existing names.
+  to->val_type_name_map_ = from->val_type_name_map_;
+  to->expr_name_counter_ = from->expr_name_counter_;
+
   // Wire up definitions and uses on cloned vals
   for (auto val : from->vals()) {
     ir_cloner.clone(val)->setDefinition(ir_cloner.clone(val->definition_));
@@ -366,6 +378,9 @@ void Fusion::clear() noexcept {
   axioms_.reset();
   metadata_.clear();
 
+  val_type_name_map_.clear();
+  expr_name_counter_ = 0;
+
   invalidateTvsAndUses();
 
   is_during_update_uses_ = false;
@@ -975,7 +990,7 @@ void Fusion::registerVal(Val* val) {
   c->vals_up_.emplace_back(val);
   c->vals_.insert(val);
   c->per_fusion_vals_[this].insert(val);
-  val->setName(IrContainerPasskey(), c->getValName(val->vtype()));
+  val->setName(IrContainerPasskey(), getValName(val->vtype()));
 }
 
 void Fusion::registerExpr(Expr* expr) {
@@ -992,7 +1007,7 @@ void Fusion::registerExpr(Expr* expr) {
   c->exprs_up_.emplace_back(expr);
   c->exprs_.insert(expr);
   c->per_fusion_exprs_[this].insert(expr);
-  expr->setName(IrContainerPasskey(), c->getExprName());
+  expr->setName(IrContainerPasskey(), getExprName());
 
   for (Val* input : expr->inputs()) {
     assertInContainer(input, "Input to expr is invalid, ");

csrc/fusion.h

@@ -660,6 +660,24 @@ class NVF_API Fusion : public PolymorphicBase {
   std::unique_ptr<std::vector<Val*>> axioms_;
 
   std::unordered_map<Val*, std::pair<Val*, Expr*>> metadata_;
+
+  // Per-Fusion name counters. Each Fusion independently tracks name assignment
+  // so that cloned Fusions get matching names (T0→T0) regardless of whether
+  // they share an IrContainer. This is required by downstream consumers that
+  // use tv->name() as a map key (alias_memory, GreedyParams, etc.).
+  std::unordered_map<ValType, StmtNameType> val_type_name_map_;
+  StmtNameType expr_name_counter_ = 0;
+
+  StmtNameType getValName(ValType vtype) {
+    if (val_type_name_map_.find(vtype) == val_type_name_map_.end()) {
+      val_type_name_map_[vtype] = 0;
+    }
+    return val_type_name_map_[vtype]++;
+  }
+
+  StmtNameType getExprName() {
+    return expr_name_counter_++;
+  }
 };
 
 // Template implementations for Fusion::manage<T>() that use IrCloner