You are an expert in writing code in many different languages. Your goal is to perform code completion for the following code, keeping in mind the rest of the code and the file meta data.
    Metadata details:
    filename: macos.rs
    path of file: ./repos/cargo-binstall/crates/detect-targets/src/detect
    
    the code of the file until where you have to start completion: use std::process::Stdio;

use tokio::process::Command;

const AARCH64: &str = "aarch64-apple-darwin";
const X86: &str = "x86_64-apple-darwin";
/// https://doc.rust-lang.org/nightly/rustc/platform-support/x86_64h-apple-darwin.html
///
/// This target is an x86_64 target that only supports Apple's late-gen
/// (Haswell-compatible) Intel chips.
///
/// It enables a set of target features available on these chips (AVX2 and similar),
/// and MachO binaries built with this target may be used as the x86_64h entry in
/// universal binaries ("fat" MachO binaries), and will fail to load on machines
/// that do not support this.
///
/// It is similar to x86_64-apple-darwin in nearly all respects, although
/// the minimum supported OS version is slightly higher (it requires 10.8
/// rather than x86_64-apple-darwin's 10.7).
const X86H: &str = "x86_64h-apple-darwin";
const UNIVERSAL: &str = "universal-apple-darwin";
const UNIVERSAL2: &str = "universal2-apple-darwin";

async fn is_arch_supported(arch_name: &str) -> bool {
    Command::new("arch")
        .args(["-arch", arch_name, "/usr/bin/true"])
        .stdin(Stdio::null())
        .stdout(Stdio::null())
        .stderr(Stdio::null())
        .status()
     
    
pub(super) async fn detect_alternative_targets(target: &str) -> impl Iterator<Item = String> {
    match target {
        AARCH64 => {
            // Spawn `arch` in parallel (probably from different threads if
            // mutlti-thread runtime is used).
            //
            // These two tasks are never cancelled, so it can only fail due to
            // panic, in which cause we would propagate by also panic here.
            let x86_64h_task = tokio::spawn(is_arch_supported("x86_64h"));
            let x86_64_task = tokio::spawn(is_arch_supported("x86_64"));
            [
                // Prefer universal as it provides native arm executable
                Some(UNIVERSAL),
                Some(UNIVERSAL2),
                // Prefer x86h since it is more optimized
                x86_64h_task.await.unwrap().then_some(X86H),
                x86_64_task.await.unwrap().then_some(X86),
            ]
        }
        X86 => [
            is_arch_supported("x86_64h").await.then_some(X86H),
            Some(UNIVERSAL),
            Some(UNIVERSAL2),
            None,
        ],
        X86H => [Some(X86), Some(UNIVERSAL), Some(UNIVERSAL2), None],
        _ => [None, None, None, None],
    }
    .into_iter()
    .flatten()
    .map(ToString::to_string)
}