Prevent edge_transform_passes from running twice during recipe-based lowering (pytorch#23005)

### Summary
After a recent change, the `edge_transform_passes` were also run by the
`EdgeProgramManagerTransformStage` as well as the
`EdgeTransformAndLowerStage`, resulting in a double application. This PR
removes them from the `EdgeProgramManagerTransformStage`.

### Test plan
`pytest export/tests/test_export_session.py`

Author: MartinPavella

export/recipe.py

@@ -207,9 +207,12 @@ class LoweringRecipe:
                       per-method partitioner lists. Use the dict form when
                       backends need per-method compile specs.
         edge_transform_passes: Optional list of callables that take (method_name: str, exported_program: ExportedProgram)
-                               and return either List[PassType] or PassManager to be applied during edge lowering.
+                               and return either List[PassType] or PassManager. Applied during
+                               TO_EDGE_TRANSFORM_AND_LOWER as per-ExportedProgram graph-module passes.
         edge_manager_transform_passes: Optional list of callables that take EdgeProgramManager as argument
-                                        and return passes to be applied. Applied sequentially after TO_EDGE stage.
+                                        and return passes to be applied. Applied sequentially by
+                                        EDGE_PROGRAM_MANAGER_TRANSFORM, which runs after
+                                        TO_EDGE_TRANSFORM_AND_LOWER in the default pipeline.
         edge_compile_config: Optional edge compilation configuration
         pre_partitioning_callback: Optional callable invoked just before partitioning with
                                    `(partitioners, programs)` arguments.

export/stages.py

@@ -734,14 +734,6 @@ class EdgeProgramManagerTransformStage(Stage):
 
     def __init__(
         self,
-        edge_transform_passes: (
-            None
-            | List[
-                Callable[
-                    [str, ExportedProgram], List[PassType] | GraphModulePassManager
-                ]
-            ]
-        ) = None,
         edge_manager_transform_passes: (
             None
             | List[
@@ -759,7 +751,6 @@ def __init__(
                                            backends to control pass ordering and dependencies.
         """
         super().__init__()
-        self._edge_transform_passes = edge_transform_passes or []
         self._edge_manager_transform_passes = edge_manager_transform_passes or []
 
     @classmethod
@@ -770,7 +761,6 @@ def from_recipe(
             return cls()
 
         return cls(
-            edge_transform_passes=lowering_recipe.edge_transform_passes,
             edge_manager_transform_passes=lowering_recipe.edge_manager_transform_passes,
         )
 
@@ -803,35 +793,10 @@ def run(self, artifact: PipelineArtifact) -> None:
                 f"Expected EdgeProgramManager but got {type(edge_program_manager)}"
             )
 
-        if not self._edge_transform_passes and not self._edge_manager_transform_passes:
+        if not self._edge_manager_transform_passes:
             self._artifact = artifact
             return
 
-        # Detect if any callable returns PassManager
-        pass_manager = None
-        transform_passes = defaultdict(list)
-        for method_name in edge_program_manager.methods:
-            # Resolve transform passes if it's a callable
-            ep = edge_program_manager.exported_program(method_name)
-            for pass_callable in self._edge_transform_passes or []:
-                if not callable(pass_callable):
-                    raise ValueError(
-                        "Transform passes must be a callable that resolves to passes"
-                    )
-                passes = pass_callable(method_name, ep)
-                if isinstance(passes, GraphModulePassManager):
-                    pass_manager = passes
-                    break
-                else:
-                    transform_passes[method_name].extend(passes)
-            if pass_manager:
-                break
-
-        # See EdgeTransformAndLowerStage.run.
-        final_passes = pass_manager or _drop_empty(transform_passes) or None
-        if final_passes is not None:
-            edge_program_manager = edge_program_manager.transform(final_passes)
-
         # Run edge manager transform passes
         for pass_callable in self._edge_manager_transform_passes:
             passes = pass_callable(edge_program_manager)

export/tests/test_export_session.py

@@ -757,6 +757,30 @@ def test_no_transform_passes_means_no_stage(self) -> None:
             StageType.EDGE_PROGRAM_MANAGER_TRANSFORM, session._get_default_pipeline()
         )
 
+    def test_edge_transform_passes_not_duplicated_in_default_pipeline(self) -> None:
+        # Before the fix, from_recipe() gave edge_transform_passes to
+        # EDGE_PROGRAM_MANAGER_TRANSFORM as well as TO_EDGE_TRANSFORM_AND_LOWER,
+        # so they ran twice. Verify the stage no longer holds them at all.
+        from executorch.export.stages import EdgeProgramManagerTransformStage
+
+        edge_pass = Mock()
+        epm_pass = Mock()
+
+        stage = EdgeProgramManagerTransformStage.from_recipe(
+            LoweringRecipe(
+                edge_transform_passes=[edge_pass],
+                edge_manager_transform_passes=[epm_pass],
+            )
+        )
+
+        # The stage must only know about edge_manager_transform_passes.
+        self.assertEqual(stage._edge_manager_transform_passes, [epm_pass])
+        self.assertFalse(
+            hasattr(stage, "_edge_transform_passes"),
+            "EdgeProgramManagerTransformStage must not hold edge_transform_passes "
+            "because TO_EDGE_TRANSFORM_AND_LOWER already applies them.",
+        )
+
     def test_example_inputs_required_for_nn_module(self) -> None:
         """Test that example_inputs are required for nn.Module."""
         with self.assertRaises(ValueError) as cm: