Switch azure to macOS 10.15.

CONTRIBUTING.md

@@ -115,10 +115,8 @@ may also need to install additional tools for the target. For example, on Ubuntu
 you should install the `gcc-multilib` package.
 
 If you can't install an alternate target, you can set the
-`CFG_DISABLE_CROSS_TESTS=1` environment variable to disable these tests.
+`CFG_DISABLE_CROSS_TESTS=1` environment variable to disable these tests. The
-Unfortunately 32-bit support on macOS is going away, so you may not be able to
+Windows cross tests only support the MSVC toolchain.
-run these tests on macOS. The Windows cross tests only support the MSVC
-toolchain.
 
 Some of the nightly tests require the `rustc-dev` component installed. This
 component includes the compiler as a library. This may already be installed

azure-pipelines.yml

@@ -26,12 +26,12 @@ jobs:
 
 - job: macOS
   pool:
-    vmImage: macos-10.13
+    vmImage: macos-10.15
   steps:
     - template: ci/azure-test-all.yml
   variables:
     TOOLCHAIN: stable
-    OTHER_TARGET: i686-apple-darwin
+    OTHER_TARGET: x86_64-apple-ios
 
 - job: Windows
   pool:

ci/azure-install-rust.yml

@@ -1,15 +1,4 @@
 steps:
-  - bash: |
-      set -e
-      if command -v rustup; then
-        echo `command -v rustup` `rustup -V` already installed
-        rustup self update
-      else
-        curl -sSL https://sh.rustup.rs | sh -s -- -y --default-toolchain="$TOOLCHAIN" --profile=minimal
-        echo "##vso[task.prependpath]$HOME/.cargo/bin"
-      fi
-    displayName: Install rustup
-
   - bash: |
       set -e
       rustup set profile minimal

crates/cargo-test-support/src/cross_compile.rs

@@ -9,22 +9,26 @@
 //!
 //! These tests are all disabled on rust-lang/rust's CI, but run in Cargo's CI.
 
-use crate::{basic_bin_manifest, main_file, project};
+use crate::{basic_manifest, main_file, project};
+use cargo::util::ProcessError;
+use cargo::CargoResult;
 use std::env;
-use std::process::Command;
+use std::fmt::Write;
+use std::process::{Command, Output};
 use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::Once;
 
+/// Whether or not the resulting cross binaries can run on the host.
+static CAN_RUN_ON_HOST: AtomicBool = AtomicBool::new(false);
+
 pub fn disabled() -> bool {
-    // First, disable if `./configure` requested so.
+    // First, disable if requested.
     match env::var("CFG_DISABLE_CROSS_TESTS") {
         Ok(ref s) if *s == "1" => return true,
         _ => {}
     }
 
-    // Right now, the Windows bots cannot cross compile due to the Mingw setup,
+    // Cross tests are only tested to work on macos, linux, and MSVC windows.
-    // so we disable ourselves on all but macOS/Linux setups where the rustc
-    // install script ensures we have both architectures.
     if !(cfg!(target_os = "macos") || cfg!(target_os = "linux") || cfg!(target_env = "msvc")) {
         return true;
     }
@@ -32,29 +36,43 @@ pub fn disabled() -> bool {
     // It's not particularly common to have a cross-compilation setup, so
     // try to detect that before we fail a bunch of tests through no fault
     // of the user.
-    static CAN_RUN_CROSS_TESTS: AtomicBool = AtomicBool::new(false);
+    static CAN_BUILD_CROSS_TESTS: AtomicBool = AtomicBool::new(false);
     static CHECK: Once = Once::new();
 
     let cross_target = alternate();
 
-    CHECK.call_once(|| {
+    let run_cross_test = || -> CargoResult<Output> {
         let p = project()
             .at("cross_test")
-            .file("Cargo.toml", &basic_bin_manifest("cross_test"))
+            .file("Cargo.toml", &basic_manifest("cross_test", "1.0.0"))
-            .file("src/cross_test.rs", &main_file(r#""testing!""#, &[]))
+            .file("src/main.rs", &main_file(r#""testing!""#, &[]))
             .build();
 
-        let result = p
+        let build_result = p
             .cargo("build --target")
             .arg(&cross_target)
             .exec_with_output();
 
-        if result.is_ok() {
+        if build_result.is_ok() {
-            CAN_RUN_CROSS_TESTS.store(true, Ordering::SeqCst);
+            CAN_BUILD_CROSS_TESTS.store(true, Ordering::SeqCst);
         }
+
+        let result = p
+            .cargo("run --target")
+            .arg(&cross_target)
+            .exec_with_output();
+
+        if result.is_ok() {
+            CAN_RUN_ON_HOST.store(true, Ordering::SeqCst);
+        }
+        build_result
+    };
+
+    CHECK.call_once(|| {
+        drop(run_cross_test());
     });
 
-    if CAN_RUN_CROSS_TESTS.load(Ordering::SeqCst) {
+    if CAN_BUILD_CROSS_TESTS.load(Ordering::SeqCst) {
         // We were able to compile a simple project, so the user has the
         // necessary `std::` bits installed. Therefore, tests should not
         // be disabled.
@@ -75,74 +93,134 @@ pub fn disabled() -> bool {
     }
 
     // We are responsible for warning the user, which we do by panicking.
-    let rustup_available = Command::new("rustup").output().is_ok();
+    let mut message = format!(
-
-    let linux_help = if cfg!(target_os = "linux") {
         "
-
+Cannot cross compile to {}.
-You may need to install runtime libraries for your Linux distribution as well."
-            .to_string()
-    } else {
-        "".to_string()
-    };
-
-    let rustup_help = if rustup_available {
-        format!(
-            "
-
-Alternatively, you can install the necessary libraries for cross-compilation with
-
-    rustup target add {}{}",
-            cross_target, linux_help
-        )
-    } else {
-        "".to_string()
-    };
-
-    panic!(
-        "Cannot cross compile to {}.
 
 This failure can be safely ignored. If you would prefer to not see this
-failure, you can set the environment variable CFG_DISABLE_CROSS_TESTS to \"1\".{}
+failure, you can set the environment variable CFG_DISABLE_CROSS_TESTS to \"1\".
+
+Alternatively, you can install the necessary libraries to enable cross
+compilation tests. Cross compilation tests depend on your host platform.
 ",
-        cross_target, rustup_help
+        cross_target
     );
+
+    if cfg!(target_os = "linux") {
+        message.push_str(
+            "
+Linux cross tests target i686-unknown-linux-gnu, which requires the ability to
+build and run 32-bit targets. This requires the 32-bit libraries to be
+installed. For example, on Ubuntu, run `sudo apt install gcc-multilib` to
+install the necessary libraries.
+",
+        );
+    } else if cfg!(target_os = "macos") {
+        message.push_str(
+            "
+macOS cross tests target x86_64-apple-ios, which requires the iOS SDK to be
+installed. This should be included with Xcode automatically. If you are using
+the Xcode command line tools, you'll need to install the full Xcode app (from
+the Apple App Store), and switch to it with this command:
+
+    sudo xcode-select --switch /Applications/Xcode.app/Contents/Developer
+
+Some cross-tests want to *run* the executables on the host. These tests will
+be ignored if this is not possible. On macOS, this means you need an iOS
+simulator installed to run these tests. To install a simulator, open Xcode, go
+to preferences > Components, and download the latest iOS simulator.
+",
+        );
+    } else if cfg!(target_os = "windows") {
+        message.push_str(
+            "
+Windows cross tests target i686-pc-windows-msvc, which requires the ability
+to build and run 32-bit targets. This should work automatically if you have
+properly installed Visual Studio build tools.
+",
+        );
+    } else {
+        // The check at the top should prevent this.
+        panic!("platform should have been skipped");
     }
 
-pub fn alternate() -> String {
+    let rustup_available = Command::new("rustup").output().is_ok();
-    let platform = match env::consts::OS {
+    if rustup_available {
-        "linux" => "unknown-linux-gnu",
+        write!(
-        "macos" => "apple-darwin",
+            message,
-        "windows" => "pc-windows-msvc",
+            "
-        _ => unreachable!(),
+Make sure that the appropriate `rustc` target is installed with rustup:
-    };
+
-    let arch = match env::consts::ARCH {
+    rustup target add {}
-        "x86" => "x86_64",
+",
-        "x86_64" => "i686",
+            cross_target
-        _ => unreachable!(),
+        )
-    };
+        .unwrap();
-    format!("{}-{}", arch, platform)
+    } else {
+        write!(
+            message,
+            "
+rustup does not appear to be installed. Make sure that the appropriate
+`rustc` target is installed for the target `{}`.
+",
+            cross_target
+        )
+        .unwrap();
+    }
+
+    // Show the actual error message.
+    match run_cross_test() {
+        Ok(_) => message.push_str("\nUh oh, second run succeeded?\n"),
+        Err(err) => match err.downcast_ref::<ProcessError>() {
+            Some(proc_err) => write!(message, "\nTest error: {}\n", proc_err).unwrap(),
+            None => write!(message, "\nUnexpected non-process error: {}\n", err).unwrap(),
+        },
+    }
+
+    panic!(message);
+}
+
+/// The alternate target-triple to build with.
+///
+/// Only use this function on tests that check `cross_compile::disabled`.
+pub fn alternate() -> &'static str {
+    if cfg!(target_os = "macos") {
+        "x86_64-apple-ios"
+    } else if cfg!(target_os = "linux") {
+        "i686-unknown-linux-gnu"
+    } else if cfg!(all(target_os = "windows", target_env = "msvc")) {
+        "i686-pc-windows-msvc"
+    } else {
+        panic!("This test should be gated on cross_compile::disabled.");
+    }
 }
 
 pub fn alternate_arch() -> &'static str {
-    match env::consts::ARCH {
+    if cfg!(target_os = "macos") {
-        "x86" => "x86_64",
+        "x86_64"
-        "x86_64" => "x86",
+    } else {
-        _ => unreachable!(),
+        "x86"
     }
 }
 
-pub fn host() -> String {
+/// Whether or not the host can run cross-compiled executables.
-    let platform = match env::consts::OS {
+pub fn can_run_on_host() -> bool {
-        "linux" => "unknown-linux-gnu",
+    if disabled() {
-        "macos" => "apple-darwin",
+        return false;
-        "windows" => "pc-windows-msvc",
+    }
-        _ => unreachable!(),
+    // macos is currently configured to cross compile to x86_64-apple-ios
-    };
+    // which requires a simulator to run. Azure's CI image appears to have the
-    let arch = match env::consts::ARCH {
+    // SDK installed, but are not configured to launch iOS images with a
-        "x86" => "i686",
+    // simulator.
-        "x86_64" => "x86_64",
+    if cfg!(target_os = "macos") {
-        _ => unreachable!(),
+        if CAN_RUN_ON_HOST.load(Ordering::SeqCst) {
-    };
+            return true;
-    format!("{}-{}", arch, platform)
+        } else {
+            println!("Note: Cannot run on host, skipping.");
+            return false;
+        }
+    } else {
+        assert!(CAN_RUN_ON_HOST.load(Ordering::SeqCst));
+        return true;
+    }
 }

tests/testsuite/build_script.rs

@@ -3554,6 +3554,8 @@ fn rename_with_link_search_path() {
 }
 
 #[cargo_test]
+// Don't have a cdylib cross target on macos.
+#[cfg_attr(target_os = "macos", ignore)]
 fn rename_with_link_search_path_cross() {
     if cross_compile::disabled() {
         return;

tests/testsuite/cross_compile.rs

@@ -51,8 +51,10 @@ fn simple_cross() {
     p.cargo("build -v --target").arg(&target).run();
     assert!(p.target_bin(&target, "foo").is_file());
 
+    if cross_compile::can_run_on_host() {
         p.process(&p.target_bin(&target, "foo")).run();
     }
+}
 
 #[cargo_test]
 fn simple_cross_config() {
@@ -110,8 +112,10 @@ fn simple_cross_config() {
     p.cargo("build -v").run();
     assert!(p.target_bin(&target, "foo").is_file());
 
+    if cross_compile::can_run_on_host() {
         p.process(&p.target_bin(&target, "foo")).run();
     }
+}
 
 #[cargo_test]
 fn simple_deps() {
@@ -144,8 +148,10 @@ fn simple_deps() {
     p.cargo("build --target").arg(&target).run();
     assert!(p.target_bin(&target, "foo").is_file());
 
+    if cross_compile::can_run_on_host() {
         p.process(&p.target_bin(&target, "foo")).run();
     }
+}
 
 #[cargo_test]
 fn linker() {
@@ -292,7 +298,7 @@ fn plugin_with_extra_dylib_dep() {
 
 #[cargo_test]
 fn cross_tests() {
-    if cross_compile::disabled() {
+    if !cross_compile::can_run_on_host() {
         return;
     }
 
@@ -382,7 +388,7 @@ fn no_cross_doctests() {
     p.cargo("test").with_stderr(&host_output).run();
 
     println!("b");
-    let target = cross_compile::host();
+    let target = rustc_host();
     p.cargo("test --target")
         .arg(&target)
         .with_stderr(&format!(
@@ -398,13 +404,33 @@ fn no_cross_doctests() {
 
     println!("c");
     let target = cross_compile::alternate();
-    p.cargo("test --target")
+
+    // This will build the library, but does not build or run doc tests.
+    // This should probably be a warning or error.
+    p.cargo("test -v --doc --target")
+        .arg(&target)
+        .with_stderr(
+            "\
+[COMPILING] foo v0.0.1 ([CWD])
+[RUNNING] `rustc --crate-name foo [..]
+[FINISHED] test [unoptimized + debuginfo] target(s) in [..]
+",
+        )
+        .run();
+
+    if !cross_compile::can_run_on_host() {
+        return;
+    }
+
+    // This tests the library, but does not run the doc tests.
+    p.cargo("test -v --target")
         .arg(&target)
         .with_stderr(&format!(
             "\
 [COMPILING] foo v0.0.1 ([CWD])
+[RUNNING] `rustc --crate-name foo [..]--test[..]
 [FINISHED] test [unoptimized + debuginfo] target(s) in [..]
-[RUNNING] target/{triple}/debug/deps/foo-[..][EXE]
+[RUNNING] `[CWD]/target/{triple}/debug/deps/foo-[..][EXE]`
 ",
             triple = target
         ))
@@ -413,7 +439,7 @@ fn no_cross_doctests() {
 
 #[cargo_test]
 fn simple_cargo_run() {
-    if cross_compile::disabled() {
+    if !cross_compile::can_run_on_host() {
         return;
     }
 
@@ -954,6 +980,8 @@ fn platform_specific_variables_reflected_in_build_scripts() {
 }
 
 #[cargo_test]
+// Don't have a dylib cross target on macos.
+#[cfg_attr(target_os = "macos", ignore)]
 fn cross_test_dylib() {
     if cross_compile::disabled() {
         return;

tests/testsuite/metadata.rs

@@ -1,6 +1,5 @@
 //! Tests for the `cargo metadata` command.
 
-use cargo_test_support::cross_compile::alternate;
 use cargo_test_support::registry::Package;
 use cargo_test_support::{basic_bin_manifest, basic_lib_manifest, main_file, project, rustc_host};
 
@@ -1911,6 +1910,9 @@ fn filter_platform() {
     Package::new("host-dep", "0.0.1").publish();
     Package::new("alt-dep", "0.0.1").publish();
     Package::new("cfg-dep", "0.0.1").publish();
+    // Just needs to be a valid target that is different from host.
+    // Presumably nobody runs these tests on wasm. 🙃
+    let alt_target = "wasm32-unknown-unknown";
     let p = project()
         .file(
             "Cargo.toml",
@@ -1933,7 +1935,7 @@ fn filter_platform() {
                 cfg-dep = "0.0.1"
                 "#,
                 rustc_host(),
-                alternate()
+                alt_target
             ),
         )
         .file("src/lib.rs", "")
@@ -2177,7 +2179,7 @@ fn filter_platform() {
       "links": null
     }
     "#
-    .replace("$ALT_TRIPLE", &alternate())
+    .replace("$ALT_TRIPLE", alt_target)
     .replace("$HOST_TRIPLE", &rustc_host());
 
     // Normal metadata, no filtering, returns *everything*.
@@ -2281,7 +2283,7 @@ fn filter_platform() {
   "workspace_root": "[..]/foo"
 }
 "#
-            .replace("$ALT_TRIPLE", &alternate())
+            .replace("$ALT_TRIPLE", alt_target)
             .replace("$HOST_TRIPLE", &rustc_host())
             .replace("$ALT_DEP", alt_dep)
             .replace("$CFG_DEP", cfg_dep)
@@ -2293,7 +2295,7 @@ fn filter_platform() {
 
     // Filter on alternate, removes cfg and host.
     p.cargo("metadata --filter-platform")
-        .arg(alternate())
+        .arg(alt_target)
         .with_json(
             &r#"
 {
@@ -2355,7 +2357,7 @@ fn filter_platform() {
   "workspace_root": "[..]foo"
 }
 "#
-            .replace("$ALT_TRIPLE", &alternate())
+            .replace("$ALT_TRIPLE", alt_target)
             .replace("$ALT_DEP", alt_dep)
             .replace("$NORMAL_DEP", normal_dep)
             .replace("$FOO", &foo),

tests/testsuite/test.rs

@@ -3664,6 +3664,8 @@ fn cargo_test_doctest_xcompile_ignores() {
         // -Zdoctest-xcompile is unstable
         return;
     }
+    // -Zdoctest-xcompile also enables --enable-per-target-ignores which
+    // allows the ignore-TARGET syntax.
     let p = project()
         .file("Cargo.toml", &basic_lib_manifest("foo"))
         .file(
@@ -3713,7 +3715,7 @@ fn cargo_test_doctest_xcompile_ignores() {
 
 #[cargo_test]
 fn cargo_test_doctest_xcompile() {
-    if cross_compile::disabled() {
+    if !cross_compile::can_run_on_host() {
         return;
     }
     if !is_nightly() {
@@ -3753,7 +3755,7 @@ fn cargo_test_doctest_xcompile() {
 
 #[cargo_test]
 fn cargo_test_doctest_xcompile_runner() {
-    if cross_compile::disabled() {
+    if !cross_compile::can_run_on_host() {
         return;
     }
     if !is_nightly() {
@@ -3789,9 +3791,10 @@ fn cargo_test_doctest_xcompile_runner() {
         config,
         format!(
             r#"
-[target.'cfg(target_arch = "x86")']
+[target.'cfg(target_arch = "{}")']
 runner = "{}"
 "#,
+            cross_compile::alternate_arch(),
             runner_str
         ),
     )
@@ -3801,14 +3804,17 @@ runner = "{}"
         .file("Cargo.toml", &basic_lib_manifest("foo"))
         .file(
             "src/lib.rs",
+            &format!(
                 r#"
                 ///```
-            ///assert!(cfg!(target_arch = "x86"));
+                ///assert!(cfg!(target_arch = "{}"));
                 ///```
-            pub fn foo() -> u8 {
+                pub fn foo() -> u8 {{
                     4
-            }
+                }}
                 "#,
+                cross_compile::alternate_arch()
+            ),
         )
         .build();
 
@@ -3830,7 +3836,7 @@ runner = "{}"
 
 #[cargo_test]
 fn cargo_test_doctest_xcompile_no_runner() {
-    if cross_compile::disabled() {
+    if !cross_compile::can_run_on_host() {
         return;
     }
     if !is_nightly() {
@@ -3842,15 +3848,17 @@ fn cargo_test_doctest_xcompile_no_runner() {
         .file("Cargo.toml", &basic_lib_manifest("foo"))
         .file(
             "src/lib.rs",
+            &format!(
                 r#"
-
                 ///```
-            ///assert!(cfg!(target_arch = "x86"));
+                ///assert!(cfg!(target_arch = "{}"));
                 ///```
-            pub fn foo() -> u8 {
+                pub fn foo() -> u8 {{
                     4
-            }
+                }}
                 "#,
+                cross_compile::alternate_arch()
+            ),
         )
         .build();