Avoid BoundSymbol repeating itself in its subsymbols after functionalization

thunder/core/transform_common.py

@@ -848,6 +848,12 @@ def computation(x):
         new_bsyms.append(new_functional_bsym)
         bsym_inplace_to_functional[new_bsym] = new_functional_bsym
 
+        if (
+            len(new_functional_bsym.subsymbols) == 1
+            and new_functional_bsym.rhs == new_functional_bsym.subsymbols[0].rhs
+        ):
+            new_functional_bsym.subsymbols = new_functional_bsym.subsymbols[0].subsymbols
+
     required_copy_bsyms, swap_map_for_return = collect_required_copy_bsyms_for_args(
         intermediate_trace,
         removed_copy_bsyms,

thunder/tests/test_inplace_functionalization.py

@@ -455,3 +455,32 @@ def f(a, b):
     b_out = jitted(a, b)
     torch.testing.assert_close(b_out, b__out)
     assert b.data_ptr() == b_out.data_ptr()
+
+
+@instantiate(
+    dtypes=NOTHING,
+)
+def test_no_self_repeat_in_subsymbols(executor, device, _):
+
+    def f(a, b, c):
+        a.add_(b, alpha=c)
+        return a.add_(b, alpha=c)
+
+    def functional_f(a, b, c):
+        d = a.add(b, alpha=c)
+        return d.add(b, alpha=c)
+
+    a = make_tensor((2, 2), device=device, dtype=torch.float32)
+    b = make_tensor((2, 2), device=device, dtype=torch.float32)
+    c = make_tensor((1,), device=device, dtype=torch.float32)
+
+    a_out_ref = executor.make_callable(functional_f)(a, b, c)
+
+    jitted = executor.make_callable(f)
+    a_out = jitted(a, b, c)
+    torch.testing.assert_close(a_out, a_out_ref)
+
+    traces = thunder.last_traces(jitted)
+    for t in filter(lambda t: t._provenance is not None and "Functionalize in-place ops" in t._provenance.pss, traces):
+        for bsym in filter(lambda b: b.subsymbols, t.bound_symbols):
+            assert bsym.rhs != bsym.subsymbols[0].rhs, bsym