Mirrors/rust
1
0
Fork 0
mirror of https://github.com/rust-lang/rust.git synced 2026-04-27 18:57:42 +03:00
Code Issues Packages Projects Releases Wiki Activity

Auto merge of #134887 - Zalathar:rollup-ghpz7oy, r=Zalathar

Browse Source 
Rollup of 5 pull requests

Successful merges:

 - #134799 (nits: Cleanups in `librustdoc::clean`)
 - #134851 (docs: inline `alloc::ffi::c_str` types to `alloc::ffi`)
 - #134869 (Bump compiler cc)
 - #134876 (bootstrap: Consolidate the macros for declaring compiletest test suites)
 - #134883 (bootstrap: Fix `./x check bootstrap` by moving `shared_helpers::tests`)

r? `@ghost`
`@rustbot` modify labels: rollup
This commit is contained in:
bors
2024-12-29 12:43:22 +00:00
parent e7738afb70 fc89cb202f
commit 64feb9b502
10 changed files with 142 additions and 123 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Cargo.lock
+2 -2
View File
@@ -405,9 +405,9 @@ version = "0.1.0"
[[package]]
name = "cc"
version = "1.2.5"
version = "1.2.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c31a0499c1dc64f458ad13872de75c0eb7e3fdb0e67964610c914b034fc5956e"
checksum = "8d6dbb628b8f8555f86d0323c2eb39e3ec81901f4b83e091db8a6a76d316a333"
dependencies = [
"shlex",
]
compiler/rustc_codegen_ssa/Cargo.toml
+1 -1
View File
@@ -10,7 +10,7 @@ arrayvec = { version = "0.7", default-features = false }
bitflags = "2.4.1"
# Pinned so `cargo update` bumps don't cause breakage. Please also update the
# `cc` in `rustc_llvm` if you update the `cc` here.
cc = "=1.2.5"
cc = "=1.2.6"
either = "1.5.0"
itertools = "0.12"
pathdiff = "0.2.0"
compiler/rustc_llvm/Cargo.toml
+1 -1
View File
@@ -12,5 +12,5 @@ libc = "0.2.73"
# tidy-alphabetical-start
# Pinned so `cargo update` bumps don't cause breakage. Please also update the
# pinned `cc` in `rustc_codegen_ssa` if you update `cc` here.
cc = "=1.2.5"
cc = "=1.2.6"
# tidy-alphabetical-end
library/alloc/src/ffi/mod.rs
+1 -1
View File
@@ -83,7 +83,7 @@
#[doc(inline)]
#[stable(feature = "alloc_c_string", since = "1.64.0")]
pub use self::c_str::CString;
#[doc(no_inline)]
#[doc(inline)]
#[stable(feature = "alloc_c_string", since = "1.64.0")]
pub use self::c_str::{FromVecWithNulError, IntoStringError, NulError};
src/bootstrap/src/core/build_steps/test.rs
+113 -103
View File
@@ -1133,69 +1133,21 @@ fn testdir(builder: &Builder<'_>, host: TargetSelection) -> PathBuf {
builder.out.join(host).join("test")
}
macro_rules! default_test {
($name:ident { path: $path:expr, mode: $mode:expr, suite: $suite:expr }) => {
test!($name { path: $path, mode: $mode, suite: $suite, default: true, host: false });
};
}
macro_rules! default_test_with_compare_mode {
($name:ident { path: $path:expr, mode: $mode:expr, suite: $suite:expr,
compare_mode: $compare_mode:expr }) => {
test_with_compare_mode!($name {
path: $path,
mode: $mode,
suite: $suite,
default: true,
host: false,
compare_mode: $compare_mode
});
};
}
macro_rules! host_test {
($name:ident { path: $path:expr, mode: $mode:expr, suite: $suite:expr }) => {
test!($name { path: $path, mode: $mode, suite: $suite, default: true, host: true });
};
}
/// Declares a test step that invokes compiletest on a particular test suite.
macro_rules! test {
($name:ident { path: $path:expr, mode: $mode:expr, suite: $suite:expr, default: $default:expr,
host: $host:expr }) => {
test_definitions!($name {
path: $path,
mode: $mode,
suite: $suite,
default: $default,
host: $host,
compare_mode: None
});
};
}
macro_rules! test_with_compare_mode {
($name:ident { path: $path:expr, mode: $mode:expr, suite: $suite:expr, default: $default:expr,
host: $host:expr, compare_mode: $compare_mode:expr }) => {
test_definitions!($name {
path: $path,
mode: $mode,
suite: $suite,
default: $default,
host: $host,
compare_mode: Some($compare_mode)
});
};
}
macro_rules! test_definitions {
($name:ident {
path: $path:expr,
mode: $mode:expr,
suite: $suite:expr,
default: $default:expr,
host: $host:expr,
compare_mode: $compare_mode:expr
}) => {
(
$( #[$attr:meta] )* // allow docstrings and attributes
$name:ident {
path: $path:expr,
mode: $mode:expr,
suite: $suite:expr,
default: $default:expr
$( , only_hosts: $only_hosts:expr )? // default: false
$( , compare_mode: $compare_mode:expr )? // default: None
$( , )? // optional trailing comma
}
) => {
$( #[$attr] )*
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct $name {
pub compiler: Compiler,
@@ -1205,7 +1157,12 @@ pub struct $name {
impl Step for $name {
type Output = ();
const DEFAULT: bool = $default;
const ONLY_HOSTS: bool = $host;
const ONLY_HOSTS: bool = (const {
#[allow(unused_assignments, unused_mut)]
let mut value = false;
$( value = $only_hosts; )?
value
});
fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> {
run.suite_path($path)
@@ -1224,7 +1181,12 @@ fn run(self, builder: &Builder<'_>) {
mode: $mode,
suite: $suite,
path: $path,
compare_mode: $compare_mode,
compare_mode: (const {
#[allow(unused_assignments, unused_mut)]
let mut value = None;
$( value = $compare_mode; )?
value
}),
})
}
}
@@ -1232,13 +1194,18 @@ fn run(self, builder: &Builder<'_>) {
}
/// Declares an alias for running the [`Coverage`] tests in only one mode.
/// Adapted from [`test_definitions`].
/// Adapted from [`test`].
macro_rules! coverage_test_alias {
($name:ident {
alias_and_mode: $alias_and_mode:expr, // &'static str
default: $default:expr, // bool
only_hosts: $only_hosts:expr $(,)? // bool
}) => {
(
$( #[$attr:meta] )* // allow docstrings and attributes
$name:ident {
alias_and_mode: $alias_and_mode:expr, // &'static str
default: $default:expr, // bool
only_hosts: $only_hosts:expr // bool
$( , )? // optional trailing comma
}
) => {
$( #[$attr] )*
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct $name {
pub compiler: Compiler,
@@ -1410,37 +1377,74 @@ fn run(self, builder: &Builder<'_>) {
}
}
default_test!(Ui { path: "tests/ui", mode: "ui", suite: "ui" });
test!(Ui { path: "tests/ui", mode: "ui", suite: "ui", default: true });
default_test!(Crashes { path: "tests/crashes", mode: "crashes", suite: "crashes" });
test!(Crashes { path: "tests/crashes", mode: "crashes", suite: "crashes", default: true });
default_test!(Codegen { path: "tests/codegen", mode: "codegen", suite: "codegen" });
test!(Codegen { path: "tests/codegen", mode: "codegen", suite: "codegen", default: true });
default_test!(CodegenUnits {
test!(CodegenUnits {
path: "tests/codegen-units",
mode: "codegen-units",
suite: "codegen-units"
suite: "codegen-units",
default: true,
});
default_test!(Incremental { path: "tests/incremental", mode: "incremental", suite: "incremental" });
test!(Incremental {
path: "tests/incremental",
mode: "incremental",
suite: "incremental",
default: true,
});
default_test_with_compare_mode!(Debuginfo {
test!(Debuginfo {
path: "tests/debuginfo",
mode: "debuginfo",
suite: "debuginfo",
compare_mode: "split-dwarf"
default: true,
compare_mode: Some("split-dwarf"),
});
host_test!(UiFullDeps { path: "tests/ui-fulldeps", mode: "ui", suite: "ui-fulldeps" });
test!(UiFullDeps {
path: "tests/ui-fulldeps",
mode: "ui",
suite: "ui-fulldeps",
default: true,
only_hosts: true,
});
host_test!(Rustdoc { path: "tests/rustdoc", mode: "rustdoc", suite: "rustdoc" });
host_test!(RustdocUi { path: "tests/rustdoc-ui", mode: "ui", suite: "rustdoc-ui" });
test!(Rustdoc {
path: "tests/rustdoc",
mode: "rustdoc",
suite: "rustdoc",
default: true,
only_hosts: true,
});
test!(RustdocUi {
path: "tests/rustdoc-ui",
mode: "ui",
suite: "rustdoc-ui",
default: true,
only_hosts: true,
});
host_test!(RustdocJson { path: "tests/rustdoc-json", mode: "rustdoc-json", suite: "rustdoc-json" });
test!(RustdocJson {
path: "tests/rustdoc-json",
mode: "rustdoc-json",
suite: "rustdoc-json",
default: true,
only_hosts: true,
});
host_test!(Pretty { path: "tests/pretty", mode: "pretty", suite: "pretty" });
test!(Pretty {
path: "tests/pretty",
mode: "pretty",
suite: "pretty",
default: true,
only_hosts: true,
});
/// Special-handling is needed for `run-make`, so don't use `default_test` for defining `RunMake`
/// Special-handling is needed for `run-make`, so don't use `test!` for defining `RunMake`
/// tests.
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub struct RunMake {
@@ -1475,7 +1479,7 @@ fn run(self, builder: &Builder<'_>) {
}
}
default_test!(Assembly { path: "tests/assembly", mode: "assembly", suite: "assembly" });
test!(Assembly { path: "tests/assembly", mode: "assembly", suite: "assembly", default: true });
/// Coverage tests are a bit more complicated than other test suites, because
/// we want to run the same set of test files in multiple different modes,
@@ -1552,27 +1556,33 @@ fn run(self, builder: &Builder<'_>) {
}
}
// Runs `tests/coverage` in "coverage-map" mode only.
// Used by `x test` and `x test coverage-map`.
coverage_test_alias!(CoverageMap {
alias_and_mode: "coverage-map",
default: true,
only_hosts: false,
});
// Runs `tests/coverage` in "coverage-run" mode only.
// Used by `x test` and `x test coverage-run`.
coverage_test_alias!(CoverageRun {
alias_and_mode: "coverage-run",
default: true,
// Compiletest knows how to automatically skip these tests when cross-compiling,
// but skipping the whole step here makes it clearer that they haven't run at all.
only_hosts: true,
});
coverage_test_alias! {
/// Runs the `tests/coverage` test suite in "coverage-map" mode only.
/// Used by `x test` and `x test coverage-map`.
CoverageMap {
alias_and_mode: "coverage-map",
default: true,
only_hosts: false,
}
}
coverage_test_alias! {
/// Runs the `tests/coverage` test suite in "coverage-run" mode only.
/// Used by `x test` and `x test coverage-run`.
CoverageRun {
alias_and_mode: "coverage-run",
default: true,
// Compiletest knows how to automatically skip these tests when cross-compiling,
// but skipping the whole step here makes it clearer that they haven't run at all.
only_hosts: true,
}
}
host_test!(CoverageRunRustdoc {
test!(CoverageRunRustdoc {
path: "tests/coverage-run-rustdoc",
mode: "coverage-run",
suite: "coverage-run-rustdoc"
suite: "coverage-run-rustdoc",
default: true,
only_hosts: true,
});
// For the mir-opt suite we do not use macros, as we need custom behavior when blessing.
src/bootstrap/src/utils/mod.rs
+2
View File
@@ -14,3 +14,5 @@
pub(crate) mod render_tests;
pub(crate) mod shared_helpers;
pub(crate) mod tarball;
#[cfg(test)]
mod tests;
src/bootstrap/src/utils/shared_helpers.rs
+3 -2
View File
@@ -13,8 +13,9 @@
use std::process::Command;
use std::str::FromStr;
#[cfg(test)]
mod tests;
// If we were to declare a tests submodule here, the shim binaries that include this
// module via `#[path]` would fail to find it, which breaks `./x check bootstrap`.
// So instead the unit tests for this module are in `super::tests::shared_helpers_tests`.
/// Returns the environment variable which the dynamic library lookup path
/// resides in for this platform.
src/bootstrap/src/utils/tests/mod.rs
+1
View File
@@ -0,0 +1 @@
mod shared_helpers_tests;
src/bootstrap/src/utils/shared_helpers/tests.rs → src/bootstrap/src/utils/tests/shared_helpers_tests.rs
+8 -1
View File
@@ -1,4 +1,11 @@
use super::parse_value_from_args;
//! The `shared_helpers` module can't have its own tests submodule, because
//! that would cause problems for the shim binaries that include it via
//! `#[path]`, so instead those unit tests live here.
//!
//! To prevent tidy from complaining about this file not being named `tests.rs`,
//! it lives inside a submodule directory named `tests`.
use crate::utils::shared_helpers::parse_value_from_args;
#[test]
fn test_parse_value_from_args() {
src/librustdoc/clean/mod.rs
+10 -12
View File
@@ -268,7 +268,7 @@ fn clean_poly_trait_ref_with_constraints<'tcx>(
)
}
fn clean_lifetime(lifetime: &hir::Lifetime, cx: &mut DocContext<'_>) -> Lifetime {
fn clean_lifetime(lifetime: &hir::Lifetime, cx: &DocContext<'_>) -> Lifetime {
if let Some(
rbv::ResolvedArg::EarlyBound(did)
| rbv::ResolvedArg::LateBound(_, _, did)
@@ -362,9 +362,9 @@ pub(crate) fn clean_predicate<'tcx>(
let bound_predicate = predicate.kind();
match bound_predicate.skip_binder() {
ty::ClauseKind::Trait(pred) => clean_poly_trait_predicate(bound_predicate.rebind(pred), cx),
ty::ClauseKind::RegionOutlives(pred) => clean_region_outlives_predicate(pred),
ty::ClauseKind::RegionOutlives(pred) => Some(clean_region_outlives_predicate(pred)),
ty::ClauseKind::TypeOutlives(pred) => {
clean_type_outlives_predicate(bound_predicate.rebind(pred), cx)
Some(clean_type_outlives_predicate(bound_predicate.rebind(pred), cx))
}
ty::ClauseKind::Projection(pred) => {
Some(clean_projection_predicate(bound_predicate.rebind(pred), cx))
@@ -396,32 +396,30 @@ fn clean_poly_trait_predicate<'tcx>(
})
}
fn clean_region_outlives_predicate(
pred: ty::RegionOutlivesPredicate<'_>,
) -> Option<WherePredicate> {
fn clean_region_outlives_predicate(pred: ty::RegionOutlivesPredicate<'_>) -> WherePredicate {
let ty::OutlivesPredicate(a, b) = pred;
Some(WherePredicate::RegionPredicate {
WherePredicate::RegionPredicate {
lifetime: clean_middle_region(a).expect("failed to clean lifetime"),
bounds: vec![GenericBound::Outlives(
clean_middle_region(b).expect("failed to clean bounds"),
)],
})
}
}
fn clean_type_outlives_predicate<'tcx>(
pred: ty::Binder<'tcx, ty::TypeOutlivesPredicate<'tcx>>,
cx: &mut DocContext<'tcx>,
) -> Option<WherePredicate> {
) -> WherePredicate {
let ty::OutlivesPredicate(ty, lt) = pred.skip_binder();
Some(WherePredicate::BoundPredicate {
WherePredicate::BoundPredicate {
ty: clean_middle_ty(pred.rebind(ty), cx, None, None),
bounds: vec![GenericBound::Outlives(
clean_middle_region(lt).expect("failed to clean lifetimes"),
)],
bound_params: Vec::new(),
})
}
}
fn clean_middle_term<'tcx>(
@@ -1860,7 +1858,7 @@ pub(crate) fn clean_ty<'tcx>(ty: &hir::Ty<'tcx>, cx: &mut DocContext<'tcx>) -> T
/// Returns `None` if the type could not be normalized
fn normalize<'tcx>(
cx: &mut DocContext<'tcx>,
cx: &DocContext<'tcx>,
ty: ty::Binder<'tcx, Ty<'tcx>>,
) -> Option<ty::Binder<'tcx, Ty<'tcx>>> {
// HACK: low-churn fix for #79459 while we wait for a trait normalization fix