Write a placeholder for repro inputs that have no source form

Accepting a FakeScriptObject as its own example-input metadata let a graph
taking a DeviceMesh reach the reproducer writer, where arg_like raised
TypeError: it only knew how to write tensors, numbers and sequences. A
DeviceMesh has no source form to write down -- it needs a live process
group -- so there is nothing arg_like could emit that would run.

Write None for it, and for an input that could not be inferred, which is
what the warning above the input list already promises. The script is then
one the reader can finish rather than one that cannot be generated at all.

That warning was being built and then dropped: the non-serialized branch
assigned over input_str instead of appending to it, so the holes arrived
unexplained. Append, and raise the warning for a FakeScriptObject too.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

Author: bhimrazy

thunder/dynamo/report.py

@@ -13,6 +13,7 @@
 import shutil
 
 import torch
+from torch._library.fake_class_registry import FakeScriptObject
 from thunder.core.pytree import tree_flatten
 from thunder.core.utils import sequencify, create_python_callable_from_bsym
 from thunder.dynamo.compiler import thunderfx, ThunderCompiler
@@ -210,7 +211,12 @@ class FXGraphReport:
     reproduction and benchmarking scripts for various executors.
     """
 
-    def __init__(self, graph: torch.fx.GraphModule, graph_name: str, example_input_meta: list[ExampleInputMetaData]):
+    def __init__(
+        self,
+        graph: torch.fx.GraphModule,
+        graph_name: str,
+        example_input_meta: list[ExampleInputMetaData | FakeScriptObject],
+    ):
         if LooseVersion(torch.__version__) < LooseVersion("2.6.0"):
             # NOTE: PyTorch 2.6 changes the structure of GraphModule for higher order ops.
             # In newer torch version the higher order ops are nested as submodules within the module that uses them,
@@ -293,15 +299,15 @@ def write_inductor_repro(self, folder, use_benchmark: bool = False, serialize_in
 
     def _get_input_str(self, folder, inputs, serialize_inputs):
         input_str = ""
-        if any(arg is None for arg in inputs):
+        if any(arg is None or isinstance(arg, FakeScriptObject) for arg in inputs):
             input_str += "# Warning: The inputs that cannot be inferred are set to None, requiring the user to manually give inputs according to the code\n"
         if serialize_inputs:
             example_inputs = self.make_example_inputs()
             input_file_name = folder / f"{self.graph_name}_inputs.pt"
             torch.save(example_inputs, input_file_name)
             input_str += f"{INPUTS_NAME} = torch.load('{input_file_name}')\n"
         else:
-            input_str = f"{INPUTS_NAME} = [\n"
+            input_str += f"{INPUTS_NAME} = [\n"
             input_str += textwrap.indent("\n".join(arg_like(a) for a in inputs), "    ")
             input_str += "\n]"
         return input_str

thunder/dynamo/utils.py

@@ -148,7 +148,7 @@ class SubgraphInfo:
     original_split_graph_module: torch.fx.GraphModule | None
     split_graph_module: torch.fx.GraphModule | None
     thunder_compiled_fns: list[Callable] | None
-    thunder_compiled_fns_example_inputs: list[list[ExampleInputMetaData]] | None
+    thunder_compiled_fns_example_inputs: list[list[ExampleInputMetaData | FakeScriptObject]] | None
     submodule_to_compiled_functions: dict[torch.fx.GraphModule, CompiledFunction]
     split_reasons: list | None = None
 
@@ -875,6 +875,11 @@ def arg_like(arg: Any):
         return "[" + "".join(arg_like(a) for a in arg) + "],"
     elif isinstance(arg, (int, bool, float)):
         return f"{arg},"
+    elif arg is None or isinstance(arg, FakeScriptObject):
+        # Nothing here has a source form to write down: a DeviceMesh needs a live process group,
+        # and a placeholder we could not infer is already None. Leave a hole for the reader to
+        # fill, which is what the warning _get_input_str puts above the inputs promises.
+        return "None,"
     else:
         raise TypeError(f"Unsupported input type: {type(arg)}")