When converting a proc alias to IR, use the alias name in the IR.

PiperOrigin-RevId: 820685674

Author: richmckeever

xls/dslx/frontend/proc_id.h

@@ -53,10 +53,18 @@ struct ProcId {
   //    [{A, 0}, {E, 0}, {B, 0}, {C, 0}]
   std::vector<std::pair<Proc*, int>> proc_instance_stack;
 
+  // The name of the proc alias, in a situation where we are converting a proc
+  // to IR via an alias to it.
+  std::optional<std::string> alias_name;
+
   std::string ToString() const {
     if (proc_instance_stack.empty()) {
       return "";
     }
+    if (proc_instance_stack.size() == 1 && alias_name.has_value()) {
+      return *alias_name;
+    }
+
     // The first proc in a chain never needs an instance count. Leaving it out
     // specifically when the chain length is more than 1 gets us the historical
     // output in most cases (where there was only an instance count at the end

xls/dslx/ir_convert/extract_conversion_order.cc

@@ -649,22 +649,25 @@ static absl::StatusOr<std::vector<ConversionRecord>> GetOrderForProc(
   TypeInfo* config_ti = type_info;
   TypeInfo* next_ti = type_info;
   ParametricEnv env;
+  std::optional<std::string> alias_name;
   if (resolved_proc_alias.has_value()) {
     config_ti = resolved_proc_alias->config_type_info;
     next_ti = resolved_proc_alias->next_type_info;
     env = resolved_proc_alias->env;
+    alias_name = resolved_proc_alias->name;
   }
 
   // The next function of a proc is the entry function when converting a proc to
   // IR.
-  XLS_RETURN_IF_ERROR(
-      AddToReady(&p->next(),
-                 /*invocation=*/nullptr, p->owner(), next_ti, env, &ready,
-                 ProcId{.proc_instance_stack = {{p, 0}}}, is_top));
-  XLS_RETURN_IF_ERROR(AddToReady(&p->config(),
-                                 /*invocation=*/nullptr, p->owner(), config_ti,
-                                 env, &ready,
-                                 ProcId{.proc_instance_stack = {{p, 0}}}));
+  XLS_RETURN_IF_ERROR(AddToReady(
+      &p->next(),
+      /*invocation=*/nullptr, p->owner(), next_ti, env, &ready,
+      ProcId{.proc_instance_stack = {{p, 0}}, .alias_name = alias_name},
+      is_top));
+  XLS_RETURN_IF_ERROR(AddToReady(
+      &p->config(),
+      /*invocation=*/nullptr, p->owner(), config_ti, env, &ready,
+      ProcId{.proc_instance_stack = {{p, 0}}, .alias_name = alias_name}));
 
   // Constants and "member" vars are assigned and defined in Procs' "config'"
   // functions, so we need to execute those before their "next" functions.

xls/dslx/ir_convert/function_converter.cc

@@ -828,22 +828,21 @@ absl::Status FunctionConverter::HandleExternNameRef(
       imported_info->module->FindMemberWithName(node->identifier());
   XLS_RET_CHECK(member.has_value());
   return absl::visit(
-      Visitor{
-          [&](Function* f) { return DefAlias(f, /*to=*/node); },
-          [&](ConstantDef* c) -> absl::Status {
-            XLS_RET_CHECK(node_to_ir_.contains(c->value()))
-                << absl::StreamFormat(
-                       "ConstantDef `%s` not found in node_to_ir_ map",
-                       c->ToString());
-            return DefAlias(c->value(), /*to=*/node);
-          },
-          [&](auto) {
-            return absl::UnimplementedError(absl::StrFormat(
-                "Unsupported module member type %s for external name "
-                "reference: `%s` @ %s",
-                GetModuleMemberTypeName(*member.value()), node->identifier(),
-                node->span().ToString(file_table())));
-          }},
+      Visitor{[&](Function* f) { return DefAlias(f, /*to=*/node); },
+              [&](ConstantDef* c) -> absl::Status {
+                XLS_RET_CHECK(node_to_ir_.contains(c->value()))
+                    << absl::StreamFormat(
+                           "ConstantDef `%s` not found in node_to_ir_ map",
+                           c->ToString());
+                return DefAlias(c->value(), /*to=*/node);
+              },
+              [&](auto) {
+                return absl::UnimplementedError(absl::StrFormat(
+                    "Unsupported module member type %s for external name "
+                    "reference: `%s` @ %s",
+                    GetModuleMemberTypeName(*member.value()),
+                    node->identifier(), node->span().ToString(file_table())));
+              }},
       *member.value());
 }
 
@@ -3466,11 +3465,23 @@ absl::Status FunctionConverter::HandleProcNextFunction(
             << initial_element.ToHumanString();
   }
 
-  XLS_ASSIGN_OR_RETURN(
-      std::string mangled_name,
-      MangleDslxName(module_->name(), proc_id.ToString(),
-                     CallingConvention::kProcNext, f->GetFreeParametricKeySet(),
-                     parametric_env));
+  std::string mangled_name;
+  if (proc_id.alias_name.has_value() &&
+      proc_id.proc_instance_stack.size() == 1) {
+    // Don't include the parametrics for the target proc in the mangled name of
+    // a proc alias.
+    XLS_ASSIGN_OR_RETURN(
+        mangled_name, MangleDslxName(module_->name(), proc_id.ToString(),
+                                     CallingConvention::kProcNext,
+                                     absl::btree_set<std::string>{}, nullptr));
+  } else {
+    XLS_ASSIGN_OR_RETURN(
+        mangled_name,
+        MangleDslxName(module_->name(), proc_id.ToString(),
+                       CallingConvention::kProcNext,
+                       f->GetFreeParametricKeySet(), parametric_env));
+  }
+
   std::string token_name = "__token";
   std::string state_name = "__state";
 

xls/dslx/ir_convert/testdata/ir_converter_test_HandlesBasicProcAlias.ir

@@ -4,7 +4,7 @@ file_number 0 "test_module.x"
 
 chan test_module__output_c(bits[32], id=0, kind=streaming, ops=send_only, flow_control=ready_valid, strictness=proven_mutually_exclusive)
 
-top proc __test_module__Foo_0_next(__state: bits[32], init={1}) {
+top proc __test_module__FooAlias_next(__state: bits[32], init={1}) {
   __state: bits[32] = state_read(state_element=__state, id=2)
   literal.6: bits[32] = literal(value=2, id=6)
   after_all.4: token = after_all(id=4)

xls/dslx/ir_convert/testdata/ir_converter_test_HandlesParametricProcAlias.ir

@@ -4,7 +4,7 @@ file_number 0 "test_module.x"
 
 chan test_module__output_c(bits[16], id=0, kind=streaming, ops=send_only, flow_control=ready_valid, strictness=proven_mutually_exclusive)
 
-top proc __test_module__Foo_0__16_next(__state: bits[16], init={1}) {
+top proc __test_module__FooAlias_next(__state: bits[16], init={1}) {
   __state: bits[16] = state_read(state_element=__state, id=2)
   literal.7: bits[16] = literal(value=2, id=7)
   after_all.5: token = after_all(id=5)

xls/dslx/ir_convert/testdata/ir_converter_test_HandlesProcAliasToImportedProc.ir

@@ -4,7 +4,7 @@ file_number 0 "imported.x"
 
 chan test_module__output_c(bits[16], id=0, kind=streaming, ops=send_only, flow_control=ready_valid, strictness=proven_mutually_exclusive)
 
-top proc __imported__Foo_0__16_next(__state: bits[16], init={1}) {
+top proc __imported__FooAlias_next(__state: bits[16], init={1}) {
   __state: bits[16] = state_read(state_element=__state, id=2)
   literal.7: bits[16] = literal(value=2, id=7)
   after_all.5: token = after_all(id=5)

xls/dslx/type_system/type_info.h

@@ -75,6 +75,7 @@ struct InvocationCalleeData {
 
 // The information for a `ProcAlias` that is resolved during type inference.
 struct ResolvedProcAlias {
+  std::string name;
   Proc* proc;
   ParametricEnv env;
   TypeInfo* config_type_info;

xls/dslx/type_system_v2/inference_table_converter_impl.cc

@@ -2391,7 +2391,8 @@ class InferenceTableConverterImpl : public InferenceTableConverter,
 
     // For a non-parametric proc, that's it.
     if (alias->parametrics().empty()) {
-      return ResolvedProcAlias{.proc = proc,
+      return ResolvedProcAlias{.name = alias->identifier(),
+                               .proc = proc,
                                .env = ParametricEnv{},
                                .config_type_info = ti,
                                .next_type_info = ti};
@@ -2454,7 +2455,8 @@ class InferenceTableConverterImpl : public InferenceTableConverter,
       XLS_RETURN_IF_ERROR(ConvertSubtree(member, std::nullopt, next_context));
     }
 
-    return ResolvedProcAlias{.proc = proc,
+    return ResolvedProcAlias{.name = alias->identifier(),
+                             .proc = proc,
                              .env = env,
                              .config_type_info = config_ti,
                              .next_type_info = next_ti};