Restore mlir-opt `--run-reproducer` option to opt-in running a reproducer

[mehdi_amini]

Summary

When tooling out there produces a reproducer that is archived, the first thing
a user is likely to expect is to process this as they do with any MLIR file.
However https://reviews.llvm.org/D126447 changed the behavior of mlir-opt to
eliminate the --run-reproducer option and instead automatically run it when
present in the input file. This creates a discrepancy in how mlir-opt behaves
when fed with an input file, and is surprising for users.
The explicit passing of --run-reproducer to express user-intent seems more
in line with what is expected from mlir-opt.

[rkayaith]

mlir/include/mlir/Tools/mlir-opt/MlirOptMain.h

119

docstring needs updating

mlir/lib/Tools/mlir-opt/MlirOptMain.cpp

261–263

Can you guard the reproOptions.attachResourceParser(parseConfig) line instead/as well, right now the resource would be "consumed" even if unused, and won't appear in the output IR.

mlir/docs/PassManagement.md

mlir_reproducer: {
       pipeline: "builtin.module(func.func(cse,canonicalize),inline)",
       disable_threading: true,
       verify_each: true
     }
   }
 #-}
 ```
 
-The configuration dumped can be passed to `mlir-opt`. This will result in
-parsing the configuration of the reproducer and adjusting the necessary opt
-state, e.g. configuring the pass manager, context, etc.
+The configuration dumped can be passed to `mlir-opt` by specifying
+`-run-reproducer` flag. This will result in parsing the configuration of the reproducer
+and adjusting the necessary opt state, e.g. configuring the pass manager, context, etc.
 
 Beyond specifying a filename, one can also register a `ReproducerStreamFactory`
 function that would be invoked in the case of a crash and the reproducer written
 to its stream.
 
 ### Local Reproducer Generation
 
 An additional flag may be passed to

mlir/include/mlir/Tools/mlir-opt/MlirOptMain.h

public:
 
   /// Populate the passmanager, if any callback was set.
   LogicalResult setupPassPipeline(PassManager &pm) const {
     if (passPipelineCallback)
       return passPipelineCallback(pm);
     return success();
   }
 
+  /// Enable running the reproducer information stored in resources (if
+  /// present).
+  MlirOptMainConfig &runReproducer(bool enableReproducer) {
+    runReproducerFlag = enableReproducer;
+    return *this;
+  };
+
+  /// Return true if the reproducer should be run.
+  bool shouldRunReproducer() const { return runReproducerFlag; }
+
   /// Show the registered dialects before trying to load the input file.
   MlirOptMainConfig &showDialects(bool show) {
     showDialectsFlag = show;
     return *this;
   }
   bool shouldShowDialects() const { return showDialectsFlag; }
 
   /// Set whether to split the input file based on the `// -----` marker into
protected:
   std::vector<tracing::BreakpointManager *> logActionLocationFilter;
 
   /// Emit bytecode at given version.
   std::optional<int64_t> emitBytecodeVersion = std::nullopt;
 
   /// The callback to populate the pass manager.
   std::function<LogicalResult(PassManager &)> passPipelineCallback;
 
+  /// Enable running the reproducer.
+  bool runReproducerFlag = false;
+
   /// Show the registered dialects before trying to load the input file.
   bool showDialectsFlag = false;
 
   /// Split the input file based on the `// -----` marker into pieces and
   /// process each chunk independently.
   bool splitInputFileFlag = false;
 
   /// Use an explicit top-level module op during parsing.

mlir/lib/Tools/mlir-opt/MlirOptMain.cpp

static cl::opt<bool, /*ExternalStorage=*/true> enableDebuggerHook(
         cl::location(enableDebuggerActionHookFlag), cl::init(false));
 
     static cl::opt<bool, /*ExternalStorage=*/true> explicitModule(
         "no-implicit-module",
         cl::desc("Disable implicit addition of a top-level module op during "
                  "parsing"),
         cl::location(useExplicitModuleFlag), cl::init(false));
 
+    static cl::opt<bool, /*ExternalStorage=*/true> runReproducer(
+        "run-reproducer", cl::desc("Run the pipeline stored in the reproducer"),
+        cl::location(runReproducerFlag), cl::init(false));
+
     static cl::opt<bool, /*ExternalStorage=*/true> showDialects(
         "show-dialects",
         cl::desc("Print the list of registered dialects and exit"),
         cl::location(showDialectsFlag), cl::init(false));
 
     static cl::opt<bool, /*ExternalStorage=*/true> splitInputFile(
         "split-input-file",
         cl::desc("Split the input file into pieces and process each "
performActions(raw_ostream &os,
   // Prepare the parser config, and attach any useful/necessary resource
   // handlers. Unhandled external resources are treated as passthrough, i.e.
   // they are not processed and will be emitted directly to the output
   // untouched.
   PassReproducerOptions reproOptions;
   FallbackAsmResourceMap fallbackResourceMap;
   ParserConfig parseConfig(context, /*verifyAfterParse=*/true,
                            &fallbackResourceMap);
+  if (config.shouldRunReproducer())
     reproOptions.attachResourceParser(parseConfig);
 
   // Parse the input file and reset the context threading state.
   TimingScope parserTiming = timing.nest("Parser");
   OwningOpRef<Operation *> op = parseSourceFileForTool(
       sourceMgr, parseConfig, !config.shouldUseExplicitModule());
   context->enableMultithreading(wasThreadingEnabled);
   if (!op)
     return failure();
   parserTiming.stop();
 
   // Prepare the pass manager, applying command-line and reproducer options.
   PassManager pm(op.get()->getName(), PassManager::Nesting::Implicit);
   pm.enableVerifier(config.shouldVerifyPasses());
   if (failed(applyPassManagerCLOptions(pm)))
     return failure();
   pm.enableTiming(timing);
-  if (failed(reproOptions.apply(pm)) || failed(config.setupPassPipeline(pm)))
+  if (config.shouldRunReproducer() && failed(reproOptions.apply(pm)))
+    return failure();
+  if (failed(config.setupPassPipeline(pm)))
     return failure();
 
   // Run the pipeline.
   if (failed(pm.run(*op)))
     return failure();
 
   // Print the output.
   TimingScope outputTiming = timing.nest("Output");

mlir/test/Pass/run-reproducer.mlir

-// RUN: mlir-opt %s -dump-pass-pipeline 2>&1 | FileCheck %s
-// RUN: mlir-opt %s -mlir-print-ir-before=cse 2>&1 | FileCheck -check-prefix=BEFORE %s
+// RUN: mlir-opt %s --run-reproducer -dump-pass-pipeline 2>&1 | FileCheck %s
+// RUN: mlir-opt %s --run-reproducer -mlir-print-ir-before=cse 2>&1 | FileCheck -check-prefix=BEFORE %s
 
 func.func @foo() {
   %0 = arith.constant 0 : i32
   return
 }
 
 func.func @bar() {
   return