rust-lang/rust-analyzer · warning

cargo runnable should deserialize

Error message

cargo runnable should deserialize

What it means

The companion assertion of the cargo-runnable round-trip test: it deserializes the expected JSON back into Runnable and expects success. A panic here means the JSON fixture no longer matches the Runnable/RunnableArgs serde schema — serde_json::from_value returned a deserialization error (missing field, wrong shape, or the kind tag not selecting the Cargo variant).

Source

Thrown at crates/rust-analyzer/src/lsp/ext.rs:1009

        };
        let expected = json!({
            "label": "cargo test -p my-crate",
            "kind": "cargo",
            "args": {
                "environment": {"RUSTC_TOOLCHAIN": "/toolchain"},
                "cwd": "/project",
                "overrideCargo": null,
                "workspaceRoot": "/project",
                "cargoArgs": ["test", "--package", "my-crate", "--lib"],
                "executableArgs": ["my_test", "--exact"],
            }
        });

        let serialized = serde_json::to_value(&runnable).expect("serialized runnable");
        assert_eq!(serialized, expected);

        let deserialized: Runnable =
            serde_json::from_value(expected).expect("cargo runnable should deserialize");
        let RunnableArgs::Cargo(cargo) = &deserialized.args else {
            panic!("expected Cargo variant, got {:?}", deserialized.args);
        };
        assert_eq!(cargo.cargo_args, vec!["test", "--package", "my-crate", "--lib"]);
        assert_eq!(cargo.executable_args, vec!["my_test", "--exact"]);
    }

    #[test]
    fn shell_runnable_round_trips() {
        let runnable = Runnable {
            label: "nextest test_one".to_owned(),
            location: None,
            args: RunnableArgs::Shell(ShellRunnableArgs {
                environment: [("RUSTC_TOOLCHAIN".to_owned(), "/toolchain".to_owned())]
                    .into_iter()
                    .collect(),
                cwd: "/project".into(),
                program: "cargo".into(),

View on GitHub (pinned to e8f7e90aa3)

Solutions

1. Compare the fixture JSON against the current serde derive on Runnable and fix mismatched field names/shape.
2. Ensure the enum uses a discriminant (the `kind` tag) so Cargo and Shell variants deserialize distinctly.
3. Run with RUST_BACKTRACE=1 and print the serde error to see the exact missing/mismatched field.
4. Update the expected JSON (via UPDATE_EXPECT=1 or manually) only after verifying the new schema is intended and the client extension matches.

Example fix

// before: untagged enum
#[derive(Serialize, Deserialize)]
enum RunnableArgs { Cargo(CargoRunnable), Shell(ShellRunnable) }
// after: internally tagged so variants are distinguishable
#[derive(Serialize, Deserialize)]
#[serde(tag = "kind", rename_all = "snake_case")]
enum RunnableArgs { Cargo(CargoRunnable), Shell(ShellRunnable) }

// validate fixture matches current schema before from_value
let value = serde_json::to_value(&runnable).expect("fixture must serialize");
assert!(value.get("kind").is_some(), "runnable payload must carry a kind tag");

fn is_cargo_runnable(v: &serde_json::Value) -> bool {
    v.get("kind").and_then(|k| k.as_str()) == Some("cargo")
        && v.get("cargoArgs").map(|a| a.is_array()).unwrap_or(false)
}

When it happens

Trigger: Changing the serde representation of RunnableArgs::Cargo (field names, tagging strategy like untagged vs internally tagged, removing/renaming cargoArgs or executableArgs) so the fixture JSON in the test fails to deserialize.

Common situations: Contributors refactoring the rust-analyzer runnable LSP extension types, accidentally switching to a tag-less enum where a shell payload parses as cargo, or renaming fields without updating the test's expected JSON.

Related errors

• shell runnable should deserialize
• serialized runnable
• no block

AI-assisted analysis of rust-lang/rust-analyzer@e8f7e90aa3 (2026-09-03). Data as JSON: /api/errors/0bb212fa69e755b6. Report an issue: GitHub.