Merge pull request #852 from candy-lang/support-all-tracingmodes-in-cli

Support all `TracingMode`s in CLI

compiler/cli/src/debug.rs

@@ -90,24 +90,47 @@ pub struct PathAndExecutionTargetAndTracing {
     #[arg(long, value_enum, default_value_t = ExecutionTargetKind::Module)]
     execution_target: ExecutionTargetKind,
 
-    #[arg(long)]
-    register_fuzzables: bool,
-
-    #[arg(long)]
-    trace_calls: bool,
-
-    #[arg(long)]
-    trace_evaluated_expressions: bool,
+    // The tracing modes can be specified as follows:
+    //
+    // - not specified or `--register-fuzzables=off`: off
+    // - `--register-fuzzables` or `--register-fuzzables=only-current`: only current
+    // - `--register-fuzzables=all`: all
+    //
+    // (Same for `trace-calls` and `evaluated-expressions`.)
+    #[arg(
+        long,
+        default_value("off"),
+        default_missing_value("only-current"),
+        num_args(0..=1),
+        require_equals(true)
+    )]
+    register_fuzzables: TracingMode,
+
+    #[arg(
+        long,
+        default_value("off"),
+        default_missing_value("only-current"),
+        num_args(0..=1),
+        require_equals(true)
+    )]
+    trace_calls: TracingMode,
+
+    #[arg(
+        long,
+        default_value("off"),
+        default_missing_value("only-current"),
+        num_args(0..=1),
+        require_equals(true)
+    )]
+    trace_evaluated_expressions: TracingMode,
 }
 impl PathAndExecutionTargetAndTracing {
     #[must_use]
     const fn to_tracing_config(&self) -> TracingConfig {
         TracingConfig {
-            register_fuzzables: TracingMode::only_current_or_off(self.register_fuzzables),
-            calls: TracingMode::only_current_or_off(self.trace_calls),
-            evaluated_expressions: TracingMode::only_current_or_off(
-                self.trace_evaluated_expressions,
-            ),
+            register_fuzzables: self.register_fuzzables,
+            calls: self.trace_calls,
+            evaluated_expressions: self.trace_evaluated_expressions,
         }
     }
 }
@@ -165,40 +188,40 @@ pub fn debug(options: Options) -> ProgramResult {
             let module = module_for_path(options.path.clone())?;
             let execution_target = options.execution_target.resolve(module.clone());
             let tracing = options.to_tracing_config();
-            let mir = db.mir(execution_target, tracing.clone());
+            let mir = db.mir(execution_target, tracing);
             mir.ok()
-                .map(|(mir, _)| RichIr::for_mir(&module, &mir, &tracing))
+                .map(|(mir, _)| RichIr::for_mir(&module, &mir, tracing))
         }
         Options::OptimizedMir(options) => {
             let module = module_for_path(options.path.clone())?;
             let execution_target = options.execution_target.resolve(module.clone());
             let tracing = options.to_tracing_config();
-            let mir = db.optimized_mir(execution_target, tracing.clone());
+            let mir = db.optimized_mir(execution_target, tracing);
             mir.ok()
-                .map(|(mir, _, _)| RichIr::for_optimized_mir(&module, &mir, &tracing))
+                .map(|(mir, _, _)| RichIr::for_optimized_mir(&module, &mir, tracing))
         }
         Options::Lir(options) => {
             let module = module_for_path(options.path.clone())?;
             let execution_target = options.execution_target.resolve(module.clone());
             let tracing = options.to_tracing_config();
-            let lir = db.lir(execution_target, tracing.clone());
+            let lir = db.lir(execution_target, tracing);
             lir.ok()
-                .map(|(lir, _)| RichIr::for_lir(&module, &lir, &tracing))
+                .map(|(lir, _)| RichIr::for_lir(&module, &lir, tracing))
         }
         Options::OptimizedLir(options) => {
             let module = module_for_path(options.path.clone())?;
             let execution_target = options.execution_target.resolve(module.clone());
             let tracing = options.to_tracing_config();
-            let lir = db.optimized_lir(execution_target, tracing.clone());
+            let lir = db.optimized_lir(execution_target, tracing);
             lir.ok()
-                .map(|(lir, _)| RichIr::for_optimized_lir(&module, &lir, &tracing))
+                .map(|(lir, _)| RichIr::for_optimized_lir(&module, &lir, tracing))
         }
         Options::VmByteCode(options) => {
             let module = module_for_path(options.path.clone())?;
             let execution_target = options.execution_target.resolve(module.clone());
             let tracing = options.to_tracing_config();
-            let (vm_byte_code, _) = compile_byte_code(&db, execution_target, tracing.clone());
-            Some(RichIr::for_byte_code(&module, &vm_byte_code, &tracing))
+            let (vm_byte_code, _) = compile_byte_code(&db, execution_target, tracing);
+            Some(RichIr::for_byte_code(&module, &vm_byte_code, tracing))
         }
         #[cfg(feature = "inkwell")]
         Options::LlvmIr(options) => {
@@ -380,35 +403,35 @@ impl GoldOptions {
             visit("HIR", hir.text);
 
             let (mir, _) = db
-                .mir(execution_target.clone(), Self::TRACING_CONFIG.clone())
+                .mir(execution_target.clone(), Self::TRACING_CONFIG)
                 .unwrap();
-            let mir = RichIr::for_mir(&module, &mir, &Self::TRACING_CONFIG);
+            let mir = RichIr::for_mir(&module, &mir, Self::TRACING_CONFIG);
             visit("MIR", mir.text);
 
             let (optimized_mir, _, _) = db
-                .optimized_mir(execution_target.clone(), Self::TRACING_CONFIG.clone())
+                .optimized_mir(execution_target.clone(), Self::TRACING_CONFIG)
                 .unwrap();
             let optimized_mir =
-                RichIr::for_optimized_mir(&module, &optimized_mir, &Self::TRACING_CONFIG);
+                RichIr::for_optimized_mir(&module, &optimized_mir, Self::TRACING_CONFIG);
             visit("Optimized MIR", optimized_mir.text);
 
             let (lir, _) = db
-                .lir(execution_target.clone(), Self::TRACING_CONFIG.clone())
+                .lir(execution_target.clone(), Self::TRACING_CONFIG)
                 .unwrap();
-            let lir = RichIr::for_lir(&module, &lir, &Self::TRACING_CONFIG);
+            let lir = RichIr::for_lir(&module, &lir, Self::TRACING_CONFIG);
             visit("LIR", lir.text);
 
             let (optimized_lir, _) = db
-                .optimized_lir(execution_target.clone(), Self::TRACING_CONFIG.clone())
+                .optimized_lir(execution_target.clone(), Self::TRACING_CONFIG)
                 .unwrap();
             let optimized_lir =
-                RichIr::for_optimized_lir(&module, &optimized_lir, &Self::TRACING_CONFIG);
+                RichIr::for_optimized_lir(&module, &optimized_lir, Self::TRACING_CONFIG);
             visit("Optimized LIR", optimized_lir.text);
 
             let (vm_byte_code, _) =
-                compile_byte_code(db, execution_target.clone(), Self::TRACING_CONFIG.clone());
+                compile_byte_code(db, execution_target.clone(), Self::TRACING_CONFIG);
             let vm_byte_code_rich_ir =
-                RichIr::for_byte_code(&module, &vm_byte_code, &Self::TRACING_CONFIG);
+                RichIr::for_byte_code(&module, &vm_byte_code, Self::TRACING_CONFIG);
             visit(
                 "VM Byte Code",
                 Self::format_byte_code(&vm_byte_code, &vm_byte_code_rich_ir),

compiler/frontend/Cargo.toml

@@ -7,6 +7,7 @@ rust-version = "1.56"
 [lib]
 
 [dependencies]
+clap = { version = "4.1.8", features = ["derive"] }
 derive_more = "0.99.17"
 dunce = "1.0.4"
 enumset = "1.0.12"

compiler/frontend/src/hir_to_mir.rs

@@ -56,7 +56,7 @@ fn mir(db: &dyn HirToMir, target: ExecutionTarget, tracing: TracingConfig) -> Mi
                 module,
                 target_is_main_function,
                 &hir,
-                &tracing,
+                tracing,
                 &mut errors,
             );
             (mir, errors)
@@ -185,7 +185,7 @@ fn generate_needs_function(body: &mut BodyBuilder) -> Id {
 struct LoweringContext<'a> {
     mapping: &'a mut FxHashMap<hir::Id, Id>,
     needs_function: Id,
-    tracing: &'a TracingConfig,
+    tracing: TracingConfig,
     ongoing_destructuring: Option<OngoingDestructuring>,
     errors: &'a mut FxHashSet<CompilerError>,
 }
@@ -202,7 +202,7 @@ impl<'a> LoweringContext<'a> {
         module: Module,
         target_is_main_function: bool,
         hir: &hir::Body,
-        tracing: &TracingConfig,
+        tracing: TracingConfig,
         errors: &mut FxHashSet<CompilerError>,
     ) -> Mir {
         Mir::build(|body| {

compiler/frontend/src/mir_optimize/mod.rs

@@ -95,7 +95,7 @@ fn optimized_mir(
 ) -> OptimizedMirResult {
     let module = target.module();
     debug!("{module}: Compiling.");
-    let (mir, errors) = db.mir(target.clone(), tracing.clone())?;
+    let (mir, errors) = db.mir(target.clone(), tracing)?;
     let mut mir = (*mir).clone();
     let mut pureness = PurenessInsights::default();
     let mut errors = (*errors).clone();
@@ -216,7 +216,7 @@ impl Context<'_> {
     }
 }
 
-#[allow(clippy::unnecessary_wraps)]
+#[allow(clippy::trivially_copy_pass_by_ref, clippy::unnecessary_wraps)]
 fn recover_from_cycle(
     _db: &dyn OptimizeMir,
     cycle: &[String],

compiler/frontend/src/rich_ir.rs

@@ -290,8 +290,8 @@ impl RichIrBuilder {
             .push(range);
     }
 
-    pub fn push_tracing_config(&mut self, tracing_config: &TracingConfig) {
-        fn push_mode(builder: &mut RichIrBuilder, title: &str, mode: &TracingMode) {
+    pub fn push_tracing_config(&mut self, tracing_config: TracingConfig) {
+        fn push_mode(builder: &mut RichIrBuilder, title: &str, mode: TracingMode) {
             builder.push_comment_line(format!(
                 "• {title} {}",
                 match mode {
@@ -308,13 +308,13 @@ impl RichIrBuilder {
         push_mode(
             self,
             "Include tracing of fuzzable functions?",
-            &tracing_config.register_fuzzables,
+            tracing_config.register_fuzzables,
         );
-        push_mode(self, "Include tracing of calls?", &tracing_config.calls);
+        push_mode(self, "Include tracing of calls?", tracing_config.calls);
         push_mode(
             self,
             "Include tracing of evaluated expressions?",
-            &tracing_config.evaluated_expressions,
+            tracing_config.evaluated_expressions,
         );
     }
 
@@ -373,25 +373,25 @@ impl RichIr {
         Self::for_ir("HIR", module, None, |builder| body.build_rich_ir(builder))
     }
     #[must_use]
-    pub fn for_mir(module: &Module, mir: &Mir, tracing_config: &TracingConfig) -> Self {
+    pub fn for_mir(module: &Module, mir: &Mir, tracing_config: TracingConfig) -> Self {
         Self::for_ir("MIR", module, tracing_config, |builder| {
             mir.build_rich_ir(builder);
         })
     }
     #[must_use]
-    pub fn for_optimized_mir(module: &Module, mir: &Mir, tracing_config: &TracingConfig) -> Self {
+    pub fn for_optimized_mir(module: &Module, mir: &Mir, tracing_config: TracingConfig) -> Self {
         Self::for_ir("Optimized MIR", module, tracing_config, |builder| {
             mir.build_rich_ir(builder);
         })
     }
     #[must_use]
-    pub fn for_lir(module: &Module, lir: &Lir, tracing_config: &TracingConfig) -> Self {
+    pub fn for_lir(module: &Module, lir: &Lir, tracing_config: TracingConfig) -> Self {
         Self::for_ir("LIR", module, tracing_config, |builder| {
             lir.build_rich_ir(builder);
         })
     }
     #[must_use]
-    pub fn for_optimized_lir(module: &Module, lir: &Lir, tracing_config: &TracingConfig) -> Self {
+    pub fn for_optimized_lir(module: &Module, lir: &Lir, tracing_config: TracingConfig) -> Self {
         Self::for_ir("Optimized LIR", module, tracing_config, |builder| {
             lir.build_rich_ir(builder);
         })
@@ -400,7 +400,7 @@ impl RichIr {
     fn for_ir(
         ir_name: &str,
         module: &Module,
-        tracing_config: impl Into<Option<&TracingConfig>>,
+        tracing_config: impl Into<Option<TracingConfig>>,
         build_rich_ir: impl FnOnce(&mut RichIrBuilder),
     ) -> Self {
         let mut builder = RichIrBuilder::default();

compiler/frontend/src/tracing.rs

@@ -1,6 +1,7 @@
+use clap::ValueEnum;
 use serde::{Deserialize, Serialize};
 
-#[derive(PartialEq, Eq, Hash, Debug, Clone, Serialize, Deserialize)]
+#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct TracingConfig {
     pub register_fuzzables: TracingMode,
@@ -27,7 +28,7 @@ impl TracingConfig {
     }
 }
 
-#[derive(PartialEq, Eq, Hash, Debug, Clone, Serialize, Deserialize)]
+#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq, Serialize, Deserialize, ValueEnum)]
 #[serde(rename_all = "camelCase")]
 pub enum TracingMode {
     Off,

compiler/language_server/src/debug_adapter/session.rs

@@ -192,7 +192,7 @@ impl DebugSession {
                 let byte_code = compile_byte_code(
                     &self.db,
                     ExecutionTarget::MainFunction(module.clone()),
-                    tracing.clone(),
+                    tracing,
                 )
                 .0;