wip

mike dupont · mike dupont · commit f3487696cbeb · 2025-08-29T20:51:25.000-04:00
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/Cargo.toml b/Cargo.toml
@@ -3,7 +3,7 @@ resolver = "2"
 members = [
 # tidy-alphabetical-start
   "compiler/rustc",
-  "crates/rust-bootstrap", # Our new crate
+  "crates/rust-bootstrap", "crates/syscall_instrumentation_macro", # Our new crate
   "src/build_helper",
   "src/rustc-std-workspace/rustc-std-workspace-alloc",
   "src/rustc-std-workspace/rustc-std-workspace-core",
diff --git a/compiler/rustc_log/Cargo.toml b/compiler/rustc_log/Cargo.toml
@@ -5,7 +5,7 @@ edition = "2024"
 
 [dependencies]
 # tidy-alphabetical-start
-tracing-core = "=0.1.30" # FIXME(Nilstrieb) tracing has a deadlock: https://github.com/tokio-rs/tracing/issues/2635
+tracing-core = { path = "../../../mcp/monomcp/vendor/tracing-vendor/tracing/tracing-core", version = "0.1.30" } # FIXME(Nilstrieb) tracing has a deadlock: https://github.com/tokio-rs/tracing/issues/2635
 tracing-subscriber = { version = "0.3.3", default-features = false, features = ["fmt", "env-filter", "smallvec", "parking_lot", "ansi"] }
 tracing-tree = "0.3.1"
 tracing.workspace = true
diff --git a/crates/rust-bootstrap/Cargo.toml b/crates/rust-bootstrap/Cargo.toml
@@ -28,4 +28,8 @@ flate2 = "1.0"
 xz2 = "0.1"
 tempfile = "3.20.0"
 chrono = { version = "0.4", features = ["serde"] }
-once_cell = "1.19"
+once_cell = "1.19"
+cargo = { path = "../../../mcp/monomcp/vendor/cargo-rust-lang" }
+tracing-core = { path = "../../../mcp/monomcp/vendor/tracing-vendor/tracing/tracing-core" }
+tracing = { path = "../../../mcp/monomcp/vendor/tracing-vendor/tracing-0.1.41/tracing" }
+syscall_instrumentation_macro = { path = "../syscall_instrumentation_macro" }
diff --git a/crates/rust-bootstrap/src/bootstrap_stages/build_bootstrap/mod.rs b/crates/rust-bootstrap/src/bootstrap_stages/build_bootstrap/mod.rs
@@ -110,7 +110,7 @@ pub fn build_bootstrap(build_state: &BuildState) -> Result<(), Box<dyn Error>> {
     let additional_cargo_flags_str: Vec<&str> = additional_cargo_flags.iter().map(|s| s.as_str()).collect();
     args.extend_from_slice(&additional_cargo_flags_str);
 
-    command_executor::execute_and_report_command("cargo", &args)?;
+    crate::cargo_integration::run_cargo_command(&["version"], &build_state.rust_root)?;
 
     Ok(())
 }
diff --git a/crates/rust-bootstrap/src/cargo_integration/create_compile_options.rs b/crates/rust-bootstrap/src/cargo_integration/create_compile_options.rs
@@ -0,0 +1,8 @@
+use cargo::GlobalContext;
+use cargo::ops::CompileOptions;
+use cargo::util::CargoResult;
+use cargo::core::compiler::UserIntent;
+
+pub fn create_compile_options(gctx: &GlobalContext) -> CargoResult<CompileOptions> {
+    CompileOptions::new(gctx, UserIntent::Build)
+}
diff --git a/crates/rust-bootstrap/src/cargo_integration/init_global_context.rs b/crates/rust-bootstrap/src/cargo_integration/init_global_context.rs
@@ -0,0 +1,15 @@
+use cargo::GlobalContext;
+use cargo::util::CargoResult;
+use std::env;
+use std::path::PathBuf;
+use cargo::core::shell::Shell;
+
+pub fn init_global_context() -> CargoResult<GlobalContext> {
+    // Hardcoding homedir to bypass potential issues with `home` crate in Termux.
+    // This is a known and stable path in the Termux environment.
+    let homedir = PathBuf::from("/data/data/com.termux/files/home/.cargo");
+    let cwd = env::current_dir()?;
+    let gctx = GlobalContext::new(Shell::new(), cwd, homedir);
+    println!("GlobalContext homedir: {:?}", gctx.home().as_path_unlocked());
+    Ok(gctx)
+}
diff --git a/crates/rust-bootstrap/src/cargo_integration/init_workspace.rs b/crates/rust-bootstrap/src/cargo_integration/init_workspace.rs
@@ -0,0 +1,10 @@
+use std::path::PathBuf;
+use cargo::core::Workspace;
+use cargo::GlobalContext;
+use cargo::util::CargoResult;
+
+pub fn init_workspace<'gctx>(gctx: &'gctx GlobalContext, rust_root: &PathBuf) -> CargoResult<Workspace<'gctx>> {
+    let manifest_path = rust_root.join("Cargo.toml");
+    println!("init_workspace: manifest_path: {:?}", manifest_path);
+    Workspace::new(&manifest_path, gctx)
+}
diff --git a/crates/rust-bootstrap/src/cargo_integration/mod.rs b/crates/rust-bootstrap/src/cargo_integration/mod.rs
@@ -0,0 +1,52 @@
+use std::error::Error;
+use std::path::PathBuf;
+
+pub mod init_global_context;
+pub mod init_workspace;
+pub mod create_compile_options;
+pub mod parse_cargo_args;
+pub mod parse_global_args;
+
+use cargo::ops::compile;
+use cargo::util::command_prelude::ArgMatchesExt;
+
+pub fn run_cargo_command(args: &[&str], rust_root: &PathBuf) -> Result<(), Box<dyn Error>> {
+    println!("Running cargo command via integration: {:?}", args);
+    println!("rust_root: {:?}", rust_root);
+
+    // Temporarily change current directory to rust_root
+    let original_cwd = std::env::current_dir()?;
+    std::env::set_current_dir(rust_root)?;
+
+    let (global_matches, subcommand_args) = parse_global_args::parse_global_args(args)?;
+
+    let mut gctx = init_global_context::init_global_context()?;
+    println!("gctx.cwd(): {:?}", gctx.cwd());
+
+    // Configure GlobalContext with global arguments
+    gctx.configure(
+        global_matches.verbose(),
+        global_matches.flag("quiet"),
+        global_matches.get_one::<String>("color").map(String::as_str),
+        global_matches.flag("frozen"),
+        global_matches.flag("locked"),
+        global_matches.flag("offline"),
+        &None, // target_dir, not handled by global args
+        &global_matches.get_many::<String>("unstable-features").unwrap_or_default().cloned().collect::<Vec<String>>(),
+        &global_matches.get_many::<String>("config").unwrap_or_default().cloned().collect::<Vec<String>>(),
+    )?;
+
+    let ws = init_workspace::init_workspace(&gctx, rust_root)?;
+    println!("ws.root(): {:?}", ws.root());
+
+    // Convert Vec<String> to Vec<&str> for parse_cargo_args
+    let subcommand_args_str: Vec<&str> = subcommand_args.iter().map(|s| s.as_str()).collect();
+    let compile_options = parse_cargo_args::parse_cargo_args(&gctx, &subcommand_args_str, rust_root)?;
+
+    compile(&ws, &compile_options)?;
+
+    // Restore original current directory
+    std::env::set_current_dir(original_cwd)?;
+
+    Ok(())
+}
diff --git a/crates/rust-bootstrap/src/cargo_integration/parse_cargo_args.rs b/crates/rust-bootstrap/src/cargo_integration/parse_cargo_args.rs
@@ -0,0 +1,56 @@
+use cargo::GlobalContext;
+use cargo::ops::CompileOptions;
+use cargo::util::CargoResult;
+use cargo::core::compiler::UserIntent;
+use cargo::core::Workspace;
+use cargo::util::command_prelude::{CommandExt, ArgMatchesExt, ProfileChecking, subcommand};
+use std::path::PathBuf;
+use clap::{Command, ArgMatches};
+
+pub fn parse_cargo_args<'gctx>(gctx: &'gctx GlobalContext, raw_args: &[&str], rust_root: &PathBuf) -> CargoResult<CompileOptions> {
+    let command = subcommand("build")
+        .about("Compile a local package and all of its dependencies")
+        .arg_future_incompat_report()
+        .arg_message_format()
+        .arg_silent_suggestion()
+        .arg_package_spec(
+            "Package to build (see `cargo help pkgid`)",
+            "Build all packages in the workspace",
+            "Exclude packages from the build",
+        )
+        .arg_targets_all(
+            "Build only this package's library",
+            "Build only the specified binary",
+            "Build all binaries",
+            "Build only the specified example",
+            "Build all examples",
+            "Build only the specified test target",
+            "Build all targets that have `test = true` set",
+            "Build only the specified bench target",
+            "Build all targets that have `bench = true` set",
+            "Build all targets",
+        )
+        .arg_features()
+        .arg_release("Build artifacts in release mode, with optimizations")
+        .arg_redundant_default_mode("debug", "build", "release")
+        .arg_profile("Build artifacts with the specified profile")
+        .arg_parallel()
+        .arg_target_triple("Build for the target triple")
+        .arg_target_dir()
+        .arg_artifact_dir()
+        .arg_build_plan()
+        .arg_unit_graph()
+        .arg_timings()
+        .arg_compile_time_deps()
+        .arg_manifest_path()
+        .arg_lockfile_path()
+        .arg_ignore_rust_version();
+
+    let matches = command.try_get_matches_from(raw_args)?;
+
+    let ws = Workspace::new(rust_root, gctx)?;
+
+    let compile_options = matches.compile_options(gctx, UserIntent::Build, Some(&ws), ProfileChecking::Custom)?;
+
+    Ok(compile_options)
+}
diff --git a/crates/rust-bootstrap/src/cargo_integration/parse_global_args.rs b/crates/rust-bootstrap/src/cargo_integration/parse_global_args.rs
@@ -0,0 +1,69 @@
+use cargo::util::CargoResult;
+use clap::{Command, ArgMatches, ArgAction, Arg};
+use cargo::util::command_prelude::{flag, opt, multi_opt};
+
+pub fn parse_global_args(raw_args: &[&str]) -> CargoResult<(ArgMatches, Vec<String>)> {
+    let command = Command::new("cargo")
+        .arg(flag("version", "Print version info and exit").short('V'))
+        .arg(flag("list", "List installed commands"))
+        .arg(
+            opt(
+                "explain",
+                "Provide a detailed explanation of a rustc error message",
+            )
+            .value_name("CODE"),
+        )
+        .arg(
+            opt(
+                "verbose",
+                "Use verbose output (-vv very verbose/build.rs output)",
+            )
+            .short('v')
+            .action(ArgAction::Count)
+            .global(true),
+        )
+        .arg(flag("quiet", "Do not print cargo log messages").short('q').global(true))
+        .arg(
+            opt("color", "Coloring")
+                .value_name("WHEN")
+                .global(true)
+                .value_parser(["auto", "always", "never"])
+                .ignore_case(true),
+        )
+        .arg(
+            flag("locked", "Assert that `Cargo.lock` will remain unchanged")
+                .help_heading("Manifest Options")
+                .global(true),
+        )
+        .arg(
+            flag("offline", "Run without accessing the network")
+                .help_heading("Manifest Options")
+                .global(true),
+        )
+        .arg(
+            flag("frozen", "Equivalent to specifying both --locked and --offline")
+                .help_heading("Manifest Options")
+                .global(true),
+        )
+        .arg(multi_opt("config", "KEY=VALUE|PATH", "Override a configuration value").global(true))
+        .arg(Arg::new("unstable-features")
+            .help("Unstable (nightly-only) flags to Cargo, see 'cargo -Z help' for details")
+            .short('Z')
+            .value_name("FLAG")
+            .action(ArgAction::Append)
+            .global(true)
+        );
+
+    let matches = command.try_get_matches_from(raw_args)?;
+
+    let subcommand_name = matches.subcommand_name();
+    let subcommand_args = matches.subcommand().map(|(_, args)| args.clone());
+
+    let remaining_args: Vec<String> = if let Some(sub_args) = subcommand_args {
+        sub_args.get_many::<String>("").unwrap_or_default().cloned().collect()
+    } else {
+        Vec::new()
+    };
+
+    Ok((matches, remaining_args))
+}
diff --git a/crates/rust-bootstrap/src/git_analyzer/tests/test_commits.rs b/crates/rust-bootstrap/src/git_analyzer/tests/test_commits.rs
@@ -38,8 +38,8 @@ mod tests {
 
         // Assert that the record batch was created successfully and matches the schema
         let expected_schema = git_commits_schema();
-        assert_eq!(commits_batch.schema(), expected_schema);
-        assert!(commits_batch.num_rows() > 0); // Ensure some commits were extracted
+        assert_eq!(commits_batch.record_batch.schema(), expected_schema);
+        assert!(commits_batch.record_batch.num_rows() > 0); // Ensure some commits were extracted
 
         Ok(())
     }
diff --git a/crates/rust-bootstrap/src/lib.rs b/crates/rust-bootstrap/src/lib.rs
@@ -8,6 +8,7 @@ pub mod trace_events;
 pub mod tracer;
 pub mod parquet_trace_reporter;
 pub mod builder;
+pub mod cargo_integration;
 
 pub use config::args::Args;
 pub use bootstrap_stages::config_loader as loader;
diff --git a/crates/rust-bootstrap/src/main.rs b/crates/rust-bootstrap/src/main.rs
@@ -1,6 +1,7 @@
 use rust_bootstrap::{Args, BuildState, loader, parquet_reporter, bootstrap_stages, builder::Builder};
 use rust_bootstrap::bootstrap_stages::stage0_detector::Stage0;
 use rust_bootstrap::bootstrap_stages::operational_logger::logger;
+use syscall_instrumentation_macro::instrument_syscall;
 
 use clap::Parser;
 use std::error::Error;
@@ -51,5 +52,13 @@ fn main() -> Result<(), Box<dyn Error>> {
     let operational_log_batch = logger::get_logged_events_as_record_batch()?;
     parquet_reporter::write_record_batch_to_parquet(operational_log_batch, "operational_log.parquet")?;
 
+    // Test the syscall instrumentation macro
+    my_dummy_function(10, 20);
+
     Ok(())
 }
+
+#[instrument_syscall]
+fn my_dummy_function(a: i32, b: i32) -> i32 {
+    a + b
+}
diff --git a/crates/rust-bootstrap/tests/cargo_integration_tests.rs b/crates/rust-bootstrap/tests/cargo_integration_tests.rs
@@ -0,0 +1,70 @@
+// tests/cargo_integration_tests.rs
+
+use rust_bootstrap::cargo_integration::init_global_context;
+use rust_bootstrap::cargo_integration::init_workspace;
+use rust_bootstrap::cargo_integration::parse_cargo_args;
+use rust_bootstrap::cargo_integration::run_cargo_command;
+
+use std::path::PathBuf;
+use std::fs;
+
+#[test]
+fn test_init_global_context() {
+    let gctx = init_global_context::init_global_context();
+    assert!(gctx.is_ok(), "Failed to initialize GlobalContext: {:?}", gctx.err());
+}
+
+#[test]
+fn test_init_workspace() {
+    let gctx = init_global_context::init_global_context().unwrap();
+
+    // Use the absolute path to the rust repository's Cargo.toml
+    let rust_repo_root = PathBuf::from("/data/data/com.termux/files/home/storage/github/rust/");
+    let manifest_path = rust_repo_root.join("Cargo.toml");
+
+    let ws = init_workspace::init_workspace(&gctx, &rust_repo_root);
+    assert!(ws.is_ok(), "Failed to initialize Workspace: {:?}", ws.err());
+}
+
+// #[test]
+// fn test_parse_cargo_args() {
+//     let gctx = init_global_context::init_global_context().unwrap();
+
+//     // Create a dummy Cargo.toml for testing workspace initialization
+//     let temp_dir = PathBuf::from("target/test_parse_args_workspace");
+//     fs::create_dir_all(&temp_dir).unwrap();
+//     let temp_dir_abs = temp_dir.canonicalize().unwrap(); // Convert to absolute path
+//     let manifest_path = temp_dir_abs.join("Cargo.toml");
+//     fs::write(&manifest_path, "[package]\nname = \"test-package\"\nversion = \"0.1.0\"\nedition = \"2021\"
+// ").unwrap();
+
+//     let args = &["build", "--release"];
+//     let compile_options = parse_cargo_args::parse_cargo_args(&gctx, args, &temp_dir_abs); // Pass absolute path
+//     assert!(compile_options.is_ok(), "Failed to parse cargo args: {:?}", compile_options.err());
+
+//     // TODO: Add assertions to check the parsed CompileOptions fields
+
+//     // Clean up dummy files
+//     fs::remove_dir_all(&temp_dir).unwrap();
+// }
+
+// #[test]
+// fn test_run_cargo_command_version() {
+//     // This test will attempt to run a simple 'cargo version' command
+//     // using the integrated library calls.
+//     let temp_dir = PathBuf::from("target/test_run_cargo_command_version");
+//     fs::create_dir_all(&temp_dir).unwrap();
+//     let temp_dir_abs = temp_dir.canonicalize().unwrap(); // Convert to absolute path
+//     let manifest_path = temp_dir_abs.join("Cargo.toml");
+//     fs::write(&manifest_path, "[package]\nname = \"test-package\"\nversion = \"0.1.0\"\nedition = \"2021\"
+// ").unwrap();
+
+//     let args = &["version"];
+//     let result = run_cargo_command(args, &temp_dir_abs); // Pass absolute path
+//     assert!(result.is_ok(), "Failed to run cargo version command: {:?}", result.err());
+
+//     // TODO: Add assertions to check the output of the command
+
+//     // Clean up dummy files
+//     fs::remove_dir_all(&temp_dir).unwrap();
+// }
diff --git a/crates/syscall_instrumentation_macro/Cargo.toml b/crates/syscall_instrumentation_macro/Cargo.toml
@@ -0,0 +1,11 @@
+[package]
+name = "syscall_instrumentation_macro"
+version = "0.1.0"
+edition = "2024"
+
+[lib]
+proc-macro = true
+
+[dependencies]
+quote = "1.0"
+syn = { version = "2.0", features = ["full"] }
diff --git a/crates/syscall_instrumentation_macro/src/lib.rs b/crates/syscall_instrumentation_macro/src/lib.rs

Original file line number	Diff line number	Diff line change
`@@ -110,7 +110,7 @@ pub fn build_bootstrap(build_state: &BuildState) -> Result<(), Box<dyn Error>> {`
`110`	`110`	`let additional_cargo_flags_str: Vec<&str> = additional_cargo_flags.iter().map(\|s\| s.as_str()).collect();`
`111`	`111`	`args.extend_from_slice(&additional_cargo_flags_str);`
`112`	`112`
`113`		`- command_executor::execute_and_report_command("cargo", &args)?;`
	`113`	`+ crate::cargo_integration::run_cargo_command(&["version"], &build_state.rust_root)?;`
`114`	`114`
`115`	`115`	`Ok(())`
`116`	`116`	`}`