feat(cargo-wdk): support target architecture override through config.toml and CARGO_BUILD_TARGET

.github/actions/install-wdk/action.yaml

@@ -139,26 +139,18 @@ runs:
             Write-Host "Using specified version: $version"
         }
 
-        $packages = "C:\packages"
-
-        # Install WDK packages for both host and target architectures
-        # Host architecture needed for build tools and binaries
-        # Target architecture needed for content (libraries, headers)
-        $hostWdkPackage = "Microsoft.Windows.WDK.$hostArch"
-        $targetWdkPackage = "Microsoft.Windows.WDK.$targetArch"
-
-        # Determine packages to install (avoid duplicates if host == target)
-        $packagesToInstall = @($hostWdkPackage)
-        if ($targetWdkPackage -ne $hostWdkPackage) {
-            $packagesToInstall += $targetWdkPackage
-        }
+        $packagesRootDir = "C:\packages"
+
+        # Install WDK packages for both x64 and ARM64 architectures
+
+        $packagesToInstall = @("Microsoft.Windows.WDK.x64", "Microsoft.Windows.WDK.ARM64")
 
         Write-Host "Installing WDK NuGet packages for version $version..."
         Write-Host "Required packages: $($packagesToInstall -join ', ')"
 
         foreach ($packageName in $packagesToInstall) {
             Write-Host "Installing $packageName version $version..."
-            nuget install $packageName -Version $version -OutputDirectory $packages
+            nuget install $packageName -Version $version -OutputDirectory $packagesRootDir
             if ($LASTEXITCODE -ne 0) { 
                 throw "Failed to install $packageName version $version"
             }
@@ -168,7 +160,7 @@ runs:
 
         # Discover installed package paths in packages folder
         Write-Host "Discovering installed package paths..."
-        $packageDirs = Get-ChildItem -Path $packages -Directory | Where-Object { $_.Name -like "Microsoft.Windows.*.$sdkVersion.*" }
+        $packageDirs = Get-ChildItem -Path $packagesRootDir -Directory | Where-Object { $_.Name -like "Microsoft.Windows.*.$sdkVersion.*" }
         Write-Host "Found $($packageDirs.Count) package directories:"
         foreach ($dir in $packageDirs) {
             Write-Host "  - $($dir.Name)"
@@ -220,6 +212,8 @@ runs:
             "WDKContentRoot" = "$targetWdkPackageDir\c\"
             "WDKBinRoot" = "$hostWdkPackageDir\c\bin\$sdkVersion.0"
             "WDKToolRoot" = "$hostWdkPackageDir\c\tools\$sdkVersion.0"
+            "NugetPackagesRoot" = "$packagesRootDir"
+            "FullVersionNumber" = "$version"
         }
 
         # Validate paths exist before setting environment variables

.github/workflows/local-development-makefile.yaml

@@ -66,16 +66,25 @@ jobs:
         uses: dtolnay/rust-toolchain@nightly
         with:
           components: clippy, rustfmt
+          targets: |
+            x86_64-pc-windows-msvc
+            aarch64-pc-windows-msvc
 
       - name: Install Beta Rust Toolchain
         uses: dtolnay/rust-toolchain@beta
         with:
           components: clippy
+          targets: |
+            x86_64-pc-windows-msvc
+            aarch64-pc-windows-msvc
 
       - name: Install Stable Rust Toolchain
         uses: dtolnay/rust-toolchain@stable
         with:
           components: clippy
+          targets: |
+            x86_64-pc-windows-msvc
+            aarch64-pc-windows-msvc
 
       - name: Install Cargo Make
         uses: taiki-e/install-action@v2

.github/workflows/test.yaml

@@ -72,6 +72,9 @@ jobs:
         uses: dtolnay/rust-toolchain@master
         with:
           toolchain: ${{ matrix.rust_toolchain }}
+          targets: |
+            x86_64-pc-windows-msvc
+            aarch64-pc-windows-msvc
           components: llvm-tools-preview
 
       - name: Install cargo-llvm-cov

.vscode/settings.json

@@ -16,6 +16,7 @@
     "./crates/cargo-wdk/tests/mixed-package-kmdf-workspace/Cargo.toml",
     "./crates/cargo-wdk/tests/umdf-driver/Cargo.toml",
     "./crates/cargo-wdk/tests/wdm-driver/Cargo.toml",
+    "./crates/cargo-wdk/tests/kmdf-driver-with-target-override/Cargo.toml",
     "./examples/sample-kmdf-driver/Cargo.toml",
     "./examples/sample-umdf-driver/Cargo.toml",
     "./examples/sample-wdm-driver/Cargo.toml",

crates/cargo-wdk/src/actions/build/build_task.rs

@@ -8,21 +8,23 @@
 use std::path::{Path, PathBuf};
 
 use anyhow::Result;
+use cargo_metadata::Message;
 use mockall_double::double;
 use tracing::debug;
+use wdk_build::CpuArchitecture;
 
 #[double]
 use crate::providers::exec::CommandExec;
 use crate::{
-    actions::{Profile, TargetArch, build::error::BuildTaskError, to_target_triple},
+    actions::{Profile, build::error::BuildTaskError, to_target_triple},
     trace,
 };
 
 /// Builds specified package by running `cargo build`  
 pub struct BuildTask<'a> {
     package_name: &'a str,
     profile: Option<&'a Profile>,
-    target_arch: TargetArch,
+    target_arch: Option<CpuArchitecture>,
     verbosity_level: clap_verbosity_flag::Verbosity,
     manifest_path: PathBuf,
     command_exec: &'a CommandExec,
@@ -49,7 +51,7 @@ impl<'a> BuildTask<'a> {
         package_name: &'a str,
         working_dir: &'a Path,
         profile: Option<&'a Profile>,
-        target_arch: TargetArch,
+        target_arch: Option<CpuArchitecture>,
         verbosity_level: clap_verbosity_flag::Verbosity,
         command_exec: &'a CommandExec,
     ) -> Self {
@@ -69,16 +71,27 @@ impl<'a> BuildTask<'a> {
         }
     }
 
-    /// Entry point method to run the build task
+    /// Run `cargo build` with the configured options
+    ///
     /// # Returns
-    /// * `Result<(), BuildTaskError>` - Result indicating success or failure of
-    ///   the build task
+    /// `Result<impl Iterator<Item = Result<Message, std::io::Error>>,
+    /// BuildTaskError>`
+    ///
+    /// The returned iterator yields `Result<Message, std::io::Error>` values.
+    /// Consumers must handle these results while iterating, because parsing
+    /// errors surface lazily when the message stream is consumed.
+    ///
     /// # Errors
-    /// * `BuildTaskError::CargoBuild` - If there is an error running the cargo
-    ///   build command
-    pub fn run(&self) -> Result<(), BuildTaskError> {
+    /// * `BuildTaskError::EmptyManifestPath` - If the manifest path is empty or
+    ///   not a valid unicode
+    /// * `BuildTaskError::CargoBuild` - If there is an error running the `cargo
+    ///   build` command
+    pub fn run(
+        &self,
+    ) -> Result<impl Iterator<Item = Result<Message, std::io::Error>>, BuildTaskError> {
         debug!("Running cargo build");
         let mut args = vec!["build".to_string()];
+        args.push("--message-format=json".to_string());
         args.push("-p".to_string());
         args.push(self.package_name.to_string());
         if let Some(path) = self.manifest_path.to_str() {
@@ -91,7 +104,7 @@ impl<'a> BuildTask<'a> {
             args.push("--profile".to_string());
             args.push(profile.to_string());
         }
-        if let TargetArch::Selected(target_arch) = self.target_arch {
+        if let Some(target_arch) = self.target_arch {
             args.push("--target".to_string());
             args.push(to_target_triple(target_arch));
         }
@@ -105,26 +118,37 @@ impl<'a> BuildTask<'a> {
 
         // Run cargo build from the provided working directory so that config.toml
         // is respected
-        self.command_exec
+        let output = self
+            .command_exec
             .run("cargo", &args, None, Some(self.working_dir))?;
+
         debug!("cargo build done");
-        Ok(())
+        Ok(Message::parse_stream(std::io::Cursor::new(output.stdout)))
     }
 }
 
 #[cfg(test)]
 mod tests {
+    use std::{
+        os::windows::process::ExitStatusExt,
+        process::{ExitStatus, Output},
+    };
+
+    use cargo_metadata::{BuildFinished, Message};
     use wdk_build::CpuArchitecture;
 
     use super::*;
-    use crate::actions::{Profile, TargetArch};
+    use crate::{
+        actions::Profile,
+        providers::{error::CommandError, exec::MockCommandExec},
+    };
 
     #[test]
     fn new_succeeds_for_valid_args() {
         let working_dir = PathBuf::from("C:/absolute/path/to/working/dir");
         let package_name = "test_package";
         let profile = Profile::Dev;
-        let target_arch = TargetArch::Selected(CpuArchitecture::Amd64);
+        let target_arch = Some(CpuArchitecture::Amd64);
         let verbosity_level = clap_verbosity_flag::Verbosity::default();
         let command_exec = CommandExec::new();
 
@@ -157,7 +181,7 @@ mod tests {
         let working_dir = PathBuf::from("relative/path/to/working/dir");
         let package_name = "test_package";
         let profile = Some(Profile::Dev);
-        let target_arch = TargetArch::Selected(CpuArchitecture::Amd64);
+        let target_arch = Some(CpuArchitecture::Arm64);
         let verbosity_level = clap_verbosity_flag::Verbosity::default();
         let command_exec = CommandExec::new();
 
@@ -170,4 +194,120 @@ mod tests {
             &command_exec,
         );
     }
+
+    #[test]
+    fn run_invokes_cargo_build_with_expected_args_and_returns_output() {
+        let working_dir = PathBuf::from("C:/abs/driver");
+        let manifest_path = working_dir.join("Cargo.toml");
+        let manifest_path_string = manifest_path.to_string_lossy().to_string();
+        let profile = Profile::Release;
+        let target_arch = CpuArchitecture::Amd64;
+        let verbosity = clap_verbosity_flag::Verbosity::default();
+        let expected_args = vec![
+            "build".to_string(),
+            "--message-format=json".to_string(),
+            "-p".to_string(),
+            "my-driver".to_string(),
+            "--manifest-path".to_string(),
+            manifest_path_string,
+            "--profile".to_string(),
+            "release".to_string(),
+            "--target".to_string(),
+            "x86_64-pc-windows-msvc".to_string(),
+        ];
+        let expected_working_dir = working_dir.clone();
+        let mut expected_stdout = br#"{"reason":"build-finished","success":true}"#.to_vec();
+        expected_stdout.push(b'\n');
+        let expected_stdout_for_mock = expected_stdout.clone();
+
+        let mut mock = MockCommandExec::new();
+        mock.expect_run()
+            .withf(move |command, args, _env, working_dir_opt| {
+                let matches_command = command == "cargo";
+                let matches_args = args.len() == expected_args.len()
+                    && args
+                        .iter()
+                        .zip(expected_args.iter())
+                        .all(|(actual, expected)| actual == expected);
+                let working_dir = working_dir_opt
+                    .expect("working directory must be provided when running cargo build");
+                let matches_working_dir = working_dir == expected_working_dir.as_path();
+                matches_command && matches_args && matches_working_dir
+            })
+            .return_once(move |_, _, _, _| {
+                Ok(Output {
+                    status: ExitStatus::default(),
+                    stdout: expected_stdout_for_mock,
+                    stderr: Vec::new(),
+                })
+            });
+        let task = BuildTask::new(
+            "my-driver",
+            &working_dir,
+            Some(&profile),
+            Some(target_arch),
+            verbosity,
+            &mock,
+        );
+
+        let messages = task
+            .run()
+            .expect("expected an iterator over parsed cargo message objects")
+            .collect::<std::result::Result<Vec<_>, _>>()
+            .expect("expected valid cargo messages");
+
+        assert!(
+            matches!(
+                messages.as_slice(),
+                [Message::BuildFinished(BuildFinished { success: true, .. })]
+            ),
+            "expected one successful BuildFinished message, got: {messages:?}"
+        );
+    }
+
+    #[test]
+    fn run_returns_error_when_cargo_command_fails() {
+        let working_dir = PathBuf::from("C:/abs/driver");
+        let mut mock = MockCommandExec::new();
+        mock.expect_run().return_once(|_, _, _, _| {
+            let failure_output = Output {
+                status: ExitStatus::from_raw(1),
+                stdout: b"error".to_vec(),
+                stderr: b"failure".to_vec(),
+            };
+            Err(CommandError::from_output(
+                "cargo",
+                &["build"],
+                &failure_output,
+            ))
+        });
+
+        let task = BuildTask::new(
+            "my-driver",
+            &working_dir,
+            None,
+            None,
+            clap_verbosity_flag::Verbosity::default(),
+            &mock,
+        );
+
+        let err = task.run().err().expect("expected cargo failure");
+        let BuildTaskError::CargoBuild(command_error) = err else {
+            panic!("expected cargo build error");
+        };
+        match command_error {
+            CommandError::CommandFailed {
+                command,
+                args,
+                stdout,
+            } => {
+                assert_eq!(command, "cargo");
+                assert_eq!(args, vec!["build".to_string()]);
+                assert_eq!(stdout, "error");
+            }
+            CommandError::IoError(_, _, err) => {
+                panic!("expected CommandFailed, got IoError: {err}")
+            }
+        }
+    }
 }

crates/cargo-wdk/src/actions/build/error.rs

@@ -35,13 +35,17 @@ pub enum BuildActionError {
     OneOrMoreRustProjectsFailedToBuild(PathBuf),
     #[error("One or more workspace members failed to build in the workspace: {0}")]
     OneOrMoreWorkspaceMembersFailedToBuild(PathBuf),
+    #[error("Unsupported target arch: {0}")]
+    UnsupportedArchitecture(String),
+    #[error("Failed to detect target arch")]
+    CannotDetectTargetArch,
+    #[error("Could not determine target directory for packaging. Cause: {0}")]
+    CannotDetermineTargetDir(String),
 }
 
 /// Errors for the low level build task layer
 #[derive(Error, Debug)]
 pub enum BuildTaskError {
-    #[error("Error getting canonicalized path for manifest file")]
-    CanonicalizeManifestPath(#[from] std::io::Error),
     #[error("Empty manifest path found error")]
     EmptyManifestPath,
     #[error("Error running cargo build command")]