Benchmark: VS Code 2.0 vs. JetBrains RustRover 1.0 vs. Neovim 0.10 for Rust 1.96 Development

// Example 1: Axum 0.7 async web server for Rust 1.96 benchmarking
// Demonstrates typical project structure used in compilation benchmarks
use axum::{
    routing::get,
    Router,
    extract::State,
    http::StatusCode,
    response::Json,
};
use tower_http::trace::TraceLayer;
use tracing_subscriber::{layer::SubscriberExt, util::SubscriberInitExt};
use std::sync::Arc;
use serde::{Deserialize, Serialize};

// Application state shared across routes
#[derive(Clone)]
struct AppState {
    start_time: std::time::Instant,
    request_count: Arc,
}

// Request payload for POST endpoint
#[derive(Deserialize)]
struct EchoRequest {
    message: String,
}

// Response payload for echo endpoint
#[derive(Serialize)]
struct EchoResponse {
    message: String,
    server_uptime_ms: u128,
    total_requests: u64,
}

#[tokio::main]
async fn main() -> Result<(), Box> {
    // Initialize tracing for request logging
    tracing_subscriber::registry()
        .with(tracing_subscriber::EnvFilter::new(
            std::env::var(\"RUST_LOG\").unwrap_or_else(|_| \"info\".into()),
        ))
        .with(tracing_subscriber::fmt::layer())
        .init();

    // Initialize shared application state
    let state = AppState {
        start_time: std::time::Instant::now(),
        request_count: Arc::new(std::sync::atomic::AtomicU64::new(0)),
    };

    // Build router with routes and middleware
    let app = Router::new()
        .route(\"/\", get(root))
        .route(\"/echo\", get(echo_get).post(echo_post))
        .layer(TraceLayer::new_for_http())
        .with_state(state);

    // Start server on 0.0.0.0:3000
    let listener = tokio::net::TcpListener::bind(\"0.0.0.0:3000\").await?;
    tracing::info!(\"Server running on http://0.0.0.0:3000\");
    axum::serve(listener, app).await?;

    Ok(())
}

// Root endpoint handler
async fn root() -> &'static str {
    \"Rust 1.96 Axum Benchmark Server\"
}

// GET /echo handler
async fn echo_get(
    State(state): State,
) -> Result, StatusCode> {
    let count = state.request_count.fetch_add(1, std::sync::atomic::Ordering::SeqCst);
    Ok(Json(EchoResponse {
        message: \"Hello from GET echo\".into(),
        server_uptime_ms: state.start_time.elapsed().as_millis(),
        total_requests: count + 1,
    }))
}

// POST /echo handler with error handling
async fn echo_post(
    State(state): State,
    Json(payload): Json,
) -> Result, (StatusCode, String)> {
    // Validate payload length
    if payload.message.len() > 1024 {
        return Err((StatusCode::BAD_REQUEST, \"Message too long (max 1024 chars)\".into()));
    }

    let count = state.request_count.fetch_add(1, std::sync::atomic::Ordering::SeqCst);
    Ok(Json(EchoResponse {
        message: payload.message,
        server_uptime_ms: state.start_time.elapsed().as_millis(),
        total_requests: count + 1,
    }))
}

// Example 2: Cargo.toml LSP config generator for VS Code/RustRover/Neovim
// Used to automate setup time benchmarks across editors
use cargo_toml::{CargoToml, Manifest};
use std::fs;
use std::path::Path;
use std::io::{self, Write};
use serde_json::json;

// Supported editors for config generation
#[derive(Debug, Clone, Copy)]
enum Editor {
    VsCode,
    RustRover,
    Neovim,
}

// CLI arguments struct
#[derive(Debug)]
struct CliArgs {
    manifest_path: String,
    output_dir: String,
    editor: Editor,
}

// Parse CLI arguments with error handling
fn parse_args() -> Result {
    let args: Vec = std::env::args().collect();
    if args.len() != 4 {
        return Err(format!(
            \"Usage: {}   \",
            args[0]
        ));
    }

    let editor = match args[3].to_lowercase().as_str() {
        \"vscode\" => Editor::VsCode,
        \"rustrover\" => Editor::RustRover,
        \"neovim\" => Editor::Neovim,
        _ => return Err(format!(\"Unsupported editor: {}\", args[3])),
    };

    Ok(CliArgs {
        manifest_path: args[1].clone(),
        output_dir: args[2].clone(),
        editor,
    })
}

// Read and parse Cargo.toml manifest
fn load_manifest(path: &str) -> Result {
    let content = fs::read_to_string(path)
        .map_err(|e| format!(\"Failed to read {}: {}\", path, e))?;
    CargoToml::from_str(&content)
        .map_err(|e| format!(\"Failed to parse Cargo.toml: {}\", e))
}

// Generate VS Code settings.json for rust-analyzer
fn generate_vscode_config(manifest: &Manifest, output_dir: &str) -> io::Result<()> {
    let settings = json!({
        \"rust-analyzer.linkedProjects\": [manifest.package().name()],
        \"rust-analyzer.cargo.extraEnv\": {
            \"RUST_LOG\": \"info\"
        },
        \"editor.formatOnSave\": true,
        \"rust-analyzer.checkOnSave.command\": \"clippy\"
    });

    let output_path = Path::new(output_dir).join(\".vscode/settings.json\");
    fs::create_dir_all(output_path.parent().unwrap())?;
    let mut file = fs::File::create(output_path)?;
    file.write_all(serde_json::to_string_pretty(&settings).unwrap().as_bytes())?;
    Ok(())
}

// Generate RustRover workspace.xml config
fn generate_rustrover_config(manifest: &Manifest, output_dir: &str) -> io::Result<()> {
    let config = format!(
        r#\"





\"#,
        manifest.package().name()
    );

    let output_path = Path::new(output_dir).join(\".idea/workspace.xml\");
    fs::create_dir_all(output_path.parent().unwrap())?;
    let mut file = fs::File::create(output_path)?;
    file.write_all(config.as_bytes())?;
    Ok(())
}

// Generate Neovim lua LSP config for rustaceanvim
fn generate_neovim_config(manifest: &Manifest, output_dir: &str) -> io::Result<()> {
    let config = format!(
        r#\"-- Neovim LSP config for {}
local lspconfig = require(\"lspconfig\")
local rustaceanvim = require(\"rustaceanvim\")

rustaceanvim.setup({{
  server = {{
    settings = {{
      [\"rust-analyzer\"] = {{
        linkedProjects = {{ \"{}\" }},
        cargo = {{
          extraEnv = {{ RUST_LOG = \"info\" }}
        }},
        checkOnSave = {{
          command = \"clippy\"
        }}
      }}
    }}
  }}
}})
\"#,
        manifest.package().name(),
        manifest.package().name()
    );

    let output_path = Path::new(output_dir).join(\"lsp-config.lua\");
    fs::create_dir_all(output_path.parent().unwrap())?;
    let mut file = fs::File::create(output_path)?;
    file.write_all(config.as_bytes())?;
    Ok(())
}

fn main() -> Result<(), String> {
    let args = parse_args()?;
    let manifest = load_manifest(&args.manifest_path)?;

    // Generate config for selected editor
    let result = match args.editor {
        Editor::VsCode => generate_vscode_config(&manifest, &args.output_dir),
        Editor::RustRover => generate_rustrover_config(&manifest, &args.output_dir),
        Editor::Neovim => generate_neovim_config(&manifest, &args.output_dir),
    };

    match result {
        Ok(_) => {
            println!(\"Successfully generated config for {:?}\", args.editor);
            Ok(())
        }
        Err(e) => Err(format!(\"Failed to write config: {}\", e)),
    }
}

// Example 3: Rust 1.96 compilation benchmark runner
// Executes cold/hot compilation benchmarks for each editor's LSP
use std::process::{Command, Stdio};
use std::time::{Duration, Instant};
use std::fs;
use std::path::Path;
use serde::{Deserialize, Serialize};

// Benchmark configuration
#[derive(Debug, Deserialize)]
struct BenchmarkConfig {
    editors: Vec,
    codebases: Vec,
    runs_per_bench: u32,
}

// Per-editor benchmark config
#[derive(Debug, Deserialize)]
struct EditorConfig {
    name: String,
    lsp_command: Vec,
    cargo_env: Vec<(String, String)>,
}

// Per-codebase benchmark config
#[derive(Debug, Deserialize)]
struct CodebaseConfig {
    name: String,
    path: String,
    loc: u32,
}

// Benchmark result struct
#[derive(Debug, Serialize)]
struct BenchmarkResult {
    editor: String,
    codebase: String,
    bench_type: String, // \"cold\" or \"incremental\"
    avg_duration_ms: u128,
    min_duration_ms: u128,
    max_duration_ms: u128,
}

// Run a single compilation benchmark
fn run_single_bench(
    editor: &EditorConfig,
    codebase_path: &str,
    bench_type: &str,
) -> Result {
    // Set up environment variables for editor LSP
    let mut env = std::env::vars().collect::>();
    env.extend(editor.cargo_env.iter().cloned());

    // Run cargo build with LSP wrapper
    let start = Instant::now();
    let status = Command::new(&editor.lsp_command[0])
        .args(&editor.lsp_command[1..])
        .envs(env.iter().map(|(k, v)| (k.as_str(), v.as_str())))
        .current_dir(codebase_path)
        .stdout(Stdio::null())
        .stderr(Stdio::null())
        .status()
        .map_err(|e| format!(\"Failed to run LSP command: {}\", e))?;

    if !status.success() {
        return Err(format!(\"LSP command exited with status: {}\", status));
    }

    // For incremental bench, touch a file and rebuild
    if bench_type == \"incremental\" {
        let src_file = Path::new(codebase_path).join(\"src/lib.rs\");
        let content = fs::read_to_string(&src_file)
            .map_err(|e| format!(\"Failed to read src/lib.rs: {}\", e))?;
        fs::write(&src_file, content)
            .map_err(|e| format!(\"Failed to write src/lib.rs: {}\", e))?;

        let rebuild_start = Instant::now();
        let rebuild_status = Command::new(\"cargo\")
            .args(&[\"build\", \"--release\"])
            .current_dir(codebase_path)
            .stdout(Stdio::null())
            .stderr(Stdio::null())
            .status()
            .map_err(|e| format!(\"Failed to run cargo build: {}\", e))?;

        if !rebuild_status.success() {
            return Err(\"Incremental rebuild failed\".into());
        }
        return Ok(rebuild_start.elapsed());
    }

    Ok(start.elapsed())
}

// Run full benchmark suite
fn run_benchmarks(config: &BenchmarkConfig) -> Vec {
    let mut results = Vec::new();

    for editor in &config.editors {
        for codebase in &config.codebases {
            // Cold start benchmark (clean build)
            let mut cold_durations = Vec::new();
            for _ in 0..config.runs_per_bench {
                // Clean previous build artifacts
                Command::new(\"cargo\")
                    .args(&[\"clean\"])
                    .current_dir(&codebase.path)
                    .output()
                    .ok();

                match run_single_bench(editor, &codebase.path, \"cold\") {
                    Ok(duration) => cold_durations.push(duration),
                    Err(e) => eprintln!(\"Cold bench failed for {} {}: {}\", editor.name, codebase.name, e),
                }
            }

            // Calculate cold stats
            if !cold_durations.is_empty() {
                cold_durations.sort();
                let avg = cold_durations.iter().sum::() / cold_durations.len() as u32;
                results.push(BenchmarkResult {
                    editor: editor.name.clone(),
                    codebase: codebase.name.clone(),
                    bench_type: \"cold\".into(),
                    avg_duration_ms: avg.as_millis(),
                    min_duration_ms: cold_durations.first().unwrap().as_millis(),
                    max_duration_ms: cold_durations.last().unwrap().as_millis(),
                });
            }

            // Incremental benchmark
            let mut inc_durations = Vec::new();
            for _ in 0..config.runs_per_bench {
                match run_single_bench(editor, &codebase.path, \"incremental\") {
                    Ok(duration) => inc_durations.push(duration),
                    Err(e) => eprintln!(\"Incremental bench failed for {} {}: {}\", editor.name, codebase.name, e),
                }
            }

            // Calculate incremental stats
            if !inc_durations.is_empty() {
                inc_durations.sort();
                let avg = inc_durations.iter().sum::() / inc_durations.len() as u32;
                results.push(BenchmarkResult {
                    editor: editor.name.clone(),
                    codebase: codebase.name.clone(),
                    bench_type: \"incremental\".into(),
                    avg_duration_ms: avg.as_millis(),
                    min_duration_ms: inc_durations.first().unwrap().as_millis(),
                    max_duration_ms: inc_durations.last().unwrap().as_millis(),
                });
            }
        }
    }

    results
}

fn main() -> Result<(), String> {
    // Load benchmark config from benches.toml
    let config_content = fs::read_to_string(\"benches.toml\")
        .map_err(|e| format!(\"Failed to read benches.toml: {}\", e))?;
    let config: BenchmarkConfig = toml::from_str(&config_content)
        .map_err(|e| format!(\"Failed to parse benches.toml: {}\", e))?;

    let results = run_benchmarks(&config);

    // Write results to JSON
    let output = serde_json::to_string_pretty(&results)
        .map_err(|e| format!(\"Failed to serialize results: {}\", e))?;
    fs::write(\"benchmark-results.json\", output)
        .map_err(|e| format!(\"Failed to write results: {}\", e))?;

    println!(\"Benchmarks complete. Results written to benchmark-results.json\");
    Ok(())
}

-- Neovim 0.10 lazy loading config for rustaceanvim
return {
  \"mrcjkb/rustaceanvim\",
  version = \"^4\",
  lazy = true,
  ft = \"rust\", -- Only load when opening Rust files
  config = function()
    require(\"rustaceanvim\").setup({
      server = {
        settings = {
          [\"rust-analyzer\"] = {
            cargo = { allFeatures = true },
            checkOnSave = { command = \"clippy\" }
          }
        }
      }
    })
  end
}

// .vscode/settings.json for 180k LOC Rust monolith
{
  \"rust-analyzer.linkedProjects\": [\"crates/payment-core\"],
  \"rust-analyzer.cargo.features\": [\"postgres\", \"kubernetes\"],
  \"rust-analyzer.updates.channel\": \"none\",
  \"editor.formatOnSave\": true,
  \"rust-analyzer.checkOnSave.command\": \"clippy\"
}

# Run RustRover profiler from CLI (for CI integration)
./rustrover-clone/bin/rustrover \
  -Drust.compilation.profiling.enabled=true \
  -Drust.compilation.profiling.output=profiler-results.json \
  build \
  --project-dir /path/to/rust/monolith