Rollup merge of #143168 - Kivooeo:tf16, r=tgross35
`tests/ui`: A New Order [16/N]
> [!NOTE]
>
> Intermediate commits are intended to help review, but will be squashed prior to merge.
Some `tests/ui/` housekeeping, to trim down number of tests directly under `tests/ui/`. Part of rust-lang/rust#133895.
r? `@tgross35`
(just small one to test new method, also I should squash all this commits except move commit, so we after review will end up having like one move commit and one commit with changes, right?)
diff --git a/Cargo.lock b/Cargo.lock
index e1cf17e..110d171 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -367,6 +367,26 @@
]
[[package]]
+name = "capstone"
+version = "0.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "015ef5d5ca1743e3f94af9509ba6bd2886523cfee46e48d15c2ef5216fd4ac9a"
+dependencies = [
+ "capstone-sys",
+ "libc",
+]
+
+[[package]]
+name = "capstone-sys"
+version = "0.17.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2267cb8d16a1e4197863ec4284ffd1aec26fe7e57c58af46b02590a0235809a0"
+dependencies = [
+ "cc",
+ "libc",
+]
+
+[[package]]
name = "cargo-miri"
version = "0.1.0"
dependencies = [
@@ -738,7 +758,7 @@
"tracing-subscriber",
"unified-diff",
"walkdir",
- "windows",
+ "windows 0.61.3",
]
[[package]]
@@ -1592,7 +1612,7 @@
"js-sys",
"log",
"wasm-bindgen",
- "windows-core",
+ "windows-core 0.61.2",
]
[[package]]
@@ -1917,6 +1937,25 @@
]
[[package]]
+name = "ipc-channel"
+version = "0.19.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6fb8251fb7bcd9ccd3725ed8deae9fe7db8e586495c9eb5b0c52e6233e5e75ea"
+dependencies = [
+ "bincode",
+ "crossbeam-channel",
+ "fnv",
+ "lazy_static",
+ "libc",
+ "mio",
+ "rand 0.8.5",
+ "serde",
+ "tempfile",
+ "uuid",
+ "windows 0.58.0",
+]
+
+[[package]]
name = "is_terminal_polyfill"
version = "1.70.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -2302,6 +2341,18 @@
]
[[package]]
+name = "mio"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "78bed444cc8a2160f01cbcf811ef18cac863ad68ae8ca62092e8db51d51c761c"
+dependencies = [
+ "libc",
+ "log",
+ "wasi 0.11.1+wasi-snapshot-preview1",
+ "windows-sys 0.59.0",
+]
+
+[[package]]
name = "miow"
version = "0.6.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -2316,18 +2367,22 @@
dependencies = [
"aes",
"bitflags",
+ "capstone",
"chrono",
"chrono-tz",
"colored",
"directories",
"getrandom 0.3.3",
+ "ipc-channel",
"libc",
"libffi",
"libloading",
"measureme",
+ "nix",
"rand 0.9.1",
"regex",
"rustc_version",
+ "serde",
"smallvec",
"tempfile",
"tikv-jemalloc-sys",
@@ -3519,7 +3574,7 @@
"thorin-dwp",
"tracing",
"wasm-encoder 0.219.2",
- "windows",
+ "windows 0.61.3",
]
[[package]]
@@ -3578,7 +3633,7 @@
"tempfile",
"thin-vec",
"tracing",
- "windows",
+ "windows 0.61.3",
]
[[package]]
@@ -3641,7 +3696,7 @@
"shlex",
"stable_mir",
"tracing",
- "windows",
+ "windows 0.61.3",
]
[[package]]
@@ -3696,7 +3751,7 @@
"termcolor",
"termize",
"tracing",
- "windows",
+ "windows 0.61.3",
]
[[package]]
@@ -4457,7 +4512,7 @@
"rustc_target",
"termize",
"tracing",
- "windows",
+ "windows 0.61.3",
]
[[package]]
@@ -5142,7 +5197,7 @@
"libc",
"objc2-core-foundation",
"objc2-io-kit",
- "windows",
+ "windows 0.61.3",
]
[[package]]
@@ -6036,12 +6091,22 @@
[[package]]
name = "windows"
+version = "0.58.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dd04d41d93c4992d421894c18c8b43496aa748dd4c081bac0dc93eb0489272b6"
+dependencies = [
+ "windows-core 0.58.0",
+ "windows-targets 0.52.6",
+]
+
+[[package]]
+name = "windows"
version = "0.61.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9babd3a767a4c1aef6900409f85f5d53ce2544ccdfaa86dad48c91782c6d6893"
dependencies = [
"windows-collections",
- "windows-core",
+ "windows-core 0.61.2",
"windows-future",
"windows-link",
"windows-numerics",
@@ -6064,7 +6129,20 @@
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "3beeceb5e5cfd9eb1d76b381630e82c4241ccd0d27f1a39ed41b2760b255c5e8"
dependencies = [
- "windows-core",
+ "windows-core 0.61.2",
+]
+
+[[package]]
+name = "windows-core"
+version = "0.58.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6ba6d44ec8c2591c134257ce647b7ea6b20335bf6379a27dac5f1641fcf59f99"
+dependencies = [
+ "windows-implement 0.58.0",
+ "windows-interface 0.58.0",
+ "windows-result 0.2.0",
+ "windows-strings 0.1.0",
+ "windows-targets 0.52.6",
]
[[package]]
@@ -6073,11 +6151,11 @@
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c0fdd3ddb90610c7638aa2b3a3ab2904fb9e5cdbecc643ddb3647212781c4ae3"
dependencies = [
- "windows-implement",
- "windows-interface",
+ "windows-implement 0.60.0",
+ "windows-interface 0.59.1",
"windows-link",
- "windows-result",
- "windows-strings",
+ "windows-result 0.3.4",
+ "windows-strings 0.4.2",
]
[[package]]
@@ -6086,13 +6164,24 @@
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "fc6a41e98427b19fe4b73c550f060b59fa592d7d686537eebf9385621bfbad8e"
dependencies = [
- "windows-core",
+ "windows-core 0.61.2",
"windows-link",
"windows-threading",
]
[[package]]
name = "windows-implement"
+version = "0.58.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2bbd5b46c938e506ecbce286b6628a02171d56153ba733b6c741fc627ec9579b"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.103",
+]
+
+[[package]]
+name = "windows-implement"
version = "0.60.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a47fddd13af08290e67f4acabf4b459f647552718f683a7b415d290ac744a836"
@@ -6104,6 +6193,17 @@
[[package]]
name = "windows-interface"
+version = "0.58.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "053c4c462dc91d3b1504c6fe5a726dd15e216ba718e84a0e46a88fbe5ded3515"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.103",
+]
+
+[[package]]
+name = "windows-interface"
version = "0.59.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "bd9211b69f8dcdfa817bfd14bf1c97c9188afa36f4750130fcdf3f400eca9fa8"
@@ -6125,12 +6225,21 @@
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9150af68066c4c5c07ddc0ce30421554771e528bde427614c61038bc2c92c2b1"
dependencies = [
- "windows-core",
+ "windows-core 0.61.2",
"windows-link",
]
[[package]]
name = "windows-result"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1d1043d8214f791817bab27572aaa8af63732e11bf84aa21a45a78d6c317ae0e"
+dependencies = [
+ "windows-targets 0.52.6",
+]
+
+[[package]]
+name = "windows-result"
version = "0.3.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "56f42bd332cc6c8eac5af113fc0c1fd6a8fd2aa08a0119358686e5160d0586c6"
@@ -6140,6 +6249,16 @@
[[package]]
name = "windows-strings"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4cd9b125c486025df0eabcb585e62173c6c9eddcec5d117d3b6e8c30e2ee4d10"
+dependencies = [
+ "windows-result 0.2.0",
+ "windows-targets 0.52.6",
+]
+
+[[package]]
+name = "windows-strings"
version = "0.4.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "56e6c93f3a0c3b36176cb1327a4958a0353d5d166c2a35cb268ace15e91d3b57"
diff --git a/compiler/rustc_abi/src/lib.rs b/compiler/rustc_abi/src/lib.rs
index 6d729b6..0df8921 100644
--- a/compiler/rustc_abi/src/lib.rs
+++ b/compiler/rustc_abi/src/lib.rs
@@ -1592,24 +1592,33 @@ pub enum TagEncoding<VariantIdx: Idx> {
/// (so converting the tag to the discriminant can require sign extension).
Direct,
- /// Niche (values invalid for a type) encoding the discriminant:
- /// Discriminant and variant index coincide.
- /// The variant `untagged_variant` contains a niche at an arbitrary
- /// offset (field `tag_field` of the enum), which for a variant with
- /// discriminant `d` is set to
- /// `(d - niche_variants.start).wrapping_add(niche_start)`
- /// (this is wrapping arithmetic using the type of the niche field).
+ /// Niche (values invalid for a type) encoding the discriminant.
+ /// Note that for this encoding, the discriminant and variant index of each variant coincide!
+ /// This invariant is codified as part of [`layout_sanity_check`](../rustc_ty_utils/layout/invariant/fn.layout_sanity_check.html).
///
- /// For example, `Option<(usize, &T)>` is represented such that
- /// `None` has a null pointer for the second tuple field, and
- /// `Some` is the identity function (with a non-null reference).
+ /// The variant `untagged_variant` contains a niche at an arbitrary
+ /// offset (field [`Variants::Multiple::tag_field`] of the enum).
+ /// For a variant with variant index `i`, such that `i != untagged_variant`,
+ /// the tag is set to `(i - niche_variants.start).wrapping_add(niche_start)`
+ /// (this is wrapping arithmetic using the type of the niche field, cf. the
+ /// [`tag_for_variant`](../rustc_const_eval/interpret/struct.InterpCx.html#method.tag_for_variant)
+ /// query implementation).
+ /// To recover the variant index `i` from a `tag`, the above formula has to be reversed,
+ /// i.e. `i = tag.wrapping_sub(niche_start) + niche_variants.start`. If `i` ends up outside
+ /// `niche_variants`, the tag must have encoded the `untagged_variant`.
+ ///
+ /// For example, `Option<(usize, &T)>` is represented such that the tag for
+ /// `None` is the null pointer in the second tuple field, and
+ /// `Some` is the identity function (with a non-null reference)
+ /// and has no additional tag, i.e. the reference being non-null uniquely identifies this variant.
///
/// Other variants that are not `untagged_variant` and that are outside the `niche_variants`
/// range cannot be represented; they must be uninhabited.
+ /// Nonetheless, uninhabited variants can also fall into the range of `niche_variants`.
Niche {
untagged_variant: VariantIdx,
- /// This range *may* contain `untagged_variant`; that is then just a "dead value" and
- /// not used to encode anything.
+ /// This range *may* contain `untagged_variant` or uninhabited variants;
+ /// these are then just "dead values" and not used to encode anything.
niche_variants: RangeInclusive<VariantIdx>,
/// This is inbounds of the type of the niche field
/// (not sign-extended, i.e., all bits beyond the niche field size are 0).
diff --git a/compiler/rustc_ast/src/lib.rs b/compiler/rustc_ast/src/lib.rs
index 4fc7c74..896d1e1 100644
--- a/compiler/rustc_ast/src/lib.rs
+++ b/compiler/rustc_ast/src/lib.rs
@@ -16,10 +16,7 @@
#![feature(box_patterns)]
#![feature(if_let_guard)]
#![feature(macro_metavar_expr)]
-#![feature(negative_impls)]
-#![feature(never_type)]
#![feature(rustdoc_internals)]
-#![feature(stmt_expr_attributes)]
#![recursion_limit = "256"]
// tidy-alphabetical-end
diff --git a/compiler/rustc_attr_data_structures/src/attributes.rs b/compiler/rustc_attr_data_structures/src/attributes.rs
index 60a4f28..5eb1931 100644
--- a/compiler/rustc_attr_data_structures/src/attributes.rs
+++ b/compiler/rustc_attr_data_structures/src/attributes.rs
@@ -253,6 +253,9 @@ pub enum AttributeKind {
/// Represents `#[inline]` and `#[rustc_force_inline]`.
Inline(InlineAttr, Span),
+ /// Represents `#[link_name]`.
+ LinkName { name: Symbol, span: Span },
+
/// Represents `#[loop_match]`.
LoopMatch(Span),
diff --git a/compiler/rustc_attr_data_structures/src/encode_cross_crate.rs b/compiler/rustc_attr_data_structures/src/encode_cross_crate.rs
index 64bcf1f..0d6ee77 100644
--- a/compiler/rustc_attr_data_structures/src/encode_cross_crate.rs
+++ b/compiler/rustc_attr_data_structures/src/encode_cross_crate.rs
@@ -29,6 +29,7 @@ pub fn encode_cross_crate(&self) -> EncodeCrossCrate {
Stability { .. } => Yes,
Cold(..) => No,
ConstContinue(..) => No,
+ LinkName { .. } => Yes,
LoopMatch(..) => No,
MayDangle(..) => No,
MustUse { .. } => Yes,
diff --git a/compiler/rustc_attr_parsing/src/attributes/link_attrs.rs b/compiler/rustc_attr_parsing/src/attributes/link_attrs.rs
new file mode 100644
index 0000000..7402221
--- /dev/null
+++ b/compiler/rustc_attr_parsing/src/attributes/link_attrs.rs
@@ -0,0 +1,30 @@
+use rustc_attr_data_structures::AttributeKind;
+use rustc_attr_data_structures::AttributeKind::LinkName;
+use rustc_feature::{AttributeTemplate, template};
+use rustc_span::{Symbol, sym};
+
+use crate::attributes::{AttributeOrder, OnDuplicate, SingleAttributeParser};
+use crate::context::{AcceptContext, Stage};
+use crate::parser::ArgParser;
+
+pub(crate) struct LinkNameParser;
+
+impl<S: Stage> SingleAttributeParser<S> for LinkNameParser {
+ const PATH: &[Symbol] = &[sym::link_name];
+ const ATTRIBUTE_ORDER: AttributeOrder = AttributeOrder::KeepFirst;
+ const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::WarnButFutureError;
+ const TEMPLATE: AttributeTemplate = template!(NameValueStr: "name");
+
+ fn convert(cx: &mut AcceptContext<'_, '_, S>, args: &ArgParser<'_>) -> Option<AttributeKind> {
+ let Some(nv) = args.name_value() else {
+ cx.expected_name_value(cx.attr_span, None);
+ return None;
+ };
+ let Some(name) = nv.value_as_str() else {
+ cx.expected_string_literal(nv.value_span, Some(nv.value_as_lit()));
+ return None;
+ };
+
+ Some(LinkName { name, span: cx.attr_span })
+ }
+}
diff --git a/compiler/rustc_attr_parsing/src/attributes/mod.rs b/compiler/rustc_attr_parsing/src/attributes/mod.rs
index d407669..584dada 100644
--- a/compiler/rustc_attr_parsing/src/attributes/mod.rs
+++ b/compiler/rustc_attr_parsing/src/attributes/mod.rs
@@ -31,6 +31,7 @@
pub(crate) mod confusables;
pub(crate) mod deprecation;
pub(crate) mod inline;
+pub(crate) mod link_attrs;
pub(crate) mod lint_helpers;
pub(crate) mod loop_match;
pub(crate) mod must_use;
diff --git a/compiler/rustc_attr_parsing/src/context.rs b/compiler/rustc_attr_parsing/src/context.rs
index 71bb86c..1ac41b9 100644
--- a/compiler/rustc_attr_parsing/src/context.rs
+++ b/compiler/rustc_attr_parsing/src/context.rs
@@ -22,6 +22,7 @@
use crate::attributes::confusables::ConfusablesParser;
use crate::attributes::deprecation::DeprecationParser;
use crate::attributes::inline::{InlineParser, RustcForceInlineParser};
+use crate::attributes::link_attrs::LinkNameParser;
use crate::attributes::lint_helpers::{AsPtrParser, PubTransparentParser};
use crate::attributes::loop_match::{ConstContinueParser, LoopMatchParser};
use crate::attributes::must_use::MustUseParser;
@@ -121,6 +122,7 @@ mod late {
Single<DeprecationParser>,
Single<ExportNameParser>,
Single<InlineParser>,
+ Single<LinkNameParser>,
Single<LoopMatchParser>,
Single<MayDangleParser>,
Single<MustUseParser>,
diff --git a/compiler/rustc_codegen_cranelift/src/intrinsics/simd.rs b/compiler/rustc_codegen_cranelift/src/intrinsics/simd.rs
index 68ff0b6..6281089 100644
--- a/compiler/rustc_codegen_cranelift/src/intrinsics/simd.rs
+++ b/compiler/rustc_codegen_cranelift/src/intrinsics/simd.rs
@@ -496,7 +496,8 @@ pub(super) fn codegen_simd_intrinsic_call<'tcx>(
| sym::simd_flog
| sym::simd_flog10
| sym::simd_flog2
- | sym::simd_round => {
+ | sym::simd_round
+ | sym::simd_round_ties_even => {
intrinsic_args!(fx, args => (a); intrinsic);
if !a.layout().ty.is_simd() {
@@ -527,6 +528,8 @@ pub(super) fn codegen_simd_intrinsic_call<'tcx>(
(sym::simd_flog2, types::F64) => "log2",
(sym::simd_round, types::F32) => "roundf",
(sym::simd_round, types::F64) => "round",
+ (sym::simd_round_ties_even, types::F32) => "rintf",
+ (sym::simd_round_ties_even, types::F64) => "rint",
_ => unreachable!("{:?}", intrinsic),
};
fx.lib_call(
diff --git a/compiler/rustc_codegen_gcc/build_system/src/abi_test.rs b/compiler/rustc_codegen_gcc/build_system/src/abi_test.rs
new file mode 100644
index 0000000..3c1531b
--- /dev/null
+++ b/compiler/rustc_codegen_gcc/build_system/src/abi_test.rs
@@ -0,0 +1,65 @@
+use std::ffi::OsStr;
+use std::path::Path;
+
+use crate::utils::run_command_with_output;
+
+fn show_usage() {
+ println!(
+ r#"
+`abi-test` command help:
+ --help : Show this help"#
+ );
+}
+
+pub fn run() -> Result<(), String> {
+ let mut args = std::env::args().skip(2);
+ // FractalFir: In the future, I'd like to add some more subcommands / options.
+ // So, this loop ought to stay for that purpose. It should also stay as a while loop(to parse args)
+ #[allow(clippy::never_loop, clippy::while_let_on_iterator)]
+ while let Some(arg) = args.next() {
+ match arg.as_str() {
+ "--help" => {
+ show_usage();
+ return Ok(());
+ }
+ _ => return Err(format!("Unknown option {arg:?}")),
+ }
+ }
+ // Ensure that we have a cloned version of abi-cafe on hand.
+ crate::utils::git_clone(
+ "https://github.com/Gankra/abi-cafe.git",
+ Some("clones/abi-cafe".as_ref()),
+ true,
+ )
+ .map_err(|err| (format!("Git clone failed with message: {err:?}!")))?;
+ // Configure abi-cafe to use the exact same rustc version we use - this is crucial.
+ // Otherwise, the concept of ABI compatibility becomes meanignless.
+ std::fs::copy("rust-toolchain", "clones/abi-cafe/rust-toolchain")
+ .expect("Could not copy toolchain configs!");
+ // Get the backend path.
+ // We will use the *debug* build of the backend - it has more checks enabled.
+ let backend_path = std::path::absolute("target/debug/librustc_codegen_gcc.so").unwrap();
+ let backend_arg = format!("--add-rustc-codegen-backend=cg_gcc:{}", backend_path.display());
+ // Run ABI cafe using cargo.
+ let cmd: &[&dyn AsRef<OsStr>] = &[
+ &"cargo",
+ &"run",
+ &"--release",
+ &"--",
+ &backend_arg,
+ // Test rust-LLVM to Rust-GCC calls
+ &"--pairs",
+ &"rustc_calls_cg_gcc",
+ &"--pairs",
+ &"cg_gcc_calls_rustc",
+ // Test Rust-GCC to C calls
+ &"--pairs",
+ &"cg_gcc_calls_c",
+ &"--pairs",
+ &"c_calls_cg_gcc",
+ ];
+ // Run ABI cafe.
+ run_command_with_output(cmd, Some(Path::new("clones/abi-cafe")))?;
+
+ Ok(())
+}
diff --git a/compiler/rustc_codegen_gcc/build_system/src/main.rs b/compiler/rustc_codegen_gcc/build_system/src/main.rs
index 078a472..ae975c9 100644
--- a/compiler/rustc_codegen_gcc/build_system/src/main.rs
+++ b/compiler/rustc_codegen_gcc/build_system/src/main.rs
@@ -1,5 +1,6 @@
use std::{env, process};
+mod abi_test;
mod build;
mod clean;
mod clone_gcc;
@@ -12,7 +13,6 @@
mod rustc_info;
mod test;
mod utils;
-
const BUILD_DIR: &str = "build";
macro_rules! arg_error {
@@ -44,7 +44,8 @@ fn usage() {
info : Displays information about the build environment and project configuration.
clone-gcc : Clones the GCC compiler from a specified source.
fmt : Runs rustfmt
- fuzz : Fuzzes `cg_gcc` using rustlantis"
+ fuzz : Fuzzes `cg_gcc` using rustlantis
+ abi-test : Runs the abi-cafe test suite on the codegen, checking for ABI compatibility with LLVM"
);
}
@@ -59,6 +60,7 @@ pub enum Command {
Info,
Fmt,
Fuzz,
+ AbiTest,
}
fn main() {
@@ -77,6 +79,7 @@ fn main() {
Some("test") => Command::Test,
Some("info") => Command::Info,
Some("clone-gcc") => Command::CloneGcc,
+ Some("abi-test") => Command::AbiTest,
Some("fmt") => Command::Fmt,
Some("fuzz") => Command::Fuzz,
Some("--help") => {
@@ -102,6 +105,7 @@ fn main() {
Command::CloneGcc => clone_gcc::run(),
Command::Fmt => fmt::run(),
Command::Fuzz => fuzz::run(),
+ Command::AbiTest => abi_test::run(),
} {
eprintln!("Command failed to run: {e}");
process::exit(1);
diff --git a/compiler/rustc_codegen_gcc/build_system/src/test.rs b/compiler/rustc_codegen_gcc/build_system/src/test.rs
index bcaab0f..f1f31f8 100644
--- a/compiler/rustc_codegen_gcc/build_system/src/test.rs
+++ b/compiler/rustc_codegen_gcc/build_system/src/test.rs
@@ -738,14 +738,7 @@ fn test_libcore(env: &Env, args: &TestArg) -> Result<(), String> {
let path = get_sysroot_dir().join("sysroot_src/library/coretests");
let _ = remove_dir_all(path.join("target"));
// TODO(antoyo): run in release mode when we fix the failures.
- // TODO(antoyo): remove the --skip f16::test_total_cmp when this issue is fixed:
- // https://github.com/rust-lang/rust/issues/141503
- run_cargo_command(
- &[&"test", &"--", &"--skip", &"f16::test_total_cmp"],
- Some(&path),
- env,
- args,
- )?;
+ run_cargo_command(&[&"test"], Some(&path), env, args)?;
Ok(())
}
diff --git a/compiler/rustc_codegen_gcc/patches/0001-Pin-compiler_builtins-to-0.1.160.patch b/compiler/rustc_codegen_gcc/patches/0001-Pin-compiler_builtins-to-0.1.160.patch
deleted file mode 100644
index 39266e0..0000000
--- a/compiler/rustc_codegen_gcc/patches/0001-Pin-compiler_builtins-to-0.1.160.patch
+++ /dev/null
@@ -1,39 +0,0 @@
-From cdb3d407740e4f15c3746051f8ba89b8e74e99d3 Mon Sep 17 00:00:00 2001
-From: None <none@example.com>
-Date: Fri, 30 May 2025 13:46:22 -0400
-Subject: [PATCH] Pin compiler_builtins to 0.1.160
-
----
- library/alloc/Cargo.toml | 2 +-
- library/std/Cargo.toml | 2 +-
- 2 files changed, 2 insertions(+), 2 deletions(-)
-
-diff --git a/library/alloc/Cargo.toml b/library/alloc/Cargo.toml
-index 9d0d957..365c9dc 100644
---- a/library/alloc/Cargo.toml
-+++ b/library/alloc/Cargo.toml
-@@ -16,7 +16,7 @@ bench = false
-
- [dependencies]
- core = { path = "../core", public = true }
--compiler_builtins = { version = "=0.1.159", features = ['rustc-dep-of-std'] }
-+compiler_builtins = { version = "=0.1.160", features = ['rustc-dep-of-std'] }
-
- [features]
- compiler-builtins-mem = ['compiler_builtins/mem']
-diff --git a/library/std/Cargo.toml b/library/std/Cargo.toml
-index 4ff4895..31371f0 100644
---- a/library/std/Cargo.toml
-+++ b/library/std/Cargo.toml
-@@ -18,7 +18,7 @@ cfg-if = { version = "1.0", features = ['rustc-dep-of-std'] }
- panic_unwind = { path = "../panic_unwind", optional = true }
- panic_abort = { path = "../panic_abort" }
- core = { path = "../core", public = true }
--compiler_builtins = { version = "=0.1.159" }
-+compiler_builtins = { version = "=0.1.160" }
- unwind = { path = "../unwind" }
- hashbrown = { version = "0.15", default-features = false, features = [
- 'rustc-dep-of-std',
---
-2.49.0
-
diff --git a/compiler/rustc_codegen_gcc/rust-toolchain b/compiler/rustc_codegen_gcc/rust-toolchain
index bafe497..8be204c 100644
--- a/compiler/rustc_codegen_gcc/rust-toolchain
+++ b/compiler/rustc_codegen_gcc/rust-toolchain
@@ -1,3 +1,3 @@
[toolchain]
-channel = "nightly-2025-05-21"
+channel = "nightly-2025-06-02"
components = ["rust-src", "rustc-dev", "llvm-tools-preview"]
diff --git a/compiler/rustc_codegen_gcc/src/builder.rs b/compiler/rustc_codegen_gcc/src/builder.rs
index 7852aeb..1fce547 100644
--- a/compiler/rustc_codegen_gcc/src/builder.rs
+++ b/compiler/rustc_codegen_gcc/src/builder.rs
@@ -520,8 +520,7 @@ fn llbb(&self) -> Block<'gcc> {
self.block
}
- fn append_block(cx: &'a CodegenCx<'gcc, 'tcx>, func: RValue<'gcc>, name: &str) -> Block<'gcc> {
- let func = cx.rvalue_as_function(func);
+ fn append_block(_: &'a CodegenCx<'gcc, 'tcx>, func: Function<'gcc>, name: &str) -> Block<'gcc> {
func.new_block(name)
}
@@ -782,6 +781,7 @@ fn frem(&mut self, a: RValue<'gcc>, b: RValue<'gcc>) -> RValue<'gcc> {
return self.context.new_call(self.location, fmod, &[a, b]);
}
TypeKind::FP128 => {
+ // TODO(antoyo): use get_simple_function_f128_2args.
let f128_type = self.type_f128();
let fmodf128 = self.context.new_function(
None,
@@ -938,22 +938,36 @@ fn dynamic_alloca(&mut self, _len: RValue<'gcc>, _align: Align) -> RValue<'gcc>
fn load(&mut self, pointee_ty: Type<'gcc>, ptr: RValue<'gcc>, align: Align) -> RValue<'gcc> {
let block = self.llbb();
let function = block.get_function();
+ // NOTE(FractalFir): In some cases, we *should* skip the call to get_aligned.
+ // For example, calling `get_aligned` on a i8 is pointless(since it can only be 1 aligned)
+ // Calling get_aligned on a `u128`/`i128` causes the attribute to become "stacked"
+ //
+ // From GCCs perspective:
+ // __int128_t __attribute__((aligned(16))) __attribute__((aligned(16)))
+ // and:
+ // __int128_t __attribute__((aligned(16)))
+ // are 2 distinct, incompatible types.
+ //
+ // So, we skip the call to `get_aligned` in such a case. *Ideally*, we could do this for all the types,
+ // but the GCC APIs to facilitate this just aren't quite there yet.
+
+ // This checks that we only skip `get_aligned` on 128 bit ints if they have the correct alignment.
+ // Otherwise, this may be an under-aligned load, so we will still call get_aligned.
+ let mut can_skip_align = (pointee_ty == self.cx.u128_type
+ || pointee_ty == self.cx.i128_type)
+ && align == self.int128_align;
+ // We can skip the call to `get_aligned` for byte-sized types with alignment of 1.
+ can_skip_align = can_skip_align
+ || (pointee_ty == self.cx.u8_type || pointee_ty == self.cx.i8_type)
+ && align.bytes() == 1;
+ // Skip the call to `get_aligned` when possible.
+ let aligned_type =
+ if can_skip_align { pointee_ty } else { pointee_ty.get_aligned(align.bytes()) };
+
+ let ptr = self.context.new_cast(self.location, ptr, aligned_type.make_pointer());
// NOTE: instead of returning the dereference here, we have to assign it to a variable in
// the current basic block. Otherwise, it could be used in another basic block, causing a
// dereference after a drop, for instance.
- // FIXME(antoyo): this check that we don't call get_aligned() a second time on a type.
- // Ideally, we shouldn't need to do this check.
- // FractalFir: the `align == self.int128_align` check ensures we *do* call `get_aligned` if
- // the alignment of a `u128`/`i128` is not the one mandated by the ABI. This ensures we handle
- // under-aligned loads correctly.
- let aligned_type = if (pointee_ty == self.cx.u128_type || pointee_ty == self.cx.i128_type)
- && align == self.int128_align
- {
- pointee_ty
- } else {
- pointee_ty.get_aligned(align.bytes())
- };
- let ptr = self.context.new_cast(self.location, ptr, aligned_type.make_pointer());
let deref = ptr.dereference(self.location).to_rvalue();
let loaded_value = function.new_local(
self.location,
@@ -1105,7 +1119,13 @@ fn nonnull_metadata(&mut self, _load: RValue<'gcc>) {
// TODO(antoyo)
}
- fn store(&mut self, val: RValue<'gcc>, ptr: RValue<'gcc>, align: Align) -> RValue<'gcc> {
+ fn store(&mut self, mut val: RValue<'gcc>, ptr: RValue<'gcc>, align: Align) -> RValue<'gcc> {
+ if self.structs_as_pointer.borrow().contains(&val) {
+ // NOTE: hack to workaround a limitation of the rustc API: see comment on
+ // CodegenCx.structs_as_pointer
+ val = val.dereference(self.location).to_rvalue();
+ }
+
self.store_with_flags(val, ptr, align, MemFlags::empty())
}
@@ -1551,16 +1571,13 @@ fn insert_value(
aggregate_value
}
- fn set_personality_fn(&mut self, _personality: RValue<'gcc>) {
+ fn set_personality_fn(&mut self, _personality: Function<'gcc>) {
#[cfg(feature = "master")]
- {
- let personality = self.rvalue_as_function(_personality);
- self.current_func().set_personality_function(personality);
- }
+ self.current_func().set_personality_function(_personality);
}
#[cfg(feature = "master")]
- fn cleanup_landing_pad(&mut self, pers_fn: RValue<'gcc>) -> (RValue<'gcc>, RValue<'gcc>) {
+ fn cleanup_landing_pad(&mut self, pers_fn: Function<'gcc>) -> (RValue<'gcc>, RValue<'gcc>) {
self.set_personality_fn(pers_fn);
// NOTE: insert the current block in a variable so that a later call to invoke knows to
@@ -1581,7 +1598,7 @@ fn cleanup_landing_pad(&mut self, pers_fn: RValue<'gcc>) -> (RValue<'gcc>, RValu
}
#[cfg(not(feature = "master"))]
- fn cleanup_landing_pad(&mut self, _pers_fn: RValue<'gcc>) -> (RValue<'gcc>, RValue<'gcc>) {
+ fn cleanup_landing_pad(&mut self, _pers_fn: Function<'gcc>) -> (RValue<'gcc>, RValue<'gcc>) {
let value1 = self
.current_func()
.new_local(self.location, self.u8_type.make_pointer(), "landing_pad0")
@@ -1591,7 +1608,7 @@ fn cleanup_landing_pad(&mut self, _pers_fn: RValue<'gcc>) -> (RValue<'gcc>, RVal
(value1, value2)
}
- fn filter_landing_pad(&mut self, pers_fn: RValue<'gcc>) {
+ fn filter_landing_pad(&mut self, pers_fn: Function<'gcc>) {
// TODO(antoyo): generate the correct landing pad
self.cleanup_landing_pad(pers_fn);
}
diff --git a/compiler/rustc_codegen_gcc/src/common.rs b/compiler/rustc_codegen_gcc/src/common.rs
index 58ff2f1..fdd4782 100644
--- a/compiler/rustc_codegen_gcc/src/common.rs
+++ b/compiler/rustc_codegen_gcc/src/common.rs
@@ -234,19 +234,6 @@ fn scalar_to_backend(&self, cv: Scalar, layout: abi::Scalar, ty: Type<'gcc>) ->
match cv {
Scalar::Int(int) => {
let data = int.to_bits(layout.size(self));
-
- // FIXME(antoyo): there's some issues with using the u128 code that follows, so hard-code
- // the paths for floating-point values.
- // TODO: Remove this code?
- /*if ty == self.float_type {
- return self
- .context
- .new_rvalue_from_double(ty, f32::from_bits(data as u32) as f64);
- }
- if ty == self.double_type {
- return self.context.new_rvalue_from_double(ty, f64::from_bits(data as u64));
- }*/
-
let value = self.const_uint_big(self.type_ix(bitsize), data);
let bytesize = layout.size(self).bytes();
if bitsize > 1 && ty.is_integral() && bytesize as u32 == ty.get_size() {
diff --git a/compiler/rustc_codegen_gcc/src/context.rs b/compiler/rustc_codegen_gcc/src/context.rs
index ff141ad..1d02981 100644
--- a/compiler/rustc_codegen_gcc/src/context.rs
+++ b/compiler/rustc_codegen_gcc/src/context.rs
@@ -118,14 +118,15 @@ pub struct CodegenCx<'gcc, 'tcx> {
/// A counter that is used for generating local symbol names
local_gen_sym_counter: Cell<usize>,
- eh_personality: Cell<Option<RValue<'gcc>>>,
+ eh_personality: Cell<Option<Function<'gcc>>>,
#[cfg(feature = "master")]
pub rust_try_fn: Cell<Option<(Type<'gcc>, Function<'gcc>)>>,
pub pointee_infos: RefCell<FxHashMap<(Ty<'tcx>, Size), Option<PointeeInfo>>>,
/// NOTE: a hack is used because the rustc API is not suitable to libgccjit and as such,
- /// `const_undef()` returns struct as pointer so that they can later be assigned a value.
+ /// `const_undef()` returns struct as pointer so that they can later be assigned a value (in
+ /// e.g. Builder::insert_value).
/// As such, this set remembers which of these pointers were returned by this function so that
/// they can be dereferenced later.
/// FIXME(antoyo): fix the rustc API to avoid having this hack.
@@ -155,6 +156,13 @@ pub fn new(
.layout_of(ty::TypingEnv::fully_monomorphized().as_query_input(rust_type))
.unwrap();
let align = layout.align.abi.bytes();
+ // For types with size 1, the alignment can be 1 and only 1
+ // So, we can skip the call to ``get_aligned`.
+ // In the future, we can add a GCC API to query the type align,
+ // and call `get_aligned` if and only if that differs from Rust's expectations.
+ if layout.size.bytes() == 1 {
+ return context.new_c_type(ctype);
+ }
#[cfg(feature = "master")]
{
context.new_c_type(ctype).get_aligned(align)
@@ -373,8 +381,7 @@ pub fn bitcast_if_needed(
impl<'gcc, 'tcx> BackendTypes for CodegenCx<'gcc, 'tcx> {
type Value = RValue<'gcc>;
type Metadata = RValue<'gcc>;
- // TODO(antoyo): change to Function<'gcc>.
- type Function = RValue<'gcc>;
+ type Function = Function<'gcc>;
type BasicBlock = Block<'gcc>;
type Type = Type<'gcc>;
@@ -392,11 +399,10 @@ fn vtables(
&self.vtables
}
- fn get_fn(&self, instance: Instance<'tcx>) -> RValue<'gcc> {
+ fn get_fn(&self, instance: Instance<'tcx>) -> Function<'gcc> {
let func = get_fn(self, instance);
*self.current_func.borrow_mut() = Some(func);
- // FIXME(antoyo): this is a wrong cast. That requires changing the compiler API.
- unsafe { std::mem::transmute(func) }
+ func
}
fn get_fn_addr(&self, instance: Instance<'tcx>) -> RValue<'gcc> {
@@ -420,7 +426,7 @@ fn get_fn_addr(&self, instance: Instance<'tcx>) -> RValue<'gcc> {
ptr
}
- fn eh_personality(&self) -> RValue<'gcc> {
+ fn eh_personality(&self) -> Function<'gcc> {
// The exception handling personality function.
//
// If our compilation unit has the `eh_personality` lang item somewhere
@@ -458,9 +464,7 @@ fn eh_personality(&self) -> RValue<'gcc> {
let symbol_name = tcx.symbol_name(instance).name;
let fn_abi = self.fn_abi_of_instance(instance, ty::List::empty());
self.linkage.set(FunctionType::Extern);
- let func = self.declare_fn(symbol_name, fn_abi);
- let func: RValue<'gcc> = unsafe { std::mem::transmute(func) };
- func
+ self.declare_fn(symbol_name, fn_abi)
}
_ => {
let name = if wants_msvc_seh(self.sess()) {
@@ -468,8 +472,7 @@ fn eh_personality(&self) -> RValue<'gcc> {
} else {
"rust_eh_personality"
};
- let func = self.declare_func(name, self.type_i32(), &[], true);
- unsafe { std::mem::transmute::<Function<'gcc>, RValue<'gcc>>(func) }
+ self.declare_func(name, self.type_i32(), &[], true)
}
};
// TODO(antoyo): apply target cpu attributes.
@@ -481,11 +484,11 @@ fn sess(&self) -> &Session {
self.tcx.sess
}
- fn set_frame_pointer_type(&self, _llfn: RValue<'gcc>) {
+ fn set_frame_pointer_type(&self, _llfn: Function<'gcc>) {
// TODO(antoyo)
}
- fn apply_target_cpu_attr(&self, _llfn: RValue<'gcc>) {
+ fn apply_target_cpu_attr(&self, _llfn: Function<'gcc>) {
// TODO(antoyo)
}
diff --git a/compiler/rustc_codegen_gcc/src/debuginfo.rs b/compiler/rustc_codegen_gcc/src/debuginfo.rs
index 3a265fb..4c85851 100644
--- a/compiler/rustc_codegen_gcc/src/debuginfo.rs
+++ b/compiler/rustc_codegen_gcc/src/debuginfo.rs
@@ -1,7 +1,7 @@
use std::ops::Range;
use std::sync::Arc;
-use gccjit::{Location, RValue};
+use gccjit::{Function, Location, RValue};
use rustc_abi::Size;
use rustc_codegen_ssa::mir::debuginfo::{DebugScope, FunctionDebugContext, VariableKind};
use rustc_codegen_ssa::traits::{DebugInfoBuilderMethods, DebugInfoCodegenMethods};
@@ -221,7 +221,7 @@ fn create_function_debug_context(
&self,
instance: Instance<'tcx>,
fn_abi: &FnAbi<'tcx, Ty<'tcx>>,
- llfn: RValue<'gcc>,
+ llfn: Function<'gcc>,
mir: &mir::Body<'tcx>,
) -> Option<FunctionDebugContext<'tcx, Self::DIScope, Self::DILocation>> {
if self.sess().opts.debuginfo == DebugInfo::None {
@@ -272,7 +272,7 @@ fn dbg_scope_fn(
&self,
_instance: Instance<'tcx>,
_fn_abi: &FnAbi<'tcx, Ty<'tcx>>,
- _maybe_definition_llfn: Option<RValue<'gcc>>,
+ _maybe_definition_llfn: Option<Function<'gcc>>,
) -> Self::DIScope {
// TODO(antoyo): implement.
}
diff --git a/compiler/rustc_codegen_gcc/src/declare.rs b/compiler/rustc_codegen_gcc/src/declare.rs
index bed8207..691fd87 100644
--- a/compiler/rustc_codegen_gcc/src/declare.rs
+++ b/compiler/rustc_codegen_gcc/src/declare.rs
@@ -94,7 +94,7 @@ pub fn declare_entry_fn(
_fn_type: Type<'gcc>,
#[cfg(feature = "master")] callconv: Option<FnAttribute<'gcc>>,
#[cfg(not(feature = "master"))] callconv: Option<()>,
- ) -> RValue<'gcc> {
+ ) -> Function<'gcc> {
// TODO(antoyo): use the fn_type parameter.
let const_string = self.context.new_type::<u8>().make_pointer().make_pointer();
let return_type = self.type_i32();
@@ -111,8 +111,7 @@ pub fn declare_entry_fn(
// NOTE: it is needed to set the current_func here as well, because get_fn() is not called
// for the main function.
*self.current_func.borrow_mut() = Some(func);
- // FIXME(antoyo): this is a wrong cast. That requires changing the compiler API.
- unsafe { std::mem::transmute(func) }
+ func
}
pub fn declare_fn(&self, name: &str, fn_abi: &FnAbi<'tcx, Ty<'tcx>>) -> Function<'gcc> {
diff --git a/compiler/rustc_codegen_gcc/src/intrinsic/mod.rs b/compiler/rustc_codegen_gcc/src/intrinsic/mod.rs
index 09132c3..4c10380 100644
--- a/compiler/rustc_codegen_gcc/src/intrinsic/mod.rs
+++ b/compiler/rustc_codegen_gcc/src/intrinsic/mod.rs
@@ -4,7 +4,9 @@
#[cfg(feature = "master")]
use std::iter;
-use gccjit::{ComparisonOp, Function, FunctionType, RValue, ToRValue, Type, UnaryOp};
+#[cfg(feature = "master")]
+use gccjit::Type;
+use gccjit::{ComparisonOp, Function, FunctionType, RValue, ToRValue, UnaryOp};
#[cfg(feature = "master")]
use rustc_abi::ExternAbi;
use rustc_abi::{BackendRepr, HasDataLayout};
@@ -300,6 +302,8 @@ fn codegen_intrinsic_call(
let fn_args = instance.args;
let simple = get_simple_intrinsic(self, name);
+ // TODO(antoyo): Only call get_simple_function_f128 and get_simple_function_f128_2args when
+ // it is the symbols for the supported f128 builtins.
let simple_func = get_simple_function(self, name)
.or_else(|| get_simple_function_f128(self, name))
.or_else(|| get_simple_function_f128_2args(self, name));
@@ -441,7 +445,7 @@ fn codegen_intrinsic_call(
match int_type_width_signed(args[0].layout.ty, self) {
Some((width, signed)) => match name {
sym::ctlz | sym::cttz => {
- let func = self.current_func.borrow().expect("func");
+ let func = self.current_func();
let then_block = func.new_block("then");
let else_block = func.new_block("else");
let after_block = func.new_block("after");
@@ -1109,7 +1113,7 @@ fn pop_count(&mut self, value: RValue<'gcc>) -> RValue<'gcc> {
// for (int counter = 0; value != 0; counter++) {
// value &= value - 1;
// }
- let func = self.current_func.borrow().expect("func");
+ let func = self.current_func();
let loop_head = func.new_block("head");
let loop_body = func.new_block("body");
let loop_tail = func.new_block("tail");
@@ -1188,7 +1192,7 @@ fn saturating_add(
let result_type = lhs.get_type();
if signed {
// Based on algorithm from: https://stackoverflow.com/a/56531252/389119
- let func = self.current_func.borrow().expect("func");
+ let func = self.current_func();
let res = func.new_local(self.location, result_type, "saturating_sum");
let supports_native_type = self.is_native_int_type(result_type);
let overflow = if supports_native_type {
@@ -1259,7 +1263,7 @@ fn saturating_sub(
let result_type = lhs.get_type();
if signed {
// Based on algorithm from: https://stackoverflow.com/a/56531252/389119
- let func = self.current_func.borrow().expect("func");
+ let func = self.current_func();
let res = func.new_local(self.location, result_type, "saturating_diff");
let supports_native_type = self.is_native_int_type(result_type);
let overflow = if supports_native_type {
@@ -1483,10 +1487,9 @@ fn gen_fn<'a, 'gcc, 'tcx>(
// FIXME(eddyb) find a nicer way to do this.
cx.linkage.set(FunctionType::Internal);
let func = cx.declare_fn(name, fn_abi);
- let func_val = unsafe { std::mem::transmute::<Function<'gcc>, RValue<'gcc>>(func) };
- cx.set_frame_pointer_type(func_val);
- cx.apply_target_cpu_attr(func_val);
- let block = Builder::append_block(cx, func_val, "entry-block");
+ cx.set_frame_pointer_type(func);
+ cx.apply_target_cpu_attr(func);
+ let block = Builder::append_block(cx, func, "entry-block");
let bx = Builder::build(cx, block);
codegen(bx);
(return_type, func)
diff --git a/compiler/rustc_codegen_gcc/src/intrinsic/simd.rs b/compiler/rustc_codegen_gcc/src/intrinsic/simd.rs
index ac8b7f4..2e50881 100644
--- a/compiler/rustc_codegen_gcc/src/intrinsic/simd.rs
+++ b/compiler/rustc_codegen_gcc/src/intrinsic/simd.rs
@@ -780,6 +780,7 @@ macro_rules! return_error {
sym::simd_fsin => "sin",
sym::simd_fsqrt => "sqrt",
sym::simd_round => "round",
+ sym::simd_round_ties_even => "rint",
sym::simd_trunc => "trunc",
_ => return_error!(InvalidMonomorphization::UnrecognizedIntrinsic { span, name }),
};
@@ -827,6 +828,7 @@ macro_rules! return_error {
| sym::simd_fsin
| sym::simd_fsqrt
| sym::simd_round
+ | sym::simd_round_ties_even
| sym::simd_trunc
) {
return simd_simple_float_intrinsic(name, in_elem, in_ty, in_len, bx, span, args);
diff --git a/compiler/rustc_codegen_gcc/tests/failing-ui-tests.txt b/compiler/rustc_codegen_gcc/tests/failing-ui-tests.txt
index d931f0d..544d0bf 100644
--- a/compiler/rustc_codegen_gcc/tests/failing-ui-tests.txt
+++ b/compiler/rustc_codegen_gcc/tests/failing-ui-tests.txt
@@ -9,6 +9,7 @@
tests/ui/iterators/iter-sum-overflow-overflow-checks.rs
tests/ui/mir/mir_drop_order.rs
tests/ui/mir/mir_let_chains_drop_order.rs
+tests/ui/mir/mir_match_guard_let_chains_drop_order.rs
tests/ui/oom_unwind.rs
tests/ui/panic-runtime/abort-link-to-unwinding-crates.rs
tests/ui/panic-runtime/abort.rs
diff --git a/compiler/rustc_codegen_llvm/src/intrinsic.rs b/compiler/rustc_codegen_llvm/src/intrinsic.rs
index f7f0628..9930eae 100644
--- a/compiler/rustc_codegen_llvm/src/intrinsic.rs
+++ b/compiler/rustc_codegen_llvm/src/intrinsic.rs
@@ -1537,6 +1537,7 @@ macro_rules! return_error {
sym::simd_fsin => "llvm.sin",
sym::simd_fsqrt => "llvm.sqrt",
sym::simd_round => "llvm.round",
+ sym::simd_round_ties_even => "llvm.rint",
sym::simd_trunc => "llvm.trunc",
_ => return_error!(InvalidMonomorphization::UnrecognizedIntrinsic { span, name }),
};
@@ -1563,6 +1564,7 @@ macro_rules! return_error {
| sym::simd_fsqrt
| sym::simd_relaxed_fma
| sym::simd_round
+ | sym::simd_round_ties_even
| sym::simd_trunc
) {
return simd_simple_float_intrinsic(name, in_elem, in_ty, in_len, bx, span, args);
@@ -2309,7 +2311,13 @@ macro_rules! arith_unary {
// Unary integer intrinsics
if matches!(
name,
- sym::simd_bswap | sym::simd_bitreverse | sym::simd_ctlz | sym::simd_ctpop | sym::simd_cttz
+ sym::simd_bswap
+ | sym::simd_bitreverse
+ | sym::simd_ctlz
+ | sym::simd_ctpop
+ | sym::simd_cttz
+ | sym::simd_funnel_shl
+ | sym::simd_funnel_shr
) {
let vec_ty = bx.cx.type_vector(
match *in_elem.kind() {
@@ -2330,6 +2338,8 @@ macro_rules! arith_unary {
sym::simd_ctlz => "llvm.ctlz",
sym::simd_ctpop => "llvm.ctpop",
sym::simd_cttz => "llvm.cttz",
+ sym::simd_funnel_shl => "llvm.fshl",
+ sym::simd_funnel_shr => "llvm.fshr",
_ => unreachable!(),
};
let int_size = in_elem.int_size_and_signed(bx.tcx()).0.bits();
@@ -2350,6 +2360,11 @@ macro_rules! arith_unary {
// simple unary argument cases
Ok(bx.call_intrinsic(llvm_intrinsic, &[vec_ty], &[args[0].immediate()]))
}
+ sym::simd_funnel_shl | sym::simd_funnel_shr => Ok(bx.call_intrinsic(
+ llvm_intrinsic,
+ &[vec_ty],
+ &[args[0].immediate(), args[1].immediate(), args[2].immediate()],
+ )),
_ => unreachable!(),
};
}
diff --git a/compiler/rustc_codegen_ssa/src/back/linker.rs b/compiler/rustc_codegen_ssa/src/back/linker.rs
index fba84de..ede1149 100644
--- a/compiler/rustc_codegen_ssa/src/back/linker.rs
+++ b/compiler/rustc_codegen_ssa/src/back/linker.rs
@@ -1870,8 +1870,13 @@ pub(crate) fn linked_symbols(
crate_type: CrateType,
) -> Vec<(String, SymbolExportKind)> {
match crate_type {
- CrateType::Executable | CrateType::Cdylib | CrateType::Dylib | CrateType::Sdylib => (),
- CrateType::Staticlib | CrateType::ProcMacro | CrateType::Rlib => {
+ CrateType::Executable
+ | CrateType::ProcMacro
+ | CrateType::Cdylib
+ | CrateType::Dylib
+ | CrateType::Sdylib => (),
+ CrateType::Staticlib | CrateType::Rlib => {
+ // These are not linked, so no need to generate symbols.o for them.
return Vec::new();
}
}
diff --git a/compiler/rustc_codegen_ssa/src/codegen_attrs.rs b/compiler/rustc_codegen_ssa/src/codegen_attrs.rs
index acdda32..7680f8e 100644
--- a/compiler/rustc_codegen_ssa/src/codegen_attrs.rs
+++ b/compiler/rustc_codegen_ssa/src/codegen_attrs.rs
@@ -123,6 +123,7 @@ fn codegen_fn_attrs(tcx: TyCtxt<'_>, did: LocalDefId) -> CodegenFnAttrs {
}
AttributeKind::Naked(_) => codegen_fn_attrs.flags |= CodegenFnAttrFlags::NAKED,
AttributeKind::Align { align, .. } => codegen_fn_attrs.alignment = Some(*align),
+ AttributeKind::LinkName { name, .. } => codegen_fn_attrs.link_name = Some(*name),
AttributeKind::NoMangle(attr_span) => {
if tcx.opt_item_name(did.to_def_id()).is_some() {
codegen_fn_attrs.flags |= CodegenFnAttrFlags::NO_MANGLE;
@@ -262,7 +263,6 @@ fn codegen_fn_attrs(tcx: TyCtxt<'_>, did: LocalDefId) -> CodegenFnAttrs {
}
}
}
- sym::link_name => codegen_fn_attrs.link_name = attr.value_str(),
sym::link_ordinal => {
link_ordinal_span = Some(attr.span());
if let ordinal @ Some(_) = check_link_ordinal(tcx, attr) {
diff --git a/compiler/rustc_codegen_ssa/src/mir/operand.rs b/compiler/rustc_codegen_ssa/src/mir/operand.rs
index 99957c6..da615cc 100644
--- a/compiler/rustc_codegen_ssa/src/mir/operand.rs
+++ b/compiler/rustc_codegen_ssa/src/mir/operand.rs
@@ -479,17 +479,8 @@ pub fn codegen_get_discr<Bx: BuilderMethods<'a, 'tcx, Value = V>>(
_ => (tag_imm, bx.cx().immediate_backend_type(tag_op.layout)),
};
- // Layout ensures that we only get here for cases where the discriminant
+ // `layout_sanity_check` ensures that we only get here for cases where the discriminant
// value and the variant index match, since that's all `Niche` can encode.
- // But for emphasis and debugging, let's double-check one anyway.
- debug_assert_eq!(
- self.layout
- .ty
- .discriminant_for_variant(bx.tcx(), untagged_variant)
- .unwrap()
- .val,
- u128::from(untagged_variant.as_u32()),
- );
let relative_max = niche_variants.end().as_u32() - niche_variants.start().as_u32();
diff --git a/compiler/rustc_const_eval/src/util/caller_location.rs b/compiler/rustc_const_eval/src/util/caller_location.rs
index ab2de27..f489b05 100644
--- a/compiler/rustc_const_eval/src/util/caller_location.rs
+++ b/compiler/rustc_const_eval/src/util/caller_location.rs
@@ -21,13 +21,14 @@ fn alloc_caller_location<'tcx>(
assert!(!filename.as_str().as_bytes().contains(&0));
let loc_details = ecx.tcx.sess.opts.unstable_opts.location_detail;
- let file_wide_ptr = {
+ let filename = {
let filename = if loc_details.file { filename.as_str() } else { "<redacted>" };
let filename_with_nul = filename.to_owned() + "\0";
// This can fail if rustc runs out of memory right here. Trying to emit an error would be
// pointless, since that would require allocating more memory than these short strings.
let file_ptr = ecx.allocate_bytes_dedup(filename_with_nul.as_bytes()).unwrap();
- Immediate::new_slice(file_ptr.into(), filename_with_nul.len().try_into().unwrap(), ecx)
+ let file_len = u64::try_from(filename.len()).unwrap();
+ Immediate::new_slice(file_ptr.into(), file_len, ecx)
};
let line = if loc_details.line { Scalar::from_u32(line) } else { Scalar::from_u32(0) };
let col = if loc_details.column { Scalar::from_u32(col) } else { Scalar::from_u32(0) };
@@ -41,11 +42,8 @@ fn alloc_caller_location<'tcx>(
let location = ecx.allocate(loc_layout, MemoryKind::CallerLocation).unwrap();
// Initialize fields.
- ecx.write_immediate(
- file_wide_ptr,
- &ecx.project_field(&location, FieldIdx::from_u32(0)).unwrap(),
- )
- .expect("writing to memory we just allocated cannot fail");
+ ecx.write_immediate(filename, &ecx.project_field(&location, FieldIdx::from_u32(0)).unwrap())
+ .expect("writing to memory we just allocated cannot fail");
ecx.write_scalar(line, &ecx.project_field(&location, FieldIdx::from_u32(1)).unwrap())
.expect("writing to memory we just allocated cannot fail");
ecx.write_scalar(col, &ecx.project_field(&location, FieldIdx::from_u32(2)).unwrap())
diff --git a/compiler/rustc_error_messages/src/lib.rs b/compiler/rustc_error_messages/src/lib.rs
index 4e4345c..4b3ecad 100644
--- a/compiler/rustc_error_messages/src/lib.rs
+++ b/compiler/rustc_error_messages/src/lib.rs
@@ -3,7 +3,6 @@
#![doc(rust_logo)]
#![feature(rustc_attrs)]
#![feature(rustdoc_internals)]
-#![feature(type_alias_impl_trait)]
// tidy-alphabetical-end
use std::borrow::Cow;
diff --git a/compiler/rustc_feature/src/accepted.rs b/compiler/rustc_feature/src/accepted.rs
index cfe0f4e..2d68736 100644
--- a/compiler/rustc_feature/src/accepted.rs
+++ b/compiler/rustc_feature/src/accepted.rs
@@ -341,7 +341,7 @@ macro_rules! declare_features {
(accepted, pattern_parentheses, "1.31.0", Some(51087)),
/// Allows `use<'a, 'b, A, B>` in `impl Trait + use<...>` for precise capture of generic args.
(accepted, precise_capturing, "1.82.0", Some(123432)),
- /// Allows `use<..>` precise capturign on impl Trait in traits.
+ /// Allows `use<..>` precise capturing on impl Trait in traits.
(accepted, precise_capturing_in_traits, "1.87.0", Some(130044)),
/// Allows procedural macros in `proc-macro` crates.
(accepted, proc_macro, "1.29.0", Some(38356)),
@@ -388,7 +388,7 @@ macro_rules! declare_features {
(accepted, self_struct_ctor, "1.32.0", Some(51994)),
/// Allows use of x86 SHA512, SM3 and SM4 target-features and intrinsics
(accepted, sha512_sm_x86, "CURRENT_RUSTC_VERSION", Some(126624)),
- /// Shortern the tail expression lifetime
+ /// Shorten the tail expression lifetime
(accepted, shorter_tail_lifetimes, "1.84.0", Some(123739)),
/// Allows using subslice patterns, `[a, .., b]` and `[a, xs @ .., b]`.
(accepted, slice_patterns, "1.42.0", Some(62254)),
diff --git a/compiler/rustc_hir_analysis/src/check/intrinsic.rs b/compiler/rustc_hir_analysis/src/check/intrinsic.rs
index 060fc51..cebf7d1 100644
--- a/compiler/rustc_hir_analysis/src/check/intrinsic.rs
+++ b/compiler/rustc_hir_analysis/src/check/intrinsic.rs
@@ -594,8 +594,9 @@ pub(crate) fn check_intrinsic_type(
| sym::simd_ceil
| sym::simd_floor
| sym::simd_round
+ | sym::simd_round_ties_even
| sym::simd_trunc => (1, 0, vec![param(0)], param(0)),
- sym::simd_fma | sym::simd_relaxed_fma => {
+ sym::simd_fma | sym::simd_relaxed_fma | sym::simd_funnel_shl | sym::simd_funnel_shr => {
(1, 0, vec![param(0), param(0), param(0)], param(0))
}
sym::simd_gather => (3, 0, vec![param(0), param(1), param(2)], param(0)),
diff --git a/compiler/rustc_hir_analysis/src/lib.rs b/compiler/rustc_hir_analysis/src/lib.rs
index 76ab2e5..2ff7cae 100644
--- a/compiler/rustc_hir_analysis/src/lib.rs
+++ b/compiler/rustc_hir_analysis/src/lib.rs
@@ -65,7 +65,6 @@
#![feature(debug_closure_helpers)]
#![feature(gen_blocks)]
#![feature(if_let_guard)]
-#![feature(iter_from_coroutine)]
#![feature(iter_intersperse)]
#![feature(never_type)]
#![feature(rustdoc_internals)]
diff --git a/compiler/rustc_hir_typeck/src/coercion.rs b/compiler/rustc_hir_typeck/src/coercion.rs
index 6fa473d..57d3c5d 100644
--- a/compiler/rustc_hir_typeck/src/coercion.rs
+++ b/compiler/rustc_hir_typeck/src/coercion.rs
@@ -278,8 +278,8 @@ fn coerce(&self, a: Ty<'tcx>, b: Ty<'tcx>) -> CoerceResult<'tcx> {
/// fall back to subtyping (`unify_and`).
fn coerce_from_inference_variable(&self, a: Ty<'tcx>, b: Ty<'tcx>) -> CoerceResult<'tcx> {
debug!("coerce_from_inference_variable(a={:?}, b={:?})", a, b);
- assert!(a.is_ty_var() && self.shallow_resolve(a) == a);
- assert!(self.shallow_resolve(b) == b);
+ debug_assert!(a.is_ty_var() && self.shallow_resolve(a) == a);
+ debug_assert!(self.shallow_resolve(b) == b);
if b.is_ty_var() {
// Two unresolved type variables: create a `Coerce` predicate.
@@ -323,6 +323,8 @@ fn coerce_borrowed_pointer(
mutbl_b: hir::Mutability,
) -> CoerceResult<'tcx> {
debug!("coerce_borrowed_pointer(a={:?}, b={:?})", a, b);
+ debug_assert!(self.shallow_resolve(a) == a);
+ debug_assert!(self.shallow_resolve(b) == b);
// If we have a parameter of type `&M T_a` and the value
// provided is `expr`, we will be adding an implicit borrow,
@@ -514,10 +516,10 @@ fn coerce_borrowed_pointer(
///
/// [unsized coercion](https://doc.rust-lang.org/reference/type-coercions.html#unsized-coercions)
#[instrument(skip(self), level = "debug")]
- fn coerce_unsized(&self, mut source: Ty<'tcx>, mut target: Ty<'tcx>) -> CoerceResult<'tcx> {
- source = self.shallow_resolve(source);
- target = self.shallow_resolve(target);
+ fn coerce_unsized(&self, source: Ty<'tcx>, target: Ty<'tcx>) -> CoerceResult<'tcx> {
debug!(?source, ?target);
+ debug_assert!(self.shallow_resolve(source) == source);
+ debug_assert!(self.shallow_resolve(target) == target);
// We don't apply any coercions incase either the source or target
// aren't sufficiently well known but tend to instead just equate
@@ -531,6 +533,54 @@ fn coerce_unsized(&self, mut source: Ty<'tcx>, mut target: Ty<'tcx>) -> CoerceRe
return Err(TypeError::Mismatch);
}
+ // This is an optimization because coercion is one of the most common
+ // operations that we do in typeck, since it happens at every assignment
+ // and call arg (among other positions).
+ //
+ // These targets are known to never be RHS in `LHS: CoerceUnsized<RHS>`.
+ // That's because these are built-in types for which a core-provided impl
+ // doesn't exist, and for which a user-written impl is invalid.
+ //
+ // This is technically incomplete when users write impossible bounds like
+ // `where T: CoerceUnsized<usize>`, for example, but that trait is unstable
+ // and coercion is allowed to be incomplete. The only case where this matters
+ // is impossible bounds.
+ //
+ // Note that some of these types implement `LHS: Unsize<RHS>`, but they
+ // do not implement *`CoerceUnsized`* which is the root obligation of the
+ // check below.
+ match target.kind() {
+ ty::Bool
+ | ty::Char
+ | ty::Int(_)
+ | ty::Uint(_)
+ | ty::Float(_)
+ | ty::Infer(ty::IntVar(_) | ty::FloatVar(_))
+ | ty::Str
+ | ty::Array(_, _)
+ | ty::Slice(_)
+ | ty::FnDef(_, _)
+ | ty::FnPtr(_, _)
+ | ty::Dynamic(_, _, _)
+ | ty::Closure(_, _)
+ | ty::CoroutineClosure(_, _)
+ | ty::Coroutine(_, _)
+ | ty::CoroutineWitness(_, _)
+ | ty::Never
+ | ty::Tuple(_) => return Err(TypeError::Mismatch),
+ _ => {}
+ }
+ // Additionally, we ignore `&str -> &str` coercions, which happen very
+ // commonly since strings are one of the most used argument types in Rust,
+ // we do coercions when type checking call expressions.
+ if let ty::Ref(_, source_pointee, ty::Mutability::Not) = *source.kind()
+ && source_pointee.is_str()
+ && let ty::Ref(_, target_pointee, ty::Mutability::Not) = *target.kind()
+ && target_pointee.is_str()
+ {
+ return Err(TypeError::Mismatch);
+ }
+
let traits =
(self.tcx.lang_items().unsize_trait(), self.tcx.lang_items().coerce_unsized_trait());
let (Some(unsize_did), Some(coerce_unsized_did)) = traits else {
@@ -800,6 +850,9 @@ fn coerce_dyn_star(
/// - `Pin<Box<T>>` as `Pin<&mut T>`
#[instrument(skip(self), level = "trace")]
fn coerce_pin_ref(&self, a: Ty<'tcx>, b: Ty<'tcx>) -> CoerceResult<'tcx> {
+ debug_assert!(self.shallow_resolve(a) == a);
+ debug_assert!(self.shallow_resolve(b) == b);
+
// We need to make sure the two types are compatible for coercion.
// Then we will build a ReborrowPin adjustment and return that as an InferOk.
@@ -848,6 +901,8 @@ fn coerce_from_safe_fn(
b: Ty<'tcx>,
adjustment: Option<Adjust>,
) -> CoerceResult<'tcx> {
+ debug_assert!(self.shallow_resolve(b) == b);
+
self.commit_if_ok(|snapshot| {
let outer_universe = self.infcx.universe();
@@ -888,24 +943,19 @@ fn coerce_from_fn_pointer(
fn_ty_a: ty::PolyFnSig<'tcx>,
b: Ty<'tcx>,
) -> CoerceResult<'tcx> {
- //! Attempts to coerce from the type of a Rust function item
- //! into a closure or a `proc`.
- //!
-
- let b = self.shallow_resolve(b);
debug!(?fn_ty_a, ?b, "coerce_from_fn_pointer");
+ debug_assert!(self.shallow_resolve(b) == b);
self.coerce_from_safe_fn(fn_ty_a, b, None)
}
fn coerce_from_fn_item(&self, a: Ty<'tcx>, b: Ty<'tcx>) -> CoerceResult<'tcx> {
- //! Attempts to coerce from the type of a Rust function item
- //! into a closure or a `proc`.
+ debug!("coerce_from_fn_item(a={:?}, b={:?})", a, b);
+ debug_assert!(self.shallow_resolve(a) == a);
+ debug_assert!(self.shallow_resolve(b) == b);
- let b = self.shallow_resolve(b);
let InferOk { value: b, mut obligations } =
self.at(&self.cause, self.param_env).normalize(b);
- debug!("coerce_from_fn_item(a={:?}, b={:?})", a, b);
match b.kind() {
ty::FnPtr(_, b_hdr) => {
@@ -955,6 +1005,8 @@ fn coerce_from_fn_item(&self, a: Ty<'tcx>, b: Ty<'tcx>) -> CoerceResult<'tcx> {
}
}
+ /// Attempts to coerce from the type of a non-capturing closure
+ /// into a function pointer.
fn coerce_closure_to_fn(
&self,
a: Ty<'tcx>,
@@ -962,11 +1014,8 @@ fn coerce_closure_to_fn(
args_a: GenericArgsRef<'tcx>,
b: Ty<'tcx>,
) -> CoerceResult<'tcx> {
- //! Attempts to coerce from the type of a non-capturing closure
- //! into a function pointer.
- //!
-
- let b = self.shallow_resolve(b);
+ debug_assert!(self.shallow_resolve(a) == a);
+ debug_assert!(self.shallow_resolve(b) == b);
match b.kind() {
// At this point we haven't done capture analysis, which means
@@ -1010,6 +1059,8 @@ fn coerce_raw_ptr(
mutbl_b: hir::Mutability,
) -> CoerceResult<'tcx> {
debug!("coerce_raw_ptr(a={:?}, b={:?})", a, b);
+ debug_assert!(self.shallow_resolve(a) == a);
+ debug_assert!(self.shallow_resolve(b) == b);
let (is_ref, mt_a) = match *a.kind() {
ty::Ref(_, ty, mutbl) => (true, ty::TypeAndMut { ty, mutbl }),
diff --git a/compiler/rustc_hir_typeck/src/method/suggest.rs b/compiler/rustc_hir_typeck/src/method/suggest.rs
index d0a4887..df1ee0e 100644
--- a/compiler/rustc_hir_typeck/src/method/suggest.rs
+++ b/compiler/rustc_hir_typeck/src/method/suggest.rs
@@ -3055,7 +3055,7 @@ fn suggest_unwrapping_inner_self(
pub(crate) fn note_unmet_impls_on_type(
&self,
err: &mut Diag<'_>,
- errors: Vec<FulfillmentError<'tcx>>,
+ errors: &[FulfillmentError<'tcx>],
suggest_derive: bool,
) {
let preds: Vec<_> = errors
diff --git a/compiler/rustc_hir_typeck/src/op.rs b/compiler/rustc_hir_typeck/src/op.rs
index b9d2450..87a7cd6 100644
--- a/compiler/rustc_hir_typeck/src/op.rs
+++ b/compiler/rustc_hir_typeck/src/op.rs
@@ -322,7 +322,7 @@ fn check_overloaded_binop(
lhs_expr.span,
format!("cannot use `{}` on type `{}`", s, lhs_ty_str),
);
- self.note_unmet_impls_on_type(&mut err, errors, false);
+ self.note_unmet_impls_on_type(&mut err, &errors, false);
(err, None)
}
Op::BinOp(bin_op) => {
@@ -382,7 +382,7 @@ fn check_overloaded_binop(
err.span_label(rhs_expr.span, rhs_ty_str);
}
let suggest_derive = self.can_eq(self.param_env, lhs_ty, rhs_ty);
- self.note_unmet_impls_on_type(&mut err, errors, suggest_derive);
+ self.note_unmet_impls_on_type(&mut err, &errors, suggest_derive);
(err, output_def_id)
}
};
@@ -582,22 +582,6 @@ fn check_overloaded_binop(
// concatenation (e.g., "Hello " + "World!"). This means
// we don't want the note in the else clause to be emitted
} else if lhs_ty.has_non_region_param() {
- // Look for a TraitPredicate in the Fulfillment errors,
- // and use it to generate a suggestion.
- //
- // Note that lookup_op_method must be called again but
- // with a specific rhs_ty instead of a placeholder so
- // the resulting predicate generates a more specific
- // suggestion for the user.
- let errors = self
- .lookup_op_method(
- (lhs_expr, lhs_ty),
- Some((rhs_expr, rhs_ty)),
- lang_item_for_binop(self.tcx, op),
- op.span(),
- expected,
- )
- .unwrap_err();
if !errors.is_empty() {
for error in errors {
if let Some(trait_pred) =
@@ -946,7 +930,7 @@ pub(crate) fn check_user_unop(
ty::Str | ty::Never | ty::Char | ty::Tuple(_) | ty::Array(_, _) => {}
ty::Ref(_, lty, _) if *lty.kind() == ty::Str => {}
_ => {
- self.note_unmet_impls_on_type(&mut err, errors, true);
+ self.note_unmet_impls_on_type(&mut err, &errors, true);
}
}
}
diff --git a/compiler/rustc_infer/src/infer/freshen.rs b/compiler/rustc_infer/src/infer/freshen.rs
index cae6741..ddc0b11 100644
--- a/compiler/rustc_infer/src/infer/freshen.rs
+++ b/compiler/rustc_infer/src/infer/freshen.rs
@@ -110,17 +110,16 @@ fn cx(&self) -> TyCtxt<'tcx> {
fn fold_region(&mut self, r: ty::Region<'tcx>) -> ty::Region<'tcx> {
match r.kind() {
- ty::ReBound(..) => {
- // leave bound regions alone
- r
- }
+ // Leave bound regions alone, since they affect selection via the leak check.
+ ty::ReBound(..) => r,
+ // Leave error regions alone, since they affect selection b/c of incompleteness.
+ ty::ReError(_) => r,
ty::ReEarlyParam(..)
| ty::ReLateParam(_)
| ty::ReVar(_)
| ty::RePlaceholder(..)
| ty::ReStatic
- | ty::ReError(_)
| ty::ReErased => self.cx().lifetimes.re_erased,
}
}
diff --git a/compiler/rustc_lint/src/foreign_modules.rs b/compiler/rustc_lint/src/foreign_modules.rs
index d066879..d6c402d 100644
--- a/compiler/rustc_lint/src/foreign_modules.rs
+++ b/compiler/rustc_lint/src/foreign_modules.rs
@@ -1,4 +1,5 @@
use rustc_abi::FIRST_VARIANT;
+use rustc_attr_data_structures::{AttributeKind, find_attr};
use rustc_data_structures::stack::ensure_sufficient_stack;
use rustc_data_structures::unord::{UnordMap, UnordSet};
use rustc_hir as hir;
@@ -6,7 +7,7 @@
use rustc_middle::query::Providers;
use rustc_middle::ty::{self, AdtDef, Instance, Ty, TyCtxt};
use rustc_session::declare_lint;
-use rustc_span::{Span, Symbol, sym};
+use rustc_span::{Span, Symbol};
use tracing::{debug, instrument};
use crate::lints::{BuiltinClashingExtern, BuiltinClashingExternSub};
@@ -182,7 +183,11 @@ fn name_of_extern_decl(tcx: TyCtxt<'_>, fi: hir::OwnerId) -> SymbolName {
// information, we could have codegen_fn_attrs also give span information back for
// where the attribute was defined. However, until this is found to be a
// bottleneck, this does just fine.
- (overridden_link_name, tcx.get_attr(fi, sym::link_name).unwrap().span())
+ (
+ overridden_link_name,
+ find_attr!(tcx.get_all_attrs(fi), AttributeKind::LinkName {span, ..} => *span)
+ .unwrap(),
+ )
})
{
SymbolName::Link(overridden_link_name, overridden_link_name_span)
diff --git a/compiler/rustc_lint/src/unused.rs b/compiler/rustc_lint/src/unused.rs
index a868c88..a206f71 100644
--- a/compiler/rustc_lint/src/unused.rs
+++ b/compiler/rustc_lint/src/unused.rs
@@ -183,6 +183,7 @@ fn check_stmt(&mut self, cx: &LateContext<'_>, s: &hir::Stmt<'_>) {
let mut op_warned = false;
if let Some(must_use_op) = must_use_op {
+ let span = expr.span.find_oldest_ancestor_in_same_ctxt();
cx.emit_span_lint(
UNUSED_MUST_USE,
expr.span,
@@ -191,11 +192,11 @@ fn check_stmt(&mut self, cx: &LateContext<'_>, s: &hir::Stmt<'_>) {
label: expr.span,
suggestion: if expr_is_from_block {
UnusedOpSuggestion::BlockTailExpr {
- before_span: expr.span.shrink_to_lo(),
- after_span: expr.span.shrink_to_hi(),
+ before_span: span.shrink_to_lo(),
+ after_span: span.shrink_to_hi(),
}
} else {
- UnusedOpSuggestion::NormalExpr { span: expr.span.shrink_to_lo() }
+ UnusedOpSuggestion::NormalExpr { span: span.shrink_to_lo() }
},
},
);
@@ -508,9 +509,10 @@ fn emit_must_use_untranslated(
);
}
MustUsePath::Def(span, def_id, reason) => {
+ let span = span.find_oldest_ancestor_in_same_ctxt();
cx.emit_span_lint(
UNUSED_MUST_USE,
- *span,
+ span,
UnusedDef {
pre: descr_pre,
post: descr_post,
diff --git a/compiler/rustc_macros/src/symbols.rs b/compiler/rustc_macros/src/symbols.rs
index 2b00b7d..78a4d47 100644
--- a/compiler/rustc_macros/src/symbols.rs
+++ b/compiler/rustc_macros/src/symbols.rs
@@ -190,17 +190,6 @@ fn symbols_with_errors(input: TokenStream) -> (TokenStream, Vec<syn::Error>) {
let mut symbols_stream = quote! {};
let mut prefill_stream = quote! {};
let mut entries = Entries::with_capacity(input.keywords.len() + input.symbols.len() + 10);
- let mut prev_key: Option<(Span, String)> = None;
-
- let mut check_order = |span: Span, s: &str, errors: &mut Errors| {
- if let Some((prev_span, ref prev_str)) = prev_key {
- if s < prev_str {
- errors.error(span, format!("Symbol `{s}` must precede `{prev_str}`"));
- errors.error(prev_span, format!("location of previous symbol `{prev_str}`"));
- }
- }
- prev_key = Some((span, s.to_string()));
- };
// Generate the listed keywords.
for keyword in input.keywords.iter() {
@@ -219,7 +208,6 @@ fn symbols_with_errors(input: TokenStream) -> (TokenStream, Vec<syn::Error>) {
// Generate the listed symbols.
for symbol in input.symbols.iter() {
let name = &symbol.name;
- check_order(symbol.name.span(), &name.to_string(), &mut errors);
let value = match &symbol.value {
Value::SameAsName => name.to_string(),
diff --git a/compiler/rustc_macros/src/symbols/tests.rs b/compiler/rustc_macros/src/symbols/tests.rs
index 9c53453..f0a7a21 100644
--- a/compiler/rustc_macros/src/symbols/tests.rs
+++ b/compiler/rustc_macros/src/symbols/tests.rs
@@ -84,18 +84,3 @@ fn check_dup_symbol_and_keyword() {
};
test_symbols_macro(input, &["Symbol `splat` is duplicated", "location of previous definition"]);
}
-
-#[test]
-fn check_symbol_order() {
- let input = quote! {
- Keywords {}
- Symbols {
- zebra,
- aardvark,
- }
- };
- test_symbols_macro(
- input,
- &["Symbol `aardvark` must precede `zebra`", "location of previous symbol `zebra`"],
- );
-}
diff --git a/compiler/rustc_metadata/src/lib.rs b/compiler/rustc_metadata/src/lib.rs
index 23ffb1e..3e50689 100644
--- a/compiler/rustc_metadata/src/lib.rs
+++ b/compiler/rustc_metadata/src/lib.rs
@@ -7,7 +7,6 @@
#![feature(file_buffered)]
#![feature(gen_blocks)]
#![feature(if_let_guard)]
-#![feature(iter_from_coroutine)]
#![feature(macro_metavar_expr)]
#![feature(min_specialization)]
#![feature(never_type)]
diff --git a/compiler/rustc_middle/src/lib.rs b/compiler/rustc_middle/src/lib.rs
index ce2cb33..b30b9b6 100644
--- a/compiler/rustc_middle/src/lib.rs
+++ b/compiler/rustc_middle/src/lib.rs
@@ -48,7 +48,6 @@
#![feature(gen_blocks)]
#![feature(if_let_guard)]
#![feature(intra_doc_pointers)]
-#![feature(iter_from_coroutine)]
#![feature(min_specialization)]
#![feature(negative_impls)]
#![feature(never_type)]
diff --git a/compiler/rustc_middle/src/mir/syntax.rs b/compiler/rustc_middle/src/mir/syntax.rs
index c50a30c..92eefd8 100644
--- a/compiler/rustc_middle/src/mir/syntax.rs
+++ b/compiler/rustc_middle/src/mir/syntax.rs
@@ -284,15 +284,15 @@ pub enum FakeBorrowKind {
///
/// This is used when lowering deref patterns, where shallow borrows wouldn't prevent something
/// like:
- // ```compile_fail
- // let mut b = Box::new(false);
- // match b {
- // deref!(true) => {} // not reached because `*b == false`
- // _ if { *b = true; false } => {} // not reached because the guard is `false`
- // deref!(false) => {} // not reached because the guard changed it
- // // UB because we reached the unreachable.
- // }
- // ```
+ /// ```compile_fail
+ /// let mut b = Box::new(false);
+ /// match b {
+ /// deref!(true) => {} // not reached because `*b == false`
+ /// _ if { *b = true; false } => {} // not reached because the guard is `false`
+ /// deref!(false) => {} // not reached because the guard changed it
+ /// // UB because we reached the unreachable.
+ /// }
+ /// ```
Deep,
}
diff --git a/compiler/rustc_middle/src/query/mod.rs b/compiler/rustc_middle/src/query/mod.rs
index ddedea3..8a3d26e 100644
--- a/compiler/rustc_middle/src/query/mod.rs
+++ b/compiler/rustc_middle/src/query/mod.rs
@@ -1283,15 +1283,15 @@
return_result_from_ensure_ok
}
- /// Check whether the function has any recursion that could cause the inliner to trigger
- /// a cycle.
- query mir_callgraph_reachable(key: (ty::Instance<'tcx>, LocalDefId)) -> bool {
+ /// Return the set of (transitive) callees that may result in a recursive call to `key`.
+ query mir_callgraph_cyclic(key: LocalDefId) -> &'tcx UnordSet<LocalDefId> {
fatal_cycle
+ arena_cache
desc { |tcx|
- "computing if `{}` (transitively) calls `{}`",
- key.0,
- tcx.def_path_str(key.1),
+ "computing (transitive) callees of `{}` that may recurse",
+ tcx.def_path_str(key),
}
+ cache_on_disk_if { true }
}
/// Obtain all the calls into other local functions
diff --git a/compiler/rustc_mir_transform/src/inline.rs b/compiler/rustc_mir_transform/src/inline.rs
index f48dba9..c27087f 100644
--- a/compiler/rustc_mir_transform/src/inline.rs
+++ b/compiler/rustc_mir_transform/src/inline.rs
@@ -770,14 +770,15 @@ fn check_mir_is_available<'tcx, I: Inliner<'tcx>>(
return Ok(());
}
- if callee_def_id.is_local()
+ if let Some(callee_def_id) = callee_def_id.as_local()
&& !inliner
.tcx()
.is_lang_item(inliner.tcx().parent(caller_def_id), rustc_hir::LangItem::FnOnce)
{
// If we know for sure that the function we're calling will itself try to
// call us, then we avoid inlining that function.
- if inliner.tcx().mir_callgraph_reachable((callee, caller_def_id.expect_local())) {
+ if inliner.tcx().mir_callgraph_cyclic(caller_def_id.expect_local()).contains(&callee_def_id)
+ {
debug!("query cycle avoidance");
return Err("caller might be reachable from callee");
}
diff --git a/compiler/rustc_mir_transform/src/inline/cycle.rs b/compiler/rustc_mir_transform/src/inline/cycle.rs
index a944960..08f3ce5 100644
--- a/compiler/rustc_mir_transform/src/inline/cycle.rs
+++ b/compiler/rustc_mir_transform/src/inline/cycle.rs
@@ -1,5 +1,6 @@
use rustc_data_structures::fx::{FxHashMap, FxHashSet, FxIndexSet};
use rustc_data_structures::stack::ensure_sufficient_stack;
+use rustc_data_structures::unord::UnordSet;
use rustc_hir::def_id::{DefId, LocalDefId};
use rustc_middle::mir::TerminatorKind;
use rustc_middle::ty::{self, GenericArgsRef, InstanceKind, TyCtxt, TypeVisitableExt};
@@ -7,137 +8,143 @@
use rustc_span::sym;
use tracing::{instrument, trace};
-// FIXME: check whether it is cheaper to precompute the entire call graph instead of invoking
-// this query ridiculously often.
-#[instrument(level = "debug", skip(tcx, root, target))]
-pub(crate) fn mir_callgraph_reachable<'tcx>(
- tcx: TyCtxt<'tcx>,
- (root, target): (ty::Instance<'tcx>, LocalDefId),
-) -> bool {
- trace!(%root, target = %tcx.def_path_str(target));
- assert_ne!(
- root.def_id().expect_local(),
- target,
- "you should not call `mir_callgraph_reachable` on immediate self recursion"
- );
- assert!(
- matches!(root.def, InstanceKind::Item(_)),
- "you should not call `mir_callgraph_reachable` on shims"
- );
- assert!(
- !tcx.is_constructor(root.def_id()),
- "you should not call `mir_callgraph_reachable` on enum/struct constructor functions"
- );
- #[instrument(
- level = "debug",
- skip(tcx, typing_env, target, stack, seen, recursion_limiter, caller, recursion_limit)
- )]
- fn process<'tcx>(
- tcx: TyCtxt<'tcx>,
- typing_env: ty::TypingEnv<'tcx>,
- caller: ty::Instance<'tcx>,
- target: LocalDefId,
- stack: &mut Vec<ty::Instance<'tcx>>,
- seen: &mut FxHashSet<ty::Instance<'tcx>>,
- recursion_limiter: &mut FxHashMap<DefId, usize>,
- recursion_limit: Limit,
- ) -> bool {
- trace!(%caller);
- for &(callee, args) in tcx.mir_inliner_callees(caller.def) {
- let Ok(args) = caller.try_instantiate_mir_and_normalize_erasing_regions(
- tcx,
- typing_env,
- ty::EarlyBinder::bind(args),
- ) else {
- trace!(?caller, ?typing_env, ?args, "cannot normalize, skipping");
- continue;
- };
- let Ok(Some(callee)) = ty::Instance::try_resolve(tcx, typing_env, callee, args) else {
- trace!(?callee, "cannot resolve, skipping");
- continue;
- };
-
- // Found a path.
- if callee.def_id() == target.to_def_id() {
- return true;
- }
-
- if tcx.is_constructor(callee.def_id()) {
- trace!("constructors always have MIR");
- // Constructor functions cannot cause a query cycle.
- continue;
- }
-
- match callee.def {
- InstanceKind::Item(_) => {
- // If there is no MIR available (either because it was not in metadata or
- // because it has no MIR because it's an extern function), then the inliner
- // won't cause cycles on this.
- if !tcx.is_mir_available(callee.def_id()) {
- trace!(?callee, "no mir available, skipping");
- continue;
- }
- }
- // These have no own callable MIR.
- InstanceKind::Intrinsic(_) | InstanceKind::Virtual(..) => continue,
- // These have MIR and if that MIR is inlined, instantiated and then inlining is run
- // again, a function item can end up getting inlined. Thus we'll be able to cause
- // a cycle that way
- InstanceKind::VTableShim(_)
- | InstanceKind::ReifyShim(..)
- | InstanceKind::FnPtrShim(..)
- | InstanceKind::ClosureOnceShim { .. }
- | InstanceKind::ConstructCoroutineInClosureShim { .. }
- | InstanceKind::ThreadLocalShim { .. }
- | InstanceKind::CloneShim(..) => {}
-
- // This shim does not call any other functions, thus there can be no recursion.
- InstanceKind::FnPtrAddrShim(..) => {
- continue;
- }
- InstanceKind::DropGlue(..)
- | InstanceKind::FutureDropPollShim(..)
- | InstanceKind::AsyncDropGlue(..)
- | InstanceKind::AsyncDropGlueCtorShim(..) => {
- // FIXME: A not fully instantiated drop shim can cause ICEs if one attempts to
- // have its MIR built. Likely oli-obk just screwed up the `ParamEnv`s, so this
- // needs some more analysis.
- if callee.has_param() {
- continue;
- }
- }
- }
-
- if seen.insert(callee) {
- let recursion = recursion_limiter.entry(callee.def_id()).or_default();
- trace!(?callee, recursion = *recursion);
- if recursion_limit.value_within_limit(*recursion) {
- *recursion += 1;
- stack.push(callee);
- let found_recursion = ensure_sufficient_stack(|| {
- process(
- tcx,
- typing_env,
- callee,
- target,
- stack,
- seen,
- recursion_limiter,
- recursion_limit,
- )
- });
- if found_recursion {
- return true;
- }
- stack.pop();
- } else {
- // Pessimistically assume that there could be recursion.
- return true;
- }
+#[instrument(level = "debug", skip(tcx), ret)]
+fn should_recurse<'tcx>(tcx: TyCtxt<'tcx>, callee: ty::Instance<'tcx>) -> bool {
+ match callee.def {
+ // If there is no MIR available (either because it was not in metadata or
+ // because it has no MIR because it's an extern function), then the inliner
+ // won't cause cycles on this.
+ InstanceKind::Item(_) => {
+ if !tcx.is_mir_available(callee.def_id()) {
+ return false;
}
}
- false
+
+ // These have no own callable MIR.
+ InstanceKind::Intrinsic(_) | InstanceKind::Virtual(..) => return false,
+
+ // These have MIR and if that MIR is inlined, instantiated and then inlining is run
+ // again, a function item can end up getting inlined. Thus we'll be able to cause
+ // a cycle that way
+ InstanceKind::VTableShim(_)
+ | InstanceKind::ReifyShim(..)
+ | InstanceKind::FnPtrShim(..)
+ | InstanceKind::ClosureOnceShim { .. }
+ | InstanceKind::ConstructCoroutineInClosureShim { .. }
+ | InstanceKind::ThreadLocalShim { .. }
+ | InstanceKind::CloneShim(..) => {}
+
+ // This shim does not call any other functions, thus there can be no recursion.
+ InstanceKind::FnPtrAddrShim(..) => return false,
+
+ // FIXME: A not fully instantiated drop shim can cause ICEs if one attempts to
+ // have its MIR built. Likely oli-obk just screwed up the `ParamEnv`s, so this
+ // needs some more analysis.
+ InstanceKind::DropGlue(..)
+ | InstanceKind::FutureDropPollShim(..)
+ | InstanceKind::AsyncDropGlue(..)
+ | InstanceKind::AsyncDropGlueCtorShim(..) => {
+ if callee.has_param() {
+ return false;
+ }
+ }
}
+
+ crate::pm::should_run_pass(tcx, &crate::inline::Inline, crate::pm::Optimizations::Allowed)
+ || crate::inline::ForceInline::should_run_pass_for_callee(tcx, callee.def.def_id())
+}
+
+#[instrument(
+ level = "debug",
+ skip(tcx, typing_env, seen, involved, recursion_limiter, recursion_limit),
+ ret
+)]
+fn process<'tcx>(
+ tcx: TyCtxt<'tcx>,
+ typing_env: ty::TypingEnv<'tcx>,
+ caller: ty::Instance<'tcx>,
+ target: LocalDefId,
+ seen: &mut FxHashSet<ty::Instance<'tcx>>,
+ involved: &mut FxHashSet<LocalDefId>,
+ recursion_limiter: &mut FxHashMap<DefId, usize>,
+ recursion_limit: Limit,
+) -> bool {
+ trace!(%caller);
+ let mut cycle_found = false;
+
+ for &(callee, args) in tcx.mir_inliner_callees(caller.def) {
+ let Ok(args) = caller.try_instantiate_mir_and_normalize_erasing_regions(
+ tcx,
+ typing_env,
+ ty::EarlyBinder::bind(args),
+ ) else {
+ trace!(?caller, ?typing_env, ?args, "cannot normalize, skipping");
+ continue;
+ };
+ let Ok(Some(callee)) = ty::Instance::try_resolve(tcx, typing_env, callee, args) else {
+ trace!(?callee, "cannot resolve, skipping");
+ continue;
+ };
+
+ // Found a path.
+ if callee.def_id() == target.to_def_id() {
+ cycle_found = true;
+ }
+
+ if tcx.is_constructor(callee.def_id()) {
+ trace!("constructors always have MIR");
+ // Constructor functions cannot cause a query cycle.
+ continue;
+ }
+
+ if !should_recurse(tcx, callee) {
+ continue;
+ }
+
+ if seen.insert(callee) {
+ let recursion = recursion_limiter.entry(callee.def_id()).or_default();
+ trace!(?callee, recursion = *recursion);
+ let found_recursion = if recursion_limit.value_within_limit(*recursion) {
+ *recursion += 1;
+ ensure_sufficient_stack(|| {
+ process(
+ tcx,
+ typing_env,
+ callee,
+ target,
+ seen,
+ involved,
+ recursion_limiter,
+ recursion_limit,
+ )
+ })
+ } else {
+ // Pessimistically assume that there could be recursion.
+ true
+ };
+ if found_recursion {
+ if let Some(callee) = callee.def_id().as_local() {
+ // Calling `optimized_mir` of a non-local definition cannot cycle.
+ involved.insert(callee);
+ }
+ cycle_found = true;
+ }
+ }
+ }
+
+ cycle_found
+}
+
+#[instrument(level = "debug", skip(tcx), ret)]
+pub(crate) fn mir_callgraph_cyclic<'tcx>(
+ tcx: TyCtxt<'tcx>,
+ root: LocalDefId,
+) -> UnordSet<LocalDefId> {
+ assert!(
+ !tcx.is_constructor(root.to_def_id()),
+ "you should not call `mir_callgraph_reachable` on enum/struct constructor functions"
+ );
+
// FIXME(-Znext-solver=no): Remove this hack when trait solver overflow can return an error.
// In code like that pointed out in #128887, the type complexity we ask the solver to deal with
// grows as we recurse into the call graph. If we use the same recursion limit here and in the
@@ -146,16 +153,32 @@ fn process<'tcx>(
// the default recursion limits are quite generous for us. If we need to recurse 64 times
// into the call graph, we're probably not going to find any useful MIR inlining.
let recursion_limit = tcx.recursion_limit() / 2;
+ let mut involved = FxHashSet::default();
+ let typing_env = ty::TypingEnv::post_analysis(tcx, root);
+ let Ok(Some(root_instance)) = ty::Instance::try_resolve(
+ tcx,
+ typing_env,
+ root.to_def_id(),
+ ty::GenericArgs::identity_for_item(tcx, root.to_def_id()),
+ ) else {
+ trace!("cannot resolve, skipping");
+ return involved.into();
+ };
+ if !should_recurse(tcx, root_instance) {
+ trace!("cannot walk, skipping");
+ return involved.into();
+ }
process(
tcx,
- ty::TypingEnv::post_analysis(tcx, target),
+ typing_env,
+ root_instance,
root,
- target,
- &mut Vec::new(),
&mut FxHashSet::default(),
+ &mut involved,
&mut FxHashMap::default(),
recursion_limit,
- )
+ );
+ involved.into()
}
pub(crate) fn mir_inliner_callees<'tcx>(
diff --git a/compiler/rustc_mir_transform/src/lib.rs b/compiler/rustc_mir_transform/src/lib.rs
index 6b32254..c441529 100644
--- a/compiler/rustc_mir_transform/src/lib.rs
+++ b/compiler/rustc_mir_transform/src/lib.rs
@@ -216,7 +216,7 @@ pub fn provide(providers: &mut Providers) {
optimized_mir,
is_mir_available,
is_ctfe_mir_available: is_mir_available,
- mir_callgraph_reachable: inline::cycle::mir_callgraph_reachable,
+ mir_callgraph_cyclic: inline::cycle::mir_callgraph_cyclic,
mir_inliner_callees: inline::cycle::mir_inliner_callees,
promoted_mir,
deduced_param_attrs: deduce_param_attrs::deduced_param_attrs,
diff --git a/compiler/rustc_next_trait_solver/src/solve/assembly/mod.rs b/compiler/rustc_next_trait_solver/src/solve/assembly/mod.rs
index a300558..c281ef2 100644
--- a/compiler/rustc_next_trait_solver/src/solve/assembly/mod.rs
+++ b/compiler/rustc_next_trait_solver/src/solve/assembly/mod.rs
@@ -383,10 +383,10 @@ pub(super) fn assemble_and_evaluate_candidates<G: GoalKind<D>>(
let mut candidates = vec![];
- if let TypingMode::Coherence = self.typing_mode() {
- if let Ok(candidate) = self.consider_coherence_unknowable_candidate(goal) {
- return vec![candidate];
- }
+ if let TypingMode::Coherence = self.typing_mode()
+ && let Ok(candidate) = self.consider_coherence_unknowable_candidate(goal)
+ {
+ return vec![candidate];
}
self.assemble_alias_bound_candidates(goal, &mut candidates);
diff --git a/compiler/rustc_next_trait_solver/src/solve/assembly/structural_traits.rs b/compiler/rustc_next_trait_solver/src/solve/assembly/structural_traits.rs
index 5b6f978..73bb150 100644
--- a/compiler/rustc_next_trait_solver/src/solve/assembly/structural_traits.rs
+++ b/compiler/rustc_next_trait_solver/src/solve/assembly/structural_traits.rs
@@ -997,12 +997,12 @@ fn cx(&self) -> I {
}
fn try_fold_ty(&mut self, ty: I::Ty) -> Result<I::Ty, Ambiguous> {
- if let ty::Alias(ty::Projection, alias_ty) = ty.kind() {
- if let Some(term) = self.try_eagerly_replace_alias(alias_ty.into())? {
- return Ok(term.expect_ty());
- }
+ if let ty::Alias(ty::Projection, alias_ty) = ty.kind()
+ && let Some(term) = self.try_eagerly_replace_alias(alias_ty.into())?
+ {
+ Ok(term.expect_ty())
+ } else {
+ ty.try_super_fold_with(self)
}
-
- ty.try_super_fold_with(self)
}
}
diff --git a/compiler/rustc_next_trait_solver/src/solve/effect_goals.rs b/compiler/rustc_next_trait_solver/src/solve/effect_goals.rs
index 0547eb7..42264f5 100644
--- a/compiler/rustc_next_trait_solver/src/solve/effect_goals.rs
+++ b/compiler/rustc_next_trait_solver/src/solve/effect_goals.rs
@@ -42,20 +42,18 @@ fn fast_reject_assumption(
goal: Goal<I, Self>,
assumption: I::Clause,
) -> Result<(), NoSolution> {
- if let Some(host_clause) = assumption.as_host_effect_clause() {
- if host_clause.def_id() == goal.predicate.def_id()
- && host_clause.constness().satisfies(goal.predicate.constness)
- {
- if DeepRejectCtxt::relate_rigid_rigid(ecx.cx()).args_may_unify(
- goal.predicate.trait_ref.args,
- host_clause.skip_binder().trait_ref.args,
- ) {
- return Ok(());
- }
- }
+ if let Some(host_clause) = assumption.as_host_effect_clause()
+ && host_clause.def_id() == goal.predicate.def_id()
+ && host_clause.constness().satisfies(goal.predicate.constness)
+ && DeepRejectCtxt::relate_rigid_rigid(ecx.cx()).args_may_unify(
+ goal.predicate.trait_ref.args,
+ host_clause.skip_binder().trait_ref.args,
+ )
+ {
+ Ok(())
+ } else {
+ Err(NoSolution)
}
-
- Err(NoSolution)
}
fn match_assumption(
diff --git a/compiler/rustc_next_trait_solver/src/solve/eval_ctxt/mod.rs b/compiler/rustc_next_trait_solver/src/solve/eval_ctxt/mod.rs
index dd9ccad..b425876 100644
--- a/compiler/rustc_next_trait_solver/src/solve/eval_ctxt/mod.rs
+++ b/compiler/rustc_next_trait_solver/src/solve/eval_ctxt/mod.rs
@@ -429,22 +429,21 @@ pub(super) fn evaluate_goal_raw(
// If we have run this goal before, and it was stalled, check that any of the goal's
// args have changed. Otherwise, we don't need to re-run the goal because it'll remain
// stalled, since it'll canonicalize the same way and evaluation is pure.
- if let Some(stalled_on) = stalled_on {
- if !stalled_on.stalled_vars.iter().any(|value| self.delegate.is_changed_arg(*value))
- && !self
- .delegate
- .opaque_types_storage_num_entries()
- .needs_reevaluation(stalled_on.num_opaques)
- {
- return Ok((
- NestedNormalizationGoals::empty(),
- GoalEvaluation {
- certainty: Certainty::Maybe(stalled_on.stalled_cause),
- has_changed: HasChanged::No,
- stalled_on: Some(stalled_on),
- },
- ));
- }
+ if let Some(stalled_on) = stalled_on
+ && !stalled_on.stalled_vars.iter().any(|value| self.delegate.is_changed_arg(*value))
+ && !self
+ .delegate
+ .opaque_types_storage_num_entries()
+ .needs_reevaluation(stalled_on.num_opaques)
+ {
+ return Ok((
+ NestedNormalizationGoals::empty(),
+ GoalEvaluation {
+ certainty: Certainty::Maybe(stalled_on.stalled_cause),
+ has_changed: HasChanged::No,
+ stalled_on: Some(stalled_on),
+ },
+ ));
}
let (orig_values, canonical_goal) = self.canonicalize_goal(goal);
@@ -833,14 +832,11 @@ fn visit_ty(&mut self, t: I::Ty) -> Self::Result {
match t.kind() {
ty::Infer(ty::TyVar(vid)) => {
- if let ty::TermKind::Ty(term) = self.term.kind() {
- if let ty::Infer(ty::TyVar(term_vid)) = term.kind() {
- if self.delegate.root_ty_var(vid)
- == self.delegate.root_ty_var(term_vid)
- {
- return ControlFlow::Break(());
- }
- }
+ if let ty::TermKind::Ty(term) = self.term.kind()
+ && let ty::Infer(ty::TyVar(term_vid)) = term.kind()
+ && self.delegate.root_ty_var(vid) == self.delegate.root_ty_var(term_vid)
+ {
+ return ControlFlow::Break(());
}
self.check_nameable(self.delegate.universe_of_ty(vid).unwrap())?;
@@ -860,15 +856,12 @@ fn visit_ty(&mut self, t: I::Ty) -> Self::Result {
fn visit_const(&mut self, c: I::Const) -> Self::Result {
match c.kind() {
ty::ConstKind::Infer(ty::InferConst::Var(vid)) => {
- if let ty::TermKind::Const(term) = self.term.kind() {
- if let ty::ConstKind::Infer(ty::InferConst::Var(term_vid)) = term.kind()
- {
- if self.delegate.root_const_var(vid)
- == self.delegate.root_const_var(term_vid)
- {
- return ControlFlow::Break(());
- }
- }
+ if let ty::TermKind::Const(term) = self.term.kind()
+ && let ty::ConstKind::Infer(ty::InferConst::Var(term_vid)) = term.kind()
+ && self.delegate.root_const_var(vid)
+ == self.delegate.root_const_var(term_vid)
+ {
+ return ControlFlow::Break(());
}
self.check_nameable(self.delegate.universe_of_ct(vid).unwrap())
diff --git a/compiler/rustc_next_trait_solver/src/solve/normalizes_to/mod.rs b/compiler/rustc_next_trait_solver/src/solve/normalizes_to/mod.rs
index d51c87f..edb354b 100644
--- a/compiler/rustc_next_trait_solver/src/solve/normalizes_to/mod.rs
+++ b/compiler/rustc_next_trait_solver/src/solve/normalizes_to/mod.rs
@@ -112,18 +112,17 @@ fn fast_reject_assumption(
goal: Goal<I, Self>,
assumption: I::Clause,
) -> Result<(), NoSolution> {
- if let Some(projection_pred) = assumption.as_projection_clause() {
- if projection_pred.item_def_id() == goal.predicate.def_id() {
- if DeepRejectCtxt::relate_rigid_rigid(ecx.cx()).args_may_unify(
- goal.predicate.alias.args,
- projection_pred.skip_binder().projection_term.args,
- ) {
- return Ok(());
- }
- }
+ if let Some(projection_pred) = assumption.as_projection_clause()
+ && projection_pred.item_def_id() == goal.predicate.def_id()
+ && DeepRejectCtxt::relate_rigid_rigid(ecx.cx()).args_may_unify(
+ goal.predicate.alias.args,
+ projection_pred.skip_binder().projection_term.args,
+ )
+ {
+ Ok(())
+ } else {
+ Err(NoSolution)
}
-
- Err(NoSolution)
}
fn match_assumption(
diff --git a/compiler/rustc_next_trait_solver/src/solve/trait_goals.rs b/compiler/rustc_next_trait_solver/src/solve/trait_goals.rs
index 8aaa8e9..6c9fb63 100644
--- a/compiler/rustc_next_trait_solver/src/solve/trait_goals.rs
+++ b/compiler/rustc_next_trait_solver/src/solve/trait_goals.rs
@@ -127,33 +127,32 @@ fn fast_reject_assumption(
goal: Goal<I, Self>,
assumption: I::Clause,
) -> Result<(), NoSolution> {
- if let Some(trait_clause) = assumption.as_trait_clause() {
- if trait_clause.polarity() != goal.predicate.polarity {
- return Err(NoSolution);
- }
-
- if trait_clause.def_id() == goal.predicate.def_id() {
- if DeepRejectCtxt::relate_rigid_rigid(ecx.cx()).args_may_unify(
- goal.predicate.trait_ref.args,
- trait_clause.skip_binder().trait_ref.args,
- ) {
- return Ok(());
- }
- }
-
+ fn trait_def_id_matches<I: Interner>(
+ cx: I,
+ clause_def_id: I::DefId,
+ goal_def_id: I::DefId,
+ ) -> bool {
+ clause_def_id == goal_def_id
// PERF(sized-hierarchy): Sizedness supertraits aren't elaborated to improve perf, so
- // check for a `Sized` subtrait when looking for `MetaSized`. `PointeeSized` bounds
- // are syntactic sugar for a lack of bounds so don't need this.
- if ecx.cx().is_lang_item(goal.predicate.def_id(), TraitSolverLangItem::MetaSized)
- && ecx.cx().is_lang_item(trait_clause.def_id(), TraitSolverLangItem::Sized)
- {
- let meta_sized_clause =
- trait_predicate_with_def_id(ecx.cx(), trait_clause, goal.predicate.def_id());
- return Self::fast_reject_assumption(ecx, goal, meta_sized_clause);
- }
+ // check for a `MetaSized` supertrait being matched against a `Sized` assumption.
+ //
+ // `PointeeSized` bounds are syntactic sugar for a lack of bounds so don't need this.
+ || (cx.is_lang_item(clause_def_id, TraitSolverLangItem::Sized)
+ && cx.is_lang_item(goal_def_id, TraitSolverLangItem::MetaSized))
}
- Err(NoSolution)
+ if let Some(trait_clause) = assumption.as_trait_clause()
+ && trait_clause.polarity() == goal.predicate.polarity
+ && trait_def_id_matches(ecx.cx(), trait_clause.def_id(), goal.predicate.def_id())
+ && DeepRejectCtxt::relate_rigid_rigid(ecx.cx()).args_may_unify(
+ goal.predicate.trait_ref.args,
+ trait_clause.skip_binder().trait_ref.args,
+ )
+ {
+ return Ok(());
+ } else {
+ Err(NoSolution)
+ }
}
fn match_assumption(
diff --git a/compiler/rustc_parse/src/parser/ty.rs b/compiler/rustc_parse/src/parser/ty.rs
index f181097..d874a07 100644
--- a/compiler/rustc_parse/src/parser/ty.rs
+++ b/compiler/rustc_parse/src/parser/ty.rs
@@ -1071,7 +1071,7 @@ pub fn parse_bound_constness(&mut self) -> PResult<'a, BoundConstness> {
&& self.look_ahead(1, |t| t.is_keyword(kw::Const))
&& self.look_ahead(2, |t| *t == token::CloseBracket)
{
- let start = self.prev_token.span;
+ let start = self.token.span;
self.bump();
self.expect_keyword(exp!(Const)).unwrap();
self.bump();
diff --git a/compiler/rustc_parse/src/validate_attr.rs b/compiler/rustc_parse/src/validate_attr.rs
index 68d78af..8b1d864 100644
--- a/compiler/rustc_parse/src/validate_attr.rs
+++ b/compiler/rustc_parse/src/validate_attr.rs
@@ -302,6 +302,7 @@ fn emit_malformed_attribute(
| sym::no_mangle
| sym::must_use
| sym::track_caller
+ | sym::link_name
) {
return;
}
diff --git a/compiler/rustc_passes/src/check_attr.rs b/compiler/rustc_passes/src/check_attr.rs
index 877bb9b..ae486a5 100644
--- a/compiler/rustc_passes/src/check_attr.rs
+++ b/compiler/rustc_passes/src/check_attr.rs
@@ -191,6 +191,9 @@ fn check_attributes(
Attribute::Parsed(AttributeKind::AsPtr(attr_span)) => {
self.check_applied_to_fn_or_method(hir_id, *attr_span, span, target)
}
+ Attribute::Parsed(AttributeKind::LinkName { span: attr_span, name }) => {
+ self.check_link_name(hir_id, *attr_span, *name, span, target)
+ }
Attribute::Parsed(AttributeKind::MayDangle(attr_span)) => {
self.check_may_dangle(hir_id, *attr_span)
}
@@ -283,7 +286,6 @@ fn check_attributes(
[sym::ffi_const, ..] => self.check_ffi_const(attr.span(), target),
[sym::link_ordinal, ..] => self.check_link_ordinal(attr, span, target),
[sym::link, ..] => self.check_link(hir_id, attr, span, target),
- [sym::link_name, ..] => self.check_link_name(hir_id, attr, span, target),
[sym::link_section, ..] => self.check_link_section(hir_id, attr, span, target),
[sym::macro_use, ..] | [sym::macro_escape, ..] => {
self.check_macro_use(hir_id, attr, target)
@@ -1604,7 +1606,14 @@ fn check_link(&self, hir_id: HirId, attr: &Attribute, span: Span, target: Target
}
/// Checks if `#[link_name]` is applied to an item other than a foreign function or static.
- fn check_link_name(&self, hir_id: HirId, attr: &Attribute, span: Span, target: Target) {
+ fn check_link_name(
+ &self,
+ hir_id: HirId,
+ attr_span: Span,
+ name: Symbol,
+ span: Span,
+ target: Target,
+ ) {
match target {
Target::ForeignFn | Target::ForeignStatic => {}
// FIXME(#80564): We permit struct fields, match arms and macro defs to have an
@@ -1612,27 +1621,18 @@ fn check_link_name(&self, hir_id: HirId, attr: &Attribute, span: Span, target: T
// erroneously allowed it and some crates used it accidentally, to be compatible
// with crates depending on them, we can't throw an error here.
Target::Field | Target::Arm | Target::MacroDef => {
- self.inline_attr_str_error_with_macro_def(hir_id, attr.span(), "link_name");
+ self.inline_attr_str_error_with_macro_def(hir_id, attr_span, "link_name");
}
_ => {
- // FIXME: #[cold] was previously allowed on non-functions/statics and some crates
+ // FIXME: #[link_name] was previously allowed on non-functions/statics and some crates
// used this, so only emit a warning.
- let attr_span = matches!(target, Target::ForeignMod).then_some(attr.span());
- if let Some(s) = attr.value_str() {
- self.tcx.emit_node_span_lint(
- UNUSED_ATTRIBUTES,
- hir_id,
- attr.span(),
- errors::LinkName { span, attr_span, value: s.as_str() },
- );
- } else {
- self.tcx.emit_node_span_lint(
- UNUSED_ATTRIBUTES,
- hir_id,
- attr.span(),
- errors::LinkName { span, attr_span, value: "..." },
- );
- };
+ let help_span = matches!(target, Target::ForeignMod).then_some(attr_span);
+ self.tcx.emit_node_span_lint(
+ UNUSED_ATTRIBUTES,
+ hir_id,
+ attr_span,
+ errors::LinkName { span, help_span, value: name.as_str() },
+ );
}
}
}
diff --git a/compiler/rustc_passes/src/errors.rs b/compiler/rustc_passes/src/errors.rs
index f89d925..eaff1cc 100644
--- a/compiler/rustc_passes/src/errors.rs
+++ b/compiler/rustc_passes/src/errors.rs
@@ -502,7 +502,7 @@ pub(crate) struct Link {
#[warning]
pub(crate) struct LinkName<'a> {
#[help]
- pub attr_span: Option<Span>,
+ pub help_span: Option<Span>,
#[label]
pub span: Span,
pub value: &'a str,
diff --git a/compiler/rustc_resolve/src/imports.rs b/compiler/rustc_resolve/src/imports.rs
index 1b7a2c3..2e81b54 100644
--- a/compiler/rustc_resolve/src/imports.rs
+++ b/compiler/rustc_resolve/src/imports.rs
@@ -174,7 +174,14 @@ pub(crate) struct ImportData<'ra> {
pub parent_scope: ParentScope<'ra>,
pub module_path: Vec<Segment>,
- /// The resolution of `module_path`.
+ /// The resolution of `module_path`:
+ ///
+ /// | `module_path` | `imported_module` | remark |
+ /// |-|-|-|
+ /// |`use prefix::foo`| `ModuleOrUniformRoot::Module(prefix)` | - |
+ /// |`use ::foo` | `ModuleOrUniformRoot::ExternPrelude` | 2018+ editions |
+ /// |`use ::foo` | `ModuleOrUniformRoot::CrateRootAndExternPrelude` | a special case in 2015 edition |
+ /// |`use foo` | `ModuleOrUniformRoot::CurrentScope` | - |
pub imported_module: Cell<Option<ModuleOrUniformRoot<'ra>>>,
pub vis: ty::Visibility,
}
diff --git a/compiler/rustc_span/src/symbol.rs b/compiler/rustc_span/src/symbol.rs
index 0045801..4b8762d 100644
--- a/compiler/rustc_span/src/symbol.rs
+++ b/compiler/rustc_span/src/symbol.rs
@@ -150,14 +150,10 @@
// As well as the symbols listed, there are symbols for the strings
// "0", "1", ..., "9", which are accessible via `sym::integer`.
//
- // The proc macro will abort if symbols are not in alphabetical order (as
- // defined by `impl Ord for str`) or if any symbols are duplicated. Vim
- // users can sort the list by selecting it and executing the command
- // `:'<,'>!LC_ALL=C sort`.
- //
// There is currently no checking that all symbols are used; that would be
// nice to have.
Symbols {
+ // tidy-alphabetical-start
Abi,
AcqRel,
Acquire,
@@ -175,18 +171,18 @@
AsyncGenPending,
AsyncGenReady,
AtomicBool,
- AtomicI128,
+ AtomicI8,
AtomicI16,
AtomicI32,
AtomicI64,
- AtomicI8,
+ AtomicI128,
AtomicIsize,
AtomicPtr,
- AtomicU128,
+ AtomicU8,
AtomicU16,
AtomicU32,
AtomicU64,
- AtomicU8,
+ AtomicU128,
AtomicUsize,
BTreeEntry,
BTreeMap,
@@ -607,10 +603,10 @@
catch_unwind,
cause,
cdylib,
- ceilf128,
ceilf16,
ceilf32,
ceilf64,
+ ceilf128,
cfg,
cfg_accessible,
cfg_attr,
@@ -747,10 +743,10 @@
copy,
copy_closures,
copy_nonoverlapping,
- copysignf128,
copysignf16,
copysignf32,
copysignf64,
+ copysignf128,
core,
core_panic,
core_panic_2015_macro,
@@ -763,10 +759,10 @@
coroutine_state,
coroutine_yield,
coroutines,
- cosf128,
cosf16,
cosf32,
cosf64,
+ cosf128,
count,
coverage,
coverage_attribute,
@@ -874,8 +870,8 @@
dotdot_in_tuple_patterns,
dotdoteq_in_patterns,
dreg,
- dreg_low16,
dreg_low8,
+ dreg_low16,
drop,
drop_in_place,
drop_types_in_const,
@@ -928,16 +924,16 @@
exhaustive_integer_patterns,
exhaustive_patterns,
existential_type,
- exp2f128,
exp2f16,
exp2f32,
exp2f64,
+ exp2f128,
expect,
expected,
- expf128,
expf16,
expf32,
expf64,
+ expf128,
explicit_extern_abis,
explicit_generic_args_with_impl_trait,
explicit_tail_calls,
@@ -958,9 +954,6 @@
external,
external_doc,
f,
- f128,
- f128_epsilon,
- f128_nan,
f16,
f16_epsilon,
f16_nan,
@@ -999,10 +992,13 @@
f64_legacy_const_neg_infinity,
f64_legacy_const_radix,
f64_nan,
- fabsf128,
+ f128,
+ f128_epsilon,
+ f128_nan,
fabsf16,
fabsf32,
fabsf64,
+ fabsf128,
fadd_algebraic,
fadd_fast,
fake_variadic,
@@ -1024,22 +1020,22 @@
flags,
float,
float_to_int_unchecked,
- floorf128,
floorf16,
floorf32,
floorf64,
- fmaf128,
+ floorf128,
fmaf16,
fmaf32,
fmaf64,
+ fmaf128,
fmt,
fmt_debug,
fmul_algebraic,
fmul_fast,
- fmuladdf128,
fmuladdf16,
fmuladdf32,
fmuladdf64,
+ fmuladdf128,
fn_align,
fn_body,
fn_delegation,
@@ -1140,13 +1136,12 @@
html_root_url,
hwaddress,
i,
- i128,
- i128_legacy_const_max,
- i128_legacy_const_min,
- i128_legacy_fn_max_value,
- i128_legacy_fn_min_value,
- i128_legacy_mod,
- i128_type,
+ i8,
+ i8_legacy_const_max,
+ i8_legacy_const_min,
+ i8_legacy_fn_max_value,
+ i8_legacy_fn_min_value,
+ i8_legacy_mod,
i16,
i16_legacy_const_max,
i16_legacy_const_min,
@@ -1165,12 +1160,13 @@
i64_legacy_fn_max_value,
i64_legacy_fn_min_value,
i64_legacy_mod,
- i8,
- i8_legacy_const_max,
- i8_legacy_const_min,
- i8_legacy_fn_max_value,
- i8_legacy_fn_min_value,
- i8_legacy_mod,
+ i128,
+ i128_legacy_const_max,
+ i128_legacy_const_min,
+ i128_legacy_fn_max_value,
+ i128_legacy_fn_min_value,
+ i128_legacy_mod,
+ i128_type,
ident,
if_let,
if_let_guard,
@@ -1292,19 +1288,19 @@
loaded_from_disk,
local,
local_inner_macros,
- log10f128,
- log10f16,
- log10f32,
- log10f64,
- log2f128,
log2f16,
log2f32,
log2f64,
+ log2f128,
+ log10f16,
+ log10f32,
+ log10f64,
+ log10f128,
log_syntax,
- logf128,
logf16,
logf32,
logf64,
+ logf128,
loongarch_target_feature,
loop_break_value,
loop_match,
@@ -1334,14 +1330,14 @@
match_beginning_vert,
match_default_bindings,
matches_macro,
- maximumf128,
maximumf16,
maximumf32,
maximumf64,
- maxnumf128,
+ maximumf128,
maxnumf16,
maxnumf32,
maxnumf64,
+ maxnumf128,
may_dangle,
may_unwind,
maybe_uninit,
@@ -1372,14 +1368,14 @@
min_generic_const_args,
min_specialization,
min_type_alias_impl_trait,
- minimumf128,
minimumf16,
minimumf32,
minimumf64,
- minnumf128,
+ minimumf128,
minnumf16,
minnumf32,
minnumf64,
+ minnumf128,
mips_target_feature,
mir_assume,
mir_basic_block,
@@ -1634,14 +1630,14 @@
post_dash_lto: "post-lto",
postfix_match,
powerpc_target_feature,
- powf128,
powf16,
powf32,
powf64,
- powif128,
+ powf128,
powif16,
powif32,
powif64,
+ powif128,
pre_dash_lto: "pre-lto",
precise_capturing,
precise_capturing_in_traits,
@@ -1786,14 +1782,14 @@
ropi_rwpi: "ropi-rwpi",
rotate_left,
rotate_right,
- round_ties_even_f128,
round_ties_even_f16,
round_ties_even_f32,
round_ties_even_f64,
- roundf128,
+ round_ties_even_f128,
roundf16,
roundf32,
roundf64,
+ roundf128,
rt,
rtm_target_feature,
rust,
@@ -1973,14 +1969,16 @@
simd_fexp2,
simd_ffi,
simd_flog,
- simd_flog10,
simd_flog2,
+ simd_flog10,
simd_floor,
simd_fma,
simd_fmax,
simd_fmin,
simd_fsin,
simd_fsqrt,
+ simd_funnel_shl,
+ simd_funnel_shr,
simd_gather,
simd_ge,
simd_gt,
@@ -2008,6 +2006,7 @@
simd_relaxed_fma,
simd_rem,
simd_round,
+ simd_round_ties_even,
simd_saturating_add,
simd_saturating_sub,
simd_scatter,
@@ -2022,10 +2021,10 @@
simd_with_exposed_provenance,
simd_xor,
since,
- sinf128,
sinf16,
sinf32,
sinf64,
+ sinf128,
size,
size_of,
size_of_val,
@@ -2047,10 +2046,10 @@
specialization,
speed,
spotlight,
- sqrtf128,
sqrtf16,
sqrtf32,
sqrtf64,
+ sqrtf128,
sreg,
sreg_low16,
sse,
@@ -2128,10 +2127,10 @@
target_has_atomic,
target_has_atomic_equal_alignment,
target_has_atomic_load_store,
- target_has_reliable_f128,
- target_has_reliable_f128_math,
target_has_reliable_f16,
target_has_reliable_f16_math,
+ target_has_reliable_f128,
+ target_has_reliable_f128_math,
target_os,
target_pointer_width,
target_thread_local,
@@ -2174,10 +2173,10 @@
transparent_enums,
transparent_unions,
trivial_bounds,
- truncf128,
truncf16,
truncf32,
truncf64,
+ truncf128,
try_blocks,
try_capture,
try_from,
@@ -2206,12 +2205,12 @@
type_name,
type_privacy_lints,
typed_swap_nonoverlapping,
- u128,
- u128_legacy_const_max,
- u128_legacy_const_min,
- u128_legacy_fn_max_value,
- u128_legacy_fn_min_value,
- u128_legacy_mod,
+ u8,
+ u8_legacy_const_max,
+ u8_legacy_const_min,
+ u8_legacy_fn_max_value,
+ u8_legacy_fn_min_value,
+ u8_legacy_mod,
u16,
u16_legacy_const_max,
u16_legacy_const_min,
@@ -2230,12 +2229,12 @@
u64_legacy_fn_max_value,
u64_legacy_fn_min_value,
u64_legacy_mod,
- u8,
- u8_legacy_const_max,
- u8_legacy_const_min,
- u8_legacy_fn_max_value,
- u8_legacy_fn_min_value,
- u8_legacy_mod,
+ u128,
+ u128_legacy_const_max,
+ u128_legacy_const_min,
+ u128_legacy_fn_max_value,
+ u128_legacy_fn_min_value,
+ u128_legacy_mod,
ub_checks,
unaligned_volatile_load,
unaligned_volatile_store,
@@ -2388,6 +2387,7 @@
zfh,
zfhmin,
zmm_reg,
+ // tidy-alphabetical-end
}
}
diff --git a/compiler/rustc_ty_utils/src/layout/invariant.rs b/compiler/rustc_ty_utils/src/layout/invariant.rs
index c929de1..4b65c05 100644
--- a/compiler/rustc_ty_utils/src/layout/invariant.rs
+++ b/compiler/rustc_ty_utils/src/layout/invariant.rs
@@ -277,6 +277,12 @@ fn check_layout_abi<'tcx>(cx: &LayoutCx<'tcx>, layout: &TyAndLayout<'tcx>) {
if !variant.is_uninhabited() {
assert!(idx == *untagged_variant || niche_variants.contains(&idx));
}
+
+ // Ensure that for niche encoded tags the discriminant coincides with the variant index.
+ assert_eq!(
+ layout.ty.discriminant_for_variant(tcx, idx).unwrap().val,
+ u128::from(idx.as_u32()),
+ );
}
}
for variant in variants.iter() {
diff --git a/compiler/rustc_type_ir/src/elaborate.rs b/compiler/rustc_type_ir/src/elaborate.rs
index 177bad9..7ffcf7b 100644
--- a/compiler/rustc_type_ir/src/elaborate.rs
+++ b/compiler/rustc_type_ir/src/elaborate.rs
@@ -320,10 +320,10 @@ pub fn supertrait_def_ids<I: Interner>(
let trait_def_id = stack.pop()?;
for (predicate, _) in cx.explicit_super_predicates_of(trait_def_id).iter_identity() {
- if let ty::ClauseKind::Trait(data) = predicate.kind().skip_binder() {
- if set.insert(data.def_id()) {
- stack.push(data.def_id());
- }
+ if let ty::ClauseKind::Trait(data) = predicate.kind().skip_binder()
+ && set.insert(data.def_id())
+ {
+ stack.push(data.def_id());
}
}
diff --git a/compiler/rustc_type_ir/src/infer_ctxt.rs b/compiler/rustc_type_ir/src/infer_ctxt.rs
index 2bc12d0..8ba9e71 100644
--- a/compiler/rustc_type_ir/src/infer_ctxt.rs
+++ b/compiler/rustc_type_ir/src/infer_ctxt.rs
@@ -117,12 +117,20 @@ pub fn analysis_in_body(cx: I, body_def_id: I::LocalDefId) -> TypingMode<I> {
}
pub fn borrowck(cx: I, body_def_id: I::LocalDefId) -> TypingMode<I> {
- TypingMode::Borrowck { defining_opaque_types: cx.opaque_types_defined_by(body_def_id) }
+ let defining_opaque_types = cx.opaque_types_defined_by(body_def_id);
+ if defining_opaque_types.is_empty() {
+ TypingMode::non_body_analysis()
+ } else {
+ TypingMode::Borrowck { defining_opaque_types }
+ }
}
pub fn post_borrowck_analysis(cx: I, body_def_id: I::LocalDefId) -> TypingMode<I> {
- TypingMode::PostBorrowckAnalysis {
- defined_opaque_types: cx.opaque_types_defined_by(body_def_id),
+ let defined_opaque_types = cx.opaque_types_defined_by(body_def_id);
+ if defined_opaque_types.is_empty() {
+ TypingMode::non_body_analysis()
+ } else {
+ TypingMode::PostBorrowckAnalysis { defined_opaque_types }
}
}
}
diff --git a/compiler/rustc_type_ir/src/relate/solver_relating.rs b/compiler/rustc_type_ir/src/relate/solver_relating.rs
index e42639c..79f6bc5 100644
--- a/compiler/rustc_type_ir/src/relate/solver_relating.rs
+++ b/compiler/rustc_type_ir/src/relate/solver_relating.rs
@@ -284,12 +284,12 @@ fn binders<T>(
}
// If they have no bound vars, relate normally.
- if let Some(a_inner) = a.no_bound_vars() {
- if let Some(b_inner) = b.no_bound_vars() {
- self.relate(a_inner, b_inner)?;
- return Ok(a);
- }
- };
+ if let Some(a_inner) = a.no_bound_vars()
+ && let Some(b_inner) = b.no_bound_vars()
+ {
+ self.relate(a_inner, b_inner)?;
+ return Ok(a);
+ }
match self.ambient_variance {
// Checks whether `for<..> sub <: for<..> sup` holds.
diff --git a/compiler/rustc_type_ir/src/search_graph/global_cache.rs b/compiler/rustc_type_ir/src/search_graph/global_cache.rs
index 1b99cc8..eb56c1a 100644
--- a/compiler/rustc_type_ir/src/search_graph/global_cache.rs
+++ b/compiler/rustc_type_ir/src/search_graph/global_cache.rs
@@ -80,31 +80,29 @@ pub(super) fn get<'a>(
mut candidate_is_applicable: impl FnMut(&NestedGoals<X>) -> bool,
) -> Option<CacheData<'a, X>> {
let entry = self.map.get(&input)?;
- if let Some(Success { required_depth, ref nested_goals, ref result }) = entry.success {
- if available_depth.cache_entry_is_applicable(required_depth)
- && candidate_is_applicable(nested_goals)
- {
- return Some(CacheData {
- result: cx.get_tracked(&result),
- required_depth,
- encountered_overflow: false,
- nested_goals,
- });
- }
+ if let Some(Success { required_depth, ref nested_goals, ref result }) = entry.success
+ && available_depth.cache_entry_is_applicable(required_depth)
+ && candidate_is_applicable(nested_goals)
+ {
+ return Some(CacheData {
+ result: cx.get_tracked(&result),
+ required_depth,
+ encountered_overflow: false,
+ nested_goals,
+ });
}
let additional_depth = available_depth.0;
if let Some(WithOverflow { nested_goals, result }) =
entry.with_overflow.get(&additional_depth)
+ && candidate_is_applicable(nested_goals)
{
- if candidate_is_applicable(nested_goals) {
- return Some(CacheData {
- result: cx.get_tracked(result),
- required_depth: additional_depth,
- encountered_overflow: true,
- nested_goals,
- });
- }
+ return Some(CacheData {
+ result: cx.get_tracked(result),
+ required_depth: additional_depth,
+ encountered_overflow: true,
+ nested_goals,
+ });
}
None
diff --git a/library/alloc/src/collections/btree/set.rs b/library/alloc/src/collections/btree/set.rs
index aa9e5fc..d50ce02 100644
--- a/library/alloc/src/collections/btree/set.rs
+++ b/library/alloc/src/collections/btree/set.rs
@@ -1517,9 +1517,7 @@ fn from_sorted_iter<I: Iterator<Item = T>>(iter: I, alloc: A) -> BTreeSet<T, A>
// use stable sort to preserve the insertion order.
arr.sort();
- let iter = IntoIterator::into_iter(arr).map(|k| (k, SetValZST::default()));
- let map = BTreeMap::bulk_build_from_sorted_iter(iter, Global);
- BTreeSet { map }
+ BTreeSet::from_sorted_iter(IntoIterator::into_iter(arr), Global)
}
}
diff --git a/library/core/src/intrinsics/simd.rs b/library/core/src/intrinsics/simd.rs
index 40efc26..11533ab 100644
--- a/library/core/src/intrinsics/simd.rs
+++ b/library/core/src/intrinsics/simd.rs
@@ -126,6 +126,40 @@ pub unsafe fn simd_extract_dyn<T, U>(x: T, idx: u32) -> U {
#[rustc_nounwind]
pub unsafe fn simd_shr<T>(lhs: T, rhs: T) -> T;
+/// Funnel Shifts vector left elementwise, with UB on overflow.
+///
+/// Concatenates `a` and `b` elementwise (with `a` in the most significant half),
+/// creating a vector of the same length, but with each element being twice as
+/// wide. Then shift this vector left elementwise by `shift`, shifting in zeros,
+/// and extract the most significant half of each of the elements. If `a` and `b`
+/// are the same, this is equivalent to an elementwise rotate left operation.
+///
+/// `T` must be a vector of integers.
+///
+/// # Safety
+///
+/// Each element of `shift` must be less than `<int>::BITS`.
+#[rustc_intrinsic]
+#[rustc_nounwind]
+pub unsafe fn simd_funnel_shl<T>(a: T, b: T, shift: T) -> T;
+
+/// Funnel Shifts vector right elementwise, with UB on overflow.
+///
+/// Concatenates `a` and `b` elementwise (with `a` in the most significant half),
+/// creating a vector of the same length, but with each element being twice as
+/// wide. Then shift this vector right elementwise by `shift`, shifting in zeros,
+/// and extract the least significant half of each of the elements. If `a` and `b`
+/// are the same, this is equivalent to an elementwise rotate right operation.
+///
+/// `T` must be a vector of integers.
+///
+/// # Safety
+///
+/// Each element of `shift` must be less than `<int>::BITS`.
+#[rustc_intrinsic]
+#[rustc_nounwind]
+pub unsafe fn simd_funnel_shr<T>(a: T, b: T, shift: T) -> T;
+
/// "Ands" vectors elementwise.
///
/// `T` must be a vector of integers.
@@ -678,6 +712,14 @@ pub unsafe fn simd_extract_dyn<T, U>(x: T, idx: u32) -> U {
#[rustc_nounwind]
pub unsafe fn simd_round<T>(x: T) -> T;
+/// Rounds each element to the closest integer-valued float.
+/// Ties are resolved by rounding to the number with an even least significant digit
+///
+/// `T` must be a vector of floats.
+#[rustc_intrinsic]
+#[rustc_nounwind]
+pub unsafe fn simd_round_ties_even<T>(x: T) -> T;
+
/// Returns the integer part of each element as an integer-valued float.
/// In other words, non-integer values are truncated towards zero.
///
diff --git a/library/core/src/panic/location.rs b/library/core/src/panic/location.rs
index f1eeded..9722702 100644
--- a/library/core/src/panic/location.rs
+++ b/library/core/src/panic/location.rs
@@ -1,5 +1,7 @@
use crate::ffi::CStr;
use crate::fmt;
+use crate::marker::PhantomData;
+use crate::ptr::NonNull;
/// A struct containing information about the location of a panic.
///
@@ -33,14 +35,13 @@
#[derive(Copy, Clone, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[stable(feature = "panic_hooks", since = "1.10.0")]
pub struct Location<'a> {
- // Note: this filename will have exactly one nul byte at its end, but otherwise
- // it must never contain interior nul bytes. This is relied on for the conversion
- // to `CStr` below.
- //
- // The prefix of the string without the trailing nul byte will be a regular UTF8 `str`.
- file_bytes_with_nul: &'a [u8],
+ // A raw pointer is used rather than a reference because the pointer is valid for one more byte
+ // than the length stored in this pointer; the additional byte is the NUL-terminator used by
+ // `Location::file_with_nul`.
+ filename: NonNull<str>,
line: u32,
col: u32,
+ _filename: PhantomData<&'a str>,
}
#[stable(feature = "panic_hooks", since = "1.10.0")]
@@ -143,10 +144,8 @@ pub const fn caller() -> &'static Location<'static> {
#[stable(feature = "panic_hooks", since = "1.10.0")]
#[rustc_const_stable(feature = "const_location_fields", since = "1.79.0")]
pub const fn file(&self) -> &str {
- let str_len = self.file_bytes_with_nul.len() - 1;
- // SAFETY: `file_bytes_with_nul` without the trailing nul byte is guaranteed to be
- // valid UTF8.
- unsafe { crate::str::from_raw_parts(self.file_bytes_with_nul.as_ptr(), str_len) }
+ // SAFETY: The filename is valid.
+ unsafe { self.filename.as_ref() }
}
/// Returns the name of the source file as a nul-terminated `CStr`.
@@ -157,9 +156,17 @@ pub const fn file(&self) -> &str {
#[unstable(feature = "file_with_nul", issue = "141727")]
#[inline]
pub const fn file_with_nul(&self) -> &CStr {
- // SAFETY: `file_bytes_with_nul` is guaranteed to have a trailing nul byte and no
- // interior nul bytes.
- unsafe { CStr::from_bytes_with_nul_unchecked(self.file_bytes_with_nul) }
+ let filename = self.filename.as_ptr();
+
+ // SAFETY: The filename is valid for `filename_len+1` bytes, so this addition can't
+ // overflow.
+ let cstr_len = unsafe { crate::mem::size_of_val_raw(filename).unchecked_add(1) };
+
+ // SAFETY: The filename is valid for `filename_len+1` bytes.
+ let slice = unsafe { crate::slice::from_raw_parts(filename.cast(), cstr_len) };
+
+ // SAFETY: The filename is guaranteed to have a trailing nul byte and no interior nul bytes.
+ unsafe { CStr::from_bytes_with_nul_unchecked(slice) }
}
/// Returns the line number from which the panic originated.
@@ -220,3 +227,8 @@ fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(formatter, "{}:{}:{}", self.file(), self.line, self.col)
}
}
+
+#[stable(feature = "panic_hooks", since = "1.10.0")]
+unsafe impl Send for Location<'_> {}
+#[stable(feature = "panic_hooks", since = "1.10.0")]
+unsafe impl Sync for Location<'_> {}
diff --git a/library/std/src/os/illumos/mod.rs b/library/std/src/os/illumos/mod.rs
index e61926f..5fbe352 100644
--- a/library/std/src/os/illumos/mod.rs
+++ b/library/std/src/os/illumos/mod.rs
@@ -3,4 +3,5 @@
#![stable(feature = "raw_ext", since = "1.1.0")]
pub mod fs;
+pub mod net;
pub mod raw;
diff --git a/library/std/src/os/illumos/net.rs b/library/std/src/os/illumos/net.rs
new file mode 100644
index 0000000..5ef4e1e
--- /dev/null
+++ b/library/std/src/os/illumos/net.rs
@@ -0,0 +1,50 @@
+//! illumos-specific networking functionality.
+
+#![unstable(feature = "unix_socket_exclbind", issue = "123481")]
+
+use crate::io;
+use crate::os::unix::net;
+use crate::sealed::Sealed;
+use crate::sys_common::AsInner;
+
+/// illumos-specific functionality for `AF_UNIX` sockets [`UnixDatagram`]
+/// and [`UnixStream`].
+///
+/// [`UnixDatagram`]: net::UnixDatagram
+/// [`UnixStream`]: net::UnixStream
+#[unstable(feature = "unix_socket_exclbind", issue = "123481")]
+pub trait UnixSocketExt: Sealed {
+ /// Enables exclusive binding on the socket.
+ ///
+ /// If true and if the socket had been set with `SO_REUSEADDR`,
+ /// it neutralises its effect.
+ /// See [`man 3 tcp`](https://docs.oracle.com/cd/E88353_01/html/E37843/setsockopt-3c.html)
+ #[unstable(feature = "unix_socket_exclbind", issue = "123481")]
+ fn so_exclbind(&self, excl: bool) -> io::Result<()>;
+
+ /// Get the bind exclusivity bind state of the socket.
+ #[unstable(feature = "unix_socket_exclbind", issue = "123481")]
+ fn exclbind(&self) -> io::Result<bool>;
+}
+
+#[unstable(feature = "unix_socket_exclbind", issue = "123481")]
+impl UnixSocketExt for net::UnixDatagram {
+ fn exclbind(&self) -> io::Result<bool> {
+ self.as_inner().exclbind()
+ }
+
+ fn so_exclbind(&self, excl: bool) -> io::Result<()> {
+ self.as_inner().set_exclbind(excl)
+ }
+}
+
+#[unstable(feature = "unix_socket_exclbind", issue = "123481")]
+impl UnixSocketExt for net::UnixStream {
+ fn exclbind(&self) -> io::Result<bool> {
+ self.as_inner().exclbind()
+ }
+
+ fn so_exclbind(&self, excl: bool) -> io::Result<()> {
+ self.as_inner().set_exclbind(excl)
+ }
+}
diff --git a/library/std/src/os/solaris/mod.rs b/library/std/src/os/solaris/mod.rs
index e4cfd53..b4e8362 100644
--- a/library/std/src/os/solaris/mod.rs
+++ b/library/std/src/os/solaris/mod.rs
@@ -3,4 +3,5 @@
#![stable(feature = "raw_ext", since = "1.1.0")]
pub mod fs;
+pub mod net;
pub mod raw;
diff --git a/library/std/src/os/solaris/net.rs b/library/std/src/os/solaris/net.rs
new file mode 100644
index 0000000..ca841f1
--- /dev/null
+++ b/library/std/src/os/solaris/net.rs
@@ -0,0 +1,50 @@
+//! solaris-specific networking functionality.
+
+#![unstable(feature = "unix_socket_exclbind", issue = "123481")]
+
+use crate::io;
+use crate::os::unix::net;
+use crate::sealed::Sealed;
+use crate::sys_common::AsInner;
+
+/// solaris-specific functionality for `AF_UNIX` sockets [`UnixDatagram`]
+/// and [`UnixStream`].
+///
+/// [`UnixDatagram`]: net::UnixDatagram
+/// [`UnixStream`]: net::UnixStream
+#[unstable(feature = "unix_socket_exclbind", issue = "123481")]
+pub trait UnixSocketExt: Sealed {
+ /// Enables exclusive binding on the socket.
+ ///
+ /// If true and if the socket had been set with `SO_REUSEADDR`,
+ /// it neutralises its effect.
+ /// See [`man 3 tcp`](https://docs.oracle.com/cd/E88353_01/html/E37843/setsockopt-3c.html)
+ #[unstable(feature = "unix_socket_exclbind", issue = "123481")]
+ fn so_exclbind(&self, excl: bool) -> io::Result<()>;
+
+ /// Get the bind exclusivity bind state of the socket.
+ #[unstable(feature = "unix_socket_exclbind", issue = "123481")]
+ fn exclbind(&self) -> io::Result<bool>;
+}
+
+#[unstable(feature = "unix_socket_exclbind", issue = "123481")]
+impl UnixSocketExt for net::UnixDatagram {
+ fn exclbind(&self) -> io::Result<bool> {
+ self.as_inner().exclbind()
+ }
+
+ fn so_exclbind(&self, excl: bool) -> io::Result<()> {
+ self.as_inner().set_exclbind(excl)
+ }
+}
+
+#[unstable(feature = "unix_socket_exclbind", issue = "123481")]
+impl UnixSocketExt for net::UnixStream {
+ fn exclbind(&self) -> io::Result<bool> {
+ self.as_inner().exclbind()
+ }
+
+ fn so_exclbind(&self, excl: bool) -> io::Result<()> {
+ self.as_inner().set_exclbind(excl)
+ }
+}
diff --git a/library/std/src/os/unix/fs.rs b/library/std/src/os/unix/fs.rs
index 4f9259f..b776df3 100644
--- a/library/std/src/os/unix/fs.rs
+++ b/library/std/src/os/unix/fs.rs
@@ -408,24 +408,22 @@ pub trait OpenOptionsExt {
/// Pass custom flags to the `flags` argument of `open`.
///
/// The bits that define the access mode are masked out with `O_ACCMODE`, to
- /// ensure they do not interfere with the access mode set by Rusts options.
+ /// ensure they do not interfere with the access mode set by Rust's options.
///
- /// Custom flags can only set flags, not remove flags set by Rusts options.
- /// This options overwrites any previously set custom flags.
+ /// Custom flags can only set flags, not remove flags set by Rust's options.
+ /// This function overwrites any previously-set custom flags.
///
/// # Examples
///
/// ```no_run
- /// # #![feature(rustc_private)]
+ /// # mod libc { pub const O_NOFOLLOW: i32 = 0; }
/// use std::fs::OpenOptions;
/// use std::os::unix::fs::OpenOptionsExt;
///
/// # fn main() {
/// let mut options = OpenOptions::new();
/// options.write(true);
- /// if cfg!(unix) {
- /// options.custom_flags(libc::O_NOFOLLOW);
- /// }
+ /// options.custom_flags(libc::O_NOFOLLOW);
/// let file = options.open("foo.txt");
/// # }
/// ```
diff --git a/library/std/src/sys/fs/windows/remove_dir_all.rs b/library/std/src/sys/fs/windows/remove_dir_all.rs
index 06734f9..c8b1a07 100644
--- a/library/std/src/sys/fs/windows/remove_dir_all.rs
+++ b/library/std/src/sys/fs/windows/remove_dir_all.rs
@@ -33,7 +33,7 @@
use super::{AsRawHandle, DirBuff, File, FromRawHandle};
use crate::sys::c;
-use crate::sys::pal::api::WinError;
+use crate::sys::pal::api::{UnicodeStrRef, WinError, unicode_str};
use crate::thread;
// The maximum number of times to spin when waiting for deletes to complete.
@@ -74,7 +74,7 @@ unsafe fn nt_open_file(
/// `options` will be OR'd with `FILE_OPEN_REPARSE_POINT`.
fn open_link_no_reparse(
parent: &File,
- path: &[u16],
+ path: UnicodeStrRef<'_>,
access: u32,
options: u32,
) -> Result<Option<File>, WinError> {
@@ -90,9 +90,8 @@ fn open_link_no_reparse(
static ATTRIBUTES: Atomic<u32> = AtomicU32::new(c::OBJ_DONT_REPARSE);
let result = unsafe {
- let mut path_str = c::UNICODE_STRING::from_ref(path);
let mut object = c::OBJECT_ATTRIBUTES {
- ObjectName: &mut path_str,
+ ObjectName: path.as_ptr(),
RootDirectory: parent.as_raw_handle(),
Attributes: ATTRIBUTES.load(Ordering::Relaxed),
..c::OBJECT_ATTRIBUTES::with_length()
@@ -129,7 +128,7 @@ fn open_link_no_reparse(
}
}
-fn open_dir(parent: &File, name: &[u16]) -> Result<Option<File>, WinError> {
+fn open_dir(parent: &File, name: UnicodeStrRef<'_>) -> Result<Option<File>, WinError> {
// Open the directory for synchronous directory listing.
open_link_no_reparse(
parent,
@@ -140,7 +139,7 @@ fn open_dir(parent: &File, name: &[u16]) -> Result<Option<File>, WinError> {
)
}
-fn delete(parent: &File, name: &[u16]) -> Result<(), WinError> {
+fn delete(parent: &File, name: UnicodeStrRef<'_>) -> Result<(), WinError> {
// Note that the `delete` function consumes the opened file to ensure it's
// dropped immediately. See module comments for why this is important.
match open_link_no_reparse(parent, name, c::DELETE, 0) {
@@ -179,8 +178,9 @@ pub fn remove_dir_all_iterative(dir: File) -> Result<(), WinError> {
'outer: while let Some(dir) = dirlist.pop() {
let more_data = dir.fill_dir_buff(&mut buffer, restart)?;
for (name, is_directory) in buffer.iter() {
+ let name = unicode_str!(&name);
if is_directory {
- let Some(subdir) = open_dir(&dir, &name)? else { continue };
+ let Some(subdir) = open_dir(&dir, name)? else { continue };
dirlist.push(dir);
dirlist.push(subdir);
continue 'outer;
@@ -188,7 +188,7 @@ pub fn remove_dir_all_iterative(dir: File) -> Result<(), WinError> {
// Attempt to delete, retrying on sharing violation errors as these
// can often be very temporary. E.g. if something takes just a
// bit longer than expected to release a file handle.
- retry(|| delete(&dir, &name), WinError::SHARING_VIOLATION)?;
+ retry(|| delete(&dir, name), WinError::SHARING_VIOLATION)?;
}
}
if more_data {
@@ -197,7 +197,8 @@ pub fn remove_dir_all_iterative(dir: File) -> Result<(), WinError> {
} else {
// Attempt to delete, retrying on not empty errors because we may
// need to wait some time for files to be removed from the filesystem.
- retry(|| delete(&dir, &[]), WinError::DIR_NOT_EMPTY)?;
+ let name = unicode_str!("");
+ retry(|| delete(&dir, name), WinError::DIR_NOT_EMPTY)?;
restart = true;
}
}
diff --git a/library/std/src/sys/net/connection/socket/unix.rs b/library/std/src/sys/net/connection/socket/unix.rs
index b2a4961..cc111f3 100644
--- a/library/std/src/sys/net/connection/socket/unix.rs
+++ b/library/std/src/sys/net/connection/socket/unix.rs
@@ -522,6 +522,21 @@ pub fn acceptfilter(&self) -> io::Result<&CStr> {
Ok(name)
}
+ #[cfg(any(target_os = "solaris", target_os = "illumos"))]
+ pub fn set_exclbind(&self, excl: bool) -> io::Result<()> {
+ // not yet on libc crate
+ const SO_EXCLBIND: i32 = 0x1015;
+ setsockopt(self, libc::SOL_SOCKET, SO_EXCLBIND, excl)
+ }
+
+ #[cfg(any(target_os = "solaris", target_os = "illumos"))]
+ pub fn exclbind(&self) -> io::Result<bool> {
+ // not yet on libc crate
+ const SO_EXCLBIND: i32 = 0x1015;
+ let raw: c_int = getsockopt(self, libc::SOL_SOCKET, SO_EXCLBIND)?;
+ Ok(raw != 0)
+ }
+
#[cfg(any(target_os = "android", target_os = "linux",))]
pub fn set_passcred(&self, passcred: bool) -> io::Result<()> {
setsockopt(self, libc::SOL_SOCKET, libc::SO_PASSCRED, passcred as libc::c_int)
diff --git a/library/std/src/sys/pal/windows/api.rs b/library/std/src/sys/pal/windows/api.rs
index 773455c..25a6c2d 100644
--- a/library/std/src/sys/pal/windows/api.rs
+++ b/library/std/src/sys/pal/windows/api.rs
@@ -30,6 +30,7 @@
//! should go in sys/pal/windows/mod.rs rather than here. See `IoResult` as an example.
use core::ffi::c_void;
+use core::marker::PhantomData;
use super::c;
@@ -291,3 +292,75 @@ impl WinError {
pub const TIMEOUT: Self = Self::new(c::ERROR_TIMEOUT);
// tidy-alphabetical-end
}
+
+/// A wrapper around a UNICODE_STRING that is equivalent to `&[u16]`.
+///
+/// It is preferable to use the `unicode_str!` macro as that contains mitigations for #143078.
+///
+/// If the MaximumLength field of the underlying UNICODE_STRING is greater than
+/// the Length field then you can test if the string is null terminated by inspecting
+/// the u16 directly after the string. You cannot otherwise depend on nul termination.
+#[derive(Copy, Clone)]
+pub struct UnicodeStrRef<'a> {
+ s: c::UNICODE_STRING,
+ lifetime: PhantomData<&'a [u16]>,
+}
+
+static EMPTY_STRING_NULL_TERMINATED: &[u16] = &[0];
+
+impl UnicodeStrRef<'_> {
+ const fn new(slice: &[u16], is_null_terminated: bool) -> Self {
+ let (len, max_len, ptr) = if slice.is_empty() {
+ (0, 2, EMPTY_STRING_NULL_TERMINATED.as_ptr().cast_mut())
+ } else {
+ let len = slice.len() - (is_null_terminated as usize);
+ (len * 2, size_of_val(slice), slice.as_ptr().cast_mut())
+ };
+ Self {
+ s: c::UNICODE_STRING { Length: len as _, MaximumLength: max_len as _, Buffer: ptr },
+ lifetime: PhantomData,
+ }
+ }
+
+ pub const fn from_slice_with_nul(slice: &[u16]) -> Self {
+ if !slice.is_empty() {
+ debug_assert!(slice[slice.len() - 1] == 0);
+ }
+ Self::new(slice, true)
+ }
+
+ pub const fn from_slice(slice: &[u16]) -> Self {
+ Self::new(slice, false)
+ }
+
+ /// Returns a pointer to the underlying UNICODE_STRING
+ pub const fn as_ptr(&self) -> *const c::UNICODE_STRING {
+ &self.s
+ }
+}
+
+/// Create a UnicodeStringRef from a literal str or a u16 array.
+///
+/// To mitigate #143078, when using a literal str the created UNICODE_STRING
+/// will be nul terminated. The MaximumLength field of the UNICODE_STRING will
+/// be set greater than the Length field to indicate that a nul may be present.
+///
+/// If using a u16 array, the array is used exactly as provided and you cannot
+/// count on the string being nul terminated.
+/// This should generally be used for strings that come from the OS.
+///
+/// **NOTE:** we lack a UNICODE_STRING builder type as we don't currently have
+/// a use for it. If needing to dynamically build a UNICODE_STRING, the builder
+/// should try to ensure there's a nul one past the end of the string.
+pub macro unicode_str {
+ ($str:literal) => {const {
+ crate::sys::pal::windows::api::UnicodeStrRef::from_slice_with_nul(
+ crate::sys::pal::windows::api::wide_str!($str),
+ )
+ }},
+ ($array:expr) => {
+ crate::sys::pal::windows::api::UnicodeStrRef::from_slice(
+ $array,
+ )
+ }
+}
diff --git a/library/std/src/sys/pal/windows/c.rs b/library/std/src/sys/pal/windows/c.rs
index 53dec10..eee169d 100644
--- a/library/std/src/sys/pal/windows/c.rs
+++ b/library/std/src/sys/pal/windows/c.rs
@@ -37,13 +37,6 @@ pub fn nt_success(status: NTSTATUS) -> bool {
status >= 0
}
-impl UNICODE_STRING {
- pub fn from_ref(slice: &[u16]) -> Self {
- let len = size_of_val(slice);
- Self { Length: len as _, MaximumLength: len as _, Buffer: slice.as_ptr() as _ }
- }
-}
-
impl OBJECT_ATTRIBUTES {
pub fn with_length() -> Self {
Self {
diff --git a/library/std/src/sys/pal/windows/pipe.rs b/library/std/src/sys/pal/windows/pipe.rs
index bc5d05c..b5ccf03 100644
--- a/library/std/src/sys/pal/windows/pipe.rs
+++ b/library/std/src/sys/pal/windows/pipe.rs
@@ -1,9 +1,8 @@
use crate::io::{self, BorrowedCursor, IoSlice, IoSliceMut};
use crate::ops::Neg;
use crate::os::windows::prelude::*;
-use crate::sys::api::utf16;
-use crate::sys::c;
use crate::sys::handle::Handle;
+use crate::sys::{api, c};
use crate::sys_common::{FromInner, IntoInner};
use crate::{mem, ptr};
@@ -73,8 +72,8 @@ pub fn anon_pipe(ours_readable: bool, their_handle_inheritable: bool) -> io::Res
// Open a handle to the pipe filesystem (`\??\PIPE\`).
// This will be used when creating a new annon pipe.
let pipe_fs = {
- let path = c::UNICODE_STRING::from_ref(utf16!(r"\??\PIPE\"));
- object_attributes.ObjectName = &path;
+ let path = api::unicode_str!(r"\??\PIPE\");
+ object_attributes.ObjectName = path.as_ptr();
let mut pipe_fs = ptr::null_mut();
let status = c::NtOpenFile(
&mut pipe_fs,
@@ -93,8 +92,12 @@ pub fn anon_pipe(ours_readable: bool, their_handle_inheritable: bool) -> io::Res
// From now on we're using handles instead of paths to create and open pipes.
// So set the `ObjectName` to a zero length string.
+ // As a (perhaps overzealous) mitigation for #143078, we use the null pointer
+ // for empty.Buffer instead of unicode_str!("").
+ // There's no difference to the OS itself but it's possible that third party
+ // DLLs which hook in to processes could be relying on the exact form of this string.
let empty = c::UNICODE_STRING::default();
- object_attributes.ObjectName = ∅
+ object_attributes.ObjectName = &raw const empty;
// Create our side of the pipe for async access.
let ours = {
diff --git a/library/std/src/sys/process/unix/unix.rs b/library/std/src/sys/process/unix/unix.rs
index 1fe80c1..bbd03e2 100644
--- a/library/std/src/sys/process/unix/unix.rs
+++ b/library/std/src/sys/process/unix/unix.rs
@@ -968,8 +968,8 @@ pub fn kill(&self) -> io::Result<()> {
}
pub(crate) fn send_signal(&self, signal: i32) -> io::Result<()> {
- // If we've already waited on this process then the pid can be recycled
- // and used for another process, and we probably shouldn't be signaling
+ // If we've already waited on this process then the pid can be recycled and
+ // used for another process, and we probably shouldn't be sending signals to
// random processes, so return Ok because the process has exited already.
if self.status.is_some() {
return Ok(());
diff --git a/library/std/src/sys/process/unix/vxworks.rs b/library/std/src/sys/process/unix/vxworks.rs
index 51ae8c5..2275cbb 100644
--- a/library/std/src/sys/process/unix/vxworks.rs
+++ b/library/std/src/sys/process/unix/vxworks.rs
@@ -151,8 +151,8 @@ pub fn kill(&self) -> io::Result<()> {
}
pub fn send_signal(&self, signal: i32) -> io::Result<()> {
- // If we've already waited on this process then the pid can be recycled
- // and used for another process, and we probably shouldn't be killing
+ // If we've already waited on this process then the pid can be recycled and
+ // used for another process, and we probably shouldn't be sending signals to
// random processes, so return Ok because the process has exited already.
if self.status.is_some() {
Ok(())
diff --git a/src/ci/docker/host-x86_64/dist-x86_64-linux/dist.sh b/src/ci/docker/host-x86_64/dist-x86_64-linux/dist.sh
index 064ac5b..924bdbc 100755
--- a/src/ci/docker/host-x86_64/dist-x86_64-linux/dist.sh
+++ b/src/ci/docker/host-x86_64/dist-x86_64-linux/dist.sh
@@ -10,4 +10,7 @@
build-manifest bootstrap
# Use GCC for building GCC, as it seems to behave badly when built with Clang
-CC=/rustroot/bin/cc CXX=/rustroot/bin/c++ python3 ../x.py dist gcc
+# Only build GCC on full builds, not try builds
+if [ "${DIST_TRY_BUILD:-0}" == "0" ]; then
+ CC=/rustroot/bin/cc CXX=/rustroot/bin/c++ python3 ../x.py dist gcc
+fi
diff --git a/src/doc/rustc/src/lints/levels.md b/src/doc/rustc/src/lints/levels.md
index 18e827b..5b002b4 100644
--- a/src/doc/rustc/src/lints/levels.md
+++ b/src/doc/rustc/src/lints/levels.md
@@ -330,4 +330,105 @@
This feature is used heavily by Cargo; it will pass `--cap-lints allow` when
compiling your dependencies, so that if they have any warnings, they do not
-pollute the output of your build.
+pollute the output of your build. However, note that `--cap-lints allow` does **not** override lints marked as `force-warn`.
+
+## Priority of lint level sources
+
+Rust allows setting lint levels (`allow`, `warn`, `deny`, `forbid`, `force-warn`) through various sources:
+
+- **Attributes**: `#[allow(...)]`, `#![deny(...)]`, etc.
+- **Command-line options**: `--cap-lints`, `--force-warn`, `-A`, `-W`, `-D`, `-F`
+
+Here’s how these different lint controls interact:
+
+1. [`--force-warn`](#force-warn) forces a lint to warning level, and takes precedence over attributes and all other CLI flags.
+
+ ```rust,compile_fail
+ #[forbid(unused_variables)]
+ fn main() {
+ let x = 42;
+ }
+ ```
+
+ Compiled with:
+
+ ```bash
+ $ rustc --force-warn unused_variables lib.rs
+ warning: unused variable: `x`
+ --> lib.rs:3:9
+ |
+ 3 | let x = 42;
+ | ^ help: if this is intentional, prefix it with an underscore: `_x`
+ |
+ = note: requested on the command line with `--force-warn unused-variables`
+
+ warning: 1 warning emitted
+ ```
+
+2. [`--cap-lints`](#capping-lints) sets the maximum level of a lint, and takes precedence over attributes as well as the `-D`, `-W`, and `-F` CLI flags.
+
+ ```rust,compile_fail
+ #[deny(unused_variables)]
+ fn main() {
+ let x = 42;
+ }
+ ```
+
+ Compiled with:
+
+ ```bash
+ $ rustc --cap-lints=warn lib.rs
+ warning: unused variable: `x`
+ --> test1.rs:3:9
+ |
+ 3 | let x = 42;
+ | ^ help: if this is intentional, prefix it with an underscore: `_x`
+ |
+ note: the lint level is defined here
+ --> test1.rs:1:8
+ |
+ 1 | #[deny(unused_variables)]
+ | ^^^^^^^^^^^^^^^^
+
+ warning: 1 warning emitted
+ ```
+
+3. [CLI level flags](#via-compiler-flag) take precedence over attributes.
+
+ The order of the flags matter; flags on the right take precedence over earlier flags.
+
+ ```rust
+ fn main() {
+ let x = 42;
+ }
+ ```
+
+ Compiled with:
+
+ ```bash
+ $ rustc -A unused_variables -D unused_variables lib.rs
+ error: unused variable: `x`
+ --> test1.rs:2:9
+ |
+ 2 | let x = 42;
+ | ^ help: if this is intentional, prefix it with an underscore: `_x`
+ |
+ = note: requested on the command line with `-D unused-variables`
+
+ error: aborting due to 1 previous error
+ ```
+
+4. Within the source, [attributes](#via-an-attribute) at a lower-level in the syntax tree take precedence over attributes at a higher level, or from a previous attribute on the same entity as listed in left-to-right source order.
+
+ ```rust
+ #![deny(unused_variables)]
+
+ #[allow(unused_variables)]
+ fn main() {
+ let x = 42; // Allow wins
+ }
+ ```
+
+ - The exception is once a lint is set to "forbid", it is an error to try to change its level except for `deny`, which is allowed inside a forbid context, but is ignored.
+
+In terms of priority, [lint groups](groups.md) are treated as-if they are expanded to a list of all of the lints they contain. The exception is the `warnings` group which ignores attribute and CLI order and applies to all lints that would otherwise warn within the entity.
diff --git a/src/librustdoc/Cargo.toml b/src/librustdoc/Cargo.toml
index bba8e63..fdde830 100644
--- a/src/librustdoc/Cargo.toml
+++ b/src/librustdoc/Cargo.toml
@@ -8,23 +8,25 @@
path = "lib.rs"
[dependencies]
+# tidy-alphabetical-start
arrayvec = { version = "0.7", default-features = false }
askama = { version = "0.14", default-features = false, features = ["alloc", "config", "derive"] }
base64 = "0.21.7"
-itertools = "0.12"
indexmap = "2"
+itertools = "0.12"
minifier = { version = "0.3.5", default-features = false }
pulldown-cmark-escape = { version = "0.11.0", features = ["simd"] }
regex = "1"
rustdoc-json-types = { path = "../rustdoc-json-types" }
-serde_json = "1.0"
serde = { version = "1.0", features = ["derive"] }
+serde_json = "1.0"
smallvec = "1.8.1"
tempfile = "3"
+threadpool = "1.8.1"
tracing = "0.1"
tracing-tree = "0.3.0"
-threadpool = "1.8.1"
unicode-segmentation = "1.9"
+# tidy-alphabetical-end
[dependencies.tracing-subscriber]
version = "0.3.3"
diff --git a/src/librustdoc/html/render/print_item.rs b/src/librustdoc/html/render/print_item.rs
index e16acc9..e33bdc0 100644
--- a/src/librustdoc/html/render/print_item.rs
+++ b/src/librustdoc/html/render/print_item.rs
@@ -1703,6 +1703,7 @@ fn render_enum_fields(
if v.is_stripped() {
continue;
}
+ write!(w, "{}", render_attributes_in_pre(v, TAB, cx))?;
w.write_str(TAB)?;
match v.kind {
clean::VariantItem(ref var) => match var.kind {
diff --git a/src/librustdoc/lib.rs b/src/librustdoc/lib.rs
index 025c135..a3cdc4f 100644
--- a/src/librustdoc/lib.rs
+++ b/src/librustdoc/lib.rs
@@ -1,8 +1,8 @@
+// tidy-alphabetical-start
#![doc(
html_root_url = "https://doc.rust-lang.org/nightly/",
html_playground_url = "https://play.rust-lang.org/"
)]
-#![feature(rustc_private)]
#![feature(ascii_char)]
#![feature(ascii_char_variants)]
#![feature(assert_matches)]
@@ -11,18 +11,12 @@
#![feature(file_buffered)]
#![feature(format_args_nl)]
#![feature(if_let_guard)]
-#![feature(impl_trait_in_assoc_type)]
#![feature(iter_intersperse)]
-#![feature(never_type)]
#![feature(round_char_boundary)]
+#![feature(rustc_private)]
#![feature(test)]
-#![feature(type_alias_impl_trait)]
-#![feature(type_ascription)]
-#![recursion_limit = "256"]
#![warn(rustc::internal)]
-#![allow(clippy::collapsible_if, clippy::collapsible_else_if)]
-#![allow(rustc::diagnostic_outside_of_impl)]
-#![allow(rustc::untranslatable_diagnostic)]
+// tidy-alphabetical-end
extern crate thin_vec;
diff --git a/src/tools/build-manifest/src/main.rs b/src/tools/build-manifest/src/main.rs
index 4c53ea42..0520eff 100644
--- a/src/tools/build-manifest/src/main.rs
+++ b/src/tools/build-manifest/src/main.rs
@@ -14,6 +14,7 @@
static HOSTS: &[&str] = &[
"aarch64-apple-darwin",
+ "aarch64-pc-windows-gnullvm",
"aarch64-pc-windows-msvc",
"aarch64-unknown-linux-gnu",
"aarch64-unknown-linux-musl",
@@ -44,6 +45,7 @@
"x86_64-apple-darwin",
"x86_64-pc-solaris",
"x86_64-pc-windows-gnu",
+ "x86_64-pc-windows-gnullvm",
"x86_64-pc-windows-msvc",
"x86_64-unknown-freebsd",
"x86_64-unknown-illumos",
@@ -470,7 +472,7 @@ fn target_host_combination(&mut self, host: &str, manifest: &Manifest) -> Option
}
// so is rust-mingw if it's available for the target
PkgType::RustMingw => {
- if host.contains("pc-windows-gnu") {
+ if host.ends_with("pc-windows-gnu") {
components.push(host_component(pkg));
}
}
diff --git a/src/tools/cargo b/src/tools/cargo
index 409fed7..930b4f6 160000
--- a/src/tools/cargo
+++ b/src/tools/cargo
@@ -1 +1 @@
-Subproject commit 409fed7dc1553d49cb9a8c0637d12d65571346ce
+Subproject commit 930b4f62cfcd1f0eabdb30a56d91bf6844b739bf
diff --git a/src/tools/miri/Cargo.lock b/src/tools/miri/Cargo.lock
index 192d4f4..d3123ca 100644
--- a/src/tools/miri/Cargo.lock
+++ b/src/tools/miri/Cargo.lock
@@ -81,6 +81,15 @@
]
[[package]]
+name = "bincode"
+version = "1.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b1f45e9417d87227c7a56d22e471c6206462cba514c7590c09aff4cf6d1ddcad"
+dependencies = [
+ "serde",
+]
+
+[[package]]
name = "bitflags"
version = "2.9.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -113,6 +122,26 @@
]
[[package]]
+name = "capstone"
+version = "0.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "015ef5d5ca1743e3f94af9509ba6bd2886523cfee46e48d15c2ef5216fd4ac9a"
+dependencies = [
+ "capstone-sys",
+ "libc",
+]
+
+[[package]]
+name = "capstone-sys"
+version = "0.17.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2267cb8d16a1e4197863ec4284ffd1aec26fe7e57c58af46b02590a0235809a0"
+dependencies = [
+ "cc",
+ "libc",
+]
+
+[[package]]
name = "cargo-platform"
version = "0.1.9"
source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -151,6 +180,12 @@
checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
[[package]]
+name = "cfg_aliases"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "613afe47fcd5fac7ccf1db93babcb082c5994d996f20b8b159f2ad1658eb5724"
+
+[[package]]
name = "chrono"
version = "0.4.40"
source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -224,7 +259,7 @@
checksum = "117725a109d387c937a1533ce01b450cbde6b88abceea8473c4d7a85853cda3c"
dependencies = [
"lazy_static",
- "windows-sys",
+ "windows-sys 0.59.0",
]
[[package]]
@@ -243,7 +278,7 @@
"libc",
"once_cell",
"unicode-width 0.2.0",
- "windows-sys",
+ "windows-sys 0.59.0",
]
[[package]]
@@ -298,7 +333,7 @@
"libc",
"option-ext",
"redox_users",
- "windows-sys",
+ "windows-sys 0.59.0",
]
[[package]]
@@ -314,7 +349,7 @@
checksum = "976dd42dc7e85965fe702eb8164f21f450704bdde31faefd6471dba214cb594e"
dependencies = [
"libc",
- "windows-sys",
+ "windows-sys 0.59.0",
]
[[package]]
@@ -334,6 +369,12 @@
checksum = "37909eebbb50d72f9059c3b6d82c0463f2ff062c9e95845c43a6c9c0355411be"
[[package]]
+name = "fnv"
+version = "1.0.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1"
+
+[[package]]
name = "generic-array"
version = "0.14.7"
source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -401,6 +442,25 @@
]
[[package]]
+name = "ipc-channel"
+version = "0.19.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6fb8251fb7bcd9ccd3725ed8deae9fe7db8e586495c9eb5b0c52e6233e5e75ea"
+dependencies = [
+ "bincode",
+ "crossbeam-channel",
+ "fnv",
+ "lazy_static",
+ "libc",
+ "mio",
+ "rand 0.8.5",
+ "serde",
+ "tempfile",
+ "uuid",
+ "windows",
+]
+
+[[package]]
name = "itoa"
version = "1.0.15"
source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -534,23 +594,39 @@
]
[[package]]
+name = "mio"
+version = "1.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2886843bf800fba2e3377cff24abf6379b4c4d5c6681eaf9ea5b0d15090450bd"
+dependencies = [
+ "libc",
+ "log",
+ "wasi 0.11.0+wasi-snapshot-preview1",
+ "windows-sys 0.52.0",
+]
+
+[[package]]
name = "miri"
version = "0.1.0"
dependencies = [
"aes",
"bitflags",
+ "capstone",
"chrono",
"chrono-tz",
"colored",
"directories",
"getrandom 0.3.2",
+ "ipc-channel",
"libc",
"libffi",
"libloading",
"measureme",
+ "nix",
"rand 0.9.0",
"regex",
"rustc_version",
+ "serde",
"smallvec",
"tempfile",
"tikv-jemalloc-sys",
@@ -558,6 +634,18 @@
]
[[package]]
+name = "nix"
+version = "0.30.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "74523f3a35e05aba87a1d978330aef40f67b0304ac79c1c00b294c9830543db6"
+dependencies = [
+ "bitflags",
+ "cfg-if",
+ "cfg_aliases",
+ "libc",
+]
+
+[[package]]
name = "num-traits"
version = "0.2.19"
source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -748,6 +836,8 @@
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "34af8d1a0e25924bc5b7c43c079c942339d8f0a8b57c39049bef581b46327404"
dependencies = [
+ "libc",
+ "rand_chacha 0.3.1",
"rand_core 0.6.4",
]
@@ -757,13 +847,23 @@
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "3779b94aeb87e8bd4e834cee3650289ee9e0d5677f976ecdb6d219e5f4f6cd94"
dependencies = [
- "rand_chacha",
+ "rand_chacha 0.9.0",
"rand_core 0.9.3",
"zerocopy",
]
[[package]]
name = "rand_chacha"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88"
+dependencies = [
+ "ppv-lite86",
+ "rand_core 0.6.4",
+]
+
+[[package]]
+name = "rand_chacha"
version = "0.9.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d3022b5f1df60f26e1ffddd6c66e8aa15de382ae63b3a0c1bfc0e4d3e3f325cb"
@@ -777,6 +877,9 @@
version = "0.6.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c"
+dependencies = [
+ "getrandom 0.2.15",
+]
[[package]]
name = "rand_core"
@@ -879,7 +982,7 @@
"errno",
"libc",
"linux-raw-sys",
- "windows-sys",
+ "windows-sys 0.59.0",
]
[[package]]
@@ -993,7 +1096,7 @@
"getrandom 0.3.2",
"once_cell",
"rustix",
- "windows-sys",
+ "windows-sys 0.59.0",
]
[[package]]
@@ -1148,6 +1251,15 @@
checksum = "1fc81956842c57dac11422a97c3b8195a1ff727f06e85c84ed2e8aa277c9a0fd"
[[package]]
+name = "uuid"
+version = "1.16.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "458f7a779bf54acc9f347480ac654f68407d3aab21269a6e3c9f922acd9e2da9"
+dependencies = [
+ "getrandom 0.3.2",
+]
+
+[[package]]
name = "valuable"
version = "0.1.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -1242,6 +1354,79 @@
]
[[package]]
+name = "windows"
+version = "0.58.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dd04d41d93c4992d421894c18c8b43496aa748dd4c081bac0dc93eb0489272b6"
+dependencies = [
+ "windows-core",
+ "windows-targets",
+]
+
+[[package]]
+name = "windows-core"
+version = "0.58.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6ba6d44ec8c2591c134257ce647b7ea6b20335bf6379a27dac5f1641fcf59f99"
+dependencies = [
+ "windows-implement",
+ "windows-interface",
+ "windows-result",
+ "windows-strings",
+ "windows-targets",
+]
+
+[[package]]
+name = "windows-implement"
+version = "0.58.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2bbd5b46c938e506ecbce286b6628a02171d56153ba733b6c741fc627ec9579b"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "windows-interface"
+version = "0.58.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "053c4c462dc91d3b1504c6fe5a726dd15e216ba718e84a0e46a88fbe5ded3515"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "windows-result"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1d1043d8214f791817bab27572aaa8af63732e11bf84aa21a45a78d6c317ae0e"
+dependencies = [
+ "windows-targets",
+]
+
+[[package]]
+name = "windows-strings"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4cd9b125c486025df0eabcb585e62173c6c9eddcec5d117d3b6e8c30e2ee4d10"
+dependencies = [
+ "windows-result",
+ "windows-targets",
+]
+
+[[package]]
+name = "windows-sys"
+version = "0.52.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "282be5f36a8ce781fad8c8ae18fa3f9beff57ec1b52cb3de0789201425d9a33d"
+dependencies = [
+ "windows-targets",
+]
+
+[[package]]
name = "windows-sys"
version = "0.59.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
diff --git a/src/tools/miri/Cargo.toml b/src/tools/miri/Cargo.toml
index a314488..0b4b8e2 100644
--- a/src/tools/miri/Cargo.toml
+++ b/src/tools/miri/Cargo.toml
@@ -40,6 +40,12 @@
libffi = "4.0.0"
libloading = "0.8"
+[target.'cfg(target_os = "linux")'.dependencies]
+nix = { version = "0.30.1", features = ["mman", "ptrace", "signal"] }
+ipc-channel = "0.19.0"
+serde = { version = "1.0.219", features = ["derive"] }
+capstone = "0.13"
+
[dev-dependencies]
ui_test = "0.29.1"
colored = "2"
diff --git a/src/tools/miri/README.md b/src/tools/miri/README.md
index 5554c79..e609fb9 100644
--- a/src/tools/miri/README.md
+++ b/src/tools/miri/README.md
@@ -419,6 +419,9 @@
Finally, the flag is **unsound** in the sense that Miri stops tracking details such as
initialization and provenance on memory shared with native code, so it is easily possible to write
code that has UB which is missed by Miri.
+* `-Zmiri-native-lib-enable-tracing` enables the WIP detailed tracing mode for invoking native code.
+ Note that this flag is only meaningful on Linux systems; other Unixes (currently) do not support
+ tracing mode.
* `-Zmiri-measureme=<name>` enables `measureme` profiling for the interpreted program.
This can be used to find which parts of your program are executing slowly under Miri.
The profile is written out to a file inside a directory called `<name>`, and can be processed
@@ -592,7 +595,7 @@
* [Occasional memory leak in `std::mpsc` channels](https://github.com/rust-lang/rust/issues/121582) (original code in [crossbeam](https://github.com/crossbeam-rs/crossbeam/pull/1084))
* [Weak-memory-induced memory leak in Windows thread-local storage](https://github.com/rust-lang/rust/pull/124281)
* [A bug in the new `RwLock::downgrade` implementation](https://rust-lang.zulipchat.com/#narrow/channel/269128-miri/topic/Miri.20error.20library.20test) (caught by Miri before it landed in the Rust repo)
-* [Mockall reading unintialized memory when mocking `std::io::Read::read`, even if all expectations are satisfied](https://github.com/asomers/mockall/issues/647) (caught by Miri running Tokio's test suite)
+* [Mockall reading uninitialized memory when mocking `std::io::Read::read`, even if all expectations are satisfied](https://github.com/asomers/mockall/issues/647) (caught by Miri running Tokio's test suite)
* [`ReentrantLock` not correctly dealing with reuse of addresses for TLS storage of different threads](https://github.com/rust-lang/rust/pull/141248)
Violations of [Stacked Borrows] found that are likely bugs (but Stacked Borrows is currently just an experiment):
diff --git a/src/tools/miri/miri-script/src/commands.rs b/src/tools/miri/miri-script/src/commands.rs
index 8636214..d18e9c7 100644
--- a/src/tools/miri/miri-script/src/commands.rs
+++ b/src/tools/miri/miri-script/src/commands.rs
@@ -32,6 +32,7 @@ fn build_miri_sysroot(
&mut self,
quiet: bool,
target: Option<impl AsRef<OsStr>>,
+ features: &[String],
) -> Result<PathBuf> {
if let Some(miri_sysroot) = self.sh.var_os("MIRI_SYSROOT") {
// Sysroot already set, use that.
@@ -39,8 +40,8 @@ fn build_miri_sysroot(
}
// Make sure everything is built. Also Miri itself.
- self.build(".", &[], quiet)?;
- self.build("cargo-miri", &[], quiet)?;
+ self.build(".", features, &[], quiet)?;
+ self.build("cargo-miri", &[], &[], quiet)?;
let target_flag = if let Some(target) = &target {
vec![OsStr::new("--target"), target.as_ref()]
@@ -58,7 +59,7 @@ fn build_miri_sysroot(
}
let mut cmd = self
- .cargo_cmd("cargo-miri", "run")
+ .cargo_cmd("cargo-miri", "run", &[])
.arg("--quiet")
.arg("--")
.args(&["miri", "setup", "--print-sysroot"])
@@ -90,7 +91,9 @@ fn auto_actions() -> Result<()> {
Self::fmt(vec![])?;
}
if auto_clippy {
- Self::clippy(vec![])?;
+ // no features for auto actions, see
+ // https://github.com/rust-lang/miri/pull/4396#discussion_r2149654845
+ Self::clippy(vec![], vec![])?;
}
Ok(())
@@ -175,16 +178,16 @@ pub fn exec(self) -> Result<()> {
}
// Then run the actual command.
match self {
- Command::Install { flags } => Self::install(flags),
- Command::Build { flags } => Self::build(flags),
- Command::Check { flags } => Self::check(flags),
- Command::Test { bless, flags, target, coverage } =>
- Self::test(bless, flags, target, coverage),
- Command::Run { dep, verbose, target, edition, flags } =>
- Self::run(dep, verbose, target, edition, flags),
- Command::Doc { flags } => Self::doc(flags),
+ Command::Install { features, flags } => Self::install(features, flags),
+ Command::Build { features, flags } => Self::build(features, flags),
+ Command::Check { features, flags } => Self::check(features, flags),
+ Command::Test { bless, target, coverage, features, flags } =>
+ Self::test(bless, target, coverage, features, flags),
+ Command::Run { dep, verbose, target, edition, features, flags } =>
+ Self::run(dep, verbose, target, edition, features, flags),
+ Command::Doc { features, flags } => Self::doc(features, flags),
Command::Fmt { flags } => Self::fmt(flags),
- Command::Clippy { flags } => Self::clippy(flags),
+ Command::Clippy { features, flags } => Self::clippy(features, flags),
Command::Bench { target, no_install, save_baseline, load_baseline, benches } =>
Self::bench(target, no_install, save_baseline, load_baseline, benches),
Command::Toolchain { flags } => Self::toolchain(flags),
@@ -494,7 +497,7 @@ fn bench(
if !no_install {
// Make sure we have an up-to-date Miri installed and selected the right toolchain.
- Self::install(vec![])?;
+ Self::install(vec![], vec![])?;
}
let results_json_dir = if save_baseline.is_some() || load_baseline.is_some() {
Some(TempDir::new()?)
@@ -601,47 +604,48 @@ struct BenchResult {
Ok(())
}
- fn install(flags: Vec<String>) -> Result<()> {
+ fn install(features: Vec<String>, flags: Vec<String>) -> Result<()> {
let e = MiriEnv::new()?;
- e.install_to_sysroot(e.miri_dir.clone(), &flags)?;
- e.install_to_sysroot(path!(e.miri_dir / "cargo-miri"), &flags)?;
+ e.install_to_sysroot(".", &features, &flags)?;
+ e.install_to_sysroot("cargo-miri", &[], &flags)?;
Ok(())
}
- fn build(flags: Vec<String>) -> Result<()> {
+ fn build(features: Vec<String>, flags: Vec<String>) -> Result<()> {
let e = MiriEnv::new()?;
- e.build(".", &flags, /* quiet */ false)?;
- e.build("cargo-miri", &flags, /* quiet */ false)?;
+ e.build(".", &features, &flags, /* quiet */ false)?;
+ e.build("cargo-miri", &[], &flags, /* quiet */ false)?;
Ok(())
}
- fn check(flags: Vec<String>) -> Result<()> {
+ fn check(features: Vec<String>, flags: Vec<String>) -> Result<()> {
let e = MiriEnv::new()?;
- e.check(".", &flags)?;
- e.check("cargo-miri", &flags)?;
+ e.check(".", &features, &flags)?;
+ e.check("cargo-miri", &[], &flags)?;
Ok(())
}
- fn doc(flags: Vec<String>) -> Result<()> {
+ fn doc(features: Vec<String>, flags: Vec<String>) -> Result<()> {
let e = MiriEnv::new()?;
- e.doc(".", &flags)?;
- e.doc("cargo-miri", &flags)?;
+ e.doc(".", &features, &flags)?;
+ e.doc("cargo-miri", &[], &flags)?;
Ok(())
}
- fn clippy(flags: Vec<String>) -> Result<()> {
+ fn clippy(features: Vec<String>, flags: Vec<String>) -> Result<()> {
let e = MiriEnv::new()?;
- e.clippy(".", &flags)?;
- e.clippy("cargo-miri", &flags)?;
- e.clippy("miri-script", &flags)?;
+ e.clippy(".", &features, &flags)?;
+ e.clippy("cargo-miri", &[], &flags)?;
+ e.clippy("miri-script", &[], &flags)?;
Ok(())
}
fn test(
bless: bool,
- mut flags: Vec<String>,
target: Option<String>,
coverage: bool,
+ features: Vec<String>,
+ mut flags: Vec<String>,
) -> Result<()> {
let mut e = MiriEnv::new()?;
@@ -652,7 +656,7 @@ fn test(
}
// Prepare a sysroot. (Also builds cargo-miri, which we need.)
- e.build_miri_sysroot(/* quiet */ false, target.as_deref())?;
+ e.build_miri_sysroot(/* quiet */ false, target.as_deref(), &features)?;
// Forward information to test harness.
if bless {
@@ -672,10 +676,10 @@ fn test(
// Then test, and let caller control flags.
// Only in root project as `cargo-miri` has no tests.
- e.test(".", &flags)?;
+ e.test(".", &features, &flags)?;
if let Some(coverage) = &coverage {
- coverage.show_coverage_report(&e)?;
+ coverage.show_coverage_report(&e, &features)?;
}
Ok(())
@@ -686,14 +690,17 @@ fn run(
verbose: bool,
target: Option<String>,
edition: Option<String>,
+ features: Vec<String>,
flags: Vec<String>,
) -> Result<()> {
let mut e = MiriEnv::new()?;
// Preparation: get a sysroot, and get the miri binary.
- let miri_sysroot = e.build_miri_sysroot(/* quiet */ !verbose, target.as_deref())?;
- let miri_bin =
- e.build_get_binary(".").context("failed to get filename of miri executable")?;
+ let miri_sysroot =
+ e.build_miri_sysroot(/* quiet */ !verbose, target.as_deref(), &features)?;
+ let miri_bin = e
+ .build_get_binary(".", &features)
+ .context("failed to get filename of miri executable")?;
// More flags that we will pass before `flags`
// (because `flags` may contain `--`).
@@ -718,7 +725,7 @@ fn run(
// The basic command that executes the Miri driver.
let mut cmd = if dep {
// We invoke the test suite as that has all the logic for running with dependencies.
- e.cargo_cmd(".", "test")
+ e.cargo_cmd(".", "test", &features)
.args(&["--test", "ui"])
.args(quiet_flag)
.arg("--")
diff --git a/src/tools/miri/miri-script/src/coverage.rs b/src/tools/miri/miri-script/src/coverage.rs
index 8cafcea..cdf2bbb 100644
--- a/src/tools/miri/miri-script/src/coverage.rs
+++ b/src/tools/miri/miri-script/src/coverage.rs
@@ -49,7 +49,7 @@ pub fn add_env_vars(&self, e: &mut MiriEnv) -> Result<()> {
/// show_coverage_report will print coverage information using the artifact
/// files in `self.path`.
- pub fn show_coverage_report(&self, e: &MiriEnv) -> Result<()> {
+ pub fn show_coverage_report(&self, e: &MiriEnv, features: &[String]) -> Result<()> {
let profraw_files = self.profraw_files()?;
let profdata_bin = path!(e.libdir / ".." / "bin" / "llvm-profdata");
@@ -63,8 +63,9 @@ pub fn show_coverage_report(&self, e: &MiriEnv) -> Result<()> {
// Create the coverage report.
let cov_bin = path!(e.libdir / ".." / "bin" / "llvm-cov");
- let miri_bin =
- e.build_get_binary(".").context("failed to get filename of miri executable")?;
+ let miri_bin = e
+ .build_get_binary(".", features)
+ .context("failed to get filename of miri executable")?;
cmd!(
e.sh,
"{cov_bin} report --instr-profile={merged_file} --object {miri_bin} --sources src/"
diff --git a/src/tools/miri/miri-script/src/main.rs b/src/tools/miri/miri-script/src/main.rs
index 6aab2f7..673d658 100644
--- a/src/tools/miri/miri-script/src/main.rs
+++ b/src/tools/miri/miri-script/src/main.rs
@@ -14,24 +14,40 @@ pub enum Command {
/// Sets up the rpath such that the installed binary should work in any
/// working directory.
Install {
+ /// Pass features to cargo invocations on the "miri" crate in the root. This option does
+ /// **not** apply to other crates, so e.g. these features won't be used on "cargo-miri".
+ #[arg(long, value_delimiter = ',', action = clap::ArgAction::Append)]
+ features: Vec<String>,
/// Flags that are passed through to `cargo install`.
#[arg(trailing_var_arg = true, allow_hyphen_values = true)]
flags: Vec<String>,
},
/// Build Miri.
Build {
+ /// Pass features to cargo invocations on the "miri" crate in the root. This option does
+ /// **not** apply to other crates, so e.g. these features won't be used on "cargo-miri".
+ #[arg(long, value_delimiter = ',', action = clap::ArgAction::Append)]
+ features: Vec<String>,
/// Flags that are passed through to `cargo build`.
#[arg(trailing_var_arg = true, allow_hyphen_values = true)]
flags: Vec<String>,
},
/// Check Miri.
Check {
+ /// Pass features to cargo invocations on the "miri" crate in the root. This option does
+ /// **not** apply to other crates, so e.g. these features won't be used on "cargo-miri".
+ #[arg(long, value_delimiter = ',', action = clap::ArgAction::Append)]
+ features: Vec<String>,
/// Flags that are passed through to `cargo check`.
#[arg(trailing_var_arg = true, allow_hyphen_values = true)]
flags: Vec<String>,
},
/// Check Miri with Clippy.
Clippy {
+ /// Pass features to cargo invocations on the "miri" crate in the root. This option does
+ /// **not** apply to other crates, so e.g. these features won't be used on "cargo-miri".
+ #[arg(long, value_delimiter = ',', action = clap::ArgAction::Append)]
+ features: Vec<String>,
/// Flags that are passed through to `cargo clippy`.
#[arg(trailing_var_arg = true, allow_hyphen_values = true)]
flags: Vec<String>,
@@ -47,6 +63,10 @@ pub enum Command {
/// Produce coverage report.
#[arg(long)]
coverage: bool,
+ /// Pass features to cargo invocations on the "miri" crate in the root. This option does
+ /// **not** apply to other crates, so e.g. these features won't be used on "cargo-miri".
+ #[arg(long, value_delimiter = ',', action = clap::ArgAction::Append)]
+ features: Vec<String>,
/// Flags that are passed through to the test harness.
#[arg(trailing_var_arg = true, allow_hyphen_values = true)]
flags: Vec<String>,
@@ -67,6 +87,10 @@ pub enum Command {
/// The Rust edition.
#[arg(long)]
edition: Option<String>,
+ /// Pass features to cargo invocations on the "miri" crate in the root. This option does
+ /// **not** apply to other crates, so e.g. these features won't be used on "cargo-miri".
+ #[arg(long, value_delimiter = ',', action = clap::ArgAction::Append)]
+ features: Vec<String>,
/// Flags that are passed through to `miri`.
///
/// The flags set in `MIRIFLAGS` are added in front of these flags.
@@ -75,6 +99,10 @@ pub enum Command {
},
/// Build documentation.
Doc {
+ /// Pass features to cargo invocations on the "miri" crate in the root. This option does
+ /// **not** apply to other crates, so e.g. these features won't be used on "cargo-miri".
+ #[arg(long, value_delimiter = ',', action = clap::ArgAction::Append)]
+ features: Vec<String>,
/// Flags that are passed through to `cargo doc`.
#[arg(trailing_var_arg = true, allow_hyphen_values = true)]
flags: Vec<String>,
@@ -144,13 +172,13 @@ fn add_remainder(&mut self, remainder: Vec<String>) -> Result<()> {
}
match self {
- Self::Install { flags }
- | Self::Build { flags }
- | Self::Check { flags }
- | Self::Doc { flags }
+ Self::Install { flags, .. }
+ | Self::Build { flags, .. }
+ | Self::Check { flags, .. }
+ | Self::Doc { flags, .. }
| Self::Fmt { flags }
| Self::Toolchain { flags }
- | Self::Clippy { flags }
+ | Self::Clippy { flags, .. }
| Self::Run { flags, .. }
| Self::Test { flags, .. } => {
flags.extend(remainder);
diff --git a/src/tools/miri/miri-script/src/util.rs b/src/tools/miri/miri-script/src/util.rs
index 5c2a055..c100cf1 100644
--- a/src/tools/miri/miri-script/src/util.rs
+++ b/src/tools/miri/miri-script/src/util.rs
@@ -26,6 +26,12 @@ pub fn flagsplit(flags: &str) -> Vec<String> {
flags.split(' ').map(str::trim).filter(|s| !s.is_empty()).map(str::to_string).collect()
}
+/// Turns a list of features into a list of arguments to pass to cargo invocations.
+/// Each feature will go in its own argument, e.g. "--features feat1 --features feat2".
+fn features_to_args(features: &[String]) -> impl IntoIterator<Item = &str> {
+ features.iter().flat_map(|feat| ["--features", feat])
+}
+
/// Some extra state we track for building Miri, such as the right RUSTFLAGS.
pub struct MiriEnv {
/// miri_dir is the root of the miri repository checkout we are working in.
@@ -116,44 +122,70 @@ pub fn new() -> Result<Self> {
Ok(MiriEnv { miri_dir, toolchain, sh, sysroot, cargo_extra_flags, libdir })
}
- pub fn cargo_cmd(&self, crate_dir: impl AsRef<OsStr>, cmd: &str) -> Cmd<'_> {
+ /// Make sure the `features` you pass here exist for the specified `crate_dir`. For example, the
+ /// "--features" parameter of [crate::Command]s is intended only for the "miri" root crate.
+ pub fn cargo_cmd(
+ &self,
+ crate_dir: impl AsRef<OsStr>,
+ cmd: &str,
+ features: &[String],
+ ) -> Cmd<'_> {
let MiriEnv { toolchain, cargo_extra_flags, .. } = self;
let manifest_path = path!(self.miri_dir / crate_dir.as_ref() / "Cargo.toml");
+ let features = features_to_args(features);
cmd!(
self.sh,
- "cargo +{toolchain} {cmd} {cargo_extra_flags...} --manifest-path {manifest_path}"
+ "cargo +{toolchain} {cmd} {cargo_extra_flags...} --manifest-path {manifest_path} {features...}"
)
}
+ /// Make sure the `features` you pass here exist for the specified `crate_dir`. For example, the
+ /// "--features" parameter of [crate::Command]s is intended only for the "miri" root crate.
pub fn install_to_sysroot(
&self,
- path: impl AsRef<OsStr>,
+ crate_dir: impl AsRef<OsStr>,
+ features: &[String],
args: impl IntoIterator<Item = impl AsRef<OsStr>>,
) -> Result<()> {
let MiriEnv { sysroot, toolchain, cargo_extra_flags, .. } = self;
- let path = path!(self.miri_dir / path.as_ref());
+ let path = path!(self.miri_dir / crate_dir.as_ref());
+ let features = features_to_args(features);
// Install binaries to the miri toolchain's `sysroot` so they do not interact with other toolchains.
// (Not using `cargo_cmd` as `install` is special and doesn't use `--manifest-path`.)
- cmd!(self.sh, "cargo +{toolchain} install {cargo_extra_flags...} --path {path} --force --root {sysroot} {args...}").run()?;
+ cmd!(self.sh, "cargo +{toolchain} install {cargo_extra_flags...} --path {path} --force --root {sysroot} {features...} {args...}").run()?;
Ok(())
}
- pub fn build(&self, crate_dir: impl AsRef<OsStr>, args: &[String], quiet: bool) -> Result<()> {
+ pub fn build(
+ &self,
+ crate_dir: impl AsRef<OsStr>,
+ features: &[String],
+ args: &[String],
+ quiet: bool,
+ ) -> Result<()> {
let quiet_flag = if quiet { Some("--quiet") } else { None };
// We build all targets, since building *just* the bin target doesnot include
// `dev-dependencies` and that changes feature resolution. This also gets us more
// parallelism in `./miri test` as we build Miri and its tests together.
- let mut cmd =
- self.cargo_cmd(crate_dir, "build").args(&["--all-targets"]).args(quiet_flag).args(args);
+ let mut cmd = self
+ .cargo_cmd(crate_dir, "build", features)
+ .args(&["--all-targets"])
+ .args(quiet_flag)
+ .args(args);
cmd.set_quiet(quiet);
cmd.run()?;
Ok(())
}
/// Returns the path to the main crate binary. Assumes that `build` has been called before.
- pub fn build_get_binary(&self, crate_dir: impl AsRef<OsStr>) -> Result<PathBuf> {
- let cmd =
- self.cargo_cmd(crate_dir, "build").args(&["--all-targets", "--message-format=json"]);
+ pub fn build_get_binary(
+ &self,
+ crate_dir: impl AsRef<OsStr>,
+ features: &[String],
+ ) -> Result<PathBuf> {
+ let cmd = self
+ .cargo_cmd(crate_dir, "build", features)
+ .args(&["--all-targets", "--message-format=json"]);
let output = cmd.output()?;
let mut bin = None;
for line in output.stdout.lines() {
@@ -174,23 +206,43 @@ pub fn build_get_binary(&self, crate_dir: impl AsRef<OsStr>) -> Result<PathBuf>
bin.ok_or_else(|| anyhow!("found no binary in cargo output"))
}
- pub fn check(&self, crate_dir: impl AsRef<OsStr>, args: &[String]) -> Result<()> {
- self.cargo_cmd(crate_dir, "check").arg("--all-targets").args(args).run()?;
+ pub fn check(
+ &self,
+ crate_dir: impl AsRef<OsStr>,
+ features: &[String],
+ args: &[String],
+ ) -> Result<()> {
+ self.cargo_cmd(crate_dir, "check", features).arg("--all-targets").args(args).run()?;
Ok(())
}
- pub fn doc(&self, crate_dir: impl AsRef<OsStr>, args: &[String]) -> Result<()> {
- self.cargo_cmd(crate_dir, "doc").args(args).run()?;
+ pub fn doc(
+ &self,
+ crate_dir: impl AsRef<OsStr>,
+ features: &[String],
+ args: &[String],
+ ) -> Result<()> {
+ self.cargo_cmd(crate_dir, "doc", features).args(args).run()?;
Ok(())
}
- pub fn clippy(&self, crate_dir: impl AsRef<OsStr>, args: &[String]) -> Result<()> {
- self.cargo_cmd(crate_dir, "clippy").arg("--all-targets").args(args).run()?;
+ pub fn clippy(
+ &self,
+ crate_dir: impl AsRef<OsStr>,
+ features: &[String],
+ args: &[String],
+ ) -> Result<()> {
+ self.cargo_cmd(crate_dir, "clippy", features).arg("--all-targets").args(args).run()?;
Ok(())
}
- pub fn test(&self, crate_dir: impl AsRef<OsStr>, args: &[String]) -> Result<()> {
- self.cargo_cmd(crate_dir, "test").args(args).run()?;
+ pub fn test(
+ &self,
+ crate_dir: impl AsRef<OsStr>,
+ features: &[String],
+ args: &[String],
+ ) -> Result<()> {
+ self.cargo_cmd(crate_dir, "test", features).args(args).run()?;
Ok(())
}
diff --git a/src/tools/miri/rust-version b/src/tools/miri/rust-version
index 90c6e31..b2ab17f 100644
--- a/src/tools/miri/rust-version
+++ b/src/tools/miri/rust-version
@@ -1 +1 @@
-0cbc0764380630780a275c437260e4d4d5f28c92
+d41e12f1f4e4884c356f319b881921aa37040de5
diff --git a/src/tools/miri/src/alloc/isolated_alloc.rs b/src/tools/miri/src/alloc/isolated_alloc.rs
index 3a7879f..a7bb9b4 100644
--- a/src/tools/miri/src/alloc/isolated_alloc.rs
+++ b/src/tools/miri/src/alloc/isolated_alloc.rs
@@ -1,5 +1,7 @@
-use std::alloc::{self, Layout};
+use std::alloc::Layout;
+use std::ptr::NonNull;
+use nix::sys::mman;
use rustc_index::bit_set::DenseBitSet;
/// How many bytes of memory each bit in the bitset represents.
@@ -11,8 +13,8 @@
pub struct IsolatedAlloc {
/// Pointers to page-aligned memory that has been claimed by the allocator.
/// Every pointer here must point to a page-sized allocation claimed via
- /// the global allocator. These pointers are used for "small" allocations.
- page_ptrs: Vec<*mut u8>,
+ /// mmap. These pointers are used for "small" allocations.
+ page_ptrs: Vec<NonNull<u8>>,
/// Metadata about which bytes have been allocated on each page. The length
/// of this vector must be the same as that of `page_ptrs`, and the domain
/// size of the bitset must be exactly `page_size / COMPRESSION_FACTOR`.
@@ -24,7 +26,7 @@ pub struct IsolatedAlloc {
page_infos: Vec<DenseBitSet<usize>>,
/// Pointers to multiple-page-sized allocations. These must also be page-aligned,
/// with their size stored as the second element of the vector.
- huge_ptrs: Vec<(*mut u8, usize)>,
+ huge_ptrs: Vec<(NonNull<u8>, usize)>,
/// The host (not emulated) page size.
page_size: usize,
}
@@ -52,20 +54,26 @@ fn normalized_layout(layout: Layout) -> Layout {
Layout::from_size_align(size, align).unwrap()
}
- /// Returns the layout used to allocate the pages that hold small allocations.
+ /// For greater-than-page-sized allocations, returns the allocation size we need to request
+ /// including the slack we need to satisfy the alignment request.
#[inline]
- fn page_layout(&self) -> Layout {
- Layout::from_size_align(self.page_size, self.page_size).unwrap()
- }
-
- /// If the allocation is greater than a page, then round to the nearest page #.
- #[inline]
- fn huge_normalized_layout(layout: Layout, page_size: usize) -> Layout {
+ fn huge_normalized_layout(&self, layout: Layout) -> usize {
// Allocate in page-sized chunks
- let size = layout.size().next_multiple_of(page_size);
+ let size = layout.size().next_multiple_of(self.page_size);
// And make sure the align is at least one page
- let align = std::cmp::max(layout.align(), page_size);
- Layout::from_size_align(size, align).unwrap()
+ let align = std::cmp::max(layout.align(), self.page_size);
+ // pg_count gives us the # of pages needed to satisfy the size. For
+ // align > page_size where align = n * page_size, a sufficently-aligned
+ // address must exist somewhere in the range of
+ // some_page_aligned_address..some_page_aligned_address + (n-1) * page_size
+ // (since if some_page_aligned_address + n * page_size is sufficently aligned,
+ // then so is some_page_aligned_address itself per the definition of n, so we
+ // can avoid using that 1 extra page).
+ // Thus we allocate n-1 extra pages
+ let pg_count = size.div_ceil(self.page_size);
+ let extra_pages = align.strict_div(self.page_size).saturating_sub(1);
+
+ pg_count.strict_add(extra_pages).strict_mul(self.page_size)
}
/// Determined whether a given normalized (size, align) should be sent to
@@ -78,7 +86,7 @@ fn is_huge_alloc(&self, layout: &Layout) -> bool {
/// Allocates memory as described in `Layout`. This memory should be deallocated
/// by calling `dealloc` on this same allocator.
///
- /// SAFETY: See `alloc::alloc()`
+ /// SAFETY: See `alloc::alloc()`.
pub unsafe fn alloc(&mut self, layout: Layout) -> *mut u8 {
// SAFETY: Upheld by caller
unsafe { self.allocate(layout, false) }
@@ -86,7 +94,7 @@ pub unsafe fn alloc(&mut self, layout: Layout) -> *mut u8 {
/// Same as `alloc`, but zeroes out the memory.
///
- /// SAFETY: See `alloc::alloc_zeroed()`
+ /// SAFETY: See `alloc::alloc_zeroed()`.
pub unsafe fn alloc_zeroed(&mut self, layout: Layout) -> *mut u8 {
// SAFETY: Upheld by caller
unsafe { self.allocate(layout, true) }
@@ -95,14 +103,13 @@ pub unsafe fn alloc_zeroed(&mut self, layout: Layout) -> *mut u8 {
/// Abstracts over the logic of `alloc_zeroed` vs `alloc`, as determined by
/// the `zeroed` argument.
///
- /// SAFETY: See `alloc::alloc()`, with the added restriction that `page_size`
- /// corresponds to the host pagesize.
+ /// SAFETY: See `alloc::alloc()`.
unsafe fn allocate(&mut self, layout: Layout, zeroed: bool) -> *mut u8 {
let layout = IsolatedAlloc::normalized_layout(layout);
if self.is_huge_alloc(&layout) {
// SAFETY: Validity of `layout` upheld by caller; we checked that
// the size and alignment are appropriate for being a huge alloc
- unsafe { self.alloc_huge(layout, zeroed) }
+ unsafe { self.alloc_huge(layout) }
} else {
for (&mut page, pinfo) in std::iter::zip(&mut self.page_ptrs, &mut self.page_infos) {
// SAFETY: The value in `self.page_size` is used to allocate
@@ -132,7 +139,7 @@ unsafe fn allocate(&mut self, layout: Layout, zeroed: bool) -> *mut u8 {
unsafe fn alloc_small(
page_size: usize,
layout: Layout,
- page: *mut u8,
+ page: NonNull<u8>,
pinfo: &mut DenseBitSet<usize>,
zeroed: bool,
) -> Option<*mut u8> {
@@ -159,7 +166,7 @@ unsafe fn alloc_small(
// zero out, even if we allocated more
ptr.write_bytes(0, layout.size());
}
- return Some(ptr);
+ return Some(ptr.as_ptr());
}
}
}
@@ -167,26 +174,50 @@ unsafe fn alloc_small(
}
/// Expands the available memory pool by adding one page.
- fn add_page(&mut self) -> (*mut u8, &mut DenseBitSet<usize>) {
- // SAFETY: The system page size, which is the layout size, cannot be 0
- let page_ptr = unsafe { alloc::alloc(self.page_layout()) };
+ fn add_page(&mut self) -> (NonNull<u8>, &mut DenseBitSet<usize>) {
+ // SAFETY: mmap is always safe to call when requesting anonymous memory
+ let page_ptr = unsafe {
+ libc::mmap(
+ std::ptr::null_mut(),
+ self.page_size,
+ libc::PROT_READ | libc::PROT_WRITE,
+ libc::MAP_PRIVATE | libc::MAP_ANONYMOUS,
+ -1,
+ 0,
+ )
+ .cast::<u8>()
+ };
+ assert_ne!(page_ptr.addr(), usize::MAX, "mmap failed");
// `page_infos` has to have one bit for each `COMPRESSION_FACTOR`-sized chunk of bytes in the page.
- assert!(self.page_size % COMPRESSION_FACTOR == 0);
+ assert!(self.page_size.is_multiple_of(COMPRESSION_FACTOR));
self.page_infos.push(DenseBitSet::new_empty(self.page_size / COMPRESSION_FACTOR));
- self.page_ptrs.push(page_ptr);
- (page_ptr, self.page_infos.last_mut().unwrap())
+ self.page_ptrs.push(NonNull::new(page_ptr).unwrap());
+ (NonNull::new(page_ptr).unwrap(), self.page_infos.last_mut().unwrap())
}
/// Allocates in multiples of one page on the host system.
+ /// Will always be zeroed.
///
/// SAFETY: Same as `alloc()`.
- unsafe fn alloc_huge(&mut self, layout: Layout, zeroed: bool) -> *mut u8 {
- let layout = IsolatedAlloc::huge_normalized_layout(layout, self.page_size);
- // SAFETY: Upheld by caller
- let ret =
- unsafe { if zeroed { alloc::alloc_zeroed(layout) } else { alloc::alloc(layout) } };
- self.huge_ptrs.push((ret, layout.size()));
- ret
+ unsafe fn alloc_huge(&mut self, layout: Layout) -> *mut u8 {
+ let size = self.huge_normalized_layout(layout);
+ // SAFETY: mmap is always safe to call when requesting anonymous memory
+ let ret = unsafe {
+ libc::mmap(
+ std::ptr::null_mut(),
+ size,
+ libc::PROT_READ | libc::PROT_WRITE,
+ libc::MAP_PRIVATE | libc::MAP_ANONYMOUS,
+ -1,
+ 0,
+ )
+ .cast::<u8>()
+ };
+ assert_ne!(ret.addr(), usize::MAX, "mmap failed");
+ self.huge_ptrs.push((NonNull::new(ret).unwrap(), size));
+ // huge_normalized_layout ensures that we've overallocated enough space
+ // for this to be valid.
+ ret.map_addr(|a| a.next_multiple_of(layout.align()))
}
/// Deallocates a pointer from this allocator.
@@ -215,15 +246,15 @@ pub unsafe fn dealloc(&mut self, ptr: *mut u8, layout: Layout) {
let page_ptr = self.page_ptrs.remove(idx);
// SAFETY: We checked that there are no outstanding allocations
// from us pointing to this page, and we know it was allocated
- // with this layout
+ // in add_page as exactly a single page.
unsafe {
- alloc::dealloc(page_ptr, self.page_layout());
+ assert_eq!(libc::munmap(page_ptr.as_ptr().cast(), self.page_size), 0);
}
}
}
}
- /// Returns the index of the page that this was deallocated from
+ /// Returns the index of the page that this was deallocated from.
///
/// SAFETY: the pointer must have been allocated with `alloc_small`.
unsafe fn dealloc_small(&mut self, ptr: *mut u8, layout: Layout) -> usize {
@@ -236,7 +267,7 @@ unsafe fn dealloc_small(&mut self, ptr: *mut u8, layout: Layout) -> usize {
// This could be made faster if the list was sorted -- the allocator isn't fully optimized at the moment.
let pinfo = std::iter::zip(&mut self.page_ptrs, &mut self.page_infos)
.enumerate()
- .find(|(_, (page, _))| page.addr() == page_addr);
+ .find(|(_, (page, _))| page.addr().get() == page_addr);
let Some((idx_of_pinfo, (_, pinfo))) = pinfo else {
panic!("Freeing in an unallocated page: {ptr:?}\nHolding pages {:?}", self.page_ptrs)
};
@@ -252,20 +283,73 @@ unsafe fn dealloc_small(&mut self, ptr: *mut u8, layout: Layout) -> usize {
/// SAFETY: Same as `dealloc()` with the added requirement that `layout`
/// must ask for a size larger than the host pagesize.
unsafe fn dealloc_huge(&mut self, ptr: *mut u8, layout: Layout) {
- let layout = IsolatedAlloc::huge_normalized_layout(layout, self.page_size);
- // Find the pointer matching in address with the one we got
+ let size = self.huge_normalized_layout(layout);
+ // Find the huge allocation containing `ptr`.
let idx = self
.huge_ptrs
.iter()
- .position(|pg| ptr.addr() == pg.0.addr())
+ .position(|&(pg, size)| {
+ pg.addr().get() <= ptr.addr() && ptr.addr() < pg.addr().get().strict_add(size)
+ })
.expect("Freeing unallocated pages");
// And kick it from the list
- self.huge_ptrs.remove(idx);
- // SAFETY: Caller ensures validity of the layout
+ let (un_offset_ptr, size2) = self.huge_ptrs.remove(idx);
+ assert_eq!(size, size2, "got wrong layout in dealloc");
+ // SAFETY: huge_ptrs contains allocations made with mmap with the size recorded there.
unsafe {
- alloc::dealloc(ptr, layout);
+ let ret = libc::munmap(un_offset_ptr.as_ptr().cast(), size);
+ assert_eq!(ret, 0);
}
}
+
+ /// Returns a vector of page addresses managed by the allocator.
+ pub fn pages(&self) -> Vec<usize> {
+ let mut pages: Vec<usize> =
+ self.page_ptrs.iter().map(|p| p.expose_provenance().get()).collect();
+ for (ptr, size) in self.huge_ptrs.iter() {
+ for i in 0..size / self.page_size {
+ pages.push(ptr.expose_provenance().get().strict_add(i * self.page_size));
+ }
+ }
+ pages
+ }
+
+ /// Protects all owned memory as `PROT_NONE`, preventing accesses.
+ ///
+ /// SAFETY: Accessing memory after this point will result in a segfault
+ /// unless it is first unprotected.
+ pub unsafe fn prepare_ffi(&mut self) -> Result<(), nix::errno::Errno> {
+ let prot = mman::ProtFlags::PROT_NONE;
+ unsafe { self.mprotect(prot) }
+ }
+
+ /// Deprotects all owned memory by setting it to RW. Erroring here is very
+ /// likely unrecoverable, so it may panic if applying those permissions
+ /// fails.
+ pub fn unprep_ffi(&mut self) {
+ let prot = mman::ProtFlags::PROT_READ | mman::ProtFlags::PROT_WRITE;
+ unsafe {
+ self.mprotect(prot).unwrap();
+ }
+ }
+
+ /// Applies `prot` to every page managed by the allocator.
+ ///
+ /// SAFETY: Accessing memory in violation of the protection flags will
+ /// trigger a segfault.
+ unsafe fn mprotect(&mut self, prot: mman::ProtFlags) -> Result<(), nix::errno::Errno> {
+ for &pg in &self.page_ptrs {
+ unsafe {
+ mman::mprotect(pg.cast(), self.page_size, prot)?;
+ }
+ }
+ for &(hpg, size) in &self.huge_ptrs {
+ unsafe {
+ mman::mprotect(hpg.cast(), size.next_multiple_of(self.page_size), prot)?;
+ }
+ }
+ Ok(())
+ }
}
#[cfg(test)]
@@ -347,12 +431,15 @@ fn check_leaks_and_overlaps() {
sizes.append(&mut vec![256; 12]);
// Give it some multi-page ones too
sizes.append(&mut vec![32 * 1024; 4]);
+ sizes.push(4 * 1024);
// Matching aligns for the sizes
let mut aligns = vec![16; 12];
aligns.append(&mut vec![256; 2]);
aligns.append(&mut vec![64; 12]);
aligns.append(&mut vec![4096; 4]);
+ // And one that requests align > page_size
+ aligns.push(64 * 1024);
// Make sure we didn't mess up in the test itself!
assert_eq!(sizes.len(), aligns.len());
diff --git a/src/tools/miri/src/alloc_addresses/reuse_pool.rs b/src/tools/miri/src/alloc_addresses/reuse_pool.rs
index ab6aaed..b6cc017 100644
--- a/src/tools/miri/src/alloc_addresses/reuse_pool.rs
+++ b/src/tools/miri/src/alloc_addresses/reuse_pool.rs
@@ -129,7 +129,7 @@ pub fn take_addr(
let idx = rng.random_range(begin..end);
// Remove it from the pool and return.
let (chosen_addr, chosen_size, chosen_thread, clock) = subpool.remove(idx);
- debug_assert!(chosen_size >= size && chosen_addr % align.bytes() == 0);
+ debug_assert!(chosen_size >= size && chosen_addr.is_multiple_of(align.bytes()));
debug_assert!(cross_thread_reuse || chosen_thread == thread);
// No synchronization needed if we reused from the current thread.
Some((chosen_addr, if chosen_thread == thread { None } else { Some(clock) }))
diff --git a/src/tools/miri/src/bin/miri.rs b/src/tools/miri/src/bin/miri.rs
index 72057f8..92d2173 100644
--- a/src/tools/miri/src/bin/miri.rs
+++ b/src/tools/miri/src/bin/miri.rs
@@ -227,10 +227,11 @@ fn after_analysis<'tcx>(
} else {
let return_code = miri::eval_entry(tcx, entry_def_id, entry_type, &config, None)
.unwrap_or_else(|| {
+ //#[cfg(target_os = "linux")]
+ //miri::native_lib::register_retcode_sv(rustc_driver::EXIT_FAILURE);
tcx.dcx().abort_if_errors();
rustc_driver::EXIT_FAILURE
});
-
std::process::exit(return_code);
}
@@ -723,6 +724,8 @@ fn main() {
} else {
show_error!("-Zmiri-native-lib `{}` does not exist", filename);
}
+ } else if arg == "-Zmiri-native-lib-enable-tracing" {
+ miri_config.native_lib_enable_tracing = true;
} else if let Some(param) = arg.strip_prefix("-Zmiri-num-cpus=") {
let num_cpus = param
.parse::<u32>()
@@ -793,6 +796,16 @@ fn main() {
debug!("rustc arguments: {:?}", rustc_args);
debug!("crate arguments: {:?}", miri_config.args);
+ #[cfg(target_os = "linux")]
+ if !miri_config.native_lib.is_empty() && miri_config.native_lib_enable_tracing {
+ // FIXME: This should display a diagnostic / warning on error
+ // SAFETY: If any other threads exist at this point (namely for the ctrlc
+ // handler), they will not interact with anything on the main rustc/Miri
+ // thread in an async-signal-unsafe way such as by accessing shared
+ // semaphores, etc.; the handler only calls `sleep()` and `exit()`, which
+ // are async-signal-safe, as is accessing atomics
+ //let _ = unsafe { miri::native_lib::init_sv() };
+ }
run_compiler_and_exit(
&rustc_args,
&mut MiriCompilerCalls::new(miri_config, many_seeds, genmc_config),
diff --git a/src/tools/miri/src/borrow_tracker/tree_borrows/mod.rs b/src/tools/miri/src/borrow_tracker/tree_borrows/mod.rs
index 99171b0..a0761cb 100644
--- a/src/tools/miri/src/borrow_tracker/tree_borrows/mod.rs
+++ b/src/tools/miri/src/borrow_tracker/tree_borrows/mod.rs
@@ -468,10 +468,8 @@ fn tb_retag_place(
// - when `extern type` is involved we use the size of the known prefix,
// - if the pointer is not reborrowed (raw pointer) then we override the size
// to do a zero-length reborrow.
- let reborrow_size = this
- .size_and_align_of_val(place)?
- .map(|(size, _)| size)
- .unwrap_or(place.layout.size);
+ let reborrow_size =
+ this.size_and_align_of_val(place)?.map(|(size, _)| size).unwrap_or(place.layout.size);
trace!("Creating new permission: {:?} with size {:?}", new_perm, reborrow_size);
// This new tag is not guaranteed to actually be used.
diff --git a/src/tools/miri/src/borrow_tracker/tree_borrows/unimap.rs b/src/tools/miri/src/borrow_tracker/tree_borrows/unimap.rs
index dcd5a6c..ad0a565 100644
--- a/src/tools/miri/src/borrow_tracker/tree_borrows/unimap.rs
+++ b/src/tools/miri/src/borrow_tracker/tree_borrows/unimap.rs
@@ -327,7 +327,7 @@ fn consistency_large() {
for i in 0..1000 {
i.hash(&mut hasher);
let rng = hasher.finish();
- let op = rng % 3 == 0;
+ let op = rng.is_multiple_of(3);
let key = (rng / 2) % 50;
let val = (rng / 100) % 1000;
if op {
diff --git a/src/tools/miri/src/concurrency/thread.rs b/src/tools/miri/src/concurrency/thread.rs
index 38b5d4c..c8a408f 100644
--- a/src/tools/miri/src/concurrency/thread.rs
+++ b/src/tools/miri/src/concurrency/thread.rs
@@ -582,88 +582,6 @@ fn detach_thread(&mut self, id: ThreadId, allow_terminated_joined: bool) -> Inte
interp_ok(())
}
- /// Mark that the active thread tries to join the thread with `joined_thread_id`.
- fn join_thread(
- &mut self,
- joined_thread_id: ThreadId,
- data_race_handler: &mut GlobalDataRaceHandler,
- ) -> InterpResult<'tcx> {
- if self.threads[joined_thread_id].join_status == ThreadJoinStatus::Detached {
- // On Windows this corresponds to joining on a closed handle.
- throw_ub_format!("trying to join a detached thread");
- }
-
- fn after_join<'tcx>(
- threads: &mut ThreadManager<'_>,
- joined_thread_id: ThreadId,
- data_race_handler: &mut GlobalDataRaceHandler,
- ) -> InterpResult<'tcx> {
- match data_race_handler {
- GlobalDataRaceHandler::None => {}
- GlobalDataRaceHandler::Vclocks(data_race) =>
- data_race.thread_joined(threads, joined_thread_id),
- GlobalDataRaceHandler::Genmc(genmc_ctx) =>
- genmc_ctx.handle_thread_join(threads.active_thread, joined_thread_id)?,
- }
- interp_ok(())
- }
-
- // Mark the joined thread as being joined so that we detect if other
- // threads try to join it.
- self.threads[joined_thread_id].join_status = ThreadJoinStatus::Joined;
- if !self.threads[joined_thread_id].state.is_terminated() {
- trace!(
- "{:?} blocked on {:?} when trying to join",
- self.active_thread, joined_thread_id
- );
- // The joined thread is still running, we need to wait for it.
- // Unce we get unblocked, perform the appropriate synchronization.
- self.block_thread(
- BlockReason::Join(joined_thread_id),
- None,
- callback!(
- @capture<'tcx> {
- joined_thread_id: ThreadId,
- }
- |this, unblock: UnblockKind| {
- assert_eq!(unblock, UnblockKind::Ready);
- after_join(&mut this.machine.threads, joined_thread_id, &mut this.machine.data_race)
- }
- ),
- );
- } else {
- // The thread has already terminated - establish happens-before
- after_join(self, joined_thread_id, data_race_handler)?;
- }
- interp_ok(())
- }
-
- /// Mark that the active thread tries to exclusively join the thread with `joined_thread_id`.
- /// If the thread is already joined by another thread, it will throw UB
- fn join_thread_exclusive(
- &mut self,
- joined_thread_id: ThreadId,
- data_race_handler: &mut GlobalDataRaceHandler,
- ) -> InterpResult<'tcx> {
- if self.threads[joined_thread_id].join_status == ThreadJoinStatus::Joined {
- throw_ub_format!("trying to join an already joined thread");
- }
-
- if joined_thread_id == self.active_thread {
- throw_ub_format!("trying to join itself");
- }
-
- // Sanity check `join_status`.
- assert!(
- self.threads
- .iter()
- .all(|thread| { !thread.state.is_blocked_on(BlockReason::Join(joined_thread_id)) }),
- "this thread already has threads waiting for its termination"
- );
-
- self.join_thread(joined_thread_id, data_race_handler)
- }
-
/// Set the name of the given thread.
pub fn set_thread_name(&mut self, thread: ThreadId, new_thread_name: Vec<u8>) {
self.threads[thread].thread_name = Some(new_thread_name);
@@ -1114,20 +1032,102 @@ fn detach_thread(
this.machine.threads.detach_thread(thread_id, allow_terminated_joined)
}
- #[inline]
- fn join_thread(&mut self, joined_thread_id: ThreadId) -> InterpResult<'tcx> {
+ /// Mark that the active thread tries to join the thread with `joined_thread_id`.
+ ///
+ /// When the join is successful (immediately, or as soon as the joined thread finishes), `success_retval` will be written to `return_dest`.
+ fn join_thread(
+ &mut self,
+ joined_thread_id: ThreadId,
+ success_retval: Scalar,
+ return_dest: &MPlaceTy<'tcx>,
+ ) -> InterpResult<'tcx> {
let this = self.eval_context_mut();
- this.machine.threads.join_thread(joined_thread_id, &mut this.machine.data_race)?;
+ let thread_mgr = &mut this.machine.threads;
+ if thread_mgr.threads[joined_thread_id].join_status == ThreadJoinStatus::Detached {
+ // On Windows this corresponds to joining on a closed handle.
+ throw_ub_format!("trying to join a detached thread");
+ }
+
+ fn after_join<'tcx>(
+ this: &mut InterpCx<'tcx, MiriMachine<'tcx>>,
+ joined_thread_id: ThreadId,
+ success_retval: Scalar,
+ return_dest: &MPlaceTy<'tcx>,
+ ) -> InterpResult<'tcx> {
+ let threads = &this.machine.threads;
+ match &mut this.machine.data_race {
+ GlobalDataRaceHandler::None => {}
+ GlobalDataRaceHandler::Vclocks(data_race) =>
+ data_race.thread_joined(threads, joined_thread_id),
+ GlobalDataRaceHandler::Genmc(genmc_ctx) =>
+ genmc_ctx.handle_thread_join(threads.active_thread, joined_thread_id)?,
+ }
+ this.write_scalar(success_retval, return_dest)?;
+ interp_ok(())
+ }
+
+ // Mark the joined thread as being joined so that we detect if other
+ // threads try to join it.
+ thread_mgr.threads[joined_thread_id].join_status = ThreadJoinStatus::Joined;
+ if !thread_mgr.threads[joined_thread_id].state.is_terminated() {
+ trace!(
+ "{:?} blocked on {:?} when trying to join",
+ thread_mgr.active_thread, joined_thread_id
+ );
+ // The joined thread is still running, we need to wait for it.
+ // Once we get unblocked, perform the appropriate synchronization and write the return value.
+ let dest = return_dest.clone();
+ thread_mgr.block_thread(
+ BlockReason::Join(joined_thread_id),
+ None,
+ callback!(
+ @capture<'tcx> {
+ joined_thread_id: ThreadId,
+ dest: MPlaceTy<'tcx>,
+ success_retval: Scalar,
+ }
+ |this, unblock: UnblockKind| {
+ assert_eq!(unblock, UnblockKind::Ready);
+ after_join(this, joined_thread_id, success_retval, &dest)
+ }
+ ),
+ );
+ } else {
+ // The thread has already terminated - establish happens-before and write the return value.
+ after_join(this, joined_thread_id, success_retval, return_dest)?;
+ }
interp_ok(())
}
- #[inline]
- fn join_thread_exclusive(&mut self, joined_thread_id: ThreadId) -> InterpResult<'tcx> {
+ /// Mark that the active thread tries to exclusively join the thread with `joined_thread_id`.
+ /// If the thread is already joined by another thread, it will throw UB.
+ ///
+ /// When the join is successful (immediately, or as soon as the joined thread finishes), `success_retval` will be written to `return_dest`.
+ fn join_thread_exclusive(
+ &mut self,
+ joined_thread_id: ThreadId,
+ success_retval: Scalar,
+ return_dest: &MPlaceTy<'tcx>,
+ ) -> InterpResult<'tcx> {
let this = self.eval_context_mut();
- this.machine
- .threads
- .join_thread_exclusive(joined_thread_id, &mut this.machine.data_race)?;
- interp_ok(())
+ let threads = &this.machine.threads.threads;
+ if threads[joined_thread_id].join_status == ThreadJoinStatus::Joined {
+ throw_ub_format!("trying to join an already joined thread");
+ }
+
+ if joined_thread_id == this.machine.threads.active_thread {
+ throw_ub_format!("trying to join itself");
+ }
+
+ // Sanity check `join_status`.
+ assert!(
+ threads
+ .iter()
+ .all(|thread| { !thread.state.is_blocked_on(BlockReason::Join(joined_thread_id)) }),
+ "this thread already has threads waiting for its termination"
+ );
+
+ this.join_thread(joined_thread_id, success_retval, return_dest)
}
#[inline]
diff --git a/src/tools/miri/src/diagnostics.rs b/src/tools/miri/src/diagnostics.rs
index 54a7c14..9ecbd31 100644
--- a/src/tools/miri/src/diagnostics.rs
+++ b/src/tools/miri/src/diagnostics.rs
@@ -132,7 +132,9 @@ pub enum NonHaltingDiagnostic {
Int2Ptr {
details: bool,
},
- NativeCallSharedMem,
+ NativeCallSharedMem {
+ tracing: bool,
+ },
WeakMemoryOutdatedLoad {
ptr: Pointer,
},
@@ -627,7 +629,7 @@ pub fn emit_diagnostic(&self, e: NonHaltingDiagnostic) {
RejectedIsolatedOp(_) =>
("operation rejected by isolation".to_string(), DiagLevel::Warning),
Int2Ptr { .. } => ("integer-to-pointer cast".to_string(), DiagLevel::Warning),
- NativeCallSharedMem =>
+ NativeCallSharedMem { .. } =>
("sharing memory with a native function".to_string(), DiagLevel::Warning),
ExternTypeReborrow =>
("reborrow of reference to `extern type`".to_string(), DiagLevel::Warning),
@@ -663,7 +665,8 @@ pub fn emit_diagnostic(&self, e: NonHaltingDiagnostic) {
ProgressReport { .. } =>
format!("progress report: current operation being executed is here"),
Int2Ptr { .. } => format!("integer-to-pointer cast"),
- NativeCallSharedMem => format!("sharing memory with a native function called via FFI"),
+ NativeCallSharedMem { .. } =>
+ format!("sharing memory with a native function called via FFI"),
WeakMemoryOutdatedLoad { ptr } =>
format!("weak memory emulation: outdated value returned from load at {ptr}"),
ExternTypeReborrow =>
@@ -709,22 +712,41 @@ pub fn emit_diagnostic(&self, e: NonHaltingDiagnostic) {
}
v
}
- NativeCallSharedMem => {
- vec![
- note!(
- "when memory is shared with a native function call, Miri stops tracking initialization and provenance for that memory"
- ),
- note!(
- "in particular, Miri assumes that the native call initializes all memory it has access to"
- ),
- note!(
- "Miri also assumes that any part of this memory may be a pointer that is permitted to point to arbitrary exposed memory"
- ),
- note!(
- "what this means is that Miri will easily miss Undefined Behavior related to incorrect usage of this shared memory, so you should not take a clean Miri run as a signal that your FFI code is UB-free"
- ),
- ]
- }
+ NativeCallSharedMem { tracing } =>
+ if *tracing {
+ vec![
+ note!(
+ "when memory is shared with a native function call, Miri can only track initialisation and provenance on a best-effort basis"
+ ),
+ note!(
+ "in particular, Miri assumes that the native call initializes all memory it has written to"
+ ),
+ note!(
+ "Miri also assumes that any part of this memory may be a pointer that is permitted to point to arbitrary exposed memory"
+ ),
+ note!(
+ "what this means is that Miri will easily miss Undefined Behavior related to incorrect usage of this shared memory, so you should not take a clean Miri run as a signal that your FFI code is UB-free"
+ ),
+ note!(
+ "tracing memory accesses in native code is not yet fully implemented, so there can be further imprecisions beyond what is documented here"
+ ),
+ ]
+ } else {
+ vec![
+ note!(
+ "when memory is shared with a native function call, Miri stops tracking initialization and provenance for that memory"
+ ),
+ note!(
+ "in particular, Miri assumes that the native call initializes all memory it has access to"
+ ),
+ note!(
+ "Miri also assumes that any part of this memory may be a pointer that is permitted to point to arbitrary exposed memory"
+ ),
+ note!(
+ "what this means is that Miri will easily miss Undefined Behavior related to incorrect usage of this shared memory, so you should not take a clean Miri run as a signal that your FFI code is UB-free"
+ ),
+ ]
+ },
ExternTypeReborrow => {
assert!(self.borrow_tracker.as_ref().is_some_and(|b| {
matches!(
diff --git a/src/tools/miri/src/eval.rs b/src/tools/miri/src/eval.rs
index 04fe08b..44612da 100644
--- a/src/tools/miri/src/eval.rs
+++ b/src/tools/miri/src/eval.rs
@@ -150,6 +150,8 @@ pub struct MiriConfig {
pub retag_fields: RetagFields,
/// The location of the shared object files to load when calling external functions
pub native_lib: Vec<PathBuf>,
+ /// Whether to enable the new native lib tracing system.
+ pub native_lib_enable_tracing: bool,
/// Run a garbage collector for BorTags every N basic blocks.
pub gc_interval: u32,
/// The number of CPUs to be reported by miri.
@@ -199,6 +201,7 @@ fn default() -> MiriConfig {
report_progress: None,
retag_fields: RetagFields::Yes,
native_lib: vec![],
+ native_lib_enable_tracing: false,
gc_interval: 10_000,
num_cpus: 1,
page_size: None,
diff --git a/src/tools/miri/src/intrinsics/mod.rs b/src/tools/miri/src/intrinsics/mod.rs
index ec77a16..ed1851a 100644
--- a/src/tools/miri/src/intrinsics/mod.rs
+++ b/src/tools/miri/src/intrinsics/mod.rs
@@ -191,7 +191,7 @@ fn emulate_intrinsic_by_name(
let [f] = check_intrinsic_arg_count(args)?;
let f = this.read_scalar(f)?.to_f32()?;
- let res = fixed_float_value(intrinsic_name, &[f]).unwrap_or_else(||{
+ let res = fixed_float_value(this, intrinsic_name, &[f]).unwrap_or_else(|| {
// Using host floats (but it's fine, these operations do not have
// guaranteed precision).
let host = f.to_host();
@@ -235,7 +235,7 @@ fn emulate_intrinsic_by_name(
let [f] = check_intrinsic_arg_count(args)?;
let f = this.read_scalar(f)?.to_f64()?;
- let res = fixed_float_value(intrinsic_name, &[f]).unwrap_or_else(||{
+ let res = fixed_float_value(this, intrinsic_name, &[f]).unwrap_or_else(|| {
// Using host floats (but it's fine, these operations do not have
// guaranteed precision).
let host = f.to_host();
@@ -312,7 +312,7 @@ fn emulate_intrinsic_by_name(
let f1 = this.read_scalar(f1)?.to_f32()?;
let f2 = this.read_scalar(f2)?.to_f32()?;
- let res = fixed_float_value(intrinsic_name, &[f1, f2]).unwrap_or_else(|| {
+ let res = fixed_float_value(this, intrinsic_name, &[f1, f2]).unwrap_or_else(|| {
// Using host floats (but it's fine, this operation does not have guaranteed precision).
let res = f1.to_host().powf(f2.to_host()).to_soft();
@@ -330,7 +330,7 @@ fn emulate_intrinsic_by_name(
let f1 = this.read_scalar(f1)?.to_f64()?;
let f2 = this.read_scalar(f2)?.to_f64()?;
- let res = fixed_float_value(intrinsic_name, &[f1, f2]).unwrap_or_else(|| {
+ let res = fixed_float_value(this, intrinsic_name, &[f1, f2]).unwrap_or_else(|| {
// Using host floats (but it's fine, this operation does not have guaranteed precision).
let res = f1.to_host().powf(f2.to_host()).to_soft();
@@ -349,7 +349,7 @@ fn emulate_intrinsic_by_name(
let f = this.read_scalar(f)?.to_f32()?;
let i = this.read_scalar(i)?.to_i32()?;
- let res = fixed_powi_float_value(f, i).unwrap_or_else(|| {
+ let res = fixed_powi_float_value(this, f, i).unwrap_or_else(|| {
// Using host floats (but it's fine, this operation does not have guaranteed precision).
let res = f.to_host().powi(i).to_soft();
@@ -367,7 +367,7 @@ fn emulate_intrinsic_by_name(
let f = this.read_scalar(f)?.to_f64()?;
let i = this.read_scalar(i)?.to_i32()?;
- let res = fixed_powi_float_value(f, i).unwrap_or_else(|| {
+ let res = fixed_powi_float_value(this, f, i).unwrap_or_else(|| {
// Using host floats (but it's fine, this operation does not have guaranteed precision).
let res = f.to_host().powi(i).to_soft();
@@ -496,52 +496,88 @@ fn apply_random_float_error_to_imm<'tcx>(
/// - logf32, logf64, log2f32, log2f64, log10f32, log10f64
/// - powf32, powf64
///
+/// # Return
+///
/// Returns `Some(output)` if the `intrinsic` results in a defined fixed `output` specified in the C standard
/// (specifically, C23 annex F.10) when given `args` as arguments. Outputs that are unaffected by a relative error
/// (such as INF and zero) are not handled here, they are assumed to be handled by the underlying
/// implementation. Returns `None` if no specific value is guaranteed.
+///
+/// # Note
+///
+/// For `powf*` operations of the form:
+///
+/// - `(SNaN)^(±0)`
+/// - `1^(SNaN)`
+///
+/// The result is implementation-defined:
+/// - musl returns for both `1.0`
+/// - glibc returns for both `NaN`
+///
+/// This discrepancy exists because SNaN handling is not consistently defined across platforms,
+/// and the C standard leaves behavior for SNaNs unspecified.
+///
+/// Miri chooses to adhere to both implementations and returns either one of them non-deterministically.
fn fixed_float_value<S: Semantics>(
+ ecx: &mut MiriInterpCx<'_>,
intrinsic_name: &str,
args: &[IeeeFloat<S>],
) -> Option<IeeeFloat<S>> {
let one = IeeeFloat::<S>::one();
- match (intrinsic_name, args) {
+ Some(match (intrinsic_name, args) {
// cos(+- 0) = 1
- ("cosf32" | "cosf64", [input]) if input.is_zero() => Some(one),
+ ("cosf32" | "cosf64", [input]) if input.is_zero() => one,
// e^0 = 1
- ("expf32" | "expf64" | "exp2f32" | "exp2f64", [input]) if input.is_zero() => Some(one),
-
- // 1^y = 1 for any y, even a NaN.
- ("powf32" | "powf64", [base, _]) if *base == one => Some(one),
+ ("expf32" | "expf64" | "exp2f32" | "exp2f64", [input]) if input.is_zero() => one,
// (-1)^(±INF) = 1
- ("powf32" | "powf64", [base, exp]) if *base == -one && exp.is_infinite() => Some(one),
+ ("powf32" | "powf64", [base, exp]) if *base == -one && exp.is_infinite() => one,
- // FIXME(#4286): The C ecosystem is inconsistent with handling sNaN's, some return 1 others propogate
- // the NaN. We should return either 1 or the NaN non-deterministically here.
- // But for now, just handle them all the same.
+ // 1^y = 1 for any y, even a NaN
+ ("powf32" | "powf64", [base, exp]) if *base == one => {
+ let rng = ecx.machine.rng.get_mut();
+ // SNaN exponents get special treatment: they might return 1, or a NaN.
+ let return_nan = exp.is_signaling() && ecx.machine.float_nondet && rng.random();
+ // Handle both the musl and glibc cases non-deterministically.
+ if return_nan { ecx.generate_nan(args) } else { one }
+ }
+
// x^(±0) = 1 for any x, even a NaN
- ("powf32" | "powf64", [_, exp]) if exp.is_zero() => Some(one),
+ ("powf32" | "powf64", [base, exp]) if exp.is_zero() => {
+ let rng = ecx.machine.rng.get_mut();
+ // SNaN bases get special treatment: they might return 1, or a NaN.
+ let return_nan = base.is_signaling() && ecx.machine.float_nondet && rng.random();
+ // Handle both the musl and glibc cases non-deterministically.
+ if return_nan { ecx.generate_nan(args) } else { one }
+ }
- // There are a lot of cases for fixed outputs according to the C Standard, but these are mainly INF or zero
- // which are not affected by the applied error.
- _ => None,
- }
+ // There are a lot of cases for fixed outputs according to the C Standard, but these are
+ // mainly INF or zero which are not affected by the applied error.
+ _ => return None,
+ })
}
-/// Returns `Some(output)` if `powi` (called `pown` in C) results in a fixed value specified in the C standard
-/// (specifically, C23 annex F.10.4.6) when doing `base^exp`. Otherwise, returns `None`.
-fn fixed_powi_float_value<S: Semantics>(base: IeeeFloat<S>, exp: i32) -> Option<IeeeFloat<S>> {
- match (base.category(), exp) {
- // x^0 = 1, if x is not a Signaling NaN
- // FIXME(#4286): The C ecosystem is inconsistent with handling sNaN's, some return 1 others propogate
- // the NaN. We should return either 1 or the NaN non-deterministically here.
- // But for now, just handle them all the same.
- (_, 0) => Some(IeeeFloat::<S>::one()),
+/// Returns `Some(output)` if `powi` (called `pown` in C) results in a fixed value specified in the
+/// C standard (specifically, C23 annex F.10.4.6) when doing `base^exp`. Otherwise, returns `None`.
+fn fixed_powi_float_value<S: Semantics>(
+ ecx: &mut MiriInterpCx<'_>,
+ base: IeeeFloat<S>,
+ exp: i32,
+) -> Option<IeeeFloat<S>> {
+ Some(match exp {
+ 0 => {
+ let one = IeeeFloat::<S>::one();
+ let rng = ecx.machine.rng.get_mut();
+ let return_nan = ecx.machine.float_nondet && rng.random() && base.is_signaling();
+ // For SNaN treatment, we are consistent with `powf`above.
+ // (We wouldn't have two, unlike powf all implementations seem to agree for powi,
+ // but for now we are maximally conservative.)
+ if return_nan { ecx.generate_nan(&[base]) } else { one }
+ }
- _ => None,
- }
+ _ => return None,
+ })
}
/// Given an floating-point operation and a floating-point value, clamps the result to the output
diff --git a/src/tools/miri/src/intrinsics/simd.rs b/src/tools/miri/src/intrinsics/simd.rs
index 52224f3..e63992a 100644
--- a/src/tools/miri/src/intrinsics/simd.rs
+++ b/src/tools/miri/src/intrinsics/simd.rs
@@ -36,6 +36,7 @@ fn emulate_simd_intrinsic(
| "ceil"
| "floor"
| "round"
+ | "round_ties_even"
| "trunc"
| "fsqrt"
| "fsin"
@@ -71,6 +72,7 @@ enum Op<'a> {
"ceil" => Op::Round(rustc_apfloat::Round::TowardPositive),
"floor" => Op::Round(rustc_apfloat::Round::TowardNegative),
"round" => Op::Round(rustc_apfloat::Round::NearestTiesToAway),
+ "round_ties_even" => Op::Round(rustc_apfloat::Round::NearestTiesToEven),
"trunc" => Op::Round(rustc_apfloat::Round::TowardZero),
"ctlz" => Op::Numeric(sym::ctlz),
"ctpop" => Op::Numeric(sym::ctpop),
diff --git a/src/tools/miri/src/lib.rs b/src/tools/miri/src/lib.rs
index ea56582..00f26a3 100644
--- a/src/tools/miri/src/lib.rs
+++ b/src/tools/miri/src/lib.rs
@@ -10,6 +10,7 @@
#![feature(variant_count)]
#![feature(yeet_expr)]
#![feature(nonzero_ops)]
+#![cfg_attr(bootstrap, feature(nonnull_provenance))]
#![feature(strict_overflow_ops)]
#![feature(pointer_is_aligned_to)]
#![feature(ptr_metadata)]
@@ -99,6 +100,11 @@
use rustc_middle::{bug, span_bug};
use tracing::{info, trace};
+//#[cfg(target_os = "linux")]
+//pub mod native_lib {
+// pub use crate::shims::{init_sv, register_retcode_sv};
+//}
+
// Type aliases that set the provenance parameter.
pub type Pointer = interpret::Pointer<Option<machine::Provenance>>;
pub type StrictPointer = interpret::Pointer<machine::Provenance>;
diff --git a/src/tools/miri/src/machine.rs b/src/tools/miri/src/machine.rs
index b4d7db3..3a748c4 100644
--- a/src/tools/miri/src/machine.rs
+++ b/src/tools/miri/src/machine.rs
@@ -1056,7 +1056,7 @@ fn alignment_check(
// What's the offset between us and the promised alignment?
let distance = offset.bytes().wrapping_sub(promised_offset.bytes());
// That must also be aligned.
- if distance % align.bytes() == 0 {
+ if distance.is_multiple_of(align.bytes()) {
// All looking good!
None
} else {
@@ -1612,7 +1612,7 @@ fn before_terminator(ecx: &mut InterpCx<'tcx, Self>) -> InterpResult<'tcx> {
ecx.machine.since_gc += 1;
// Possibly report our progress. This will point at the terminator we are about to execute.
if let Some(report_progress) = ecx.machine.report_progress {
- if ecx.machine.basic_block_count % u64::from(report_progress) == 0 {
+ if ecx.machine.basic_block_count.is_multiple_of(u64::from(report_progress)) {
ecx.emit_diagnostic(NonHaltingDiagnostic::ProgressReport {
block_count: ecx.machine.basic_block_count,
});
diff --git a/src/tools/miri/src/shims/mod.rs b/src/tools/miri/src/shims/mod.rs
index b498551..f09fc54 100644
--- a/src/tools/miri/src/shims/mod.rs
+++ b/src/tools/miri/src/shims/mod.rs
@@ -21,6 +21,8 @@
pub mod tls;
pub use self::files::FdTable;
+//#[cfg(target_os = "linux")]
+//pub use self::native_lib::trace::{init_sv, register_retcode_sv};
pub use self::unix::{DirTable, EpollInterestTable};
/// What needs to be done after emulating an item (a shim or an intrinsic) is done.
diff --git a/src/tools/miri/src/shims/native_lib.rs b/src/tools/miri/src/shims/native_lib/mod.rs
similarity index 66%
rename from src/tools/miri/src/shims/native_lib.rs
rename to src/tools/miri/src/shims/native_lib/mod.rs
index 030c2e3..9c659f6 100644
--- a/src/tools/miri/src/shims/native_lib.rs
+++ b/src/tools/miri/src/shims/native_lib/mod.rs
@@ -1,4 +1,9 @@
//! Implements calling functions from a native library.
+
+// FIXME: disabled since it fails to build on many targets.
+//#[cfg(target_os = "linux")]
+//pub mod trace;
+
use std::ops::Deref;
use libffi::high::call as ffi;
@@ -8,8 +13,15 @@
use rustc_middle::ty::{self as ty, IntTy, UintTy};
use rustc_span::Symbol;
+//#[cfg(target_os = "linux")]
+//use self::trace::Supervisor;
use crate::*;
+//#[cfg(target_os = "linux")]
+//type CallResult<'tcx> = InterpResult<'tcx, (ImmTy<'tcx>, Option<self::trace::messages::MemEvents>)>;
+//#[cfg(not(target_os = "linux"))]
+type CallResult<'tcx> = InterpResult<'tcx, (ImmTy<'tcx>, Option<!>)>;
+
impl<'tcx> EvalContextExtPriv<'tcx> for crate::MiriInterpCx<'tcx> {}
trait EvalContextExtPriv<'tcx>: crate::MiriInterpCxExt<'tcx> {
/// Call native host function and return the output as an immediate.
@@ -19,71 +31,93 @@ fn call_native_with_args<'a>(
dest: &MPlaceTy<'tcx>,
ptr: CodePtr,
libffi_args: Vec<libffi::high::Arg<'a>>,
- ) -> InterpResult<'tcx, ImmTy<'tcx>> {
+ ) -> CallResult<'tcx> {
let this = self.eval_context_mut();
+ //#[cfg(target_os = "linux")]
+ //let alloc = this.machine.allocator.as_ref().unwrap();
+
+ // SAFETY: We don't touch the machine memory past this point.
+ //#[cfg(target_os = "linux")]
+ //let (guard, stack_ptr) = unsafe { Supervisor::start_ffi(alloc) };
// Call the function (`ptr`) with arguments `libffi_args`, and obtain the return value
// as the specified primitive integer type
- let scalar = match dest.layout.ty.kind() {
- // ints
- ty::Int(IntTy::I8) => {
- // Unsafe because of the call to native code.
- // Because this is calling a C function it is not necessarily sound,
- // but there is no way around this and we've checked as much as we can.
- let x = unsafe { ffi::call::<i8>(ptr, libffi_args.as_slice()) };
- Scalar::from_i8(x)
- }
- ty::Int(IntTy::I16) => {
- let x = unsafe { ffi::call::<i16>(ptr, libffi_args.as_slice()) };
- Scalar::from_i16(x)
- }
- ty::Int(IntTy::I32) => {
- let x = unsafe { ffi::call::<i32>(ptr, libffi_args.as_slice()) };
- Scalar::from_i32(x)
- }
- ty::Int(IntTy::I64) => {
- let x = unsafe { ffi::call::<i64>(ptr, libffi_args.as_slice()) };
- Scalar::from_i64(x)
- }
- ty::Int(IntTy::Isize) => {
- let x = unsafe { ffi::call::<isize>(ptr, libffi_args.as_slice()) };
- Scalar::from_target_isize(x.try_into().unwrap(), this)
- }
- // uints
- ty::Uint(UintTy::U8) => {
- let x = unsafe { ffi::call::<u8>(ptr, libffi_args.as_slice()) };
- Scalar::from_u8(x)
- }
- ty::Uint(UintTy::U16) => {
- let x = unsafe { ffi::call::<u16>(ptr, libffi_args.as_slice()) };
- Scalar::from_u16(x)
- }
- ty::Uint(UintTy::U32) => {
- let x = unsafe { ffi::call::<u32>(ptr, libffi_args.as_slice()) };
- Scalar::from_u32(x)
- }
- ty::Uint(UintTy::U64) => {
- let x = unsafe { ffi::call::<u64>(ptr, libffi_args.as_slice()) };
- Scalar::from_u64(x)
- }
- ty::Uint(UintTy::Usize) => {
- let x = unsafe { ffi::call::<usize>(ptr, libffi_args.as_slice()) };
- Scalar::from_target_usize(x.try_into().unwrap(), this)
- }
- // Functions with no declared return type (i.e., the default return)
- // have the output_type `Tuple([])`.
- ty::Tuple(t_list) if (*t_list).deref().is_empty() => {
- unsafe { ffi::call::<()>(ptr, libffi_args.as_slice()) };
- return interp_ok(ImmTy::uninit(dest.layout));
- }
- ty::RawPtr(..) => {
- let x = unsafe { ffi::call::<*const ()>(ptr, libffi_args.as_slice()) };
- let ptr = Pointer::new(Provenance::Wildcard, Size::from_bytes(x.addr()));
- Scalar::from_pointer(ptr, this)
- }
- _ => throw_unsup_format!("unsupported return type for native call: {:?}", link_name),
+ let res = 'res: {
+ let scalar = match dest.layout.ty.kind() {
+ // ints
+ ty::Int(IntTy::I8) => {
+ // Unsafe because of the call to native code.
+ // Because this is calling a C function it is not necessarily sound,
+ // but there is no way around this and we've checked as much as we can.
+ let x = unsafe { ffi::call::<i8>(ptr, libffi_args.as_slice()) };
+ Scalar::from_i8(x)
+ }
+ ty::Int(IntTy::I16) => {
+ let x = unsafe { ffi::call::<i16>(ptr, libffi_args.as_slice()) };
+ Scalar::from_i16(x)
+ }
+ ty::Int(IntTy::I32) => {
+ let x = unsafe { ffi::call::<i32>(ptr, libffi_args.as_slice()) };
+ Scalar::from_i32(x)
+ }
+ ty::Int(IntTy::I64) => {
+ let x = unsafe { ffi::call::<i64>(ptr, libffi_args.as_slice()) };
+ Scalar::from_i64(x)
+ }
+ ty::Int(IntTy::Isize) => {
+ let x = unsafe { ffi::call::<isize>(ptr, libffi_args.as_slice()) };
+ Scalar::from_target_isize(x.try_into().unwrap(), this)
+ }
+ // uints
+ ty::Uint(UintTy::U8) => {
+ let x = unsafe { ffi::call::<u8>(ptr, libffi_args.as_slice()) };
+ Scalar::from_u8(x)
+ }
+ ty::Uint(UintTy::U16) => {
+ let x = unsafe { ffi::call::<u16>(ptr, libffi_args.as_slice()) };
+ Scalar::from_u16(x)
+ }
+ ty::Uint(UintTy::U32) => {
+ let x = unsafe { ffi::call::<u32>(ptr, libffi_args.as_slice()) };
+ Scalar::from_u32(x)
+ }
+ ty::Uint(UintTy::U64) => {
+ let x = unsafe { ffi::call::<u64>(ptr, libffi_args.as_slice()) };
+ Scalar::from_u64(x)
+ }
+ ty::Uint(UintTy::Usize) => {
+ let x = unsafe { ffi::call::<usize>(ptr, libffi_args.as_slice()) };
+ Scalar::from_target_usize(x.try_into().unwrap(), this)
+ }
+ // Functions with no declared return type (i.e., the default return)
+ // have the output_type `Tuple([])`.
+ ty::Tuple(t_list) if (*t_list).deref().is_empty() => {
+ unsafe { ffi::call::<()>(ptr, libffi_args.as_slice()) };
+ break 'res interp_ok(ImmTy::uninit(dest.layout));
+ }
+ ty::RawPtr(..) => {
+ let x = unsafe { ffi::call::<*const ()>(ptr, libffi_args.as_slice()) };
+ let ptr = Pointer::new(Provenance::Wildcard, Size::from_bytes(x.addr()));
+ Scalar::from_pointer(ptr, this)
+ }
+ _ =>
+ break 'res Err(err_unsup_format!(
+ "unsupported return type for native call: {:?}",
+ link_name
+ ))
+ .into(),
+ };
+ interp_ok(ImmTy::from_scalar(scalar, dest.layout))
};
- interp_ok(ImmTy::from_scalar(scalar, dest.layout))
+
+ // SAFETY: We got the guard and stack pointer from start_ffi, and
+ // the allocator is the same
+ //#[cfg(target_os = "linux")]
+ //let events = unsafe { Supervisor::end_ffi(alloc, guard, stack_ptr) };
+ //#[cfg(not(target_os = "linux"))]
+ let events = None;
+
+ interp_ok((res?, events))
}
/// Get the pointer to the function of the specified name in the shared object file,
@@ -179,7 +213,12 @@ fn call_native_fn(
// The first time this happens, print a warning.
if !this.machine.native_call_mem_warned.replace(true) {
// Newly set, so first time we get here.
- this.emit_diagnostic(NonHaltingDiagnostic::NativeCallSharedMem);
+ this.emit_diagnostic(NonHaltingDiagnostic::NativeCallSharedMem {
+ //#[cfg(target_os = "linux")]
+ //tracing: self::trace::Supervisor::is_enabled(),
+ //#[cfg(not(target_os = "linux"))]
+ tracing: false,
+ });
}
this.expose_provenance(prov)?;
@@ -196,7 +235,15 @@ fn call_native_fn(
.collect::<Vec<libffi::high::Arg<'_>>>();
// Call the function and store output, depending on return type in the function signature.
- let ret = this.call_native_with_args(link_name, dest, code_ptr, libffi_args)?;
+ let (ret, maybe_memevents) =
+ this.call_native_with_args(link_name, dest, code_ptr, libffi_args)?;
+
+ if cfg!(target_os = "linux")
+ && let Some(events) = maybe_memevents
+ {
+ trace!("Registered FFI events:\n{events:#0x?}");
+ }
+
this.write_immediate(*ret, dest)?;
interp_ok(true)
}
diff --git a/src/tools/miri/src/shims/native_lib/trace/child.rs b/src/tools/miri/src/shims/native_lib/trace/child.rs
new file mode 100644
index 0000000..4961e87
--- /dev/null
+++ b/src/tools/miri/src/shims/native_lib/trace/child.rs
@@ -0,0 +1,251 @@
+use std::cell::RefCell;
+use std::rc::Rc;
+
+use ipc_channel::ipc;
+use nix::sys::{ptrace, signal};
+use nix::unistd;
+
+use super::CALLBACK_STACK_SIZE;
+use super::messages::{Confirmation, MemEvents, StartFfiInfo, TraceRequest};
+use super::parent::{ChildListener, sv_loop};
+use crate::alloc::isolated_alloc::IsolatedAlloc;
+
+static SUPERVISOR: std::sync::Mutex<Option<Supervisor>> = std::sync::Mutex::new(None);
+
+/// The main means of communication between the child and parent process,
+/// allowing the former to send requests and get info from the latter.
+pub struct Supervisor {
+ /// Sender for FFI-mode-related requests.
+ message_tx: ipc::IpcSender<TraceRequest>,
+ /// Used for synchronisation, allowing us to receive confirmation that the
+ /// parent process has handled the request from `message_tx`.
+ confirm_rx: ipc::IpcReceiver<Confirmation>,
+ /// Receiver for memory acceses that ocurred during the FFI call.
+ event_rx: ipc::IpcReceiver<MemEvents>,
+}
+
+/// Marker representing that an error occurred during creation of the supervisor.
+#[derive(Debug)]
+pub struct SvInitError;
+
+impl Supervisor {
+ /// Returns `true` if the supervisor process exists, and `false` otherwise.
+ pub fn is_enabled() -> bool {
+ SUPERVISOR.lock().unwrap().is_some()
+ }
+
+ /// Begins preparations for doing an FFI call. This should be called at
+ /// the last possible moment before entering said call. `alloc` points to
+ /// the allocator which handed out the memory used for this machine.
+ ///
+ /// As this locks the supervisor via a mutex, no other threads may enter FFI
+ /// until this one returns and its guard is dropped via `end_ffi`. The
+ /// pointer returned should be passed to `end_ffi` to avoid a memory leak.
+ ///
+ /// SAFETY: The resulting guard must be dropped *via `end_ffi`* immediately
+ /// after the desired call has concluded.
+ pub unsafe fn start_ffi(
+ alloc: &Rc<RefCell<IsolatedAlloc>>,
+ ) -> (std::sync::MutexGuard<'static, Option<Supervisor>>, Option<*mut [u8; CALLBACK_STACK_SIZE]>)
+ {
+ let mut sv_guard = SUPERVISOR.lock().unwrap();
+ // If the supervisor is not initialised for whatever reason, fast-fail.
+ // This might be desired behaviour, as even on platforms where ptracing
+ // is not implemented it enables us to enforce that only one FFI call
+ // happens at a time.
+ let Some(sv) = sv_guard.take() else {
+ return (sv_guard, None);
+ };
+
+ // Get pointers to all the pages the supervisor must allow accesses in
+ // and prepare the callback stack.
+ let page_ptrs = alloc.borrow().pages();
+ let raw_stack_ptr: *mut [u8; CALLBACK_STACK_SIZE] =
+ Box::leak(Box::new([0u8; CALLBACK_STACK_SIZE])).as_mut_ptr().cast();
+ let stack_ptr = raw_stack_ptr.expose_provenance();
+ let start_info = StartFfiInfo { page_ptrs, stack_ptr };
+
+ // SAFETY: We do not access machine memory past this point until the
+ // supervisor is ready to allow it.
+ unsafe {
+ if alloc.borrow_mut().prepare_ffi().is_err() {
+ // Don't mess up unwinding by maybe leaving the memory partly protected
+ alloc.borrow_mut().unprep_ffi();
+ panic!("Cannot protect memory for FFI call!");
+ }
+ }
+
+ // Send over the info.
+ // NB: if we do not wait to receive a blank confirmation response, it is
+ // possible that the supervisor is alerted of the SIGSTOP *before* it has
+ // actually received the start_info, thus deadlocking! This way, we can
+ // enforce an ordering for these events.
+ sv.message_tx.send(TraceRequest::StartFfi(start_info)).unwrap();
+ sv.confirm_rx.recv().unwrap();
+ *sv_guard = Some(sv);
+ // We need to be stopped for the supervisor to be able to make certain
+ // modifications to our memory - simply waiting on the recv() doesn't
+ // count.
+ signal::raise(signal::SIGSTOP).unwrap();
+ (sv_guard, Some(raw_stack_ptr))
+ }
+
+ /// Undoes FFI-related preparations, allowing Miri to continue as normal, then
+ /// gets the memory accesses and changes performed during the FFI call. Note
+ /// that this may include some spurious accesses done by `libffi` itself in
+ /// the process of executing the function call.
+ ///
+ /// SAFETY: The `sv_guard` and `raw_stack_ptr` passed must be the same ones
+ /// received by a prior call to `start_ffi`, and the allocator must be the
+ /// one passed to it also.
+ pub unsafe fn end_ffi(
+ alloc: &Rc<RefCell<IsolatedAlloc>>,
+ mut sv_guard: std::sync::MutexGuard<'static, Option<Supervisor>>,
+ raw_stack_ptr: Option<*mut [u8; CALLBACK_STACK_SIZE]>,
+ ) -> Option<MemEvents> {
+ // We can't use IPC channels here to signal that FFI mode has ended,
+ // since they might allocate memory which could get us stuck in a SIGTRAP
+ // with no easy way out! While this could be worked around, it is much
+ // simpler and more robust to simply use the signals which are left for
+ // arbitrary usage. Since this will block until we are continued by the
+ // supervisor, we can assume past this point that everything is back to
+ // normal.
+ signal::raise(signal::SIGUSR1).unwrap();
+
+ // This is safe! It just sets memory to normal expected permissions.
+ alloc.borrow_mut().unprep_ffi();
+
+ // If this is `None`, then `raw_stack_ptr` is None and does not need to
+ // be deallocated (and there's no need to worry about the guard, since
+ // it contains nothing).
+ let sv = sv_guard.take()?;
+ // SAFETY: Caller upholds that this pointer was allocated as a box with
+ // this type.
+ unsafe {
+ drop(Box::from_raw(raw_stack_ptr.unwrap()));
+ }
+ // On the off-chance something really weird happens, don't block forever.
+ let ret = sv
+ .event_rx
+ .try_recv_timeout(std::time::Duration::from_secs(5))
+ .map_err(|e| {
+ match e {
+ ipc::TryRecvError::IpcError(_) => (),
+ ipc::TryRecvError::Empty =>
+ eprintln!("Waiting for accesses from supervisor timed out!"),
+ }
+ })
+ .ok();
+ // Do *not* leave the supervisor empty, or else we might get another fork...
+ *sv_guard = Some(sv);
+ ret
+ }
+}
+
+/// Initialises the supervisor process. If this function errors, then the
+/// supervisor process could not be created successfully; else, the caller
+/// is now the child process and can communicate via `start_ffi`/`end_ffi`,
+/// receiving back events through `get_events`.
+///
+/// # Safety
+/// The invariants for `fork()` must be upheld by the caller.
+pub unsafe fn init_sv() -> Result<(), SvInitError> {
+ // FIXME: Much of this could be reimplemented via the mitosis crate if we upstream the
+ // relevant missing bits.
+
+ // On Linux, this will check whether ptrace is fully disabled by the Yama module.
+ // If Yama isn't running or we're not on Linux, we'll still error later, but
+ // this saves a very expensive fork call.
+ let ptrace_status = std::fs::read_to_string("/proc/sys/kernel/yama/ptrace_scope");
+ if let Ok(stat) = ptrace_status {
+ if let Some(stat) = stat.chars().next() {
+ // Fast-error if ptrace is fully disabled on the system.
+ if stat == '3' {
+ return Err(SvInitError);
+ }
+ }
+ }
+
+ // Initialise the supervisor if it isn't already, placing it into SUPERVISOR.
+ let mut lock = SUPERVISOR.lock().unwrap();
+ if lock.is_some() {
+ return Ok(());
+ }
+
+ // Prepare the IPC channels we need.
+ let (message_tx, message_rx) = ipc::channel().unwrap();
+ let (confirm_tx, confirm_rx) = ipc::channel().unwrap();
+ let (event_tx, event_rx) = ipc::channel().unwrap();
+ // SAFETY: Calling sysconf(_SC_PAGESIZE) is always safe and cannot error.
+ let page_size = unsafe { libc::sysconf(libc::_SC_PAGESIZE) }.try_into().unwrap();
+ super::parent::PAGE_SIZE.store(page_size, std::sync::atomic::Ordering::Relaxed);
+
+ unsafe {
+ // TODO: Maybe use clone3() instead for better signalling of when the child exits?
+ // SAFETY: Caller upholds that only one thread exists.
+ match unistd::fork().unwrap() {
+ unistd::ForkResult::Parent { child } => {
+ // If somehow another thread does exist, prevent it from accessing the lock
+ // and thus breaking our safety invariants.
+ std::mem::forget(lock);
+ // The child process is free to unwind, so we won't to avoid doubly freeing
+ // system resources.
+ let init = std::panic::catch_unwind(|| {
+ let listener =
+ ChildListener { message_rx, attached: false, override_retcode: None };
+ // Trace as many things as possible, to be able to handle them as needed.
+ let options = ptrace::Options::PTRACE_O_TRACESYSGOOD
+ | ptrace::Options::PTRACE_O_TRACECLONE
+ | ptrace::Options::PTRACE_O_TRACEFORK;
+ // Attach to the child process without stopping it.
+ match ptrace::seize(child, options) {
+ // Ptrace works :D
+ Ok(_) => {
+ let code = sv_loop(listener, child, event_tx, confirm_tx).unwrap_err();
+ // If a return code of 0 is not explicitly given, assume something went
+ // wrong and return 1.
+ std::process::exit(code.0.unwrap_or(1))
+ }
+ // Ptrace does not work and we failed to catch that.
+ Err(_) => {
+ // If we can't ptrace, Miri continues being the parent.
+ signal::kill(child, signal::SIGKILL).unwrap();
+ SvInitError
+ }
+ }
+ });
+ match init {
+ // The "Ok" case means that we couldn't ptrace.
+ Ok(e) => return Err(e),
+ Err(p) => {
+ eprintln!("Supervisor process panicked!\n{p:?}");
+ std::process::exit(1);
+ }
+ }
+ }
+ unistd::ForkResult::Child => {
+ // Make sure we never get orphaned and stuck in SIGSTOP or similar
+ // SAFETY: prctl PR_SET_PDEATHSIG is always safe to call.
+ let ret = libc::prctl(libc::PR_SET_PDEATHSIG, libc::SIGTERM);
+ assert_eq!(ret, 0);
+ // First make sure the parent succeeded with ptracing us!
+ signal::raise(signal::SIGSTOP).unwrap();
+ // If we're the child process, save the supervisor info.
+ *lock = Some(Supervisor { message_tx, confirm_rx, event_rx });
+ }
+ }
+ }
+ Ok(())
+}
+
+/// Instruct the supervisor process to return a particular code. Useful if for
+/// whatever reason this code fails to be intercepted normally. In the case of
+/// `abort_if_errors()` used in `bin/miri.rs`, the return code is erroneously
+/// given as a 0 if this is not used.
+pub fn register_retcode_sv(code: i32) {
+ let mut sv_guard = SUPERVISOR.lock().unwrap();
+ if let Some(sv) = sv_guard.take() {
+ sv.message_tx.send(TraceRequest::OverrideRetcode(code)).unwrap();
+ *sv_guard = Some(sv);
+ }
+}
diff --git a/src/tools/miri/src/shims/native_lib/trace/messages.rs b/src/tools/miri/src/shims/native_lib/trace/messages.rs
new file mode 100644
index 0000000..8a83dab
--- /dev/null
+++ b/src/tools/miri/src/shims/native_lib/trace/messages.rs
@@ -0,0 +1,80 @@
+//! Houses the types that are directly sent across the IPC channels.
+//!
+//! The overall structure of a traced FFI call, from the child process's POV, is
+//! as follows:
+//! ```
+//! message_tx.send(TraceRequest::StartFfi);
+//! confirm_rx.recv();
+//! raise(SIGSTOP);
+//! /* do ffi call */
+//! raise(SIGUSR1); // morally equivalent to some kind of "TraceRequest::EndFfi"
+//! let events = event_rx.recv();
+//! ```
+//! `TraceRequest::OverrideRetcode` can be sent at any point in the above, including
+//! before or after all of them.
+//!
+//! NB: sending these events out of order, skipping steps, etc. will result in
+//! unspecified behaviour from the supervisor process, so use the abstractions
+//! in `super::child` (namely `start_ffi()` and `end_ffi()`) to handle this. It is
+//! trivially easy to cause a deadlock or crash by messing this up!
+
+use std::ops::Range;
+
+/// An IPC request sent by the child process to the parent.
+///
+/// The sender for this channel should live on the child process.
+#[derive(serde::Serialize, serde::Deserialize, Debug, Clone)]
+pub enum TraceRequest {
+ /// Requests that tracing begins. Following this being sent, the child must
+ /// wait to receive a `Confirmation` on the respective channel and then
+ /// `raise(SIGSTOP)`.
+ ///
+ /// To avoid possible issues while allocating memory for IPC channels, ending
+ /// the tracing is instead done via `raise(SIGUSR1)`.
+ StartFfi(StartFfiInfo),
+ /// Manually overrides the code that the supervisor will return upon exiting.
+ /// Once set, it is permanent. This can be called again to change the value.
+ OverrideRetcode(i32),
+}
+
+/// Information needed to begin tracing.
+#[derive(serde::Serialize, serde::Deserialize, Debug, Clone)]
+pub struct StartFfiInfo {
+ /// A vector of page addresses. These should have been automatically obtained
+ /// with `IsolatedAlloc::pages` and prepared with `IsolatedAlloc::prepare_ffi`.
+ pub page_ptrs: Vec<usize>,
+ /// The address of an allocation that can serve as a temporary stack.
+ /// This should be a leaked `Box<[u8; CALLBACK_STACK_SIZE]>` cast to an int.
+ pub stack_ptr: usize,
+}
+
+/// A marker type confirming that the supervisor has received the request to begin
+/// tracing and is now waiting for a `SIGSTOP`.
+///
+/// The sender for this channel should live on the parent process.
+#[derive(serde::Serialize, serde::Deserialize, Debug)]
+pub struct Confirmation;
+
+/// The final results of an FFI trace, containing every relevant event detected
+/// by the tracer. Sent by the supervisor after receiving a `SIGUSR1` signal.
+///
+/// The sender for this channel should live on the parent process.
+#[derive(serde::Serialize, serde::Deserialize, Debug)]
+pub struct MemEvents {
+ /// An ordered list of memory accesses that occurred. These should be assumed
+ /// to be overcautious; that is, if the size of an access is uncertain it is
+ /// pessimistically rounded up, and if the type (read/write/both) is uncertain
+ /// it is reported as whatever would be safest to assume; i.e. a read + maybe-write
+ /// becomes a read + write, etc.
+ pub acc_events: Vec<AccessEvent>,
+}
+
+/// A single memory access, conservatively overestimated
+/// in case of ambiguity.
+#[derive(serde::Serialize, serde::Deserialize, Debug)]
+pub enum AccessEvent {
+ /// A read may have occurred on no more than the specified address range.
+ Read(Range<usize>),
+ /// A write may have occurred on no more than the specified address range.
+ Write(Range<usize>),
+}
diff --git a/src/tools/miri/src/shims/native_lib/trace/mod.rs b/src/tools/miri/src/shims/native_lib/trace/mod.rs
new file mode 100644
index 0000000..174b06b
--- /dev/null
+++ b/src/tools/miri/src/shims/native_lib/trace/mod.rs
@@ -0,0 +1,8 @@
+mod child;
+pub mod messages;
+mod parent;
+
+pub use self::child::{Supervisor, init_sv, register_retcode_sv};
+
+/// The size of the temporary stack we use for callbacks that the server executes in the client.
+const CALLBACK_STACK_SIZE: usize = 1024;
diff --git a/src/tools/miri/src/shims/native_lib/trace/parent.rs b/src/tools/miri/src/shims/native_lib/trace/parent.rs
new file mode 100644
index 0000000..dfb0b35
--- /dev/null
+++ b/src/tools/miri/src/shims/native_lib/trace/parent.rs
@@ -0,0 +1,660 @@
+use std::sync::atomic::{AtomicPtr, AtomicUsize};
+
+use ipc_channel::ipc;
+use nix::sys::{ptrace, signal, wait};
+use nix::unistd;
+
+use super::CALLBACK_STACK_SIZE;
+use super::messages::{AccessEvent, Confirmation, MemEvents, StartFfiInfo, TraceRequest};
+
+/// The flags to use when calling `waitid()`.
+/// Since bitwise or on the nix version of these flags is implemented as a trait,
+/// this cannot be const directly so we do it this way.
+const WAIT_FLAGS: wait::WaitPidFlag =
+ wait::WaitPidFlag::from_bits_truncate(libc::WUNTRACED | libc::WEXITED);
+
+/// Arch-specific maximum size a single access might perform. x86 value is set
+/// assuming nothing bigger than AVX-512 is available.
+#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
+const ARCH_MAX_ACCESS_SIZE: usize = 64;
+/// The largest arm64 simd instruction operates on 16 bytes.
+#[cfg(any(target_arch = "arm", target_arch = "aarch64"))]
+const ARCH_MAX_ACCESS_SIZE: usize = 16;
+
+/// The default word size on a given platform, in bytes.
+#[cfg(any(target_arch = "x86", target_arch = "arm"))]
+const ARCH_WORD_SIZE: usize = 4;
+#[cfg(any(target_arch = "x86_64", target_arch = "aarch64"))]
+const ARCH_WORD_SIZE: usize = 8;
+
+/// The address of the page set to be edited, initialised to a sentinel null
+/// pointer.
+static PAGE_ADDR: AtomicPtr<u8> = AtomicPtr::new(std::ptr::null_mut());
+/// The host pagesize, initialised to a sentinel zero value.
+pub static PAGE_SIZE: AtomicUsize = AtomicUsize::new(0);
+/// How many consecutive pages to unprotect. 1 by default, unlikely to be set
+/// higher than 2.
+static PAGE_COUNT: AtomicUsize = AtomicUsize::new(1);
+
+/// Allows us to get common arguments from the `user_regs_t` across architectures.
+/// Normally this would land us ABI hell, but thankfully all of our usecases
+/// consist of functions with a small number of register-sized integer arguments.
+/// See <https://man7.org/linux/man-pages/man2/syscall.2.html> for sources.
+trait ArchIndependentRegs {
+ /// Gets the address of the instruction pointer.
+ fn ip(&self) -> usize;
+ /// Set the instruction pointer; remember to also set the stack pointer, or
+ /// else the stack might get messed up!
+ fn set_ip(&mut self, ip: usize);
+ /// Set the stack pointer, ideally to a zeroed-out area.
+ fn set_sp(&mut self, sp: usize);
+}
+
+// It's fine / desirable behaviour for values to wrap here, we care about just
+// preserving the bit pattern.
+#[cfg(target_arch = "x86_64")]
+#[expect(clippy::as_conversions)]
+#[rustfmt::skip]
+impl ArchIndependentRegs for libc::user_regs_struct {
+ #[inline]
+ fn ip(&self) -> usize { self.rip as _ }
+ #[inline]
+ fn set_ip(&mut self, ip: usize) { self.rip = ip as _ }
+ #[inline]
+ fn set_sp(&mut self, sp: usize) { self.rsp = sp as _ }
+}
+
+#[cfg(target_arch = "x86")]
+#[expect(clippy::as_conversions)]
+#[rustfmt::skip]
+impl ArchIndependentRegs for libc::user_regs_struct {
+ #[inline]
+ fn ip(&self) -> usize { self.eip as _ }
+ #[inline]
+ fn set_ip(&mut self, ip: usize) { self.eip = ip as _ }
+ #[inline]
+ fn set_sp(&mut self, sp: usize) { self.esp = sp as _ }
+}
+
+#[cfg(target_arch = "aarch64")]
+#[expect(clippy::as_conversions)]
+#[rustfmt::skip]
+impl ArchIndependentRegs for libc::user_regs_struct {
+ #[inline]
+ fn ip(&self) -> usize { self.pc as _ }
+ #[inline]
+ fn set_ip(&mut self, ip: usize) { self.pc = ip as _ }
+ #[inline]
+ fn set_sp(&mut self, sp: usize) { self.sp = sp as _ }
+}
+
+/// A unified event representing something happening on the child process. Wraps
+/// `nix`'s `WaitStatus` and our custom signals so it can all be done with one
+/// `match` statement.
+pub enum ExecEvent {
+ /// Child process requests that we begin monitoring it.
+ Start(StartFfiInfo),
+ /// Child requests that we stop monitoring and pass over the events we
+ /// detected.
+ End,
+ /// The child process with the specified pid was stopped by the given signal.
+ Status(unistd::Pid, signal::Signal),
+ /// The child process with the specified pid entered or existed a syscall.
+ Syscall(unistd::Pid),
+ /// A child process exited or was killed; if we have a return code, it is
+ /// specified.
+ Died(Option<i32>),
+}
+
+/// A listener for the FFI start info channel along with relevant state.
+pub struct ChildListener {
+ /// The matching channel for the child's `Supervisor` struct.
+ pub message_rx: ipc::IpcReceiver<TraceRequest>,
+ /// Whether an FFI call is currently ongoing.
+ pub attached: bool,
+ /// If `Some`, overrides the return code with the given value.
+ pub override_retcode: Option<i32>,
+}
+
+impl Iterator for ChildListener {
+ type Item = ExecEvent;
+
+ // Allows us to monitor the child process by just iterating over the listener.
+ // NB: This should never return None!
+ fn next(&mut self) -> Option<Self::Item> {
+ // Do not block if the child has nothing to report for `waitid`.
+ let opts = WAIT_FLAGS | wait::WaitPidFlag::WNOHANG;
+ loop {
+ // Listen to any child, not just the main one. Important if we want
+ // to allow the C code to fork further, along with being a bit of
+ // defensive programming since Linux sometimes assigns threads of
+ // the same process different PIDs with unpredictable rules...
+ match wait::waitid(wait::Id::All, opts) {
+ Ok(stat) =>
+ match stat {
+ // Child exited normally with a specific code set.
+ wait::WaitStatus::Exited(_, code) => {
+ let code = self.override_retcode.unwrap_or(code);
+ return Some(ExecEvent::Died(Some(code)));
+ }
+ // Child was killed by a signal, without giving a code.
+ wait::WaitStatus::Signaled(_, _, _) =>
+ return Some(ExecEvent::Died(self.override_retcode)),
+ // Child entered a syscall. Since we're always technically
+ // tracing, only pass this along if we're actively
+ // monitoring the child.
+ wait::WaitStatus::PtraceSyscall(pid) =>
+ if self.attached {
+ return Some(ExecEvent::Syscall(pid));
+ },
+ // Child with the given pid was stopped by the given signal.
+ // It's somewhat dubious when this is returned instead of
+ // WaitStatus::Stopped, but for our purposes they are the
+ // same thing.
+ wait::WaitStatus::PtraceEvent(pid, signal, _) =>
+ if self.attached {
+ // This is our end-of-FFI signal!
+ if signal == signal::SIGUSR1 {
+ self.attached = false;
+ return Some(ExecEvent::End);
+ } else {
+ return Some(ExecEvent::Status(pid, signal));
+ }
+ } else {
+ // Just pass along the signal.
+ ptrace::cont(pid, signal).unwrap();
+ },
+ // Child was stopped at the given signal. Same logic as for
+ // WaitStatus::PtraceEvent.
+ wait::WaitStatus::Stopped(pid, signal) =>
+ if self.attached {
+ if signal == signal::SIGUSR1 {
+ self.attached = false;
+ return Some(ExecEvent::End);
+ } else {
+ return Some(ExecEvent::Status(pid, signal));
+ }
+ } else {
+ ptrace::cont(pid, signal).unwrap();
+ },
+ _ => (),
+ },
+ // This case should only trigger if all children died and we
+ // somehow missed that, but it's best we not allow any room
+ // for deadlocks.
+ Err(_) => return Some(ExecEvent::Died(None)),
+ }
+
+ // Similarly, do a non-blocking poll of the IPC channel.
+ if let Ok(req) = self.message_rx.try_recv() {
+ match req {
+ TraceRequest::StartFfi(info) =>
+ // Should never trigger - but better to panic explicitly than deadlock!
+ if self.attached {
+ panic!("Attempting to begin FFI multiple times!");
+ } else {
+ self.attached = true;
+ return Some(ExecEvent::Start(info));
+ },
+ TraceRequest::OverrideRetcode(code) => self.override_retcode = Some(code),
+ }
+ }
+
+ // Not ideal, but doing anything else might sacrifice performance.
+ std::thread::yield_now();
+ }
+ }
+}
+
+/// An error came up while waiting on the child process to do something.
+/// It likely died, with this return code if we have one.
+#[derive(Debug)]
+pub struct ExecEnd(pub Option<i32>);
+
+/// This is the main loop of the supervisor process. It runs in a separate
+/// process from the rest of Miri (but because we fork, addresses for anything
+/// created before the fork - like statics - are the same).
+pub fn sv_loop(
+ listener: ChildListener,
+ init_pid: unistd::Pid,
+ event_tx: ipc::IpcSender<MemEvents>,
+ confirm_tx: ipc::IpcSender<Confirmation>,
+) -> Result<!, ExecEnd> {
+ // Get the pagesize set and make sure it isn't still on the zero sentinel value!
+ let page_size = PAGE_SIZE.load(std::sync::atomic::Ordering::Relaxed);
+ assert_ne!(page_size, 0);
+
+ // Things that we return to the child process.
+ let mut acc_events = Vec::new();
+
+ // Memory allocated for the MiriMachine.
+ let mut ch_pages = Vec::new();
+ let mut ch_stack = None;
+
+ // An instance of the Capstone disassembler, so we don't spawn one on every access.
+ let cs = get_disasm();
+
+ // The pid of the last process we interacted with, used by default if we don't have a
+ // reason to use a different one.
+ let mut curr_pid = init_pid;
+
+ // There's an initial sigstop we need to deal with.
+ wait_for_signal(Some(curr_pid), signal::SIGSTOP, false)?;
+ ptrace::cont(curr_pid, None).unwrap();
+
+ for evt in listener {
+ match evt {
+ // start_ffi was called by the child, so prep memory.
+ ExecEvent::Start(ch_info) => {
+ // All the pages that the child process is "allowed to" access.
+ ch_pages = ch_info.page_ptrs;
+ // And the temporary callback stack it allocated for us to use later.
+ ch_stack = Some(ch_info.stack_ptr);
+
+ // We received the signal and are no longer in the main listener loop,
+ // so we can let the child move on to the end of start_ffi where it will
+ // raise a SIGSTOP. We need it to be signal-stopped *and waited for* in
+ // order to do most ptrace operations!
+ confirm_tx.send(Confirmation).unwrap();
+ // We can't trust simply calling `Pid::this()` in the child process to give the right
+ // PID for us, so we get it this way.
+ curr_pid = wait_for_signal(None, signal::SIGSTOP, false).unwrap();
+
+ ptrace::syscall(curr_pid, None).unwrap();
+ }
+ // end_ffi was called by the child.
+ ExecEvent::End => {
+ // Hand over the access info we traced.
+ event_tx.send(MemEvents { acc_events }).unwrap();
+ // And reset our values.
+ acc_events = Vec::new();
+ ch_stack = None;
+
+ // No need to monitor syscalls anymore, they'd just be ignored.
+ ptrace::cont(curr_pid, None).unwrap();
+ }
+ // Child process was stopped by a signal
+ ExecEvent::Status(pid, signal) =>
+ match signal {
+ // If it was a segfault, check if it was an artificial one
+ // caused by it trying to access the MiriMachine memory.
+ signal::SIGSEGV =>
+ handle_segfault(
+ pid,
+ &ch_pages,
+ ch_stack.unwrap(),
+ page_size,
+ &cs,
+ &mut acc_events,
+ )?,
+ // Something weird happened.
+ _ => {
+ eprintln!("Process unexpectedly got {signal}; continuing...");
+ // In case we're not tracing
+ if ptrace::syscall(pid, None).is_err() {
+ // If *this* fails too, something really weird happened
+ // and it's probably best to just panic.
+ signal::kill(pid, signal::SIGCONT).unwrap();
+ }
+ }
+ },
+ // Child entered a syscall; we wait for exits inside of this, so it
+ // should never trigger on return from a syscall we care about.
+ ExecEvent::Syscall(pid) => {
+ ptrace::syscall(pid, None).unwrap();
+ }
+ ExecEvent::Died(code) => {
+ return Err(ExecEnd(code));
+ }
+ }
+ }
+
+ unreachable!()
+}
+
+/// Spawns a Capstone disassembler for the host architecture.
+#[rustfmt::skip]
+fn get_disasm() -> capstone::Capstone {
+ use capstone::prelude::*;
+ let cs_pre = Capstone::new();
+ {
+ #[cfg(target_arch = "x86_64")]
+ {cs_pre.x86().mode(arch::x86::ArchMode::Mode64)}
+ #[cfg(target_arch = "x86")]
+ {cs_pre.x86().mode(arch::x86::ArchMode::Mode32)}
+ #[cfg(target_arch = "aarch64")]
+ {cs_pre.arm64().mode(arch::arm64::ArchMode::Arm)}
+ #[cfg(target_arch = "arm")]
+ {cs_pre.arm().mode(arch::arm::ArchMode::Arm)}
+ }
+ .detail(true)
+ .build()
+ .unwrap()
+}
+
+/// Waits for `wait_signal`. If `init_cont`, it will first do a `ptrace::cont`.
+/// We want to avoid that in some cases, like at the beginning of FFI.
+///
+/// If `pid` is `None`, only one wait will be done and `init_cont` should be false.
+fn wait_for_signal(
+ pid: Option<unistd::Pid>,
+ wait_signal: signal::Signal,
+ init_cont: bool,
+) -> Result<unistd::Pid, ExecEnd> {
+ if init_cont {
+ ptrace::cont(pid.unwrap(), None).unwrap();
+ }
+ // Repeatedly call `waitid` until we get the signal we want, or the process dies.
+ loop {
+ let wait_id = match pid {
+ Some(pid) => wait::Id::Pid(pid),
+ None => wait::Id::All,
+ };
+ let stat = wait::waitid(wait_id, WAIT_FLAGS).map_err(|_| ExecEnd(None))?;
+ let (signal, pid) = match stat {
+ // Report the cause of death, if we know it.
+ wait::WaitStatus::Exited(_, code) => {
+ return Err(ExecEnd(Some(code)));
+ }
+ wait::WaitStatus::Signaled(_, _, _) => return Err(ExecEnd(None)),
+ wait::WaitStatus::Stopped(pid, signal) => (signal, pid),
+ wait::WaitStatus::PtraceEvent(pid, signal, _) => (signal, pid),
+ // This covers PtraceSyscall and variants that are impossible with
+ // the flags set (e.g. WaitStatus::StillAlive).
+ _ => {
+ ptrace::cont(pid.unwrap(), None).unwrap();
+ continue;
+ }
+ };
+ if signal == wait_signal {
+ return Ok(pid);
+ } else {
+ ptrace::cont(pid, signal).map_err(|_| ExecEnd(None))?;
+ }
+ }
+}
+
+/// Grabs the access that caused a segfault and logs it down if it's to our memory,
+/// or kills the child and returns the appropriate error otherwise.
+fn handle_segfault(
+ pid: unistd::Pid,
+ ch_pages: &[usize],
+ ch_stack: usize,
+ page_size: usize,
+ cs: &capstone::Capstone,
+ acc_events: &mut Vec<AccessEvent>,
+) -> Result<(), ExecEnd> {
+ /// This is just here to not pollute the main namespace with `capstone::prelude::*`.
+ #[inline]
+ fn capstone_disassemble(
+ instr: &[u8],
+ addr: usize,
+ cs: &capstone::Capstone,
+ acc_events: &mut Vec<AccessEvent>,
+ ) -> capstone::CsResult<()> {
+ use capstone::prelude::*;
+
+ // The arch_detail is what we care about, but it relies on these temporaries
+ // that we can't drop. 0x1000 is the default base address for Captsone, and
+ // we're expecting 1 instruction.
+ let insns = cs.disasm_count(instr, 0x1000, 1)?;
+ let ins_detail = cs.insn_detail(&insns[0])?;
+ let arch_detail = ins_detail.arch_detail();
+
+ for op in arch_detail.operands() {
+ match op {
+ #[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
+ arch::ArchOperand::X86Operand(x86_operand) => {
+ match x86_operand.op_type {
+ // We only care about memory accesses
+ arch::x86::X86OperandType::Mem(_) => {
+ let push = addr..addr.strict_add(usize::from(x86_operand.size));
+ // It's called a "RegAccessType" but it also applies to memory
+ let acc_ty = x86_operand.access.unwrap();
+ if acc_ty.is_readable() {
+ acc_events.push(AccessEvent::Read(push.clone()));
+ }
+ if acc_ty.is_writable() {
+ acc_events.push(AccessEvent::Write(push));
+ }
+ }
+ _ => (),
+ }
+ }
+ #[cfg(target_arch = "aarch64")]
+ arch::ArchOperand::Arm64Operand(arm64_operand) => {
+ // Annoyingly, we don't always get the size here, so just be pessimistic for now.
+ match arm64_operand.op_type {
+ arch::arm64::Arm64OperandType::Mem(_) => {
+ // B = 1 byte, H = 2 bytes, S = 4 bytes, D = 8 bytes, Q = 16 bytes.
+ let size = match arm64_operand.vas {
+ // Not an fp/simd instruction.
+ arch::arm64::Arm64Vas::ARM64_VAS_INVALID => ARCH_WORD_SIZE,
+ // 1 byte.
+ arch::arm64::Arm64Vas::ARM64_VAS_1B => 1,
+ // 2 bytes.
+ arch::arm64::Arm64Vas::ARM64_VAS_1H => 2,
+ // 4 bytes.
+ arch::arm64::Arm64Vas::ARM64_VAS_4B
+ | arch::arm64::Arm64Vas::ARM64_VAS_2H
+ | arch::arm64::Arm64Vas::ARM64_VAS_1S => 4,
+ // 8 bytes.
+ arch::arm64::Arm64Vas::ARM64_VAS_8B
+ | arch::arm64::Arm64Vas::ARM64_VAS_4H
+ | arch::arm64::Arm64Vas::ARM64_VAS_2S
+ | arch::arm64::Arm64Vas::ARM64_VAS_1D => 8,
+ // 16 bytes.
+ arch::arm64::Arm64Vas::ARM64_VAS_16B
+ | arch::arm64::Arm64Vas::ARM64_VAS_8H
+ | arch::arm64::Arm64Vas::ARM64_VAS_4S
+ | arch::arm64::Arm64Vas::ARM64_VAS_2D
+ | arch::arm64::Arm64Vas::ARM64_VAS_1Q => 16,
+ };
+ let push = addr..addr.strict_add(size);
+ // FIXME: This now has access type info in the latest
+ // git version of capstone because this pissed me off
+ // and I added it. Change this when it updates.
+ acc_events.push(AccessEvent::Read(push.clone()));
+ acc_events.push(AccessEvent::Write(push));
+ }
+ _ => (),
+ }
+ }
+ #[cfg(target_arch = "arm")]
+ arch::ArchOperand::ArmOperand(arm_operand) =>
+ match arm_operand.op_type {
+ arch::arm::ArmOperandType::Mem(_) => {
+ // We don't get info on the size of the access, but
+ // we're at least told if it's a vector instruction.
+ let size = if arm_operand.vector_index.is_some() {
+ ARCH_MAX_ACCESS_SIZE
+ } else {
+ ARCH_WORD_SIZE
+ };
+ let push = addr..addr.strict_add(size);
+ let acc_ty = arm_operand.access.unwrap();
+ if acc_ty.is_readable() {
+ acc_events.push(AccessEvent::Read(push.clone()));
+ }
+ if acc_ty.is_writable() {
+ acc_events.push(AccessEvent::Write(push));
+ }
+ }
+ _ => (),
+ },
+ _ => unimplemented!(),
+ }
+ }
+
+ Ok(())
+ }
+
+ // Get information on what caused the segfault. This contains the address
+ // that triggered it.
+ let siginfo = ptrace::getsiginfo(pid).unwrap();
+ // All x86, ARM, etc. instructions only have at most one memory operand
+ // (thankfully!)
+ // SAFETY: si_addr is safe to call.
+ let addr = unsafe { siginfo.si_addr().addr() };
+ let page_addr = addr.strict_sub(addr.strict_rem(page_size));
+
+ if !ch_pages.iter().any(|pg| (*pg..pg.strict_add(page_size)).contains(&addr)) {
+ // This was a real segfault (not one of the Miri memory pages), so print some debug info and
+ // quit.
+ let regs = ptrace::getregs(pid).unwrap();
+ eprintln!("Segfault occurred during FFI at {addr:#018x}");
+ eprintln!("Expected access on pages: {ch_pages:#018x?}");
+ eprintln!("Register dump: {regs:#x?}");
+ ptrace::kill(pid).unwrap();
+ return Err(ExecEnd(None));
+ }
+
+ // Overall structure:
+ // - Get the address that caused the segfault
+ // - Unprotect the memory: we force the child to execute `mempr_off`, passing parameters via
+ // global atomic variables. This is what we use the temporary callback stack for.
+ // - Step 1 instruction
+ // - Parse executed code to estimate size & type of access
+ // - Reprotect the memory by executing `mempr_on` in the child.
+ // - Continue
+
+ // Ensure the stack is properly zeroed out!
+ for a in (ch_stack..ch_stack.strict_add(CALLBACK_STACK_SIZE)).step_by(ARCH_WORD_SIZE) {
+ ptrace::write(pid, std::ptr::with_exposed_provenance_mut(a), 0).unwrap();
+ }
+
+ // Guard against both architectures with upwards and downwards-growing stacks.
+ let stack_ptr = ch_stack.strict_add(CALLBACK_STACK_SIZE / 2);
+ let regs_bak = ptrace::getregs(pid).unwrap();
+ let mut new_regs = regs_bak;
+ let ip_prestep = regs_bak.ip();
+
+ // Move the instr ptr into the deprotection code.
+ #[expect(clippy::as_conversions)]
+ new_regs.set_ip(mempr_off as usize);
+ // Don't mess up the stack by accident!
+ new_regs.set_sp(stack_ptr);
+
+ // Modify the PAGE_ADDR global on the child process to point to the page
+ // that we want unprotected.
+ ptrace::write(
+ pid,
+ (&raw const PAGE_ADDR).cast_mut().cast(),
+ libc::c_long::try_from(page_addr).unwrap(),
+ )
+ .unwrap();
+
+ // Check if we also own the next page, and if so unprotect it in case
+ // the access spans the page boundary.
+ let flag = if ch_pages.contains(&page_addr.strict_add(page_size)) { 2 } else { 1 };
+ ptrace::write(pid, (&raw const PAGE_COUNT).cast_mut().cast(), flag).unwrap();
+
+ ptrace::setregs(pid, new_regs).unwrap();
+
+ // Our mempr_* functions end with a raise(SIGSTOP).
+ wait_for_signal(Some(pid), signal::SIGSTOP, true)?;
+
+ // Step 1 instruction.
+ ptrace::setregs(pid, regs_bak).unwrap();
+ ptrace::step(pid, None).unwrap();
+ // Don't use wait_for_signal here since 1 instruction doesn't give room
+ // for any uncertainty + we don't want it `cont()`ing randomly by accident
+ // Also, don't let it continue with unprotected memory if something errors!
+ let _ = wait::waitid(wait::Id::Pid(pid), WAIT_FLAGS).map_err(|_| ExecEnd(None))?;
+
+ // Zero out again to be safe
+ for a in (ch_stack..ch_stack.strict_add(CALLBACK_STACK_SIZE)).step_by(ARCH_WORD_SIZE) {
+ ptrace::write(pid, std::ptr::with_exposed_provenance_mut(a), 0).unwrap();
+ }
+
+ // Save registers and grab the bytes that were executed. This would
+ // be really nasty if it was a jump or similar but those thankfully
+ // won't do memory accesses and so can't trigger this!
+ let regs_bak = ptrace::getregs(pid).unwrap();
+ new_regs = regs_bak;
+ let ip_poststep = regs_bak.ip();
+ // We need to do reads/writes in word-sized chunks.
+ let diff = (ip_poststep.strict_sub(ip_prestep)).div_ceil(ARCH_WORD_SIZE);
+ let instr = (ip_prestep..ip_prestep.strict_add(diff)).fold(vec![], |mut ret, ip| {
+ // This only needs to be a valid pointer in the child process, not ours.
+ ret.append(
+ &mut ptrace::read(pid, std::ptr::without_provenance_mut(ip))
+ .unwrap()
+ .to_ne_bytes()
+ .to_vec(),
+ );
+ ret
+ });
+
+ // Now figure out the size + type of access and log it down.
+ // This will mark down e.g. the same area being read multiple times,
+ // since it's more efficient to compress the accesses at the end.
+ if capstone_disassemble(&instr, addr, cs, acc_events).is_err() {
+ // Read goes first because we need to be pessimistic.
+ acc_events.push(AccessEvent::Read(addr..addr.strict_add(ARCH_MAX_ACCESS_SIZE)));
+ acc_events.push(AccessEvent::Write(addr..addr.strict_add(ARCH_MAX_ACCESS_SIZE)));
+ }
+
+ // Reprotect everything and continue.
+ #[expect(clippy::as_conversions)]
+ new_regs.set_ip(mempr_on as usize);
+ new_regs.set_sp(stack_ptr);
+ ptrace::setregs(pid, new_regs).unwrap();
+ wait_for_signal(Some(pid), signal::SIGSTOP, true)?;
+
+ ptrace::setregs(pid, regs_bak).unwrap();
+ ptrace::syscall(pid, None).unwrap();
+ Ok(())
+}
+
+// We only get dropped into these functions via offsetting the instr pointer
+// manually, so we *must not ever* unwind from them.
+
+/// Disables protections on the page whose address is currently in `PAGE_ADDR`.
+///
+/// SAFETY: `PAGE_ADDR` should be set to a page-aligned pointer to an owned page,
+/// `PAGE_SIZE` should be the host pagesize, and the range from `PAGE_ADDR` to
+/// `PAGE_SIZE` * `PAGE_COUNT` must be owned and allocated memory. No other threads
+/// should be running.
+pub unsafe extern "C" fn mempr_off() {
+ use std::sync::atomic::Ordering;
+
+ // Again, cannot allow unwinds to happen here.
+ let len = PAGE_SIZE.load(Ordering::Relaxed).saturating_mul(PAGE_COUNT.load(Ordering::Relaxed));
+ // SAFETY: Upheld by "caller".
+ unsafe {
+ // It's up to the caller to make sure this doesn't actually overflow, but
+ // we mustn't unwind from here, so...
+ if libc::mprotect(
+ PAGE_ADDR.load(Ordering::Relaxed).cast(),
+ len,
+ libc::PROT_READ | libc::PROT_WRITE,
+ ) != 0
+ {
+ // Can't return or unwind, but we can do this.
+ std::process::exit(-1);
+ }
+ }
+ // If this fails somehow we're doomed.
+ if signal::raise(signal::SIGSTOP).is_err() {
+ std::process::exit(-1);
+ }
+}
+
+/// Reenables protection on the page set by `PAGE_ADDR`.
+///
+/// SAFETY: See `mempr_off()`.
+pub unsafe extern "C" fn mempr_on() {
+ use std::sync::atomic::Ordering;
+
+ let len = PAGE_SIZE.load(Ordering::Relaxed).wrapping_mul(PAGE_COUNT.load(Ordering::Relaxed));
+ // SAFETY: Upheld by "caller".
+ unsafe {
+ if libc::mprotect(PAGE_ADDR.load(Ordering::Relaxed).cast(), len, libc::PROT_NONE) != 0 {
+ std::process::exit(-1);
+ }
+ }
+ if signal::raise(signal::SIGSTOP).is_err() {
+ std::process::exit(-1);
+ }
+}
diff --git a/src/tools/miri/src/shims/unix/foreign_items.rs b/src/tools/miri/src/shims/unix/foreign_items.rs
index 14ebb22..b3c5839 100644
--- a/src/tools/miri/src/shims/unix/foreign_items.rs
+++ b/src/tools/miri/src/shims/unix/foreign_items.rs
@@ -945,8 +945,7 @@ fn emulate_foreign_item_inner(
}
"pthread_join" => {
let [thread, retval] = this.check_shim(abi, CanonAbi::C, link_name, args)?;
- let res = this.pthread_join(thread, retval)?;
- this.write_scalar(res, dest)?;
+ this.pthread_join(thread, retval, dest)?;
}
"pthread_detach" => {
let [thread] = this.check_shim(abi, CanonAbi::C, link_name, args)?;
diff --git a/src/tools/miri/src/shims/unix/linux/mem.rs b/src/tools/miri/src/shims/unix/linux/mem.rs
index 8e5a3021..47732f8 100644
--- a/src/tools/miri/src/shims/unix/linux/mem.rs
+++ b/src/tools/miri/src/shims/unix/linux/mem.rs
@@ -22,8 +22,7 @@ fn mremap(
let flags = this.read_scalar(flags)?.to_i32()?;
// old_address must be a multiple of the page size
- #[expect(clippy::arithmetic_side_effects)] // PAGE_SIZE is nonzero
- if old_address.addr().bytes() % this.machine.page_size != 0 || new_size == 0 {
+ if !old_address.addr().bytes().is_multiple_of(this.machine.page_size) || new_size == 0 {
this.set_last_error(LibcError("EINVAL"))?;
return interp_ok(this.eval_libc("MAP_FAILED"));
}
diff --git a/src/tools/miri/src/shims/unix/mem.rs b/src/tools/miri/src/shims/unix/mem.rs
index aefeee6..4bbbbc6 100644
--- a/src/tools/miri/src/shims/unix/mem.rs
+++ b/src/tools/miri/src/shims/unix/mem.rs
@@ -130,8 +130,7 @@ fn munmap(&mut self, addr: &OpTy<'tcx>, length: &OpTy<'tcx>) -> InterpResult<'tc
// addr must be a multiple of the page size, but apart from that munmap is just implemented
// as a dealloc.
- #[expect(clippy::arithmetic_side_effects)] // PAGE_SIZE is nonzero
- if addr.addr().bytes() % this.machine.page_size != 0 {
+ if !addr.addr().bytes().is_multiple_of(this.machine.page_size) {
return this.set_last_error_and_return_i32(LibcError("EINVAL"));
}
diff --git a/src/tools/miri/src/shims/unix/sync.rs b/src/tools/miri/src/shims/unix/sync.rs
index eee2bbc..50eb4d9 100644
--- a/src/tools/miri/src/shims/unix/sync.rs
+++ b/src/tools/miri/src/shims/unix/sync.rs
@@ -17,7 +17,7 @@ fn bytewise_equal_atomic_relaxed<'tcx>(
// We do this in chunks of 4, so that we are okay to race with (sufficiently aligned)
// 4-byte atomic accesses.
- assert!(size.bytes() % 4 == 0);
+ assert!(size.bytes().is_multiple_of(4));
for i in 0..(size.bytes() / 4) {
let offset = Size::from_bytes(i.strict_mul(4));
let load = |place: &MPlaceTy<'tcx>| {
diff --git a/src/tools/miri/src/shims/unix/thread.rs b/src/tools/miri/src/shims/unix/thread.rs
index 4b6615b..a438e71 100644
--- a/src/tools/miri/src/shims/unix/thread.rs
+++ b/src/tools/miri/src/shims/unix/thread.rs
@@ -41,7 +41,8 @@ fn pthread_join(
&mut self,
thread: &OpTy<'tcx>,
retval: &OpTy<'tcx>,
- ) -> InterpResult<'tcx, Scalar> {
+ return_dest: &MPlaceTy<'tcx>,
+ ) -> InterpResult<'tcx> {
let this = self.eval_context_mut();
if !this.ptr_is_null(this.read_pointer(retval)?)? {
@@ -51,12 +52,15 @@ fn pthread_join(
let thread = this.read_scalar(thread)?.to_int(this.libc_ty_layout("pthread_t").size)?;
let Ok(thread) = this.thread_id_try_from(thread) else {
- return interp_ok(this.eval_libc("ESRCH"));
+ this.write_scalar(this.eval_libc("ESRCH"), return_dest)?;
+ return interp_ok(());
};
- this.join_thread_exclusive(thread)?;
-
- interp_ok(Scalar::from_u32(0))
+ this.join_thread_exclusive(
+ thread,
+ /* success_retval */ Scalar::from_u32(0),
+ return_dest,
+ )
}
fn pthread_detach(&mut self, thread: &OpTy<'tcx>) -> InterpResult<'tcx, Scalar> {
diff --git a/src/tools/miri/src/shims/windows/foreign_items.rs b/src/tools/miri/src/shims/windows/foreign_items.rs
index 10f6df6..de10357 100644
--- a/src/tools/miri/src/shims/windows/foreign_items.rs
+++ b/src/tools/miri/src/shims/windows/foreign_items.rs
@@ -573,8 +573,7 @@ fn emulate_foreign_item_inner(
"WaitForSingleObject" => {
let [handle, timeout] = this.check_shim(abi, sys_conv, link_name, args)?;
- let ret = this.WaitForSingleObject(handle, timeout)?;
- this.write_scalar(ret, dest)?;
+ this.WaitForSingleObject(handle, timeout, dest)?;
}
"GetCurrentProcess" => {
let [] = this.check_shim(abi, sys_conv, link_name, args)?;
diff --git a/src/tools/miri/src/shims/windows/thread.rs b/src/tools/miri/src/shims/windows/thread.rs
index 56ae88b..a155ec6 100644
--- a/src/tools/miri/src/shims/windows/thread.rs
+++ b/src/tools/miri/src/shims/windows/thread.rs
@@ -58,13 +58,14 @@ fn WaitForSingleObject(
&mut self,
handle_op: &OpTy<'tcx>,
timeout_op: &OpTy<'tcx>,
- ) -> InterpResult<'tcx, Scalar> {
+ return_dest: &MPlaceTy<'tcx>,
+ ) -> InterpResult<'tcx> {
let this = self.eval_context_mut();
let handle = this.read_handle(handle_op, "WaitForSingleObject")?;
let timeout = this.read_scalar(timeout_op)?.to_u32()?;
- let thread = match handle {
+ let joined_thread_id = match handle {
Handle::Thread(thread) => thread,
// Unlike on posix, the outcome of joining the current thread is not documented.
// On current Windows, it just deadlocks.
@@ -76,8 +77,12 @@ fn WaitForSingleObject(
throw_unsup_format!("`WaitForSingleObject` with non-infinite timeout");
}
- this.join_thread(thread)?;
+ this.join_thread(
+ joined_thread_id,
+ /* success_retval */ this.eval_windows("c", "WAIT_OBJECT_0"),
+ return_dest,
+ )?;
- interp_ok(this.eval_windows("c", "WAIT_OBJECT_0"))
+ interp_ok(())
}
}
diff --git a/src/tools/miri/tests/fail/dangling_pointers/dangling_pointer_to_raw_pointer.rs b/src/tools/miri/tests/fail/dangling_pointers/dangling_pointer_to_raw_pointer.rs
index c63e926..9646cdb 100644
--- a/src/tools/miri/tests/fail/dangling_pointers/dangling_pointer_to_raw_pointer.rs
+++ b/src/tools/miri/tests/fail/dangling_pointers/dangling_pointer_to_raw_pointer.rs
@@ -6,7 +6,7 @@ fn direct_raw(x: *const (i32, i32)) -> *const i32 {
// Ensure that if a raw pointer is created via an intermediate
// reference, we catch that. (Just in case someone decides to
-// desugar this differenly or so.)
+// desugar this differently or so.)
fn via_ref(x: *const (i32, i32)) -> *const i32 {
unsafe { &(*x).0 as *const i32 } //~ERROR: dangling pointer
}
diff --git a/src/tools/miri/tests/pass/float.rs b/src/tools/miri/tests/pass/float.rs
index 3835791..f21c608 100644
--- a/src/tools/miri/tests/pass/float.rs
+++ b/src/tools/miri/tests/pass/float.rs
@@ -1066,17 +1066,6 @@ fn ldexp(a: f64, b: i32) -> f64 {
assert_eq!((-1f32).powf(f32::NEG_INFINITY), 1.0);
assert_eq!((-1f64).powf(f64::NEG_INFINITY), 1.0);
- // For pow (powf in rust) the C standard says:
- // x^0 = 1 for all x even a sNaN
- // FIXME(#4286): this does not match the behavior of all implementations.
- assert_eq!(SNAN_F32.powf(0.0), 1.0);
- assert_eq!(SNAN_F64.powf(0.0), 1.0);
-
- // For pown (powi in rust) the C standard says:
- // x^0 = 1 for all x even a sNaN
- // FIXME(#4286): this does not match the behavior of all implementations.
- assert_eq!(SNAN_F32.powi(0), 1.0);
- assert_eq!(SNAN_F64.powi(0), 1.0);
assert_eq!(0f32.powi(10), 0.0);
assert_eq!(0f64.powi(100), 0.0);
@@ -1500,4 +1489,18 @@ pub fn test_operations_f128(a: f128, b: f128) {
test_operations_f32(12., 5.);
test_operations_f64(19., 11.);
test_operations_f128(25., 18.);
+
+
+ // SNaN^0 = (1 | NaN)
+ ensure_nondet(|| f32::powf(SNAN_F32, 0.0).is_nan());
+ ensure_nondet(|| f64::powf(SNAN_F64, 0.0).is_nan());
+
+ // 1^SNaN = (1 | NaN)
+ ensure_nondet(|| f32::powf(1.0, SNAN_F32).is_nan());
+ ensure_nondet(|| f64::powf(1.0, SNAN_F64).is_nan());
+
+ // same as powf (keep it consistent):
+ // x^SNaN = (1 | NaN)
+ ensure_nondet(|| f32::powi(SNAN_F32, 0).is_nan());
+ ensure_nondet(|| f64::powi(SNAN_F64, 0).is_nan());
}
diff --git a/src/tools/miri/tests/pass/float_nan.rs b/src/tools/miri/tests/pass/float_nan.rs
index cadbbd5..3ffdb68 100644
--- a/src/tools/miri/tests/pass/float_nan.rs
+++ b/src/tools/miri/tests/pass/float_nan.rs
@@ -260,6 +260,7 @@ fn test_f32() {
// Intrinsics
let nan = F32::nan(Neg, Quiet, 0).as_f32();
+ let snan = F32::nan(Neg, Signaling, 1).as_f32();
check_all_outcomes(
HashSet::from_iter([F32::nan(Pos, Quiet, 0), F32::nan(Neg, Quiet, 0)]),
|| F32::from(f32::min(nan, nan)),
@@ -313,6 +314,18 @@ fn test_f32() {
HashSet::from_iter([F32::nan(Pos, Quiet, 0), F32::nan(Neg, Quiet, 0)]),
|| F32::from(nan.ln_gamma().0),
);
+ check_all_outcomes(
+ HashSet::from_iter([
+ F32::from(1.0),
+ F32::nan(Pos, Quiet, 0),
+ F32::nan(Neg, Quiet, 0),
+ F32::nan(Pos, Quiet, 1),
+ F32::nan(Neg, Quiet, 1),
+ F32::nan(Pos, Signaling, 1),
+ F32::nan(Neg, Signaling, 1),
+ ]),
+ || F32::from(snan.powf(0.0)),
+ );
}
fn test_f64() {
@@ -376,6 +389,7 @@ fn test_f64() {
// Intrinsics
let nan = F64::nan(Neg, Quiet, 0).as_f64();
+ let snan = F64::nan(Neg, Signaling, 1).as_f64();
check_all_outcomes(
HashSet::from_iter([F64::nan(Pos, Quiet, 0), F64::nan(Neg, Quiet, 0)]),
|| F64::from(f64::min(nan, nan)),
@@ -433,6 +447,18 @@ fn test_f64() {
HashSet::from_iter([F64::nan(Pos, Quiet, 0), F64::nan(Neg, Quiet, 0)]),
|| F64::from(nan.ln_gamma().0),
);
+ check_all_outcomes(
+ HashSet::from_iter([
+ F64::from(1.0),
+ F64::nan(Pos, Quiet, 0),
+ F64::nan(Neg, Quiet, 0),
+ F64::nan(Pos, Quiet, 1),
+ F64::nan(Neg, Quiet, 1),
+ F64::nan(Pos, Signaling, 1),
+ F64::nan(Neg, Signaling, 1),
+ ]),
+ || F64::from(snan.powf(0.0)),
+ );
}
fn test_casts() {
diff --git a/src/tools/miri/tests/pass/intrinsics/portable-simd.rs b/src/tools/miri/tests/pass/intrinsics/portable-simd.rs
index e14ce51..726d4c0 100644
--- a/src/tools/miri/tests/pass/intrinsics/portable-simd.rs
+++ b/src/tools/miri/tests/pass/intrinsics/portable-simd.rs
@@ -570,6 +570,10 @@ fn simd_round() {
f32x4::from_array([1.0, 1.0, 2.0, -5.0])
);
assert_eq!(
+ unsafe { intrinsics::simd_round_ties_even(f32x4::from_array([0.9, 1.001, 2.0, -4.5])) },
+ f32x4::from_array([1.0, 1.0, 2.0, -4.0])
+ );
+ assert_eq!(
f32x4::from_array([0.9, 1.001, 2.0, -4.5]).trunc(),
f32x4::from_array([0.0, 1.0, 2.0, -4.0])
);
@@ -587,6 +591,10 @@ fn simd_round() {
f64x4::from_array([1.0, 1.0, 2.0, -5.0])
);
assert_eq!(
+ unsafe { intrinsics::simd_round_ties_even(f64x4::from_array([0.9, 1.001, 2.0, -4.5])) },
+ f64x4::from_array([1.0, 1.0, 2.0, -4.0])
+ );
+ assert_eq!(
f64x4::from_array([0.9, 1.001, 2.0, -4.5]).trunc(),
f64x4::from_array([0.0, 1.0, 2.0, -4.0])
);
diff --git a/src/tools/opt-dist/src/exec.rs b/src/tools/opt-dist/src/exec.rs
index 64ce5cc..0dc6e56 100644
--- a/src/tools/opt-dist/src/exec.rs
+++ b/src/tools/opt-dist/src/exec.rs
@@ -122,7 +122,12 @@ pub fn dist(env: &Environment, dist_args: &[String]) -> Self {
let metrics_path = env.build_root().join("build").join("metrics.json");
let args = dist_args.iter().map(|arg| arg.as_str()).collect::<Vec<_>>();
let cmd = cmd(&args).env("RUST_BACKTRACE", "full");
- let cmd = add_shared_x_flags(env, cmd);
+ let mut cmd = add_shared_x_flags(env, cmd);
+ if env.is_fast_try_build() {
+ // We set build.extended=false for fast try builds, but we still need Cargo
+ cmd = cmd.arg("cargo");
+ }
+
Self { cmd, metrics_path }
}
@@ -189,5 +194,18 @@ pub fn run(self, timer: &mut TimerSection) -> anyhow::Result<()> {
}
fn add_shared_x_flags(env: &Environment, cmd: CmdBuilder) -> CmdBuilder {
- if env.is_fast_try_build() { cmd.arg("--set").arg("rust.deny-warnings=false") } else { cmd }
+ if env.is_fast_try_build() {
+ // Skip things that cannot be skipped through `x ... --skip`
+ cmd.arg("--set")
+ .arg("rust.llvm-bitcode-linker=false")
+ // Skip wasm-component-ld. This also skips cargo, which we need to re-enable for dist
+ .arg("--set")
+ .arg("build.extended=false")
+ .arg("--set")
+ .arg("rust.codegen-backends=['llvm']")
+ .arg("--set")
+ .arg("rust.deny-warnings=false")
+ } else {
+ cmd
+ }
}
diff --git a/src/tools/opt-dist/src/main.rs b/src/tools/opt-dist/src/main.rs
index d2827ec..9c8a663 100644
--- a/src/tools/opt-dist/src/main.rs
+++ b/src/tools/opt-dist/src/main.rs
@@ -407,13 +407,18 @@ fn main() -> anyhow::Result<()> {
for target in [
"rust-docs",
"rustc-docs",
+ "rustc-dev",
+ "rust-dev",
"rust-docs-json",
"rust-analyzer",
"rustc-src",
+ "extended",
"clippy",
"miri",
"rustfmt",
"gcc",
+ "generate-copyright",
+ "bootstrap",
] {
build_args.extend(["--skip".to_string(), target.to_string()]);
}
diff --git a/src/tools/test-float-parse/src/ui.rs b/src/tools/test-float-parse/src/ui.rs
index 73473eef..1a9ba0d 100644
--- a/src/tools/test-float-parse/src/ui.rs
+++ b/src/tools/test-float-parse/src/ui.rs
@@ -118,7 +118,7 @@ pub fn finish_all(tests: &[TestInfo], total_elapsed: Duration, cfg: &Config) ->
match result {
Ok(FinishedAll) => (),
Err(EarlyExit::Timeout) => {
- println!(" exited early; exceded {:?} timeout", cfg.timeout)
+ println!(" exited early; exceeded {:?} timeout", cfg.timeout)
}
Err(EarlyExit::MaxFailures) => {
println!(" exited early; exceeded {:?} max failures", cfg.max_failures)
diff --git a/src/tools/tidy/src/issues.txt b/src/tools/tidy/src/issues.txt
index 7e27e02..4f9af6d 100644
--- a/src/tools/tidy/src/issues.txt
+++ b/src/tools/tidy/src/issues.txt
@@ -1368,7 +1368,6 @@
ui/intrinsics/issue-28575.rs
ui/intrinsics/issue-84297-reifying-copy.rs
ui/invalid/issue-114435-layout-type-err.rs
-ui/issue-11881.rs
ui/issue-15924.rs
ui/issue-16822.rs
ui/issues-71798.rs
diff --git a/tests/crashes/132882.rs b/tests/crashes/132882.rs
deleted file mode 100644
index 6b5e4db..0000000
--- a/tests/crashes/132882.rs
+++ /dev/null
@@ -1,13 +0,0 @@
-//@ known-bug: #132882
-
-use std::ops::Add;
-
-pub trait Numoid
-where
- for<N: Numoid> &'a Self: Add<Self>,
-{
-}
-
-pub fn compute<N: Numoid>(a: N) -> N {
- &a + a
-}
diff --git a/tests/run-make/used-proc-macro/dep.rs b/tests/run-make/used-proc-macro/dep.rs
new file mode 100644
index 0000000..9f881d9
--- /dev/null
+++ b/tests/run-make/used-proc-macro/dep.rs
@@ -0,0 +1,4 @@
+#![crate_type = "lib"]
+
+#[used]
+static VERY_IMPORTANT_SYMBOL: u32 = 12345;
diff --git a/tests/run-make/used-proc-macro/proc_macro.rs b/tests/run-make/used-proc-macro/proc_macro.rs
new file mode 100644
index 0000000..af592ea
--- /dev/null
+++ b/tests/run-make/used-proc-macro/proc_macro.rs
@@ -0,0 +1,3 @@
+#![crate_type = "proc-macro"]
+
+extern crate dep as _;
diff --git a/tests/run-make/used-proc-macro/rmake.rs b/tests/run-make/used-proc-macro/rmake.rs
new file mode 100644
index 0000000..58b2760
--- /dev/null
+++ b/tests/run-make/used-proc-macro/rmake.rs
@@ -0,0 +1,18 @@
+// Test that #[used] statics are included in the final dylib for proc-macros too.
+
+//@ ignore-cross-compile
+//@ ignore-windows llvm-readobj --all doesn't show local symbols on Windows
+//@ needs-crate-type: proc-macro
+//@ ignore-musl (FIXME: can't find `-lunwind`)
+
+use run_make_support::{dynamic_lib_name, llvm_readobj, rustc};
+
+fn main() {
+ rustc().input("dep.rs").run();
+ rustc().input("proc_macro.rs").run();
+ llvm_readobj()
+ .input(dynamic_lib_name("proc_macro"))
+ .arg("--all")
+ .run()
+ .assert_stdout_contains("VERY_IMPORTANT_SYMBOL");
+}
diff --git a/tests/rustdoc/enum/enum-variant-non_exhaustive.rs b/tests/rustdoc/enum/enum-variant-non_exhaustive.rs
new file mode 100644
index 0000000..ea0234a
--- /dev/null
+++ b/tests/rustdoc/enum/enum-variant-non_exhaustive.rs
@@ -0,0 +1,17 @@
+// regression test for https://github.com/rust-lang/rust/issues/142599
+
+#![crate_name = "foo"]
+
+//@ snapshot type-code 'foo/enum.Type.html' '//pre[@class="rust item-decl"]/code'
+pub enum Type {
+ #[non_exhaustive]
+ // attribute that should not be shown
+ #[warn(unsafe_code)]
+ Variant,
+}
+
+// we would love to use the `following-sibling::` axis
+// (along with an `h2[@id="aliased-type"]` query),
+// but unfortunately python doesn't implement that.
+//@ snapshot type-alias-code 'foo/type.TypeAlias.html' '//pre[@class="rust item-decl"][2]/code'
+pub type TypeAlias = Type;
diff --git a/tests/rustdoc/enum/enum-variant-non_exhaustive.type-alias-code.html b/tests/rustdoc/enum/enum-variant-non_exhaustive.type-alias-code.html
new file mode 100644
index 0000000..04eea70
--- /dev/null
+++ b/tests/rustdoc/enum/enum-variant-non_exhaustive.type-alias-code.html
@@ -0,0 +1,4 @@
+<code>pub enum TypeAlias {
+ #[non_exhaustive]
+ Variant,
+}</code>
\ No newline at end of file
diff --git a/tests/rustdoc/enum/enum-variant-non_exhaustive.type-code.html b/tests/rustdoc/enum/enum-variant-non_exhaustive.type-code.html
new file mode 100644
index 0000000..6c8851e
--- /dev/null
+++ b/tests/rustdoc/enum/enum-variant-non_exhaustive.type-code.html
@@ -0,0 +1,4 @@
+<code>pub enum Type {
+ #[non_exhaustive]
+ Variant,
+}</code>
\ No newline at end of file
diff --git a/tests/rustdoc/intra-doc/deps.rs b/tests/rustdoc/intra-doc/deps.rs
new file mode 100644
index 0000000..fd40b83
--- /dev/null
+++ b/tests/rustdoc/intra-doc/deps.rs
@@ -0,0 +1,23 @@
+// Checks that links to crates are correctly generated and only existing crates
+// have a link generated.
+// Regression test for <https://github.com/rust-lang/rust/issues/137857>.
+
+//@ compile-flags: --document-private-items -Z unstable-options
+//@ compile-flags: --extern-html-root-url=empty=https://empty.example/
+// This one is to ensure that we don't link to any item we see which has
+// an external html root URL unless it actually exists.
+//@ compile-flags: --extern-html-root-url=non_existant=https://non-existant.example/
+//@ aux-build: empty.rs
+
+#![crate_name = "foo"]
+#![expect(rustdoc::broken_intra_doc_links)]
+
+//@ has 'foo/index.html'
+//@ has - '//a[@href="https://empty.example/empty/index.html"]' 'empty'
+// There should only be one intra doc links, we should not link `non_existant`.
+//@ count - '//*[@class="docblock"]//a' 1
+//! [`empty`]
+//!
+//! [`non_existant`]
+
+extern crate empty;
diff --git a/tests/ui/empty-allocation-non-null.rs b/tests/ui/allocator/empty-alloc-nonnull-guarantee.rs
similarity index 66%
rename from tests/ui/empty-allocation-non-null.rs
rename to tests/ui/allocator/empty-alloc-nonnull-guarantee.rs
index 45035a4..f408130 100644
--- a/tests/ui/empty-allocation-non-null.rs
+++ b/tests/ui/allocator/empty-alloc-nonnull-guarantee.rs
@@ -1,3 +1,7 @@
+//! Check that the default global Rust allocator produces non-null Box allocations for ZSTs.
+//!
+//! See https://github.com/rust-lang/rust/issues/11998
+
//@ run-pass
pub fn main() {
diff --git a/tests/ui/associated-types/unconstrained-lifetime-assoc-type.rs b/tests/ui/associated-types/unconstrained-lifetime-assoc-type.rs
new file mode 100644
index 0000000..2c4af7d
--- /dev/null
+++ b/tests/ui/associated-types/unconstrained-lifetime-assoc-type.rs
@@ -0,0 +1,21 @@
+//! Regression test for issue #22077
+//! lifetime parameters must be constrained in associated type definitions
+
+trait Fun {
+ type Output;
+ fn call<'x>(&'x self) -> Self::Output;
+}
+
+struct Holder {
+ x: String,
+}
+
+impl<'a> Fun for Holder {
+ //~^ ERROR E0207
+ type Output = &'a str;
+ fn call<'b>(&'b self) -> &'b str {
+ &self.x[..]
+ }
+}
+
+fn main() {}
diff --git a/tests/ui/impl-unused-rps-in-assoc-type.stderr b/tests/ui/associated-types/unconstrained-lifetime-assoc-type.stderr
similarity index 84%
rename from tests/ui/impl-unused-rps-in-assoc-type.stderr
rename to tests/ui/associated-types/unconstrained-lifetime-assoc-type.stderr
index ef61fa4..15d0820 100644
--- a/tests/ui/impl-unused-rps-in-assoc-type.stderr
+++ b/tests/ui/associated-types/unconstrained-lifetime-assoc-type.stderr
@@ -1,5 +1,5 @@
error[E0207]: the lifetime parameter `'a` is not constrained by the impl trait, self type, or predicates
- --> $DIR/impl-unused-rps-in-assoc-type.rs:11:6
+ --> $DIR/unconstrained-lifetime-assoc-type.rs:13:6
|
LL | impl<'a> Fun for Holder {
| ^^ unconstrained lifetime parameter
diff --git a/tests/ui/attributes/inline-attribute-enum-variant-error.rs b/tests/ui/attributes/inline-attribute-enum-variant-error.rs
new file mode 100644
index 0000000..305b285
--- /dev/null
+++ b/tests/ui/attributes/inline-attribute-enum-variant-error.rs
@@ -0,0 +1,9 @@
+//! Test that #[inline] attribute cannot be applied to enum variants
+
+enum Foo {
+ #[inline]
+ //~^ ERROR attribute should be applied
+ Variant,
+}
+
+fn main() {}
diff --git a/tests/ui/inline-disallow-on-variant.stderr b/tests/ui/attributes/inline-attribute-enum-variant-error.stderr
similarity index 83%
rename from tests/ui/inline-disallow-on-variant.stderr
rename to tests/ui/attributes/inline-attribute-enum-variant-error.stderr
index 255f6bc..a4564d8 100644
--- a/tests/ui/inline-disallow-on-variant.stderr
+++ b/tests/ui/attributes/inline-attribute-enum-variant-error.stderr
@@ -1,5 +1,5 @@
error[E0518]: attribute should be applied to function or closure
- --> $DIR/inline-disallow-on-variant.rs:2:5
+ --> $DIR/inline-attribute-enum-variant-error.rs:4:5
|
LL | #[inline]
| ^^^^^^^^^
diff --git a/tests/ui/attributes/inline-main.rs b/tests/ui/attributes/inline-main.rs
new file mode 100644
index 0000000..7181ee1
--- /dev/null
+++ b/tests/ui/attributes/inline-main.rs
@@ -0,0 +1,6 @@
+//! Test that #[inline(always)] can be applied to main function
+
+//@ run-pass
+
+#[inline(always)]
+fn main() {}
diff --git a/tests/ui/attributes/inner-attrs-impl-cfg.rs b/tests/ui/attributes/inner-attrs-impl-cfg.rs
new file mode 100644
index 0000000..e7a5cfa
--- /dev/null
+++ b/tests/ui/attributes/inner-attrs-impl-cfg.rs
@@ -0,0 +1,36 @@
+//! Test inner attributes (#![...]) behavior in impl blocks with cfg conditions.
+//!
+//! This test verifies that:
+//! - Inner attributes can conditionally exclude entire impl blocks
+//! - Regular attributes within impl blocks work independently
+//! - Attribute parsing doesn't consume too eagerly
+
+//@ run-pass
+
+struct Foo;
+
+impl Foo {
+ #![cfg(false)]
+
+ fn method(&self) -> bool {
+ false
+ }
+}
+
+impl Foo {
+ #![cfg(not(FALSE))]
+
+ // Check that we don't eat attributes too eagerly.
+ #[cfg(false)]
+ fn method(&self) -> bool {
+ false
+ }
+
+ fn method(&self) -> bool {
+ true
+ }
+}
+
+pub fn main() {
+ assert!(Foo.method());
+}
diff --git a/tests/ui/compiletest-self-test/ui-test-missing-annotations-detection.rs b/tests/ui/compiletest-self-test/ui-test-missing-annotations-detection.rs
new file mode 100644
index 0000000..3a110bd
--- /dev/null
+++ b/tests/ui/compiletest-self-test/ui-test-missing-annotations-detection.rs
@@ -0,0 +1,9 @@
+//! Regression test checks UI tests without error annotations are detected as failing.
+//!
+//! This tests that when we forget to use any `//~ ERROR` comments whatsoever,
+//! the test doesn't succeed
+//! Originally created in https://github.com/rust-lang/rust/pull/56244
+
+//@ should-fail
+
+fn main() {}
diff --git a/tests/ui/consts/fn_trait_refs.stderr b/tests/ui/consts/fn_trait_refs.stderr
index ee716c9..445dd75 100644
--- a/tests/ui/consts/fn_trait_refs.stderr
+++ b/tests/ui/consts/fn_trait_refs.stderr
@@ -5,145 +5,145 @@
| ^^^^^^^^^^^^^^^^^^^^^^^^
error: `[const]` can only be applied to `#[const_trait]` traits
- --> $DIR/fn_trait_refs.rs:14:6
+ --> $DIR/fn_trait_refs.rs:14:8
|
LL | T: [const] Fn<()> + [const] Destruct,
- | ^^^^^^^^^ can't be applied to `Fn`
+ | ^^^^^^^ can't be applied to `Fn`
|
note: `Fn` can't be used with `[const]` because it isn't annotated with `#[const_trait]`
--> $SRC_DIR/core/src/ops/function.rs:LL:COL
error: `[const]` can only be applied to `#[const_trait]` traits
- --> $DIR/fn_trait_refs.rs:14:6
+ --> $DIR/fn_trait_refs.rs:14:8
|
LL | T: [const] Fn<()> + [const] Destruct,
- | ^^^^^^^^^ can't be applied to `Fn`
+ | ^^^^^^^ can't be applied to `Fn`
|
note: `Fn` can't be used with `[const]` because it isn't annotated with `#[const_trait]`
--> $SRC_DIR/core/src/ops/function.rs:LL:COL
= note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
error: `[const]` can only be applied to `#[const_trait]` traits
- --> $DIR/fn_trait_refs.rs:14:6
+ --> $DIR/fn_trait_refs.rs:14:8
|
LL | T: [const] Fn<()> + [const] Destruct,
- | ^^^^^^^^^ can't be applied to `Fn`
+ | ^^^^^^^ can't be applied to `Fn`
|
note: `Fn` can't be used with `[const]` because it isn't annotated with `#[const_trait]`
--> $SRC_DIR/core/src/ops/function.rs:LL:COL
= note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
error: `[const]` can only be applied to `#[const_trait]` traits
- --> $DIR/fn_trait_refs.rs:21:6
+ --> $DIR/fn_trait_refs.rs:21:8
|
LL | T: [const] FnMut<()> + [const] Destruct,
- | ^^^^^^^^^ can't be applied to `FnMut`
+ | ^^^^^^^ can't be applied to `FnMut`
|
note: `FnMut` can't be used with `[const]` because it isn't annotated with `#[const_trait]`
--> $SRC_DIR/core/src/ops/function.rs:LL:COL
error: `[const]` can only be applied to `#[const_trait]` traits
- --> $DIR/fn_trait_refs.rs:21:6
+ --> $DIR/fn_trait_refs.rs:21:8
|
LL | T: [const] FnMut<()> + [const] Destruct,
- | ^^^^^^^^^ can't be applied to `FnMut`
+ | ^^^^^^^ can't be applied to `FnMut`
|
note: `FnMut` can't be used with `[const]` because it isn't annotated with `#[const_trait]`
--> $SRC_DIR/core/src/ops/function.rs:LL:COL
= note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
error: `[const]` can only be applied to `#[const_trait]` traits
- --> $DIR/fn_trait_refs.rs:21:6
+ --> $DIR/fn_trait_refs.rs:21:8
|
LL | T: [const] FnMut<()> + [const] Destruct,
- | ^^^^^^^^^ can't be applied to `FnMut`
+ | ^^^^^^^ can't be applied to `FnMut`
|
note: `FnMut` can't be used with `[const]` because it isn't annotated with `#[const_trait]`
--> $SRC_DIR/core/src/ops/function.rs:LL:COL
= note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
error: `[const]` can only be applied to `#[const_trait]` traits
- --> $DIR/fn_trait_refs.rs:28:6
+ --> $DIR/fn_trait_refs.rs:28:8
|
LL | T: [const] FnOnce<()>,
- | ^^^^^^^^^ can't be applied to `FnOnce`
+ | ^^^^^^^ can't be applied to `FnOnce`
|
note: `FnOnce` can't be used with `[const]` because it isn't annotated with `#[const_trait]`
--> $SRC_DIR/core/src/ops/function.rs:LL:COL
error: `[const]` can only be applied to `#[const_trait]` traits
- --> $DIR/fn_trait_refs.rs:28:6
+ --> $DIR/fn_trait_refs.rs:28:8
|
LL | T: [const] FnOnce<()>,
- | ^^^^^^^^^ can't be applied to `FnOnce`
+ | ^^^^^^^ can't be applied to `FnOnce`
|
note: `FnOnce` can't be used with `[const]` because it isn't annotated with `#[const_trait]`
--> $SRC_DIR/core/src/ops/function.rs:LL:COL
= note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
error: `[const]` can only be applied to `#[const_trait]` traits
- --> $DIR/fn_trait_refs.rs:28:6
+ --> $DIR/fn_trait_refs.rs:28:8
|
LL | T: [const] FnOnce<()>,
- | ^^^^^^^^^ can't be applied to `FnOnce`
+ | ^^^^^^^ can't be applied to `FnOnce`
|
note: `FnOnce` can't be used with `[const]` because it isn't annotated with `#[const_trait]`
--> $SRC_DIR/core/src/ops/function.rs:LL:COL
= note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
error: `[const]` can only be applied to `#[const_trait]` traits
- --> $DIR/fn_trait_refs.rs:35:6
+ --> $DIR/fn_trait_refs.rs:35:8
|
LL | T: [const] Fn<()> + [const] Destruct,
- | ^^^^^^^^^ can't be applied to `Fn`
+ | ^^^^^^^ can't be applied to `Fn`
|
note: `Fn` can't be used with `[const]` because it isn't annotated with `#[const_trait]`
--> $SRC_DIR/core/src/ops/function.rs:LL:COL
error: `[const]` can only be applied to `#[const_trait]` traits
- --> $DIR/fn_trait_refs.rs:35:6
+ --> $DIR/fn_trait_refs.rs:35:8
|
LL | T: [const] Fn<()> + [const] Destruct,
- | ^^^^^^^^^ can't be applied to `Fn`
+ | ^^^^^^^ can't be applied to `Fn`
|
note: `Fn` can't be used with `[const]` because it isn't annotated with `#[const_trait]`
--> $SRC_DIR/core/src/ops/function.rs:LL:COL
= note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
error: `[const]` can only be applied to `#[const_trait]` traits
- --> $DIR/fn_trait_refs.rs:35:6
+ --> $DIR/fn_trait_refs.rs:35:8
|
LL | T: [const] Fn<()> + [const] Destruct,
- | ^^^^^^^^^ can't be applied to `Fn`
+ | ^^^^^^^ can't be applied to `Fn`
|
note: `Fn` can't be used with `[const]` because it isn't annotated with `#[const_trait]`
--> $SRC_DIR/core/src/ops/function.rs:LL:COL
= note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
error: `[const]` can only be applied to `#[const_trait]` traits
- --> $DIR/fn_trait_refs.rs:49:6
+ --> $DIR/fn_trait_refs.rs:49:8
|
LL | T: [const] FnMut<()> + [const] Destruct,
- | ^^^^^^^^^ can't be applied to `FnMut`
+ | ^^^^^^^ can't be applied to `FnMut`
|
note: `FnMut` can't be used with `[const]` because it isn't annotated with `#[const_trait]`
--> $SRC_DIR/core/src/ops/function.rs:LL:COL
error: `[const]` can only be applied to `#[const_trait]` traits
- --> $DIR/fn_trait_refs.rs:49:6
+ --> $DIR/fn_trait_refs.rs:49:8
|
LL | T: [const] FnMut<()> + [const] Destruct,
- | ^^^^^^^^^ can't be applied to `FnMut`
+ | ^^^^^^^ can't be applied to `FnMut`
|
note: `FnMut` can't be used with `[const]` because it isn't annotated with `#[const_trait]`
--> $SRC_DIR/core/src/ops/function.rs:LL:COL
= note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
error: `[const]` can only be applied to `#[const_trait]` traits
- --> $DIR/fn_trait_refs.rs:49:6
+ --> $DIR/fn_trait_refs.rs:49:8
|
LL | T: [const] FnMut<()> + [const] Destruct,
- | ^^^^^^^^^ can't be applied to `FnMut`
+ | ^^^^^^^ can't be applied to `FnMut`
|
note: `FnMut` can't be used with `[const]` because it isn't annotated with `#[const_trait]`
--> $SRC_DIR/core/src/ops/function.rs:LL:COL
diff --git a/tests/ui/consts/unstable-const-fn-in-libcore.stderr b/tests/ui/consts/unstable-const-fn-in-libcore.stderr
index b43fa1f..95e48b7 100644
--- a/tests/ui/consts/unstable-const-fn-in-libcore.stderr
+++ b/tests/ui/consts/unstable-const-fn-in-libcore.stderr
@@ -1,17 +1,17 @@
error: `[const]` can only be applied to `#[const_trait]` traits
- --> $DIR/unstable-const-fn-in-libcore.rs:19:30
+ --> $DIR/unstable-const-fn-in-libcore.rs:19:32
|
LL | const fn unwrap_or_else<F: [const] FnOnce() -> T>(self, f: F) -> T {
- | ^^^^^^^^^ can't be applied to `FnOnce`
+ | ^^^^^^^ can't be applied to `FnOnce`
|
note: `FnOnce` can't be used with `[const]` because it isn't annotated with `#[const_trait]`
--> $SRC_DIR/core/src/ops/function.rs:LL:COL
error: `[const]` can only be applied to `#[const_trait]` traits
- --> $DIR/unstable-const-fn-in-libcore.rs:19:30
+ --> $DIR/unstable-const-fn-in-libcore.rs:19:32
|
LL | const fn unwrap_or_else<F: [const] FnOnce() -> T>(self, f: F) -> T {
- | ^^^^^^^^^ can't be applied to `FnOnce`
+ | ^^^^^^^ can't be applied to `FnOnce`
|
note: `FnOnce` can't be used with `[const]` because it isn't annotated with `#[const_trait]`
--> $SRC_DIR/core/src/ops/function.rs:LL:COL
diff --git a/tests/ui/derives/derive-Debug-enum-variants.rs b/tests/ui/derives/derive-Debug-enum-variants.rs
new file mode 100644
index 0000000..26f527f
--- /dev/null
+++ b/tests/ui/derives/derive-Debug-enum-variants.rs
@@ -0,0 +1,30 @@
+//! Test that `#[derive(Debug)]` for enums correctly formats variant names.
+
+//@ run-pass
+
+#[derive(Debug)]
+enum Foo {
+ A(usize),
+ C,
+}
+
+#[derive(Debug)]
+enum Bar {
+ D,
+}
+
+pub fn main() {
+ // Test variant with data
+ let foo_a = Foo::A(22);
+ assert_eq!("A(22)".to_string(), format!("{:?}", foo_a));
+
+ if let Foo::A(value) = foo_a {
+ println!("Value: {}", value); // This needs to remove #[allow(dead_code)]
+ }
+
+ // Test unit variant
+ assert_eq!("C".to_string(), format!("{:?}", Foo::C));
+
+ // Test unit variant from different enum
+ assert_eq!("D".to_string(), format!("{:?}", Bar::D));
+}
diff --git a/tests/ui/diverging-fn-tail-35849.rs b/tests/ui/diverging-fn-tail-35849.rs
deleted file mode 100644
index f21ce29..0000000
--- a/tests/ui/diverging-fn-tail-35849.rs
+++ /dev/null
@@ -1,8 +0,0 @@
-fn assert_sizeof() -> ! {
- unsafe {
- ::std::mem::transmute::<f64, [u8; 8]>(panic!())
- //~^ ERROR mismatched types
- }
-}
-
-fn main() { }
diff --git a/tests/ui/early-ret-binop-add.rs b/tests/ui/early-ret-binop-add.rs
deleted file mode 100644
index 3fec66f..0000000
--- a/tests/ui/early-ret-binop-add.rs
+++ /dev/null
@@ -1,10 +0,0 @@
-//@ run-pass
-
-#![allow(dead_code)]
-#![allow(unreachable_code)]
-
-use std::ops::Add;
-
-fn wsucc<T:Add<Output=T> + Copy>(n: T) -> T { n + { return n } }
-
-pub fn main() { }
diff --git a/tests/ui/elide-errors-on-mismatched-tuple.rs b/tests/ui/elide-errors-on-mismatched-tuple.rs
deleted file mode 100644
index 7d87b0a..0000000
--- a/tests/ui/elide-errors-on-mismatched-tuple.rs
+++ /dev/null
@@ -1,18 +0,0 @@
-// Hide irrelevant E0277 errors (#50333)
-
-trait T {}
-
-struct A;
-impl T for A {}
-impl A {
- fn new() -> Self {
- Self {}
- }
-}
-
-fn main() {
- let (a, b, c) = (A::new(), A::new()); // This tuple is 2 elements, should be three
- //~^ ERROR mismatched types
- let ts: Vec<&dyn T> = vec![&a, &b, &c];
- // There is no E0277 error above, as `a`, `b` and `c` are `TyErr`
-}
diff --git a/tests/ui/elided-test.rs b/tests/ui/elided-test.rs
deleted file mode 100644
index 2bedc25..0000000
--- a/tests/ui/elided-test.rs
+++ /dev/null
@@ -1,5 +0,0 @@
-// Since we're not compiling a test runner this function should be elided
-// and the build will fail because main doesn't exist
-#[test]
-fn main() {
-} //~ ERROR `main` function not found in crate `elided_test`
diff --git a/tests/ui/elided-test.stderr b/tests/ui/elided-test.stderr
deleted file mode 100644
index 7aebe5d..0000000
--- a/tests/ui/elided-test.stderr
+++ /dev/null
@@ -1,9 +0,0 @@
-error[E0601]: `main` function not found in crate `elided_test`
- --> $DIR/elided-test.rs:5:2
- |
-LL | }
- | ^ consider adding a `main` function to `$DIR/elided-test.rs`
-
-error: aborting due to 1 previous error
-
-For more information about this error, try `rustc --explain E0601`.
diff --git a/tests/ui/else-if.rs b/tests/ui/else-if.rs
deleted file mode 100644
index 2161b28..0000000
--- a/tests/ui/else-if.rs
+++ /dev/null
@@ -1,20 +0,0 @@
-//@ run-pass
-
-pub fn main() {
- if 1 == 2 {
- assert!((false));
- } else if 2 == 3 {
- assert!((false));
- } else if 3 == 4 { assert!((false)); } else { assert!((true)); }
- if 1 == 2 { assert!((false)); } else if 2 == 2 { assert!((true)); }
- if 1 == 2 {
- assert!((false));
- } else if 2 == 2 {
- if 1 == 1 {
- assert!((true));
- } else { if 2 == 1 { assert!((false)); } else { assert!((false)); } }
- }
- if 1 == 2 {
- assert!((false));
- } else { if 1 == 2 { assert!((false)); } else { assert!((true)); } }
-}
diff --git a/tests/ui/expr/early-return-in-binop.rs b/tests/ui/expr/early-return-in-binop.rs
new file mode 100644
index 0000000..389d252
--- /dev/null
+++ b/tests/ui/expr/early-return-in-binop.rs
@@ -0,0 +1,19 @@
+//! Test early return within binary operation expressions
+
+//@ run-pass
+
+#![allow(dead_code)]
+#![allow(unreachable_code)]
+
+use std::ops::Add;
+
+/// Function that performs addition with an early return in the right operand
+fn add_with_early_return<T: Add<Output = T> + Copy>(n: T) -> T {
+ n + { return n }
+}
+
+pub fn main() {
+ // Test with different numeric types to ensure generic behavior works
+ let _result1 = add_with_early_return(42i32);
+ let _result2 = add_with_early_return(3.14f64);
+}
diff --git a/tests/ui/extern/issue-47725.rs b/tests/ui/extern/issue-47725.rs
index 9ec55be..012673b 100644
--- a/tests/ui/extern/issue-47725.rs
+++ b/tests/ui/extern/issue-47725.rs
@@ -17,12 +17,9 @@
#[link_name]
//~^ ERROR malformed `link_name` attribute input
//~| HELP must be of the form
-//~| WARN attribute should be applied to a foreign function or static [unused_attributes]
-//~| WARN this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
-//~| HELP try `#[link(name = "...")]` instead
+//~| NOTE expected this to be of the form `link_name = "..."
extern "C" {
fn bar() -> u32;
}
-//~^^^ NOTE not a foreign function or static
fn main() {}
diff --git a/tests/ui/extern/issue-47725.stderr b/tests/ui/extern/issue-47725.stderr
index 0d3b77b..53d6b49 100644
--- a/tests/ui/extern/issue-47725.stderr
+++ b/tests/ui/extern/issue-47725.stderr
@@ -1,8 +1,11 @@
-error: malformed `link_name` attribute input
+error[E0539]: malformed `link_name` attribute input
--> $DIR/issue-47725.rs:17:1
|
LL | #[link_name]
- | ^^^^^^^^^^^^ help: must be of the form: `#[link_name = "name"]`
+ | ^^^^^^^^^^^^
+ | |
+ | expected this to be of the form `link_name = "..."`
+ | help: must be of the form: `#[link_name = "name"]`
warning: attribute should be applied to a foreign function or static
--> $DIR/issue-47725.rs:3:1
@@ -38,23 +41,6 @@
LL | #[link_name = "foobar"]
| ^^^^^^^^^^^^^^^^^^^^^^^
-warning: attribute should be applied to a foreign function or static
- --> $DIR/issue-47725.rs:17:1
- |
-LL | #[link_name]
- | ^^^^^^^^^^^^
-...
-LL | / extern "C" {
-LL | | fn bar() -> u32;
-LL | | }
- | |_- not a foreign function or static
- |
- = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
-help: try `#[link(name = "...")]` instead
- --> $DIR/issue-47725.rs:17:1
- |
-LL | #[link_name]
- | ^^^^^^^^^^^^
+error: aborting due to 1 previous error; 2 warnings emitted
-error: aborting due to 1 previous error; 3 warnings emitted
-
+For more information about this error, try `rustc --explain E0539`.
diff --git a/tests/ui/feature-gates/issue-43106-gating-of-builtin-attrs.stderr b/tests/ui/feature-gates/issue-43106-gating-of-builtin-attrs.stderr
index d2b1d71..1243ed5 100644
--- a/tests/ui/feature-gates/issue-43106-gating-of-builtin-attrs.stderr
+++ b/tests/ui/feature-gates/issue-43106-gating-of-builtin-attrs.stderr
@@ -387,14 +387,6 @@
|
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
-warning: attribute should be applied to a foreign function or static
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:66:1
- |
-LL | #![link_name = "1900"]
- | ^^^^^^^^^^^^^^^^^^^^^^ not a foreign function or static
- |
- = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
-
warning: attribute should be applied to a function or static
--> $DIR/issue-43106-gating-of-builtin-attrs.rs:69:1
|
@@ -411,6 +403,14 @@
|
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
+warning: attribute should be applied to a foreign function or static
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:66:1
+ |
+LL | #![link_name = "1900"]
+ | ^^^^^^^^^^^^^^^^^^^^^^ not a foreign function or static
+ |
+ = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
+
warning: `#[must_use]` has no effect when applied to a module
--> $DIR/issue-43106-gating-of-builtin-attrs.rs:72:1
|
diff --git a/tests/ui/logging-only-prints-once.rs b/tests/ui/fmt/debug-single-call.rs
similarity index 73%
rename from tests/ui/logging-only-prints-once.rs
rename to tests/ui/fmt/debug-single-call.rs
index bb8c296..b59a766 100644
--- a/tests/ui/logging-only-prints-once.rs
+++ b/tests/ui/fmt/debug-single-call.rs
@@ -1,9 +1,12 @@
+//! Test that Debug::fmt is called exactly once during formatting.
+//!
+//! This is a regression test for PR https://github.com/rust-lang/rust/pull/10715
+
//@ run-pass
//@ needs-threads
use std::cell::Cell;
-use std::fmt;
-use std::thread;
+use std::{fmt, thread};
struct Foo(Cell<isize>);
diff --git a/tests/ui/generics/unconstrained-type-params-inherent-impl.rs b/tests/ui/generics/unconstrained-type-params-inherent-impl.rs
new file mode 100644
index 0000000..c971de0
--- /dev/null
+++ b/tests/ui/generics/unconstrained-type-params-inherent-impl.rs
@@ -0,0 +1,32 @@
+//! Test for unconstrained type parameters in inherent implementations
+
+struct MyType;
+
+struct MyType1<T>(T);
+
+trait Bar {
+ type Out;
+}
+
+impl<T> MyType {
+ //~^ ERROR the type parameter `T` is not constrained
+ // T is completely unused - this should fail
+}
+
+impl<T> MyType1<T> {
+ // OK: T is used in the self type `MyType1<T>`
+}
+
+impl<T, U> MyType1<T> {
+ //~^ ERROR the type parameter `U` is not constrained
+ // T is used in self type, but U is unconstrained - this should fail
+}
+
+impl<T, U> MyType1<T>
+where
+ T: Bar<Out = U>,
+{
+ // OK: T is used in self type, U is constrained through the where clause
+}
+
+fn main() {}
diff --git a/tests/ui/impl-unused-tps-inherent.stderr b/tests/ui/generics/unconstrained-type-params-inherent-impl.stderr
similarity index 66%
rename from tests/ui/impl-unused-tps-inherent.stderr
rename to tests/ui/generics/unconstrained-type-params-inherent-impl.stderr
index 43f63cf..19b02ad 100644
--- a/tests/ui/impl-unused-tps-inherent.stderr
+++ b/tests/ui/generics/unconstrained-type-params-inherent-impl.stderr
@@ -1,14 +1,14 @@
error[E0207]: the type parameter `T` is not constrained by the impl trait, self type, or predicates
- --> $DIR/impl-unused-tps-inherent.rs:9:6
+ --> $DIR/unconstrained-type-params-inherent-impl.rs:11:6
|
LL | impl<T> MyType {
| ^ unconstrained type parameter
error[E0207]: the type parameter `U` is not constrained by the impl trait, self type, or predicates
- --> $DIR/impl-unused-tps-inherent.rs:17:8
+ --> $DIR/unconstrained-type-params-inherent-impl.rs:20:9
|
-LL | impl<T,U> MyType1<T> {
- | ^ unconstrained type parameter
+LL | impl<T, U> MyType1<T> {
+ | ^ unconstrained type parameter
error: aborting due to 2 previous errors
diff --git a/tests/ui/impl-trait/normalize-tait-in-const.stderr b/tests/ui/impl-trait/normalize-tait-in-const.stderr
index 01427c7..e17737d 100644
--- a/tests/ui/impl-trait/normalize-tait-in-const.stderr
+++ b/tests/ui/impl-trait/normalize-tait-in-const.stderr
@@ -1,17 +1,17 @@
error: `[const]` can only be applied to `#[const_trait]` traits
- --> $DIR/normalize-tait-in-const.rs:27:33
+ --> $DIR/normalize-tait-in-const.rs:27:35
|
LL | const fn with_positive<F: for<'a> [const] Fn(&'a Alias<'a>) + [const] Destruct>(fun: F) {
- | ^^^^^^^^^ can't be applied to `Fn`
+ | ^^^^^^^ can't be applied to `Fn`
|
note: `Fn` can't be used with `[const]` because it isn't annotated with `#[const_trait]`
--> $SRC_DIR/core/src/ops/function.rs:LL:COL
error: `[const]` can only be applied to `#[const_trait]` traits
- --> $DIR/normalize-tait-in-const.rs:27:33
+ --> $DIR/normalize-tait-in-const.rs:27:35
|
LL | const fn with_positive<F: for<'a> [const] Fn(&'a Alias<'a>) + [const] Destruct>(fun: F) {
- | ^^^^^^^^^ can't be applied to `Fn`
+ | ^^^^^^^ can't be applied to `Fn`
|
note: `Fn` can't be used with `[const]` because it isn't annotated with `#[const_trait]`
--> $SRC_DIR/core/src/ops/function.rs:LL:COL
diff --git a/tests/ui/impl-unused-rps-in-assoc-type.rs b/tests/ui/impl-unused-rps-in-assoc-type.rs
deleted file mode 100644
index ea41997..0000000
--- a/tests/ui/impl-unused-rps-in-assoc-type.rs
+++ /dev/null
@@ -1,18 +0,0 @@
-// Test that lifetime parameters must be constrained if they appear in
-// an associated type def'n. Issue #22077.
-
-trait Fun {
- type Output;
- fn call<'x>(&'x self) -> Self::Output;
-}
-
-struct Holder { x: String }
-
-impl<'a> Fun for Holder { //~ ERROR E0207
- type Output = &'a str;
- fn call<'b>(&'b self) -> &'b str {
- &self.x[..]
- }
-}
-
-fn main() { }
diff --git a/tests/ui/impl-unused-tps-inherent.rs b/tests/ui/impl-unused-tps-inherent.rs
deleted file mode 100644
index 83a228e..0000000
--- a/tests/ui/impl-unused-tps-inherent.rs
+++ /dev/null
@@ -1,25 +0,0 @@
-struct MyType;
-
-struct MyType1<T>(T);
-
-trait Bar {
- type Out;
-}
-
-impl<T> MyType {
- //~^ ERROR the type parameter `T` is not constrained
-}
-
-impl<T> MyType1<T> {
- // OK, T is used in `Foo<T>`.
-}
-
-impl<T,U> MyType1<T> {
- //~^ ERROR the type parameter `U` is not constrained
-}
-
-impl<T,U> MyType1<T> where T: Bar<Out=U> {
- // OK, T is used in `Foo<T>`.
-}
-
-fn main() { }
diff --git a/tests/ui/impl-unused-tps.rs b/tests/ui/impl-unused-tps.rs
deleted file mode 100644
index a5836db..0000000
--- a/tests/ui/impl-unused-tps.rs
+++ /dev/null
@@ -1,69 +0,0 @@
-trait Foo<A> {
- fn get(&self, A: &A) {}
-}
-
-trait Bar {
- type Out;
-}
-
-impl<T> Foo<T> for [isize; 0] {
- // OK, T is used in `Foo<T>`.
-}
-
-impl<T, U> Foo<T> for [isize; 1] {
- //~^ ERROR the type parameter `U` is not constrained
-}
-
-impl<T, U> Foo<T> for [isize; 2]
-where
- T: Bar<Out = U>,
-{
- // OK, `U` is now constrained by the output type parameter.
-}
-
-impl<T: Bar<Out = U>, U> Foo<T> for [isize; 3] {
- // OK, same as above but written differently.
-}
-
-impl<T, U> Foo<T> for U {
- //~^ ERROR conflicting implementations of trait `Foo<_>` for type `[isize; 0]`
-}
-
-impl<T, U> Bar for T {
- //~^ ERROR the type parameter `U` is not constrained
-
- type Out = U;
-
- // Using `U` in an associated type within the impl is not good enough!
-}
-
-impl<T, U> Bar for T
-where
- T: Bar<Out = U>,
-{
- //~^^^^ ERROR the type parameter `U` is not constrained by the impl trait, self type, or predicates
- //~| ERROR conflicting implementations of trait `Bar`
- // This crafty self-referential attempt is still no good.
-}
-
-impl<T, U, V> Foo<T> for T
-where
- (T, U): Bar<Out = V>,
-{
- //~^^^^ ERROR the type parameter `U` is not constrained
- //~| ERROR the type parameter `V` is not constrained
- //~| ERROR conflicting implementations of trait `Foo<[isize; 0]>` for type `[isize; 0]`
-
- // Here, `V` is bound by an output type parameter, but the inputs
- // are not themselves constrained.
-}
-
-impl<T, U, V> Foo<(T, U)> for T
-where
- (T, U): Bar<Out = V>,
-{
- //~^^^^ ERROR conflicting implementations of trait `Foo<([isize; 0], _)>` for type `[isize; 0]`
- // As above, but both T and U ARE constrained.
-}
-
-fn main() {}
diff --git a/tests/ui/implicit-method-bind.rs b/tests/ui/implicit-method-bind.rs
deleted file mode 100644
index 5e27516..0000000
--- a/tests/ui/implicit-method-bind.rs
+++ /dev/null
@@ -1,3 +0,0 @@
-fn main() {
- let _f = 10i32.abs; //~ ERROR attempted to take value of method
-}
diff --git a/tests/ui/implicit-method-bind.stderr b/tests/ui/implicit-method-bind.stderr
deleted file mode 100644
index e935711..0000000
--- a/tests/ui/implicit-method-bind.stderr
+++ /dev/null
@@ -1,14 +0,0 @@
-error[E0615]: attempted to take value of method `abs` on type `i32`
- --> $DIR/implicit-method-bind.rs:2:20
- |
-LL | let _f = 10i32.abs;
- | ^^^ method, not a field
- |
-help: use parentheses to call the method
- |
-LL | let _f = 10i32.abs();
- | ++
-
-error: aborting due to 1 previous error
-
-For more information about this error, try `rustc --explain E0615`.
diff --git a/tests/ui/double-type-import.rs b/tests/ui/imports/duplicate-use-bindings.rs
similarity index 72%
rename from tests/ui/double-type-import.rs
rename to tests/ui/imports/duplicate-use-bindings.rs
index 6b1eb65..8cec23e 100644
--- a/tests/ui/double-type-import.rs
+++ b/tests/ui/imports/duplicate-use-bindings.rs
@@ -1,3 +1,5 @@
+//! Test that duplicate use bindings in same namespace produce error
+
mod foo {
pub use self::bar::X;
use self::bar::X;
diff --git a/tests/ui/double-type-import.stderr b/tests/ui/imports/duplicate-use-bindings.stderr
similarity index 90%
rename from tests/ui/double-type-import.stderr
rename to tests/ui/imports/duplicate-use-bindings.stderr
index 8a8fe05..1d4f1fc 100644
--- a/tests/ui/double-type-import.stderr
+++ b/tests/ui/imports/duplicate-use-bindings.stderr
@@ -1,5 +1,5 @@
error[E0252]: the name `X` is defined multiple times
- --> $DIR/double-type-import.rs:3:9
+ --> $DIR/duplicate-use-bindings.rs:5:9
|
LL | pub use self::bar::X;
| ------------ previous import of the type `X` here
diff --git a/tests/ui/indexing/indexing-integral-types.rs b/tests/ui/indexing/indexing-integral-types.rs
new file mode 100644
index 0000000..a91696a
--- /dev/null
+++ b/tests/ui/indexing/indexing-integral-types.rs
@@ -0,0 +1,20 @@
+//! Test that only usize can be used for indexing arrays and slices.
+
+pub fn main() {
+ let v: Vec<isize> = vec![0, 1, 2, 3, 4, 5];
+ let s: String = "abcdef".to_string();
+
+ // Valid indexing with usize
+ v[3_usize];
+ v[3];
+ v[3u8]; //~ ERROR the type `[isize]` cannot be indexed by `u8`
+ v[3i8]; //~ ERROR the type `[isize]` cannot be indexed by `i8`
+ v[3u32]; //~ ERROR the type `[isize]` cannot be indexed by `u32`
+ v[3i32]; //~ ERROR the type `[isize]` cannot be indexed by `i32`
+ s.as_bytes()[3_usize];
+ s.as_bytes()[3];
+ s.as_bytes()[3u8]; //~ ERROR the type `[u8]` cannot be indexed by `u8`
+ s.as_bytes()[3i8]; //~ ERROR the type `[u8]` cannot be indexed by `i8`
+ s.as_bytes()[3u32]; //~ ERROR the type `[u8]` cannot be indexed by `u32`
+ s.as_bytes()[3i32]; //~ ERROR the type `[u8]` cannot be indexed by `i32`
+}
diff --git a/tests/ui/integral-indexing.stderr b/tests/ui/indexing/indexing-integral-types.stderr
similarity index 91%
rename from tests/ui/integral-indexing.stderr
rename to tests/ui/indexing/indexing-integral-types.stderr
index 26253e0..b63991e 100644
--- a/tests/ui/integral-indexing.stderr
+++ b/tests/ui/indexing/indexing-integral-types.stderr
@@ -1,5 +1,5 @@
error[E0277]: the type `[isize]` cannot be indexed by `u8`
- --> $DIR/integral-indexing.rs:6:7
+ --> $DIR/indexing-integral-types.rs:10:7
|
LL | v[3u8];
| ^^^ slice indices are of type `usize` or ranges of `usize`
@@ -11,7 +11,7 @@
= note: required for `Vec<isize>` to implement `Index<u8>`
error[E0277]: the type `[isize]` cannot be indexed by `i8`
- --> $DIR/integral-indexing.rs:7:7
+ --> $DIR/indexing-integral-types.rs:11:7
|
LL | v[3i8];
| ^^^ slice indices are of type `usize` or ranges of `usize`
@@ -23,7 +23,7 @@
= note: required for `Vec<isize>` to implement `Index<i8>`
error[E0277]: the type `[isize]` cannot be indexed by `u32`
- --> $DIR/integral-indexing.rs:8:7
+ --> $DIR/indexing-integral-types.rs:12:7
|
LL | v[3u32];
| ^^^^ slice indices are of type `usize` or ranges of `usize`
@@ -35,7 +35,7 @@
= note: required for `Vec<isize>` to implement `Index<u32>`
error[E0277]: the type `[isize]` cannot be indexed by `i32`
- --> $DIR/integral-indexing.rs:9:7
+ --> $DIR/indexing-integral-types.rs:13:7
|
LL | v[3i32];
| ^^^^ slice indices are of type `usize` or ranges of `usize`
@@ -47,7 +47,7 @@
= note: required for `Vec<isize>` to implement `Index<i32>`
error[E0277]: the type `[u8]` cannot be indexed by `u8`
- --> $DIR/integral-indexing.rs:12:18
+ --> $DIR/indexing-integral-types.rs:16:18
|
LL | s.as_bytes()[3u8];
| ^^^ slice indices are of type `usize` or ranges of `usize`
@@ -59,7 +59,7 @@
= note: required for `[u8]` to implement `Index<u8>`
error[E0277]: the type `[u8]` cannot be indexed by `i8`
- --> $DIR/integral-indexing.rs:13:18
+ --> $DIR/indexing-integral-types.rs:17:18
|
LL | s.as_bytes()[3i8];
| ^^^ slice indices are of type `usize` or ranges of `usize`
@@ -71,7 +71,7 @@
= note: required for `[u8]` to implement `Index<i8>`
error[E0277]: the type `[u8]` cannot be indexed by `u32`
- --> $DIR/integral-indexing.rs:14:18
+ --> $DIR/indexing-integral-types.rs:18:18
|
LL | s.as_bytes()[3u32];
| ^^^^ slice indices are of type `usize` or ranges of `usize`
@@ -83,7 +83,7 @@
= note: required for `[u8]` to implement `Index<u32>`
error[E0277]: the type `[u8]` cannot be indexed by `i32`
- --> $DIR/integral-indexing.rs:15:18
+ --> $DIR/indexing-integral-types.rs:19:18
|
LL | s.as_bytes()[3i32];
| ^^^^ slice indices are of type `usize` or ranges of `usize`
diff --git a/tests/ui/inline-disallow-on-variant.rs b/tests/ui/inline-disallow-on-variant.rs
deleted file mode 100644
index d92a4e8..0000000
--- a/tests/ui/inline-disallow-on-variant.rs
+++ /dev/null
@@ -1,7 +0,0 @@
-enum Foo {
- #[inline]
- //~^ ERROR attribute should be applied
- Variant,
-}
-
-fn main() {}
diff --git a/tests/ui/inlined-main.rs b/tests/ui/inlined-main.rs
deleted file mode 100644
index 731ac0d..0000000
--- a/tests/ui/inlined-main.rs
+++ /dev/null
@@ -1,4 +0,0 @@
-//@ run-pass
-
-#[inline(always)]
-fn main() {}
diff --git a/tests/ui/inner-attrs-on-impl.rs b/tests/ui/inner-attrs-on-impl.rs
deleted file mode 100644
index 1dce1cd..0000000
--- a/tests/ui/inner-attrs-on-impl.rs
+++ /dev/null
@@ -1,24 +0,0 @@
-//@ run-pass
-
-struct Foo;
-
-impl Foo {
- #![cfg(false)]
-
- fn method(&self) -> bool { false }
-}
-
-impl Foo {
- #![cfg(not(FALSE))]
-
- // check that we don't eat attributes too eagerly.
- #[cfg(false)]
- fn method(&self) -> bool { false }
-
- fn method(&self) -> bool { true }
-}
-
-
-pub fn main() {
- assert!(Foo.method());
-}
diff --git a/tests/ui/inner-module.rs b/tests/ui/inner-module.rs
deleted file mode 100644
index 111f2ca..0000000
--- a/tests/ui/inner-module.rs
+++ /dev/null
@@ -1,10 +0,0 @@
-//@ run-pass
-
-mod inner {
- pub mod inner2 {
- pub fn hello() { println!("hello, modular world"); }
- }
- pub fn hello() { inner2::hello(); }
-}
-
-pub fn main() { inner::hello(); inner::inner2::hello(); }
diff --git a/tests/ui/inner-static-type-parameter.rs b/tests/ui/inner-static-type-parameter.rs
deleted file mode 100644
index a1994e7..0000000
--- a/tests/ui/inner-static-type-parameter.rs
+++ /dev/null
@@ -1,11 +0,0 @@
-// see #9186
-
-enum Bar<T> { What } //~ ERROR parameter `T` is never used
-
-fn foo<T>() {
- static a: Bar<T> = Bar::What;
-//~^ ERROR can't use generic parameters from outer item
-}
-
-fn main() {
-}
diff --git a/tests/ui/integral-indexing.rs b/tests/ui/integral-indexing.rs
deleted file mode 100644
index e20553a..0000000
--- a/tests/ui/integral-indexing.rs
+++ /dev/null
@@ -1,16 +0,0 @@
-pub fn main() {
- let v: Vec<isize> = vec![0, 1, 2, 3, 4, 5];
- let s: String = "abcdef".to_string();
- v[3_usize];
- v[3];
- v[3u8]; //~ ERROR the type `[isize]` cannot be indexed by `u8`
- v[3i8]; //~ ERROR the type `[isize]` cannot be indexed by `i8`
- v[3u32]; //~ ERROR the type `[isize]` cannot be indexed by `u32`
- v[3i32]; //~ ERROR the type `[isize]` cannot be indexed by `i32`
- s.as_bytes()[3_usize];
- s.as_bytes()[3];
- s.as_bytes()[3u8]; //~ ERROR the type `[u8]` cannot be indexed by `u8`
- s.as_bytes()[3i8]; //~ ERROR the type `[u8]` cannot be indexed by `i8`
- s.as_bytes()[3u32]; //~ ERROR the type `[u8]` cannot be indexed by `u32`
- s.as_bytes()[3i32]; //~ ERROR the type `[u8]` cannot be indexed by `i32`
-}
diff --git a/tests/ui/invalid_dispatch_from_dyn_impls.rs b/tests/ui/invalid_dispatch_from_dyn_impls.rs
deleted file mode 100644
index b1d4b26..0000000
--- a/tests/ui/invalid_dispatch_from_dyn_impls.rs
+++ /dev/null
@@ -1,55 +0,0 @@
-#![feature(unsize, dispatch_from_dyn)]
-
-use std::{
- ops::DispatchFromDyn,
- marker::{Unsize, PhantomData},
-};
-
-struct WrapperWithExtraField<T>(T, i32);
-
-impl<T, U> DispatchFromDyn<WrapperWithExtraField<U>> for WrapperWithExtraField<T>
-//~^ ERROR [E0378]
-where
- T: DispatchFromDyn<U>,
-{}
-
-
-struct MultiplePointers<T: ?Sized>{
- ptr1: *const T,
- ptr2: *const T,
-}
-
-impl<T: ?Sized, U: ?Sized> DispatchFromDyn<MultiplePointers<U>> for MultiplePointers<T>
-//~^ ERROR implementing `DispatchFromDyn` does not allow multiple fields to be coerced
-where
- T: Unsize<U>,
-{}
-
-
-struct NothingToCoerce<T: ?Sized> {
- data: PhantomData<T>,
-}
-
-impl<T: ?Sized, U: ?Sized> DispatchFromDyn<NothingToCoerce<T>> for NothingToCoerce<U> {}
-//~^ ERROR implementing `DispatchFromDyn` requires a field to be coerced
-
-#[repr(C)]
-struct HasReprC<T: ?Sized>(Box<T>);
-
-impl<T: ?Sized, U: ?Sized> DispatchFromDyn<HasReprC<U>> for HasReprC<T>
-//~^ ERROR [E0378]
-where
- T: Unsize<U>,
-{}
-
-#[repr(align(64))]
-struct OverAlignedZst;
-struct OverAligned<T: ?Sized>(Box<T>, OverAlignedZst);
-
-impl<T: ?Sized, U: ?Sized> DispatchFromDyn<OverAligned<U>> for OverAligned<T>
-//~^ ERROR [E0378]
- where
- T: Unsize<U>,
-{}
-
-fn main() {}
diff --git a/tests/ui/lexical-scoping.rs b/tests/ui/lexical-scoping.rs
deleted file mode 100644
index f858369..0000000
--- a/tests/ui/lexical-scoping.rs
+++ /dev/null
@@ -1,19 +0,0 @@
-//@ run-pass
-// Tests that items in subscopes can shadow type parameters and local variables (see issue #23880).
-
-#![allow(unused)]
-struct Foo<X> { x: Box<X> }
-impl<Bar> Foo<Bar> {
- fn foo(&self) {
- type Bar = i32;
- let _: Bar = 42;
- }
-}
-
-fn main() {
- let f = 1;
- {
- fn f() {}
- f();
- }
-}
diff --git a/tests/ui/link-section.rs b/tests/ui/linkage-attr/link-section-placement.rs
similarity index 92%
rename from tests/ui/link-section.rs
rename to tests/ui/linkage-attr/link-section-placement.rs
index a8de8c2..6a143bf 100644
--- a/tests/ui/link-section.rs
+++ b/tests/ui/linkage-attr/link-section-placement.rs
@@ -1,8 +1,9 @@
+//! Test placement of functions and statics in custom link sections
+
//@ run-pass
// FIXME(static_mut_refs): Do not allow `static_mut_refs` lint
#![allow(static_mut_refs)]
-
#![allow(non_upper_case_globals)]
#[cfg(not(target_vendor = "apple"))]
#[link_section = ".moretext"]
diff --git a/tests/ui/lint/unused/must-use-macros.fixed b/tests/ui/lint/unused/must-use-macros.fixed
new file mode 100644
index 0000000..609d0c6
--- /dev/null
+++ b/tests/ui/lint/unused/must-use-macros.fixed
@@ -0,0 +1,60 @@
+// Makes sure the suggestions of the `unused_must_use` lint are not inside
+//
+// See <https://github.com/rust-lang/rust/issues/143025>
+
+//@ check-pass
+//@ run-rustfix
+
+#![expect(unused_macros)]
+#![warn(unused_must_use)]
+
+fn main() {
+ {
+ macro_rules! cmp {
+ ($a:tt, $b:tt) => {
+ $a == $b
+ };
+ }
+
+ // FIXME(Urgau): For some unknown reason the spans we get are not
+ // recorded to be from any expansions, preventing us from either
+ // suggesting in front of the macro or not at all.
+ // cmp!(1, 1);
+ }
+
+ {
+ macro_rules! cmp {
+ ($a:ident, $b:ident) => {
+ $a == $b
+ }; //~^ WARN unused comparison that must be used
+ }
+
+ let a = 1;
+ let b = 1;
+ let _ = cmp!(a, b);
+ //~^ SUGGESTION let _
+ }
+
+ {
+ macro_rules! cmp {
+ ($a:expr, $b:expr) => {
+ $a == $b
+ }; //~^ WARN unused comparison that must be used
+ }
+
+ let _ = cmp!(1, 1);
+ //~^ SUGGESTION let _
+ }
+
+ {
+ macro_rules! cmp {
+ ($a:tt, $b:tt) => {
+ $a.eq(&$b)
+ };
+ }
+
+ let _ = cmp!(1, 1);
+ //~^ WARN unused return value
+ //~| SUGGESTION let _
+ }
+}
diff --git a/tests/ui/lint/unused/must-use-macros.rs b/tests/ui/lint/unused/must-use-macros.rs
new file mode 100644
index 0000000..63e246e
--- /dev/null
+++ b/tests/ui/lint/unused/must-use-macros.rs
@@ -0,0 +1,60 @@
+// Makes sure the suggestions of the `unused_must_use` lint are not inside
+//
+// See <https://github.com/rust-lang/rust/issues/143025>
+
+//@ check-pass
+//@ run-rustfix
+
+#![expect(unused_macros)]
+#![warn(unused_must_use)]
+
+fn main() {
+ {
+ macro_rules! cmp {
+ ($a:tt, $b:tt) => {
+ $a == $b
+ };
+ }
+
+ // FIXME(Urgau): For some unknown reason the spans we get are not
+ // recorded to be from any expansions, preventing us from either
+ // suggesting in front of the macro or not at all.
+ // cmp!(1, 1);
+ }
+
+ {
+ macro_rules! cmp {
+ ($a:ident, $b:ident) => {
+ $a == $b
+ }; //~^ WARN unused comparison that must be used
+ }
+
+ let a = 1;
+ let b = 1;
+ cmp!(a, b);
+ //~^ SUGGESTION let _
+ }
+
+ {
+ macro_rules! cmp {
+ ($a:expr, $b:expr) => {
+ $a == $b
+ }; //~^ WARN unused comparison that must be used
+ }
+
+ cmp!(1, 1);
+ //~^ SUGGESTION let _
+ }
+
+ {
+ macro_rules! cmp {
+ ($a:tt, $b:tt) => {
+ $a.eq(&$b)
+ };
+ }
+
+ cmp!(1, 1);
+ //~^ WARN unused return value
+ //~| SUGGESTION let _
+ }
+}
diff --git a/tests/ui/lint/unused/must-use-macros.stderr b/tests/ui/lint/unused/must-use-macros.stderr
new file mode 100644
index 0000000..2ad174e
--- /dev/null
+++ b/tests/ui/lint/unused/must-use-macros.stderr
@@ -0,0 +1,48 @@
+warning: unused comparison that must be used
+ --> $DIR/must-use-macros.rs:28:17
+ |
+LL | $a == $b
+ | ^^^^^^^^ the comparison produces a value
+...
+LL | cmp!(a, b);
+ | ---------- in this macro invocation
+ |
+note: the lint level is defined here
+ --> $DIR/must-use-macros.rs:9:9
+ |
+LL | #![warn(unused_must_use)]
+ | ^^^^^^^^^^^^^^^
+ = note: this warning originates in the macro `cmp` (in Nightly builds, run with -Z macro-backtrace for more info)
+help: use `let _ = ...` to ignore the resulting value
+ |
+LL | let _ = cmp!(a, b);
+ | +++++++
+
+warning: unused comparison that must be used
+ --> $DIR/must-use-macros.rs:41:17
+ |
+LL | $a == $b
+ | ^^^^^^^^ the comparison produces a value
+...
+LL | cmp!(1, 1);
+ | ---------- in this macro invocation
+ |
+ = note: this warning originates in the macro `cmp` (in Nightly builds, run with -Z macro-backtrace for more info)
+help: use `let _ = ...` to ignore the resulting value
+ |
+LL | let _ = cmp!(1, 1);
+ | +++++++
+
+warning: unused return value of `std::cmp::PartialEq::eq` that must be used
+ --> $DIR/must-use-macros.rs:56:9
+ |
+LL | cmp!(1, 1);
+ | ^^^^^^^^^^
+ |
+help: use `let _ = ...` to ignore the resulting value
+ |
+LL | let _ = cmp!(1, 1);
+ | +++++++
+
+warning: 3 warnings emitted
+
diff --git a/tests/ui/lint/unused/unused-attr-duplicate.stderr b/tests/ui/lint/unused/unused-attr-duplicate.stderr
index a185811..e845246 100644
--- a/tests/ui/lint/unused/unused-attr-duplicate.stderr
+++ b/tests/ui/lint/unused/unused-attr-duplicate.stderr
@@ -90,19 +90,6 @@
| ^^^^^^^^^^^^^^^^^^^^^^^^
error: unused attribute
- --> $DIR/unused-attr-duplicate.rs:86:5
- |
-LL | #[link_name = "this_does_not_exist"]
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: remove this attribute
- |
-note: attribute also specified here
- --> $DIR/unused-attr-duplicate.rs:88:5
- |
-LL | #[link_name = "rust_dbg_extern_identity_u32"]
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
- = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
-
-error: unused attribute
--> $DIR/unused-attr-duplicate.rs:14:1
|
LL | #![crate_name = "unused_attr_duplicate2"]
@@ -253,6 +240,19 @@
| ^^^^^^^^^^^^^^^
error: unused attribute
+ --> $DIR/unused-attr-duplicate.rs:86:5
+ |
+LL | #[link_name = "this_does_not_exist"]
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: remove this attribute
+ |
+note: attribute also specified here
+ --> $DIR/unused-attr-duplicate.rs:88:5
+ |
+LL | #[link_name = "rust_dbg_extern_identity_u32"]
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+ = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
+
+error: unused attribute
--> $DIR/unused-attr-duplicate.rs:92:1
|
LL | #[export_name = "exported_symbol_name"]
diff --git a/tests/ui/log-err-phi.rs b/tests/ui/log-err-phi.rs
deleted file mode 100644
index 1bb9775..0000000
--- a/tests/ui/log-err-phi.rs
+++ /dev/null
@@ -1,7 +0,0 @@
-//@ run-pass
-
-pub fn main() {
- if false {
- println!("{}", "foobar");
- }
-}
diff --git a/tests/ui/log-knows-the-names-of-variants.rs b/tests/ui/log-knows-the-names-of-variants.rs
deleted file mode 100644
index cb82cb4..0000000
--- a/tests/ui/log-knows-the-names-of-variants.rs
+++ /dev/null
@@ -1,21 +0,0 @@
-//@ run-pass
-
-#![allow(non_camel_case_types)]
-#![allow(dead_code)]
-#[derive(Debug)]
-enum foo {
- a(usize),
- b(String),
- c,
-}
-
-#[derive(Debug)]
-enum bar {
- d, e, f
-}
-
-pub fn main() {
- assert_eq!("a(22)".to_string(), format!("{:?}", foo::a(22)));
- assert_eq!("c".to_string(), format!("{:?}", foo::c));
- assert_eq!("d".to_string(), format!("{:?}", bar::d));
-}
diff --git a/tests/ui/loud_ui.rs b/tests/ui/loud_ui.rs
deleted file mode 100644
index 2a73e49..0000000
--- a/tests/ui/loud_ui.rs
+++ /dev/null
@@ -1,6 +0,0 @@
-//@ should-fail
-
-// this test ensures that when we forget to use
-// any `//~ ERROR` comments whatsoever, that the test doesn't succeed
-
-fn main() {}
diff --git a/tests/ui/macros/must-use-in-macro-55516.stderr b/tests/ui/macros/must-use-in-macro-55516.stderr
index 7bf4aaa..b93d40d 100644
--- a/tests/ui/macros/must-use-in-macro-55516.stderr
+++ b/tests/ui/macros/must-use-in-macro-55516.stderr
@@ -7,7 +7,10 @@
= note: this `Result` may be an `Err` variant, which should be handled
= note: `-W unused-must-use` implied by `-W unused`
= help: to override `-W unused` add `#[allow(unused_must_use)]`
- = note: this warning originates in the macro `write` (in Nightly builds, run with -Z macro-backtrace for more info)
+help: use `let _ = ...` to ignore the resulting value
+ |
+LL | let _ = write!(&mut example, "{}", 42);
+ | +++++++
warning: 1 warning emitted
diff --git a/tests/ui/methods/method-missing-call.rs b/tests/ui/methods/method-missing-call.rs
deleted file mode 100644
index 7ce1e9a..0000000
--- a/tests/ui/methods/method-missing-call.rs
+++ /dev/null
@@ -1,30 +0,0 @@
-// Tests to make sure that parens are needed for method calls without arguments.
-// outputs text to make sure either an anonymous function is provided or
-// open-close '()' parens are given
-
-
-struct Point {
- x: isize,
- y: isize
-}
-impl Point {
- fn new() -> Point {
- Point{x:0, y:0}
- }
- fn get_x(&self) -> isize {
- self.x
- }
-}
-
-fn main() {
- let point: Point = Point::new();
- let px: isize = point
- .get_x;//~ ERROR attempted to take value of method `get_x` on type `Point`
-
- // Ensure the span is useful
- let ys = &[1,2,3,4,5,6,7];
- let a = ys.iter()
- .map(|x| x)
- .filter(|&&x| x == 1)
- .filter_map; //~ ERROR attempted to take value of method `filter_map` on type
-}
diff --git a/tests/ui/methods/method-missing-call.stderr b/tests/ui/methods/method-missing-call.stderr
deleted file mode 100644
index bc50846..0000000
--- a/tests/ui/methods/method-missing-call.stderr
+++ /dev/null
@@ -1,25 +0,0 @@
-error[E0615]: attempted to take value of method `get_x` on type `Point`
- --> $DIR/method-missing-call.rs:22:26
- |
-LL | .get_x;
- | ^^^^^ method, not a field
- |
-help: use parentheses to call the method
- |
-LL | .get_x();
- | ++
-
-error[E0615]: attempted to take value of method `filter_map` on type `Filter<Map<std::slice::Iter<'_, {integer}>, {closure@$DIR/method-missing-call.rs:27:20: 27:23}>, {closure@$DIR/method-missing-call.rs:28:23: 28:28}>`
- --> $DIR/method-missing-call.rs:29:16
- |
-LL | .filter_map;
- | ^^^^^^^^^^ method, not a field
- |
-help: use parentheses to call the method
- |
-LL | .filter_map(_);
- | +++
-
-error: aborting due to 2 previous errors
-
-For more information about this error, try `rustc --explain E0615`.
diff --git a/tests/ui/methods/method-value-without-call.rs b/tests/ui/methods/method-value-without-call.rs
new file mode 100644
index 0000000..43bee48
--- /dev/null
+++ b/tests/ui/methods/method-value-without-call.rs
@@ -0,0 +1,33 @@
+//! Test taking a method value without parentheses
+
+struct Point {
+ x: isize,
+ y: isize,
+}
+
+impl Point {
+ fn new() -> Point {
+ Point { x: 0, y: 0 }
+ }
+
+ fn get_x(&self) -> isize {
+ self.x
+ }
+}
+
+fn main() {
+ // Test with primitive type method
+ let _f = 10i32.abs; //~ ERROR attempted to take value of method
+
+ // Test with custom type method
+ let point: Point = Point::new();
+ let px: isize = point.get_x; //~ ERROR attempted to take value of method `get_x` on type `Point`
+
+ // Test with method chains - ensure the span is useful
+ let ys = &[1, 2, 3, 4, 5, 6, 7];
+ let a = ys
+ .iter()
+ .map(|x| x)
+ .filter(|&&x| x == 1)
+ .filter_map; //~ ERROR attempted to take value of method `filter_map` on type
+}
diff --git a/tests/ui/methods/method-value-without-call.stderr b/tests/ui/methods/method-value-without-call.stderr
new file mode 100644
index 0000000..0c3870e
--- /dev/null
+++ b/tests/ui/methods/method-value-without-call.stderr
@@ -0,0 +1,36 @@
+error[E0615]: attempted to take value of method `abs` on type `i32`
+ --> $DIR/method-value-without-call.rs:20:20
+ |
+LL | let _f = 10i32.abs;
+ | ^^^ method, not a field
+ |
+help: use parentheses to call the method
+ |
+LL | let _f = 10i32.abs();
+ | ++
+
+error[E0615]: attempted to take value of method `get_x` on type `Point`
+ --> $DIR/method-value-without-call.rs:24:27
+ |
+LL | let px: isize = point.get_x;
+ | ^^^^^ method, not a field
+ |
+help: use parentheses to call the method
+ |
+LL | let px: isize = point.get_x();
+ | ++
+
+error[E0615]: attempted to take value of method `filter_map` on type `Filter<Map<std::slice::Iter<'_, {integer}>, {closure@$DIR/method-value-without-call.rs:30:14: 30:17}>, {closure@$DIR/method-value-without-call.rs:31:17: 31:22}>`
+ --> $DIR/method-value-without-call.rs:32:10
+ |
+LL | .filter_map;
+ | ^^^^^^^^^^ method, not a field
+ |
+help: use parentheses to call the method
+ |
+LL | .filter_map(_);
+ | +++
+
+error: aborting due to 3 previous errors
+
+For more information about this error, try `rustc --explain E0615`.
diff --git a/tests/ui/mismatched_types/elide-on-tuple-mismatch.rs b/tests/ui/mismatched_types/elide-on-tuple-mismatch.rs
new file mode 100644
index 0000000..c36d041
--- /dev/null
+++ b/tests/ui/mismatched_types/elide-on-tuple-mismatch.rs
@@ -0,0 +1,25 @@
+//! Regression test for issue #50333: elide irrelevant E0277 errors on tuple mismatch
+
+// Hide irrelevant E0277 errors (#50333)
+
+trait T {}
+
+struct A;
+
+impl T for A {}
+
+impl A {
+ fn new() -> Self {
+ Self {}
+ }
+}
+
+fn main() {
+ // This creates a tuple type mismatch: 2-element tuple destructured into 3 variables
+ let (a, b, c) = (A::new(), A::new());
+ //~^ ERROR mismatched types
+
+ // This line should NOT produce an E0277 error about `Sized` trait bounds,
+ // because `a`, `b`, and `c` are `TyErr` due to the mismatch above
+ let _ts: Vec<&dyn T> = vec![&a, &b, &c];
+}
diff --git a/tests/ui/elide-errors-on-mismatched-tuple.stderr b/tests/ui/mismatched_types/elide-on-tuple-mismatch.stderr
similarity index 72%
rename from tests/ui/elide-errors-on-mismatched-tuple.stderr
rename to tests/ui/mismatched_types/elide-on-tuple-mismatch.stderr
index f852a22..7de45eb 100644
--- a/tests/ui/elide-errors-on-mismatched-tuple.stderr
+++ b/tests/ui/mismatched_types/elide-on-tuple-mismatch.stderr
@@ -1,7 +1,7 @@
error[E0308]: mismatched types
- --> $DIR/elide-errors-on-mismatched-tuple.rs:14:9
+ --> $DIR/elide-on-tuple-mismatch.rs:19:9
|
-LL | let (a, b, c) = (A::new(), A::new()); // This tuple is 2 elements, should be three
+LL | let (a, b, c) = (A::new(), A::new());
| ^^^^^^^^^ -------------------- this expression has type `(A, A)`
| |
| expected a tuple with 2 elements, found one with 3 elements
diff --git a/tests/ui/integral-variable-unification-error.rs b/tests/ui/mismatched_types/int-float-type-mismatch.rs
similarity index 64%
rename from tests/ui/integral-variable-unification-error.rs
rename to tests/ui/mismatched_types/int-float-type-mismatch.rs
index 8d16213..b45d027 100644
--- a/tests/ui/integral-variable-unification-error.rs
+++ b/tests/ui/mismatched_types/int-float-type-mismatch.rs
@@ -1,3 +1,6 @@
+//! Check that a type mismatch error is reported when trying
+//! to unify a {float} value assignment to an {integer} variable.
+
fn main() {
let mut x //~ NOTE expected due to the type of this binding
=
diff --git a/tests/ui/integral-variable-unification-error.stderr b/tests/ui/mismatched_types/int-float-type-mismatch.stderr
similarity index 86%
rename from tests/ui/integral-variable-unification-error.stderr
rename to tests/ui/mismatched_types/int-float-type-mismatch.stderr
index 1caa604..43b8609 100644
--- a/tests/ui/integral-variable-unification-error.stderr
+++ b/tests/ui/mismatched_types/int-float-type-mismatch.stderr
@@ -1,5 +1,5 @@
error[E0308]: mismatched types
- --> $DIR/integral-variable-unification-error.rs:5:9
+ --> $DIR/int-float-type-mismatch.rs:8:9
|
LL | let mut x
| ----- expected due to the type of this binding
diff --git a/tests/ui/modules/nested-modules-basic.rs b/tests/ui/modules/nested-modules-basic.rs
new file mode 100644
index 0000000..12eccec
--- /dev/null
+++ b/tests/ui/modules/nested-modules-basic.rs
@@ -0,0 +1,19 @@
+//! Basic test for nested module functionality and path resolution
+
+//@ run-pass
+
+mod inner {
+ pub mod inner2 {
+ pub fn hello() {
+ println!("hello, modular world");
+ }
+ }
+ pub fn hello() {
+ inner2::hello();
+ }
+}
+
+pub fn main() {
+ inner::hello();
+ inner::inner2::hello();
+}
diff --git a/tests/ui/parser/bounds-type.stderr b/tests/ui/parser/bounds-type.stderr
index 0d929c7..7c3e92a 100644
--- a/tests/ui/parser/bounds-type.stderr
+++ b/tests/ui/parser/bounds-type.stderr
@@ -21,10 +21,10 @@
| there is not a well-defined meaning for a `[const] ?` trait
error: `[const]` may only modify trait bounds, not lifetime bounds
- --> $DIR/bounds-type.rs:16:6
+ --> $DIR/bounds-type.rs:16:8
|
LL | T: [const] 'a,
- | ^^^^^^^^^
+ | ^^^^^^^
error: `const` may only modify trait bounds, not lifetime bounds
--> $DIR/bounds-type.rs:17:8
diff --git a/tests/ui/double-ref.rs b/tests/ui/parser/reference-whitespace-parsing.rs
similarity index 91%
rename from tests/ui/double-ref.rs
rename to tests/ui/parser/reference-whitespace-parsing.rs
index eecf68f..7109c59 100644
--- a/tests/ui/double-ref.rs
+++ b/tests/ui/parser/reference-whitespace-parsing.rs
@@ -1,3 +1,5 @@
+//! Test parsing of multiple references with various whitespace arrangements
+
//@ run-pass
#![allow(dead_code)]
diff --git a/tests/ui/max-min-classes.rs b/tests/ui/resolve/struct-function-same-name.rs
similarity index 83%
rename from tests/ui/max-min-classes.rs
rename to tests/ui/resolve/struct-function-same-name.rs
index 338a315..bb2837d 100644
--- a/tests/ui/max-min-classes.rs
+++ b/tests/ui/resolve/struct-function-same-name.rs
@@ -1,3 +1,5 @@
+//! Test that a struct and function can have the same name
+//!
//@ run-pass
#![allow(non_snake_case)]
@@ -23,7 +25,7 @@ fn product(&self) -> isize {
}
fn Foo(x: isize, y: isize) -> Foo {
- Foo { x: x, y: y }
+ Foo { x, y }
}
pub fn main() {
diff --git a/tests/ui/resolve/type-param-local-var-shadowing.rs b/tests/ui/resolve/type-param-local-var-shadowing.rs
new file mode 100644
index 0000000..e08379e
--- /dev/null
+++ b/tests/ui/resolve/type-param-local-var-shadowing.rs
@@ -0,0 +1,24 @@
+//! Test that items in subscopes correctly shadow type parameters and local variables
+//!
+//! Regression test for https://github.com/rust-lang/rust/issues/23880
+
+//@ run-pass
+
+#![allow(unused)]
+struct Foo<X> {
+ x: Box<X>,
+}
+impl<Bar> Foo<Bar> {
+ fn foo(&self) {
+ type Bar = i32;
+ let _: Bar = 42;
+ }
+}
+
+fn main() {
+ let f = 1;
+ {
+ fn f() {}
+ f();
+ }
+}
diff --git a/tests/ui/simd/intrinsic/float-math-pass.rs b/tests/ui/simd/intrinsic/float-math-pass.rs
index 4c28568..01fed85 100644
--- a/tests/ui/simd/intrinsic/float-math-pass.rs
+++ b/tests/ui/simd/intrinsic/float-math-pass.rs
@@ -85,6 +85,9 @@ fn main() {
let r = simd_round(h);
assert_eq!(x, r);
+ let r = simd_round_ties_even(h);
+ assert_eq!(z, r);
+
let r = simd_trunc(h);
assert_eq!(z, r);
}
diff --git a/tests/ui/simd/intrinsic/generic-arithmetic-2.rs b/tests/ui/simd/intrinsic/generic-arithmetic-2.rs
index fdf06b7..caec607 100644
--- a/tests/ui/simd/intrinsic/generic-arithmetic-2.rs
+++ b/tests/ui/simd/intrinsic/generic-arithmetic-2.rs
@@ -43,6 +43,10 @@ fn main() {
simd_shl(y, y);
simd_shr(x, x);
simd_shr(y, y);
+ simd_funnel_shl(x, x, x);
+ simd_funnel_shl(y, y, y);
+ simd_funnel_shr(x, x, x);
+ simd_funnel_shr(y, y, y);
simd_and(x, x);
simd_and(y, y);
simd_or(x, x);
@@ -73,6 +77,10 @@ fn main() {
//~^ ERROR expected SIMD input type, found non-SIMD `i32`
simd_shr(0, 0);
//~^ ERROR expected SIMD input type, found non-SIMD `i32`
+ simd_funnel_shl(0, 0, 0);
+ //~^ ERROR expected SIMD input type, found non-SIMD `i32`
+ simd_funnel_shr(0, 0, 0);
+ //~^ ERROR expected SIMD input type, found non-SIMD `i32`
simd_and(0, 0);
//~^ ERROR expected SIMD input type, found non-SIMD `i32`
simd_or(0, 0);
@@ -95,6 +103,10 @@ fn main() {
//~^ ERROR unsupported operation on `f32x4` with element `f32`
simd_shr(z, z);
//~^ ERROR unsupported operation on `f32x4` with element `f32`
+ simd_funnel_shl(z, z, z);
+ //~^ ERROR unsupported operation on `f32x4` with element `f32`
+ simd_funnel_shr(z, z, z);
+ //~^ ERROR unsupported operation on `f32x4` with element `f32`
simd_and(z, z);
//~^ ERROR unsupported operation on `f32x4` with element `f32`
simd_or(z, z);
diff --git a/tests/ui/simd/intrinsic/generic-arithmetic-2.stderr b/tests/ui/simd/intrinsic/generic-arithmetic-2.stderr
index 76db6d5..a27a8d7 100644
--- a/tests/ui/simd/intrinsic/generic-arithmetic-2.stderr
+++ b/tests/ui/simd/intrinsic/generic-arithmetic-2.stderr
@@ -1,147 +1,171 @@
error[E0511]: invalid monomorphization of `simd_add` intrinsic: expected SIMD input type, found non-SIMD `i32`
- --> $DIR/generic-arithmetic-2.rs:64:9
+ --> $DIR/generic-arithmetic-2.rs:68:9
|
LL | simd_add(0, 0);
| ^^^^^^^^^^^^^^
error[E0511]: invalid monomorphization of `simd_sub` intrinsic: expected SIMD input type, found non-SIMD `i32`
- --> $DIR/generic-arithmetic-2.rs:66:9
+ --> $DIR/generic-arithmetic-2.rs:70:9
|
LL | simd_sub(0, 0);
| ^^^^^^^^^^^^^^
error[E0511]: invalid monomorphization of `simd_mul` intrinsic: expected SIMD input type, found non-SIMD `i32`
- --> $DIR/generic-arithmetic-2.rs:68:9
+ --> $DIR/generic-arithmetic-2.rs:72:9
|
LL | simd_mul(0, 0);
| ^^^^^^^^^^^^^^
error[E0511]: invalid monomorphization of `simd_div` intrinsic: expected SIMD input type, found non-SIMD `i32`
- --> $DIR/generic-arithmetic-2.rs:70:9
+ --> $DIR/generic-arithmetic-2.rs:74:9
|
LL | simd_div(0, 0);
| ^^^^^^^^^^^^^^
error[E0511]: invalid monomorphization of `simd_shl` intrinsic: expected SIMD input type, found non-SIMD `i32`
- --> $DIR/generic-arithmetic-2.rs:72:9
+ --> $DIR/generic-arithmetic-2.rs:76:9
|
LL | simd_shl(0, 0);
| ^^^^^^^^^^^^^^
error[E0511]: invalid monomorphization of `simd_shr` intrinsic: expected SIMD input type, found non-SIMD `i32`
- --> $DIR/generic-arithmetic-2.rs:74:9
+ --> $DIR/generic-arithmetic-2.rs:78:9
|
LL | simd_shr(0, 0);
| ^^^^^^^^^^^^^^
+error[E0511]: invalid monomorphization of `simd_funnel_shl` intrinsic: expected SIMD input type, found non-SIMD `i32`
+ --> $DIR/generic-arithmetic-2.rs:80:9
+ |
+LL | simd_funnel_shl(0, 0, 0);
+ | ^^^^^^^^^^^^^^^^^^^^^^^^
+
+error[E0511]: invalid monomorphization of `simd_funnel_shr` intrinsic: expected SIMD input type, found non-SIMD `i32`
+ --> $DIR/generic-arithmetic-2.rs:82:9
+ |
+LL | simd_funnel_shr(0, 0, 0);
+ | ^^^^^^^^^^^^^^^^^^^^^^^^
+
error[E0511]: invalid monomorphization of `simd_and` intrinsic: expected SIMD input type, found non-SIMD `i32`
- --> $DIR/generic-arithmetic-2.rs:76:9
+ --> $DIR/generic-arithmetic-2.rs:84:9
|
LL | simd_and(0, 0);
| ^^^^^^^^^^^^^^
error[E0511]: invalid monomorphization of `simd_or` intrinsic: expected SIMD input type, found non-SIMD `i32`
- --> $DIR/generic-arithmetic-2.rs:78:9
+ --> $DIR/generic-arithmetic-2.rs:86:9
|
LL | simd_or(0, 0);
| ^^^^^^^^^^^^^
error[E0511]: invalid monomorphization of `simd_xor` intrinsic: expected SIMD input type, found non-SIMD `i32`
- --> $DIR/generic-arithmetic-2.rs:80:9
+ --> $DIR/generic-arithmetic-2.rs:88:9
|
LL | simd_xor(0, 0);
| ^^^^^^^^^^^^^^
error[E0511]: invalid monomorphization of `simd_neg` intrinsic: expected SIMD input type, found non-SIMD `i32`
- --> $DIR/generic-arithmetic-2.rs:83:9
+ --> $DIR/generic-arithmetic-2.rs:91:9
|
LL | simd_neg(0);
| ^^^^^^^^^^^
error[E0511]: invalid monomorphization of `simd_bswap` intrinsic: expected SIMD input type, found non-SIMD `i32`
- --> $DIR/generic-arithmetic-2.rs:85:9
+ --> $DIR/generic-arithmetic-2.rs:93:9
|
LL | simd_bswap(0);
| ^^^^^^^^^^^^^
error[E0511]: invalid monomorphization of `simd_bitreverse` intrinsic: expected SIMD input type, found non-SIMD `i32`
- --> $DIR/generic-arithmetic-2.rs:87:9
+ --> $DIR/generic-arithmetic-2.rs:95:9
|
LL | simd_bitreverse(0);
| ^^^^^^^^^^^^^^^^^^
error[E0511]: invalid monomorphization of `simd_ctlz` intrinsic: expected SIMD input type, found non-SIMD `i32`
- --> $DIR/generic-arithmetic-2.rs:89:9
+ --> $DIR/generic-arithmetic-2.rs:97:9
|
LL | simd_ctlz(0);
| ^^^^^^^^^^^^
error[E0511]: invalid monomorphization of `simd_cttz` intrinsic: expected SIMD input type, found non-SIMD `i32`
- --> $DIR/generic-arithmetic-2.rs:91:9
+ --> $DIR/generic-arithmetic-2.rs:99:9
|
LL | simd_cttz(0);
| ^^^^^^^^^^^^
error[E0511]: invalid monomorphization of `simd_shl` intrinsic: unsupported operation on `f32x4` with element `f32`
- --> $DIR/generic-arithmetic-2.rs:94:9
+ --> $DIR/generic-arithmetic-2.rs:102:9
|
LL | simd_shl(z, z);
| ^^^^^^^^^^^^^^
error[E0511]: invalid monomorphization of `simd_shr` intrinsic: unsupported operation on `f32x4` with element `f32`
- --> $DIR/generic-arithmetic-2.rs:96:9
+ --> $DIR/generic-arithmetic-2.rs:104:9
|
LL | simd_shr(z, z);
| ^^^^^^^^^^^^^^
+error[E0511]: invalid monomorphization of `simd_funnel_shl` intrinsic: unsupported operation on `f32x4` with element `f32`
+ --> $DIR/generic-arithmetic-2.rs:106:9
+ |
+LL | simd_funnel_shl(z, z, z);
+ | ^^^^^^^^^^^^^^^^^^^^^^^^
+
+error[E0511]: invalid monomorphization of `simd_funnel_shr` intrinsic: unsupported operation on `f32x4` with element `f32`
+ --> $DIR/generic-arithmetic-2.rs:108:9
+ |
+LL | simd_funnel_shr(z, z, z);
+ | ^^^^^^^^^^^^^^^^^^^^^^^^
+
error[E0511]: invalid monomorphization of `simd_and` intrinsic: unsupported operation on `f32x4` with element `f32`
- --> $DIR/generic-arithmetic-2.rs:98:9
+ --> $DIR/generic-arithmetic-2.rs:110:9
|
LL | simd_and(z, z);
| ^^^^^^^^^^^^^^
error[E0511]: invalid monomorphization of `simd_or` intrinsic: unsupported operation on `f32x4` with element `f32`
- --> $DIR/generic-arithmetic-2.rs:100:9
+ --> $DIR/generic-arithmetic-2.rs:112:9
|
LL | simd_or(z, z);
| ^^^^^^^^^^^^^
error[E0511]: invalid monomorphization of `simd_xor` intrinsic: unsupported operation on `f32x4` with element `f32`
- --> $DIR/generic-arithmetic-2.rs:102:9
+ --> $DIR/generic-arithmetic-2.rs:114:9
|
LL | simd_xor(z, z);
| ^^^^^^^^^^^^^^
error[E0511]: invalid monomorphization of `simd_bswap` intrinsic: unsupported operation on `f32x4` with element `f32`
- --> $DIR/generic-arithmetic-2.rs:104:9
+ --> $DIR/generic-arithmetic-2.rs:116:9
|
LL | simd_bswap(z);
| ^^^^^^^^^^^^^
error[E0511]: invalid monomorphization of `simd_bitreverse` intrinsic: unsupported operation on `f32x4` with element `f32`
- --> $DIR/generic-arithmetic-2.rs:106:9
+ --> $DIR/generic-arithmetic-2.rs:118:9
|
LL | simd_bitreverse(z);
| ^^^^^^^^^^^^^^^^^^
error[E0511]: invalid monomorphization of `simd_ctlz` intrinsic: unsupported operation on `f32x4` with element `f32`
- --> $DIR/generic-arithmetic-2.rs:108:9
+ --> $DIR/generic-arithmetic-2.rs:120:9
|
LL | simd_ctlz(z);
| ^^^^^^^^^^^^
error[E0511]: invalid monomorphization of `simd_ctpop` intrinsic: unsupported operation on `f32x4` with element `f32`
- --> $DIR/generic-arithmetic-2.rs:110:9
+ --> $DIR/generic-arithmetic-2.rs:122:9
|
LL | simd_ctpop(z);
| ^^^^^^^^^^^^^
error[E0511]: invalid monomorphization of `simd_cttz` intrinsic: unsupported operation on `f32x4` with element `f32`
- --> $DIR/generic-arithmetic-2.rs:112:9
+ --> $DIR/generic-arithmetic-2.rs:124:9
|
LL | simd_cttz(z);
| ^^^^^^^^^^^^
-error: aborting due to 24 previous errors
+error: aborting due to 28 previous errors
For more information about this error, try `rustc --explain E0511`.
diff --git a/tests/ui/simd/intrinsic/generic-arithmetic-pass.rs b/tests/ui/simd/intrinsic/generic-arithmetic-pass.rs
index 3f0325d..4c97fb2 100644
--- a/tests/ui/simd/intrinsic/generic-arithmetic-pass.rs
+++ b/tests/ui/simd/intrinsic/generic-arithmetic-pass.rs
@@ -83,6 +83,80 @@ fn main() {
all_eq!(simd_shr(simd_shl(y1, y2), y2), y1);
all_eq!(simd_shr(simd_shl(y2, y1), y1), y2);
+ all_eq!(
+ simd_funnel_shl(x1, x2, x1),
+ i32x4([
+ (1 << 1) | (2 >> 31),
+ (2 << 2) | (3 >> 30),
+ (3 << 3) | (4 >> 29),
+ (4 << 4) | (5 >> 28)
+ ])
+ );
+ all_eq!(
+ simd_funnel_shl(x2, x1, x1),
+ i32x4([
+ (2 << 1) | (1 >> 31),
+ (3 << 2) | (2 >> 30),
+ (4 << 3) | (3 >> 29),
+ (5 << 4) | (4 >> 28)
+ ])
+ );
+ all_eq!(
+ simd_funnel_shl(y1, y2, y1),
+ U32::<4>([
+ (1 << 1) | (2 >> 31),
+ (2 << 2) | (3 >> 30),
+ (3 << 3) | (4 >> 29),
+ (4 << 4) | (5 >> 28)
+ ])
+ );
+ all_eq!(
+ simd_funnel_shl(y2, y1, y1),
+ U32::<4>([
+ (2 << 1) | (1 >> 31),
+ (3 << 2) | (2 >> 30),
+ (4 << 3) | (3 >> 29),
+ (5 << 4) | (4 >> 28)
+ ])
+ );
+
+ all_eq!(
+ simd_funnel_shr(x1, x2, x1),
+ i32x4([
+ (1 << 31) | (2 >> 1),
+ (2 << 30) | (3 >> 2),
+ (3 << 29) | (4 >> 3),
+ (4 << 28) | (5 >> 4)
+ ])
+ );
+ all_eq!(
+ simd_funnel_shr(x2, x1, x1),
+ i32x4([
+ (2 << 31) | (1 >> 1),
+ (3 << 30) | (2 >> 2),
+ (4 << 29) | (3 >> 3),
+ (5 << 28) | (4 >> 4)
+ ])
+ );
+ all_eq!(
+ simd_funnel_shr(y1, y2, y1),
+ U32::<4>([
+ (1 << 31) | (2 >> 1),
+ (2 << 30) | (3 >> 2),
+ (3 << 29) | (4 >> 3),
+ (4 << 28) | (5 >> 4)
+ ])
+ );
+ all_eq!(
+ simd_funnel_shr(y2, y1, y1),
+ U32::<4>([
+ (2 << 31) | (1 >> 1),
+ (3 << 30) | (2 >> 2),
+ (4 << 29) | (3 >> 3),
+ (5 << 28) | (4 >> 4)
+ ])
+ );
+
// ensure we get logical vs. arithmetic shifts correct
let (a, b, c, d) = (-12, -123, -1234, -12345);
all_eq!(simd_shr(i32x4([a, b, c, d]), x1), i32x4([a >> 1, b >> 2, c >> 3, d >> 4]));
diff --git a/tests/ui/specialization/const_trait_impl.stderr b/tests/ui/specialization/const_trait_impl.stderr
index d36a0a1..ea3ec16 100644
--- a/tests/ui/specialization/const_trait_impl.stderr
+++ b/tests/ui/specialization/const_trait_impl.stderr
@@ -1,55 +1,55 @@
error: `[const]` can only be applied to `#[const_trait]` traits
- --> $DIR/const_trait_impl.rs:34:7
+ --> $DIR/const_trait_impl.rs:34:9
|
LL | impl<T: [const] Default> const A for T {
- | ^^^^^^^^^ can't be applied to `Default`
+ | ^^^^^^^ can't be applied to `Default`
|
note: `Default` can't be used with `[const]` because it isn't annotated with `#[const_trait]`
--> $SRC_DIR/core/src/default.rs:LL:COL
error: `[const]` can only be applied to `#[const_trait]` traits
- --> $DIR/const_trait_impl.rs:40:7
+ --> $DIR/const_trait_impl.rs:40:9
|
LL | impl<T: [const] Default + [const] Sup> const A for T {
- | ^^^^^^^^^ can't be applied to `Default`
+ | ^^^^^^^ can't be applied to `Default`
|
note: `Default` can't be used with `[const]` because it isn't annotated with `#[const_trait]`
--> $SRC_DIR/core/src/default.rs:LL:COL
error: `[const]` can only be applied to `#[const_trait]` traits
- --> $DIR/const_trait_impl.rs:46:7
+ --> $DIR/const_trait_impl.rs:46:9
|
LL | impl<T: [const] Default + [const] Sub> const A for T {
- | ^^^^^^^^^ can't be applied to `Default`
+ | ^^^^^^^ can't be applied to `Default`
|
note: `Default` can't be used with `[const]` because it isn't annotated with `#[const_trait]`
--> $SRC_DIR/core/src/default.rs:LL:COL
error: `[const]` can only be applied to `#[const_trait]` traits
- --> $DIR/const_trait_impl.rs:40:7
+ --> $DIR/const_trait_impl.rs:40:9
|
LL | impl<T: [const] Default + [const] Sup> const A for T {
- | ^^^^^^^^^ can't be applied to `Default`
+ | ^^^^^^^ can't be applied to `Default`
|
note: `Default` can't be used with `[const]` because it isn't annotated with `#[const_trait]`
--> $SRC_DIR/core/src/default.rs:LL:COL
= note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
error: `[const]` can only be applied to `#[const_trait]` traits
- --> $DIR/const_trait_impl.rs:34:7
+ --> $DIR/const_trait_impl.rs:34:9
|
LL | impl<T: [const] Default> const A for T {
- | ^^^^^^^^^ can't be applied to `Default`
+ | ^^^^^^^ can't be applied to `Default`
|
note: `Default` can't be used with `[const]` because it isn't annotated with `#[const_trait]`
--> $SRC_DIR/core/src/default.rs:LL:COL
= note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
error: `[const]` can only be applied to `#[const_trait]` traits
- --> $DIR/const_trait_impl.rs:46:7
+ --> $DIR/const_trait_impl.rs:46:9
|
LL | impl<T: [const] Default + [const] Sub> const A for T {
- | ^^^^^^^^^ can't be applied to `Default`
+ | ^^^^^^^ can't be applied to `Default`
|
note: `Default` can't be used with `[const]` because it isn't annotated with `#[const_trait]`
--> $SRC_DIR/core/src/default.rs:LL:COL
diff --git a/tests/ui/statics/static-generic-param-soundness.rs b/tests/ui/statics/static-generic-param-soundness.rs
new file mode 100644
index 0000000..aabcca51
--- /dev/null
+++ b/tests/ui/statics/static-generic-param-soundness.rs
@@ -0,0 +1,20 @@
+//! Originally, inner statics in generic functions were generated only once, causing the same
+//! static to be shared across all generic instantiations. This created a soundness hole where
+//! different types could be coerced through thread-local storage in safe code.
+//!
+//! This test checks that generic parameters from outer scopes cannot be used in inner statics,
+//! preventing this soundness issue.
+//!
+//! See https://github.com/rust-lang/rust/issues/9186
+
+enum Bar<T> {
+ //~^ ERROR parameter `T` is never used
+ What,
+}
+
+fn foo<T>() {
+ static a: Bar<T> = Bar::What;
+ //~^ ERROR can't use generic parameters from outer item
+}
+
+fn main() {}
diff --git a/tests/ui/inner-static-type-parameter.stderr b/tests/ui/statics/static-generic-param-soundness.stderr
similarity index 85%
rename from tests/ui/inner-static-type-parameter.stderr
rename to tests/ui/statics/static-generic-param-soundness.stderr
index 88d33b4..47554c7 100644
--- a/tests/ui/inner-static-type-parameter.stderr
+++ b/tests/ui/statics/static-generic-param-soundness.stderr
@@ -1,5 +1,5 @@
error[E0401]: can't use generic parameters from outer item
- --> $DIR/inner-static-type-parameter.rs:6:19
+ --> $DIR/static-generic-param-soundness.rs:16:19
|
LL | fn foo<T>() {
| - type parameter from outer item
@@ -9,9 +9,9 @@
= note: a `static` is a separate item from the item that contains it
error[E0392]: type parameter `T` is never used
- --> $DIR/inner-static-type-parameter.rs:3:10
+ --> $DIR/static-generic-param-soundness.rs:10:10
|
-LL | enum Bar<T> { What }
+LL | enum Bar<T> {
| ^ unused type parameter
|
= help: consider removing `T`, referring to it in a field, or using a marker such as `PhantomData`
diff --git a/tests/ui/test-attrs/test-function-elided-no-main.rs b/tests/ui/test-attrs/test-function-elided-no-main.rs
new file mode 100644
index 0000000..9765458
--- /dev/null
+++ b/tests/ui/test-attrs/test-function-elided-no-main.rs
@@ -0,0 +1,8 @@
+//! Test that #[test] functions are elided when not running tests, causing missing main error
+
+#[test]
+fn main() {
+ // This function would normally serve as main, but since it's marked with #[test],
+ // it gets elided when not running tests
+}
+//~^ ERROR `main` function not found in crate `test_function_elided_no_main`
diff --git a/tests/ui/test-attrs/test-function-elided-no-main.stderr b/tests/ui/test-attrs/test-function-elided-no-main.stderr
new file mode 100644
index 0000000..0bae690
--- /dev/null
+++ b/tests/ui/test-attrs/test-function-elided-no-main.stderr
@@ -0,0 +1,9 @@
+error[E0601]: `main` function not found in crate `test_function_elided_no_main`
+ --> $DIR/test-function-elided-no-main.rs:7:2
+ |
+LL | }
+ | ^ consider adding a `main` function to `$DIR/test-function-elided-no-main.rs`
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0601`.
diff --git a/tests/ui/traits/const-traits/conditionally-const-and-const-params.stderr b/tests/ui/traits/const-traits/conditionally-const-and-const-params.stderr
index f450bc6..ebd816a 100644
--- a/tests/ui/traits/const-traits/conditionally-const-and-const-params.stderr
+++ b/tests/ui/traits/const-traits/conditionally-const-and-const-params.stderr
@@ -1,8 +1,8 @@
error: `[const]` is not allowed here
- --> $DIR/conditionally-const-and-const-params.rs:8:13
+ --> $DIR/conditionally-const-and-const-params.rs:8:15
|
LL | fn add<A: [const] Add42>(self) -> Foo<{ A::add(N) }> {
- | ^^^^^^^^^
+ | ^^^^^^^
|
note: this function is not `const`, so it cannot have `[const]` trait bounds
--> $DIR/conditionally-const-and-const-params.rs:8:8
@@ -11,10 +11,10 @@
| ^^^
error: `[const]` is not allowed here
- --> $DIR/conditionally-const-and-const-params.rs:26:9
+ --> $DIR/conditionally-const-and-const-params.rs:26:11
|
LL | fn bar<A: [const] Add42, const N: usize>(_: Foo<N>) -> Foo<{ A::add(N) }> {
- | ^^^^^^^^^
+ | ^^^^^^^
|
note: this function is not `const`, so it cannot have `[const]` trait bounds
--> $DIR/conditionally-const-and-const-params.rs:26:4
diff --git a/tests/ui/traits/const-traits/conditionally-const-invalid-places.stderr b/tests/ui/traits/const-traits/conditionally-const-invalid-places.stderr
index 6231968..d0dd950 100644
--- a/tests/ui/traits/const-traits/conditionally-const-invalid-places.stderr
+++ b/tests/ui/traits/const-traits/conditionally-const-invalid-places.stderr
@@ -1,8 +1,8 @@
error: `[const]` is not allowed here
- --> $DIR/conditionally-const-invalid-places.rs:7:24
+ --> $DIR/conditionally-const-invalid-places.rs:7:26
|
LL | fn non_const_function<T: [const] Trait>() {}
- | ^^^^^^^^^
+ | ^^^^^^^
|
note: this function is not `const`, so it cannot have `[const]` trait bounds
--> $DIR/conditionally-const-invalid-places.rs:7:4
@@ -11,66 +11,66 @@
| ^^^^^^^^^^^^^^^^^^
error: `[const]` is not allowed here
- --> $DIR/conditionally-const-invalid-places.rs:9:16
+ --> $DIR/conditionally-const-invalid-places.rs:9:18
|
LL | struct Struct<T: [const] Trait> { field: T }
- | ^^^^^^^^^
+ | ^^^^^^^
|
= note: this item cannot have `[const]` trait bounds
error: `[const]` is not allowed here
- --> $DIR/conditionally-const-invalid-places.rs:10:21
+ --> $DIR/conditionally-const-invalid-places.rs:10:23
|
LL | struct TupleStruct<T: [const] Trait>(T);
- | ^^^^^^^^^
+ | ^^^^^^^
|
= note: this item cannot have `[const]` trait bounds
error: `[const]` is not allowed here
- --> $DIR/conditionally-const-invalid-places.rs:11:20
+ --> $DIR/conditionally-const-invalid-places.rs:11:22
|
LL | struct UnitStruct<T: [const] Trait>;
- | ^^^^^^^^^
+ | ^^^^^^^
|
= note: this item cannot have `[const]` trait bounds
error: `[const]` is not allowed here
- --> $DIR/conditionally-const-invalid-places.rs:14:12
+ --> $DIR/conditionally-const-invalid-places.rs:14:14
|
LL | enum Enum<T: [const] Trait> { Variant(T) }
- | ^^^^^^^^^
+ | ^^^^^^^
|
= note: this item cannot have `[const]` trait bounds
error: `[const]` is not allowed here
- --> $DIR/conditionally-const-invalid-places.rs:16:14
+ --> $DIR/conditionally-const-invalid-places.rs:16:16
|
LL | union Union<T: [const] Trait> { field: T }
- | ^^^^^^^^^
+ | ^^^^^^^
|
= note: this item cannot have `[const]` trait bounds
error: `[const]` is not allowed here
- --> $DIR/conditionally-const-invalid-places.rs:19:12
+ --> $DIR/conditionally-const-invalid-places.rs:19:14
|
LL | type Type<T: [const] Trait> = T;
- | ^^^^^^^^^
+ | ^^^^^^^
|
= note: this item cannot have `[const]` trait bounds
error: `[const]` is not allowed here
- --> $DIR/conditionally-const-invalid-places.rs:21:17
+ --> $DIR/conditionally-const-invalid-places.rs:21:19
|
LL | const CONSTANT<T: [const] Trait>: () = ();
- | ^^^^^^^^^
+ | ^^^^^^^
|
= note: this item cannot have `[const]` trait bounds
error: `[const]` is not allowed here
- --> $DIR/conditionally-const-invalid-places.rs:25:16
+ --> $DIR/conditionally-const-invalid-places.rs:25:18
|
LL | type Type<T: [const] Trait>: [const] Trait;
- | ^^^^^^^^^
+ | ^^^^^^^
|
note: associated types in non-`#[const_trait]` traits cannot have `[const]` trait bounds
--> $DIR/conditionally-const-invalid-places.rs:25:5
@@ -79,10 +79,10 @@
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
error: `[const]` is not allowed here
- --> $DIR/conditionally-const-invalid-places.rs:25:32
+ --> $DIR/conditionally-const-invalid-places.rs:25:34
|
LL | type Type<T: [const] Trait>: [const] Trait;
- | ^^^^^^^^^
+ | ^^^^^^^
|
note: associated types in non-`#[const_trait]` traits cannot have `[const]` trait bounds
--> $DIR/conditionally-const-invalid-places.rs:25:5
@@ -91,10 +91,10 @@
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
error: `[const]` is not allowed here
- --> $DIR/conditionally-const-invalid-places.rs:28:28
+ --> $DIR/conditionally-const-invalid-places.rs:28:30
|
LL | fn non_const_function<T: [const] Trait>();
- | ^^^^^^^^^
+ | ^^^^^^^
|
note: this function is not `const`, so it cannot have `[const]` trait bounds
--> $DIR/conditionally-const-invalid-places.rs:28:8
@@ -103,18 +103,18 @@
| ^^^^^^^^^^^^^^^^^^
error: `[const]` is not allowed here
- --> $DIR/conditionally-const-invalid-places.rs:29:21
+ --> $DIR/conditionally-const-invalid-places.rs:29:23
|
LL | const CONSTANT<T: [const] Trait>: ();
- | ^^^^^^^^^
+ | ^^^^^^^
|
= note: this item cannot have `[const]` trait bounds
error: `[const]` is not allowed here
- --> $DIR/conditionally-const-invalid-places.rs:34:16
+ --> $DIR/conditionally-const-invalid-places.rs:34:18
|
LL | type Type<T: [const] Trait> = ();
- | ^^^^^^^^^
+ | ^^^^^^^
|
note: associated types in non-const impls cannot have `[const]` trait bounds
--> $DIR/conditionally-const-invalid-places.rs:34:5
@@ -123,10 +123,10 @@
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
error: `[const]` is not allowed here
- --> $DIR/conditionally-const-invalid-places.rs:36:28
+ --> $DIR/conditionally-const-invalid-places.rs:36:30
|
LL | fn non_const_function<T: [const] Trait>() {}
- | ^^^^^^^^^
+ | ^^^^^^^
|
note: this function is not `const`, so it cannot have `[const]` trait bounds
--> $DIR/conditionally-const-invalid-places.rs:36:8
@@ -135,18 +135,18 @@
| ^^^^^^^^^^^^^^^^^^
error: `[const]` is not allowed here
- --> $DIR/conditionally-const-invalid-places.rs:37:21
+ --> $DIR/conditionally-const-invalid-places.rs:37:23
|
LL | const CONSTANT<T: [const] Trait>: () = ();
- | ^^^^^^^^^
+ | ^^^^^^^
|
= note: this item cannot have `[const]` trait bounds
error: `[const]` is not allowed here
- --> $DIR/conditionally-const-invalid-places.rs:44:16
+ --> $DIR/conditionally-const-invalid-places.rs:44:18
|
LL | type Type<T: [const] Trait> = ();
- | ^^^^^^^^^
+ | ^^^^^^^
|
note: inherent associated types cannot have `[const]` trait bounds
--> $DIR/conditionally-const-invalid-places.rs:44:5
@@ -155,10 +155,10 @@
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
error: `[const]` is not allowed here
- --> $DIR/conditionally-const-invalid-places.rs:46:28
+ --> $DIR/conditionally-const-invalid-places.rs:46:30
|
LL | fn non_const_function<T: [const] Trait>() {}
- | ^^^^^^^^^
+ | ^^^^^^^
|
note: this function is not `const`, so it cannot have `[const]` trait bounds
--> $DIR/conditionally-const-invalid-places.rs:46:8
@@ -167,18 +167,18 @@
| ^^^^^^^^^^^^^^^^^^
error: `[const]` is not allowed here
- --> $DIR/conditionally-const-invalid-places.rs:47:21
+ --> $DIR/conditionally-const-invalid-places.rs:47:23
|
LL | const CONSTANT<T: [const] Trait>: () = ();
- | ^^^^^^^^^
+ | ^^^^^^^
|
= note: this item cannot have `[const]` trait bounds
error: `[const]` is not allowed here
- --> $DIR/conditionally-const-invalid-places.rs:52:13
+ --> $DIR/conditionally-const-invalid-places.rs:52:15
|
LL | trait Child0: [const] Trait {}
- | ^^^^^^^^^
+ | ^^^^^^^
|
note: this trait is not a `#[const_trait]`, so it cannot have `[const]` trait bounds
--> $DIR/conditionally-const-invalid-places.rs:52:1
@@ -187,10 +187,10 @@
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
error: `[const]` is not allowed here
- --> $DIR/conditionally-const-invalid-places.rs:53:24
+ --> $DIR/conditionally-const-invalid-places.rs:53:26
|
LL | trait Child1 where Self: [const] Trait {}
- | ^^^^^^^^^
+ | ^^^^^^^
|
note: this trait is not a `#[const_trait]`, so it cannot have `[const]` trait bounds
--> $DIR/conditionally-const-invalid-places.rs:53:1
@@ -199,10 +199,10 @@
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
error: `[const]` is not allowed here
- --> $DIR/conditionally-const-invalid-places.rs:56:7
+ --> $DIR/conditionally-const-invalid-places.rs:56:9
|
LL | impl<T: [const] Trait> Trait for T {}
- | ^^^^^^^^^
+ | ^^^^^^^
|
note: this impl is not `const`, so it cannot have `[const]` trait bounds
--> $DIR/conditionally-const-invalid-places.rs:56:1
@@ -211,10 +211,10 @@
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
error: `[const]` is not allowed here
- --> $DIR/conditionally-const-invalid-places.rs:59:7
+ --> $DIR/conditionally-const-invalid-places.rs:59:9
|
LL | impl<T: [const] Trait> Struct<T> {}
- | ^^^^^^^^^
+ | ^^^^^^^
|
note: inherent impls cannot have `[const]` trait bounds
--> $DIR/conditionally-const-invalid-places.rs:59:1
diff --git a/tests/ui/traits/const-traits/const-bound-on-not-const-associated-fn.stderr b/tests/ui/traits/const-traits/const-bound-on-not-const-associated-fn.stderr
index c0af644..901c2cb 100644
--- a/tests/ui/traits/const-traits/const-bound-on-not-const-associated-fn.stderr
+++ b/tests/ui/traits/const-traits/const-bound-on-not-const-associated-fn.stderr
@@ -1,8 +1,8 @@
error: `[const]` is not allowed here
- --> $DIR/const-bound-on-not-const-associated-fn.rs:11:38
+ --> $DIR/const-bound-on-not-const-associated-fn.rs:11:40
|
LL | fn do_something_else() where Self: [const] MyTrait;
- | ^^^^^^^^^
+ | ^^^^^^^
|
note: this function is not `const`, so it cannot have `[const]` trait bounds
--> $DIR/const-bound-on-not-const-associated-fn.rs:11:8
@@ -11,10 +11,10 @@
| ^^^^^^^^^^^^^^^^^
error: `[const]` is not allowed here
- --> $DIR/const-bound-on-not-const-associated-fn.rs:22:30
+ --> $DIR/const-bound-on-not-const-associated-fn.rs:22:32
|
LL | pub fn foo(&self) where T: [const] MyTrait {
- | ^^^^^^^^^
+ | ^^^^^^^
|
note: this function is not `const`, so it cannot have `[const]` trait bounds
--> $DIR/const-bound-on-not-const-associated-fn.rs:22:12
diff --git a/tests/ui/traits/const-traits/const-bounds-non-const-trait.stderr b/tests/ui/traits/const-traits/const-bounds-non-const-trait.stderr
index 2ff5fb7..6c68e4e 100644
--- a/tests/ui/traits/const-traits/const-bounds-non-const-trait.stderr
+++ b/tests/ui/traits/const-traits/const-bounds-non-const-trait.stderr
@@ -1,8 +1,8 @@
error: `[const]` can only be applied to `#[const_trait]` traits
- --> $DIR/const-bounds-non-const-trait.rs:6:19
+ --> $DIR/const-bounds-non-const-trait.rs:6:21
|
LL | const fn perform<T: [const] NonConst>() {}
- | ^^^^^^^^^ can't be applied to `NonConst`
+ | ^^^^^^^ can't be applied to `NonConst`
|
help: mark `NonConst` as `#[const_trait]` to allow it to have `const` implementations
|
@@ -10,10 +10,10 @@
| ++++++++++++++
error: `[const]` can only be applied to `#[const_trait]` traits
- --> $DIR/const-bounds-non-const-trait.rs:6:19
+ --> $DIR/const-bounds-non-const-trait.rs:6:21
|
LL | const fn perform<T: [const] NonConst>() {}
- | ^^^^^^^^^ can't be applied to `NonConst`
+ | ^^^^^^^ can't be applied to `NonConst`
|
= note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
help: mark `NonConst` as `#[const_trait]` to allow it to have `const` implementations
diff --git a/tests/ui/traits/const-traits/const-closure-parse-not-item.stderr b/tests/ui/traits/const-traits/const-closure-parse-not-item.stderr
index cc9d9bd..fdfe3b9 100644
--- a/tests/ui/traits/const-traits/const-closure-parse-not-item.stderr
+++ b/tests/ui/traits/const-traits/const-closure-parse-not-item.stderr
@@ -1,27 +1,27 @@
error: `[const]` can only be applied to `#[const_trait]` traits
- --> $DIR/const-closure-parse-not-item.rs:7:20
+ --> $DIR/const-closure-parse-not-item.rs:7:25
|
LL | const fn test() -> impl [const] Fn() {
- | ^^^^^^^^^^^^ can't be applied to `Fn`
+ | ^^^^^^^ can't be applied to `Fn`
|
note: `Fn` can't be used with `[const]` because it isn't annotated with `#[const_trait]`
--> $SRC_DIR/core/src/ops/function.rs:LL:COL
error: `[const]` can only be applied to `#[const_trait]` traits
- --> $DIR/const-closure-parse-not-item.rs:7:20
+ --> $DIR/const-closure-parse-not-item.rs:7:25
|
LL | const fn test() -> impl [const] Fn() {
- | ^^^^^^^^^^^^ can't be applied to `Fn`
+ | ^^^^^^^ can't be applied to `Fn`
|
note: `Fn` can't be used with `[const]` because it isn't annotated with `#[const_trait]`
--> $SRC_DIR/core/src/ops/function.rs:LL:COL
= note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
error: `[const]` can only be applied to `#[const_trait]` traits
- --> $DIR/const-closure-parse-not-item.rs:7:20
+ --> $DIR/const-closure-parse-not-item.rs:7:25
|
LL | const fn test() -> impl [const] Fn() {
- | ^^^^^^^^^^^^ can't be applied to `Fn`
+ | ^^^^^^^ can't be applied to `Fn`
|
note: `Fn` can't be used with `[const]` because it isn't annotated with `#[const_trait]`
--> $SRC_DIR/core/src/ops/function.rs:LL:COL
diff --git a/tests/ui/traits/const-traits/const-closure-trait-method-fail.stderr b/tests/ui/traits/const-traits/const-closure-trait-method-fail.stderr
index 7a146b9..89b202b 100644
--- a/tests/ui/traits/const-traits/const-closure-trait-method-fail.stderr
+++ b/tests/ui/traits/const-traits/const-closure-trait-method-fail.stderr
@@ -1,17 +1,17 @@
error: `[const]` can only be applied to `#[const_trait]` traits
- --> $DIR/const-closure-trait-method-fail.rs:14:30
+ --> $DIR/const-closure-trait-method-fail.rs:14:32
|
LL | const fn need_const_closure<T: [const] FnOnce(()) -> i32>(x: T) -> i32 {
- | ^^^^^^^^^ can't be applied to `FnOnce`
+ | ^^^^^^^ can't be applied to `FnOnce`
|
note: `FnOnce` can't be used with `[const]` because it isn't annotated with `#[const_trait]`
--> $SRC_DIR/core/src/ops/function.rs:LL:COL
error: `[const]` can only be applied to `#[const_trait]` traits
- --> $DIR/const-closure-trait-method-fail.rs:14:30
+ --> $DIR/const-closure-trait-method-fail.rs:14:32
|
LL | const fn need_const_closure<T: [const] FnOnce(()) -> i32>(x: T) -> i32 {
- | ^^^^^^^^^ can't be applied to `FnOnce`
+ | ^^^^^^^ can't be applied to `FnOnce`
|
note: `FnOnce` can't be used with `[const]` because it isn't annotated with `#[const_trait]`
--> $SRC_DIR/core/src/ops/function.rs:LL:COL
diff --git a/tests/ui/traits/const-traits/const-closure-trait-method.stderr b/tests/ui/traits/const-traits/const-closure-trait-method.stderr
index 6c003f8..6de25dc 100644
--- a/tests/ui/traits/const-traits/const-closure-trait-method.stderr
+++ b/tests/ui/traits/const-traits/const-closure-trait-method.stderr
@@ -1,17 +1,17 @@
error: `[const]` can only be applied to `#[const_trait]` traits
- --> $DIR/const-closure-trait-method.rs:14:30
+ --> $DIR/const-closure-trait-method.rs:14:32
|
LL | const fn need_const_closure<T: [const] FnOnce(()) -> i32>(x: T) -> i32 {
- | ^^^^^^^^^ can't be applied to `FnOnce`
+ | ^^^^^^^ can't be applied to `FnOnce`
|
note: `FnOnce` can't be used with `[const]` because it isn't annotated with `#[const_trait]`
--> $SRC_DIR/core/src/ops/function.rs:LL:COL
error: `[const]` can only be applied to `#[const_trait]` traits
- --> $DIR/const-closure-trait-method.rs:14:30
+ --> $DIR/const-closure-trait-method.rs:14:32
|
LL | const fn need_const_closure<T: [const] FnOnce(()) -> i32>(x: T) -> i32 {
- | ^^^^^^^^^ can't be applied to `FnOnce`
+ | ^^^^^^^ can't be applied to `FnOnce`
|
note: `FnOnce` can't be used with `[const]` because it isn't annotated with `#[const_trait]`
--> $SRC_DIR/core/src/ops/function.rs:LL:COL
diff --git a/tests/ui/traits/const-traits/const-closures.stderr b/tests/ui/traits/const-traits/const-closures.stderr
index c76a734..19869b4 100644
--- a/tests/ui/traits/const-traits/const-closures.stderr
+++ b/tests/ui/traits/const-traits/const-closures.stderr
@@ -1,74 +1,74 @@
error: `[const]` can only be applied to `#[const_trait]` traits
- --> $DIR/const-closures.rs:8:10
+ --> $DIR/const-closures.rs:8:12
|
LL | F: [const] FnOnce() -> u8,
- | ^^^^^^^^^ can't be applied to `FnOnce`
+ | ^^^^^^^ can't be applied to `FnOnce`
|
note: `FnOnce` can't be used with `[const]` because it isn't annotated with `#[const_trait]`
--> $SRC_DIR/core/src/ops/function.rs:LL:COL
error: `[const]` can only be applied to `#[const_trait]` traits
- --> $DIR/const-closures.rs:9:10
+ --> $DIR/const-closures.rs:9:12
|
LL | F: [const] FnMut() -> u8,
- | ^^^^^^^^^ can't be applied to `FnMut`
+ | ^^^^^^^ can't be applied to `FnMut`
|
note: `FnMut` can't be used with `[const]` because it isn't annotated with `#[const_trait]`
--> $SRC_DIR/core/src/ops/function.rs:LL:COL
error: `[const]` can only be applied to `#[const_trait]` traits
- --> $DIR/const-closures.rs:10:10
+ --> $DIR/const-closures.rs:10:12
|
LL | F: [const] Fn() -> u8,
- | ^^^^^^^^^ can't be applied to `Fn`
+ | ^^^^^^^ can't be applied to `Fn`
|
note: `Fn` can't be used with `[const]` because it isn't annotated with `#[const_trait]`
--> $SRC_DIR/core/src/ops/function.rs:LL:COL
error: `[const]` can only be applied to `#[const_trait]` traits
- --> $DIR/const-closures.rs:8:10
+ --> $DIR/const-closures.rs:8:12
|
LL | F: [const] FnOnce() -> u8,
- | ^^^^^^^^^ can't be applied to `FnOnce`
+ | ^^^^^^^ can't be applied to `FnOnce`
|
note: `FnOnce` can't be used with `[const]` because it isn't annotated with `#[const_trait]`
--> $SRC_DIR/core/src/ops/function.rs:LL:COL
= note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
error: `[const]` can only be applied to `#[const_trait]` traits
- --> $DIR/const-closures.rs:9:10
+ --> $DIR/const-closures.rs:9:12
|
LL | F: [const] FnMut() -> u8,
- | ^^^^^^^^^ can't be applied to `FnMut`
+ | ^^^^^^^ can't be applied to `FnMut`
|
note: `FnMut` can't be used with `[const]` because it isn't annotated with `#[const_trait]`
--> $SRC_DIR/core/src/ops/function.rs:LL:COL
= note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
error: `[const]` can only be applied to `#[const_trait]` traits
- --> $DIR/const-closures.rs:10:10
+ --> $DIR/const-closures.rs:10:12
|
LL | F: [const] Fn() -> u8,
- | ^^^^^^^^^ can't be applied to `Fn`
+ | ^^^^^^^ can't be applied to `Fn`
|
note: `Fn` can't be used with `[const]` because it isn't annotated with `#[const_trait]`
--> $SRC_DIR/core/src/ops/function.rs:LL:COL
= note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
error: `[const]` can only be applied to `#[const_trait]` traits
- --> $DIR/const-closures.rs:23:18
+ --> $DIR/const-closures.rs:23:20
|
LL | const fn answer<F: [const] Fn() -> u8>(f: &F) -> u8 {
- | ^^^^^^^^^ can't be applied to `Fn`
+ | ^^^^^^^ can't be applied to `Fn`
|
note: `Fn` can't be used with `[const]` because it isn't annotated with `#[const_trait]`
--> $SRC_DIR/core/src/ops/function.rs:LL:COL
error: `[const]` can only be applied to `#[const_trait]` traits
- --> $DIR/const-closures.rs:23:18
+ --> $DIR/const-closures.rs:23:20
|
LL | const fn answer<F: [const] Fn() -> u8>(f: &F) -> u8 {
- | ^^^^^^^^^ can't be applied to `Fn`
+ | ^^^^^^^ can't be applied to `Fn`
|
note: `Fn` can't be used with `[const]` because it isn't annotated with `#[const_trait]`
--> $SRC_DIR/core/src/ops/function.rs:LL:COL
diff --git a/tests/ui/traits/const-traits/const-trait-bounds-trait-objects.stderr b/tests/ui/traits/const-traits/const-trait-bounds-trait-objects.stderr
index c58e276..090555c 100644
--- a/tests/ui/traits/const-traits/const-trait-bounds-trait-objects.stderr
+++ b/tests/ui/traits/const-traits/const-trait-bounds-trait-objects.stderr
@@ -5,10 +5,10 @@
| ^^^^^^^^^^^
error: `[const]` is not allowed here
- --> $DIR/const-trait-bounds-trait-objects.rs:10:13
+ --> $DIR/const-trait-bounds-trait-objects.rs:10:17
|
LL | let _: &dyn [const] Trait;
- | ^^^^^^^^^^^
+ | ^^^^^^^
|
= note: trait objects cannot have `[const]` trait bounds
@@ -19,10 +19,10 @@
| ^^^^^^^^^^^^^^
error: `[const]` is not allowed here
- --> $DIR/const-trait-bounds-trait-objects.rs:17:19
+ --> $DIR/const-trait-bounds-trait-objects.rs:17:23
|
LL | const fn take(_: &dyn [const] NonConst) {}
- | ^^^^^^^^^^^
+ | ^^^^^^^
|
= note: trait objects cannot have `[const]` trait bounds
diff --git a/tests/ui/traits/const-traits/feature-gate.stock.stderr b/tests/ui/traits/const-traits/feature-gate.stock.stderr
index 37d76e7..f9d966f 100644
--- a/tests/ui/traits/const-traits/feature-gate.stock.stderr
+++ b/tests/ui/traits/const-traits/feature-gate.stock.stderr
@@ -9,10 +9,10 @@
= note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
error[E0658]: const trait impls are experimental
- --> $DIR/feature-gate.rs:13:13
+ --> $DIR/feature-gate.rs:13:15
|
LL | const fn f<A: [const] T>() {}
- | ^^^^^^^^^
+ | ^^^^^^^
|
= note: see issue #67792 <https://github.com/rust-lang/rust/issues/67792> for more information
= help: add `#![feature(const_trait_impl)]` to the crate attributes to enable
@@ -29,10 +29,10 @@
= note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
error[E0658]: const trait impls are experimental
- --> $DIR/feature-gate.rs:18:12
+ --> $DIR/feature-gate.rs:18:17
|
LL | discard! { impl [const] T }
- | ^^^^^^^^^^^^
+ | ^^^^^^^
|
= note: see issue #67792 <https://github.com/rust-lang/rust/issues/67792> for more information
= help: add `#![feature(const_trait_impl)]` to the crate attributes to enable
diff --git a/tests/ui/traits/const-traits/ice-112822-expected-type-for-param.stderr b/tests/ui/traits/const-traits/ice-112822-expected-type-for-param.stderr
index f340eaa..78d7b96 100644
--- a/tests/ui/traits/const-traits/ice-112822-expected-type-for-param.stderr
+++ b/tests/ui/traits/const-traits/ice-112822-expected-type-for-param.stderr
@@ -9,29 +9,29 @@
= note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
error: `[const]` can only be applied to `#[const_trait]` traits
- --> $DIR/ice-112822-expected-type-for-param.rs:3:20
+ --> $DIR/ice-112822-expected-type-for-param.rs:3:25
|
LL | const fn test() -> impl [const] Fn() {
- | ^^^^^^^^^^^^ can't be applied to `Fn`
+ | ^^^^^^^ can't be applied to `Fn`
|
note: `Fn` can't be used with `[const]` because it isn't annotated with `#[const_trait]`
--> $SRC_DIR/core/src/ops/function.rs:LL:COL
error: `[const]` can only be applied to `#[const_trait]` traits
- --> $DIR/ice-112822-expected-type-for-param.rs:3:20
+ --> $DIR/ice-112822-expected-type-for-param.rs:3:25
|
LL | const fn test() -> impl [const] Fn() {
- | ^^^^^^^^^^^^ can't be applied to `Fn`
+ | ^^^^^^^ can't be applied to `Fn`
|
note: `Fn` can't be used with `[const]` because it isn't annotated with `#[const_trait]`
--> $SRC_DIR/core/src/ops/function.rs:LL:COL
= note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
error: `[const]` can only be applied to `#[const_trait]` traits
- --> $DIR/ice-112822-expected-type-for-param.rs:3:20
+ --> $DIR/ice-112822-expected-type-for-param.rs:3:25
|
LL | const fn test() -> impl [const] Fn() {
- | ^^^^^^^^^^^^ can't be applied to `Fn`
+ | ^^^^^^^ can't be applied to `Fn`
|
note: `Fn` can't be used with `[const]` because it isn't annotated with `#[const_trait]`
--> $SRC_DIR/core/src/ops/function.rs:LL:COL
diff --git a/tests/ui/traits/const-traits/ice-123664-unexpected-bound-var.stderr b/tests/ui/traits/const-traits/ice-123664-unexpected-bound-var.stderr
index d8d7317..1eccb16 100644
--- a/tests/ui/traits/const-traits/ice-123664-unexpected-bound-var.stderr
+++ b/tests/ui/traits/const-traits/ice-123664-unexpected-bound-var.stderr
@@ -1,17 +1,17 @@
error: `[const]` can only be applied to `#[const_trait]` traits
- --> $DIR/ice-123664-unexpected-bound-var.rs:4:25
+ --> $DIR/ice-123664-unexpected-bound-var.rs:4:27
|
LL | const fn with_positive<F: [const] Fn()>() {}
- | ^^^^^^^^^ can't be applied to `Fn`
+ | ^^^^^^^ can't be applied to `Fn`
|
note: `Fn` can't be used with `[const]` because it isn't annotated with `#[const_trait]`
--> $SRC_DIR/core/src/ops/function.rs:LL:COL
error: `[const]` can only be applied to `#[const_trait]` traits
- --> $DIR/ice-123664-unexpected-bound-var.rs:4:25
+ --> $DIR/ice-123664-unexpected-bound-var.rs:4:27
|
LL | const fn with_positive<F: [const] Fn()>() {}
- | ^^^^^^^^^ can't be applied to `Fn`
+ | ^^^^^^^ can't be applied to `Fn`
|
note: `Fn` can't be used with `[const]` because it isn't annotated with `#[const_trait]`
--> $SRC_DIR/core/src/ops/function.rs:LL:COL
diff --git a/tests/ui/traits/const-traits/non-const-op-in-closure-in-const.stderr b/tests/ui/traits/const-traits/non-const-op-in-closure-in-const.stderr
index 8211b2b..e7f10e7 100644
--- a/tests/ui/traits/const-traits/non-const-op-in-closure-in-const.stderr
+++ b/tests/ui/traits/const-traits/non-const-op-in-closure-in-const.stderr
@@ -1,17 +1,17 @@
error: `[const]` can only be applied to `#[const_trait]` traits
- --> $DIR/non-const-op-in-closure-in-const.rs:10:42
+ --> $DIR/non-const-op-in-closure-in-const.rs:10:44
|
LL | impl<A, B> const Convert<B> for A where B: [const] From<A> {
- | ^^^^^^^^^ can't be applied to `From`
+ | ^^^^^^^ can't be applied to `From`
|
note: `From` can't be used with `[const]` because it isn't annotated with `#[const_trait]`
--> $SRC_DIR/core/src/convert/mod.rs:LL:COL
error: `[const]` can only be applied to `#[const_trait]` traits
- --> $DIR/non-const-op-in-closure-in-const.rs:10:42
+ --> $DIR/non-const-op-in-closure-in-const.rs:10:44
|
LL | impl<A, B> const Convert<B> for A where B: [const] From<A> {
- | ^^^^^^^^^ can't be applied to `From`
+ | ^^^^^^^ can't be applied to `From`
|
note: `From` can't be used with `[const]` because it isn't annotated with `#[const_trait]`
--> $SRC_DIR/core/src/convert/mod.rs:LL:COL
diff --git a/tests/ui/traits/const-traits/super-traits-fail-2.nn.stderr b/tests/ui/traits/const-traits/super-traits-fail-2.nn.stderr
index 11f73cb..19f072b 100644
--- a/tests/ui/traits/const-traits/super-traits-fail-2.nn.stderr
+++ b/tests/ui/traits/const-traits/super-traits-fail-2.nn.stderr
@@ -1,8 +1,8 @@
error: `[const]` is not allowed here
- --> $DIR/super-traits-fail-2.rs:11:10
+ --> $DIR/super-traits-fail-2.rs:11:12
|
LL | trait Bar: [const] Foo {}
- | ^^^^^^^^^
+ | ^^^^^^^
|
note: this trait is not a `#[const_trait]`, so it cannot have `[const]` trait bounds
--> $DIR/super-traits-fail-2.rs:11:1
@@ -11,10 +11,10 @@
| ^^^^^^^^^^^^^^^^^^^^^^^^^
error: `[const]` can only be applied to `#[const_trait]` traits
- --> $DIR/super-traits-fail-2.rs:11:10
+ --> $DIR/super-traits-fail-2.rs:11:12
|
LL | trait Bar: [const] Foo {}
- | ^^^^^^^^^ can't be applied to `Foo`
+ | ^^^^^^^ can't be applied to `Foo`
|
help: mark `Foo` as `#[const_trait]` to allow it to have `const` implementations
|
@@ -22,10 +22,10 @@
| ++++++++++++++
error: `[const]` can only be applied to `#[const_trait]` traits
- --> $DIR/super-traits-fail-2.rs:11:10
+ --> $DIR/super-traits-fail-2.rs:11:12
|
LL | trait Bar: [const] Foo {}
- | ^^^^^^^^^ can't be applied to `Foo`
+ | ^^^^^^^ can't be applied to `Foo`
|
= note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
help: mark `Foo` as `#[const_trait]` to allow it to have `const` implementations
@@ -34,10 +34,10 @@
| ++++++++++++++
error: `[const]` can only be applied to `#[const_trait]` traits
- --> $DIR/super-traits-fail-2.rs:11:10
+ --> $DIR/super-traits-fail-2.rs:11:12
|
LL | trait Bar: [const] Foo {}
- | ^^^^^^^^^ can't be applied to `Foo`
+ | ^^^^^^^ can't be applied to `Foo`
|
= note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
help: mark `Foo` as `#[const_trait]` to allow it to have `const` implementations
diff --git a/tests/ui/traits/const-traits/super-traits-fail-2.ny.stderr b/tests/ui/traits/const-traits/super-traits-fail-2.ny.stderr
index 1767672..4921f78 100644
--- a/tests/ui/traits/const-traits/super-traits-fail-2.ny.stderr
+++ b/tests/ui/traits/const-traits/super-traits-fail-2.ny.stderr
@@ -1,8 +1,8 @@
error: `[const]` can only be applied to `#[const_trait]` traits
- --> $DIR/super-traits-fail-2.rs:11:10
+ --> $DIR/super-traits-fail-2.rs:11:12
|
LL | trait Bar: [const] Foo {}
- | ^^^^^^^^^ can't be applied to `Foo`
+ | ^^^^^^^ can't be applied to `Foo`
|
help: mark `Foo` as `#[const_trait]` to allow it to have `const` implementations
|
@@ -10,10 +10,10 @@
| ++++++++++++++
error: `[const]` can only be applied to `#[const_trait]` traits
- --> $DIR/super-traits-fail-2.rs:11:10
+ --> $DIR/super-traits-fail-2.rs:11:12
|
LL | trait Bar: [const] Foo {}
- | ^^^^^^^^^ can't be applied to `Foo`
+ | ^^^^^^^ can't be applied to `Foo`
|
= note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
help: mark `Foo` as `#[const_trait]` to allow it to have `const` implementations
@@ -22,10 +22,10 @@
| ++++++++++++++
error: `[const]` can only be applied to `#[const_trait]` traits
- --> $DIR/super-traits-fail-2.rs:11:10
+ --> $DIR/super-traits-fail-2.rs:11:12
|
LL | trait Bar: [const] Foo {}
- | ^^^^^^^^^ can't be applied to `Foo`
+ | ^^^^^^^ can't be applied to `Foo`
|
= note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
help: mark `Foo` as `#[const_trait]` to allow it to have `const` implementations
@@ -34,10 +34,10 @@
| ++++++++++++++
error: `[const]` can only be applied to `#[const_trait]` traits
- --> $DIR/super-traits-fail-2.rs:11:10
+ --> $DIR/super-traits-fail-2.rs:11:12
|
LL | trait Bar: [const] Foo {}
- | ^^^^^^^^^ can't be applied to `Foo`
+ | ^^^^^^^ can't be applied to `Foo`
|
= note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
help: mark `Foo` as `#[const_trait]` to allow it to have `const` implementations
@@ -46,10 +46,10 @@
| ++++++++++++++
error: `[const]` can only be applied to `#[const_trait]` traits
- --> $DIR/super-traits-fail-2.rs:11:10
+ --> $DIR/super-traits-fail-2.rs:11:12
|
LL | trait Bar: [const] Foo {}
- | ^^^^^^^^^ can't be applied to `Foo`
+ | ^^^^^^^ can't be applied to `Foo`
|
= note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
help: mark `Foo` as `#[const_trait]` to allow it to have `const` implementations
diff --git a/tests/ui/traits/const-traits/super-traits-fail-2.yn.stderr b/tests/ui/traits/const-traits/super-traits-fail-2.yn.stderr
index 63c33a0..a151349 100644
--- a/tests/ui/traits/const-traits/super-traits-fail-2.yn.stderr
+++ b/tests/ui/traits/const-traits/super-traits-fail-2.yn.stderr
@@ -1,8 +1,8 @@
error: `[const]` is not allowed here
- --> $DIR/super-traits-fail-2.rs:11:10
+ --> $DIR/super-traits-fail-2.rs:11:12
|
LL | trait Bar: [const] Foo {}
- | ^^^^^^^^^
+ | ^^^^^^^
|
note: this trait is not a `#[const_trait]`, so it cannot have `[const]` trait bounds
--> $DIR/super-traits-fail-2.rs:11:1
diff --git a/tests/ui/traits/const-traits/super-traits-fail-3.nnn.stderr b/tests/ui/traits/const-traits/super-traits-fail-3.nnn.stderr
index c6a06d0..eb1beb4 100644
--- a/tests/ui/traits/const-traits/super-traits-fail-3.nnn.stderr
+++ b/tests/ui/traits/const-traits/super-traits-fail-3.nnn.stderr
@@ -1,8 +1,8 @@
error: `[const]` is not allowed here
- --> $DIR/super-traits-fail-3.rs:23:10
+ --> $DIR/super-traits-fail-3.rs:23:12
|
LL | trait Bar: [const] Foo {}
- | ^^^^^^^^^
+ | ^^^^^^^
|
note: this trait is not a `#[const_trait]`, so it cannot have `[const]` trait bounds
--> $DIR/super-traits-fail-3.rs:23:1
@@ -11,30 +11,30 @@
| ^^^^^^^^^^^^^^^^^^^^^^^^^
error[E0658]: const trait impls are experimental
- --> $DIR/super-traits-fail-3.rs:23:10
+ --> $DIR/super-traits-fail-3.rs:23:12
|
LL | trait Bar: [const] Foo {}
- | ^^^^^^^^^
+ | ^^^^^^^
|
= note: see issue #67792 <https://github.com/rust-lang/rust/issues/67792> for more information
= help: add `#![feature(const_trait_impl)]` to the crate attributes to enable
= note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
error[E0658]: const trait impls are experimental
- --> $DIR/super-traits-fail-3.rs:32:15
+ --> $DIR/super-traits-fail-3.rs:32:17
|
LL | const fn foo<T: [const] Bar>(x: &T) {
- | ^^^^^^^^^
+ | ^^^^^^^
|
= note: see issue #67792 <https://github.com/rust-lang/rust/issues/67792> for more information
= help: add `#![feature(const_trait_impl)]` to the crate attributes to enable
= note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
error: `[const]` can only be applied to `#[const_trait]` traits
- --> $DIR/super-traits-fail-3.rs:23:10
+ --> $DIR/super-traits-fail-3.rs:23:12
|
LL | trait Bar: [const] Foo {}
- | ^^^^^^^^^ can't be applied to `Foo`
+ | ^^^^^^^ can't be applied to `Foo`
|
help: enable `#![feature(const_trait_impl)]` in your crate and mark `Foo` as `#[const_trait]` to allow it to have `const` implementations
|
@@ -42,10 +42,10 @@
| ++++++++++++++
error: `[const]` can only be applied to `#[const_trait]` traits
- --> $DIR/super-traits-fail-3.rs:23:10
+ --> $DIR/super-traits-fail-3.rs:23:12
|
LL | trait Bar: [const] Foo {}
- | ^^^^^^^^^ can't be applied to `Foo`
+ | ^^^^^^^ can't be applied to `Foo`
|
= note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
help: enable `#![feature(const_trait_impl)]` in your crate and mark `Foo` as `#[const_trait]` to allow it to have `const` implementations
@@ -54,10 +54,10 @@
| ++++++++++++++
error: `[const]` can only be applied to `#[const_trait]` traits
- --> $DIR/super-traits-fail-3.rs:23:10
+ --> $DIR/super-traits-fail-3.rs:23:12
|
LL | trait Bar: [const] Foo {}
- | ^^^^^^^^^ can't be applied to `Foo`
+ | ^^^^^^^ can't be applied to `Foo`
|
= note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
help: enable `#![feature(const_trait_impl)]` in your crate and mark `Foo` as `#[const_trait]` to allow it to have `const` implementations
@@ -66,10 +66,10 @@
| ++++++++++++++
error: `[const]` can only be applied to `#[const_trait]` traits
- --> $DIR/super-traits-fail-3.rs:32:15
+ --> $DIR/super-traits-fail-3.rs:32:17
|
LL | const fn foo<T: [const] Bar>(x: &T) {
- | ^^^^^^^^^ can't be applied to `Bar`
+ | ^^^^^^^ can't be applied to `Bar`
|
help: enable `#![feature(const_trait_impl)]` in your crate and mark `Bar` as `#[const_trait]` to allow it to have `const` implementations
|
@@ -77,10 +77,10 @@
| ++++++++++++++
error: `[const]` can only be applied to `#[const_trait]` traits
- --> $DIR/super-traits-fail-3.rs:32:15
+ --> $DIR/super-traits-fail-3.rs:32:17
|
LL | const fn foo<T: [const] Bar>(x: &T) {
- | ^^^^^^^^^ can't be applied to `Bar`
+ | ^^^^^^^ can't be applied to `Bar`
|
= note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
help: enable `#![feature(const_trait_impl)]` in your crate and mark `Bar` as `#[const_trait]` to allow it to have `const` implementations
diff --git a/tests/ui/traits/const-traits/super-traits-fail-3.nny.stderr b/tests/ui/traits/const-traits/super-traits-fail-3.nny.stderr
index c6a06d0..eb1beb4 100644
--- a/tests/ui/traits/const-traits/super-traits-fail-3.nny.stderr
+++ b/tests/ui/traits/const-traits/super-traits-fail-3.nny.stderr
@@ -1,8 +1,8 @@
error: `[const]` is not allowed here
- --> $DIR/super-traits-fail-3.rs:23:10
+ --> $DIR/super-traits-fail-3.rs:23:12
|
LL | trait Bar: [const] Foo {}
- | ^^^^^^^^^
+ | ^^^^^^^
|
note: this trait is not a `#[const_trait]`, so it cannot have `[const]` trait bounds
--> $DIR/super-traits-fail-3.rs:23:1
@@ -11,30 +11,30 @@
| ^^^^^^^^^^^^^^^^^^^^^^^^^
error[E0658]: const trait impls are experimental
- --> $DIR/super-traits-fail-3.rs:23:10
+ --> $DIR/super-traits-fail-3.rs:23:12
|
LL | trait Bar: [const] Foo {}
- | ^^^^^^^^^
+ | ^^^^^^^
|
= note: see issue #67792 <https://github.com/rust-lang/rust/issues/67792> for more information
= help: add `#![feature(const_trait_impl)]` to the crate attributes to enable
= note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
error[E0658]: const trait impls are experimental
- --> $DIR/super-traits-fail-3.rs:32:15
+ --> $DIR/super-traits-fail-3.rs:32:17
|
LL | const fn foo<T: [const] Bar>(x: &T) {
- | ^^^^^^^^^
+ | ^^^^^^^
|
= note: see issue #67792 <https://github.com/rust-lang/rust/issues/67792> for more information
= help: add `#![feature(const_trait_impl)]` to the crate attributes to enable
= note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
error: `[const]` can only be applied to `#[const_trait]` traits
- --> $DIR/super-traits-fail-3.rs:23:10
+ --> $DIR/super-traits-fail-3.rs:23:12
|
LL | trait Bar: [const] Foo {}
- | ^^^^^^^^^ can't be applied to `Foo`
+ | ^^^^^^^ can't be applied to `Foo`
|
help: enable `#![feature(const_trait_impl)]` in your crate and mark `Foo` as `#[const_trait]` to allow it to have `const` implementations
|
@@ -42,10 +42,10 @@
| ++++++++++++++
error: `[const]` can only be applied to `#[const_trait]` traits
- --> $DIR/super-traits-fail-3.rs:23:10
+ --> $DIR/super-traits-fail-3.rs:23:12
|
LL | trait Bar: [const] Foo {}
- | ^^^^^^^^^ can't be applied to `Foo`
+ | ^^^^^^^ can't be applied to `Foo`
|
= note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
help: enable `#![feature(const_trait_impl)]` in your crate and mark `Foo` as `#[const_trait]` to allow it to have `const` implementations
@@ -54,10 +54,10 @@
| ++++++++++++++
error: `[const]` can only be applied to `#[const_trait]` traits
- --> $DIR/super-traits-fail-3.rs:23:10
+ --> $DIR/super-traits-fail-3.rs:23:12
|
LL | trait Bar: [const] Foo {}
- | ^^^^^^^^^ can't be applied to `Foo`
+ | ^^^^^^^ can't be applied to `Foo`
|
= note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
help: enable `#![feature(const_trait_impl)]` in your crate and mark `Foo` as `#[const_trait]` to allow it to have `const` implementations
@@ -66,10 +66,10 @@
| ++++++++++++++
error: `[const]` can only be applied to `#[const_trait]` traits
- --> $DIR/super-traits-fail-3.rs:32:15
+ --> $DIR/super-traits-fail-3.rs:32:17
|
LL | const fn foo<T: [const] Bar>(x: &T) {
- | ^^^^^^^^^ can't be applied to `Bar`
+ | ^^^^^^^ can't be applied to `Bar`
|
help: enable `#![feature(const_trait_impl)]` in your crate and mark `Bar` as `#[const_trait]` to allow it to have `const` implementations
|
@@ -77,10 +77,10 @@
| ++++++++++++++
error: `[const]` can only be applied to `#[const_trait]` traits
- --> $DIR/super-traits-fail-3.rs:32:15
+ --> $DIR/super-traits-fail-3.rs:32:17
|
LL | const fn foo<T: [const] Bar>(x: &T) {
- | ^^^^^^^^^ can't be applied to `Bar`
+ | ^^^^^^^ can't be applied to `Bar`
|
= note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
help: enable `#![feature(const_trait_impl)]` in your crate and mark `Bar` as `#[const_trait]` to allow it to have `const` implementations
diff --git a/tests/ui/traits/const-traits/super-traits-fail-3.nyn.stderr b/tests/ui/traits/const-traits/super-traits-fail-3.nyn.stderr
index feca029..7c46573 100644
--- a/tests/ui/traits/const-traits/super-traits-fail-3.nyn.stderr
+++ b/tests/ui/traits/const-traits/super-traits-fail-3.nyn.stderr
@@ -1,18 +1,18 @@
error[E0658]: const trait impls are experimental
- --> $DIR/super-traits-fail-3.rs:23:10
+ --> $DIR/super-traits-fail-3.rs:23:12
|
LL | trait Bar: [const] Foo {}
- | ^^^^^^^^^
+ | ^^^^^^^
|
= note: see issue #67792 <https://github.com/rust-lang/rust/issues/67792> for more information
= help: add `#![feature(const_trait_impl)]` to the crate attributes to enable
= note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
error[E0658]: const trait impls are experimental
- --> $DIR/super-traits-fail-3.rs:32:15
+ --> $DIR/super-traits-fail-3.rs:32:17
|
LL | const fn foo<T: [const] Bar>(x: &T) {
- | ^^^^^^^^^
+ | ^^^^^^^
|
= note: see issue #67792 <https://github.com/rust-lang/rust/issues/67792> for more information
= help: add `#![feature(const_trait_impl)]` to the crate attributes to enable
diff --git a/tests/ui/traits/const-traits/super-traits-fail-3.nyy.stderr b/tests/ui/traits/const-traits/super-traits-fail-3.nyy.stderr
index feca029..7c46573 100644
--- a/tests/ui/traits/const-traits/super-traits-fail-3.nyy.stderr
+++ b/tests/ui/traits/const-traits/super-traits-fail-3.nyy.stderr
@@ -1,18 +1,18 @@
error[E0658]: const trait impls are experimental
- --> $DIR/super-traits-fail-3.rs:23:10
+ --> $DIR/super-traits-fail-3.rs:23:12
|
LL | trait Bar: [const] Foo {}
- | ^^^^^^^^^
+ | ^^^^^^^
|
= note: see issue #67792 <https://github.com/rust-lang/rust/issues/67792> for more information
= help: add `#![feature(const_trait_impl)]` to the crate attributes to enable
= note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
error[E0658]: const trait impls are experimental
- --> $DIR/super-traits-fail-3.rs:32:15
+ --> $DIR/super-traits-fail-3.rs:32:17
|
LL | const fn foo<T: [const] Bar>(x: &T) {
- | ^^^^^^^^^
+ | ^^^^^^^
|
= note: see issue #67792 <https://github.com/rust-lang/rust/issues/67792> for more information
= help: add `#![feature(const_trait_impl)]` to the crate attributes to enable
diff --git a/tests/ui/traits/const-traits/super-traits-fail-3.ynn.stderr b/tests/ui/traits/const-traits/super-traits-fail-3.ynn.stderr
index d9112c9..89e090b 100644
--- a/tests/ui/traits/const-traits/super-traits-fail-3.ynn.stderr
+++ b/tests/ui/traits/const-traits/super-traits-fail-3.ynn.stderr
@@ -1,8 +1,8 @@
error: `[const]` is not allowed here
- --> $DIR/super-traits-fail-3.rs:23:10
+ --> $DIR/super-traits-fail-3.rs:23:12
|
LL | trait Bar: [const] Foo {}
- | ^^^^^^^^^
+ | ^^^^^^^
|
note: this trait is not a `#[const_trait]`, so it cannot have `[const]` trait bounds
--> $DIR/super-traits-fail-3.rs:23:1
@@ -11,10 +11,10 @@
| ^^^^^^^^^^^^^^^^^^^^^^^^^
error: `[const]` can only be applied to `#[const_trait]` traits
- --> $DIR/super-traits-fail-3.rs:23:10
+ --> $DIR/super-traits-fail-3.rs:23:12
|
LL | trait Bar: [const] Foo {}
- | ^^^^^^^^^ can't be applied to `Foo`
+ | ^^^^^^^ can't be applied to `Foo`
|
help: mark `Foo` as `#[const_trait]` to allow it to have `const` implementations
|
@@ -22,10 +22,10 @@
| ++++++++++++++
error: `[const]` can only be applied to `#[const_trait]` traits
- --> $DIR/super-traits-fail-3.rs:23:10
+ --> $DIR/super-traits-fail-3.rs:23:12
|
LL | trait Bar: [const] Foo {}
- | ^^^^^^^^^ can't be applied to `Foo`
+ | ^^^^^^^ can't be applied to `Foo`
|
= note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
help: mark `Foo` as `#[const_trait]` to allow it to have `const` implementations
@@ -34,10 +34,10 @@
| ++++++++++++++
error: `[const]` can only be applied to `#[const_trait]` traits
- --> $DIR/super-traits-fail-3.rs:23:10
+ --> $DIR/super-traits-fail-3.rs:23:12
|
LL | trait Bar: [const] Foo {}
- | ^^^^^^^^^ can't be applied to `Foo`
+ | ^^^^^^^ can't be applied to `Foo`
|
= note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
help: mark `Foo` as `#[const_trait]` to allow it to have `const` implementations
@@ -46,10 +46,10 @@
| ++++++++++++++
error: `[const]` can only be applied to `#[const_trait]` traits
- --> $DIR/super-traits-fail-3.rs:32:15
+ --> $DIR/super-traits-fail-3.rs:32:17
|
LL | const fn foo<T: [const] Bar>(x: &T) {
- | ^^^^^^^^^ can't be applied to `Bar`
+ | ^^^^^^^ can't be applied to `Bar`
|
help: mark `Bar` as `#[const_trait]` to allow it to have `const` implementations
|
@@ -57,10 +57,10 @@
| ++++++++++++++
error: `[const]` can only be applied to `#[const_trait]` traits
- --> $DIR/super-traits-fail-3.rs:32:15
+ --> $DIR/super-traits-fail-3.rs:32:17
|
LL | const fn foo<T: [const] Bar>(x: &T) {
- | ^^^^^^^^^ can't be applied to `Bar`
+ | ^^^^^^^ can't be applied to `Bar`
|
= note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
help: mark `Bar` as `#[const_trait]` to allow it to have `const` implementations
diff --git a/tests/ui/traits/const-traits/super-traits-fail-3.yny.stderr b/tests/ui/traits/const-traits/super-traits-fail-3.yny.stderr
index 3520b61..683eeb7 100644
--- a/tests/ui/traits/const-traits/super-traits-fail-3.yny.stderr
+++ b/tests/ui/traits/const-traits/super-traits-fail-3.yny.stderr
@@ -1,8 +1,8 @@
error: `[const]` can only be applied to `#[const_trait]` traits
- --> $DIR/super-traits-fail-3.rs:23:10
+ --> $DIR/super-traits-fail-3.rs:23:12
|
LL | trait Bar: [const] Foo {}
- | ^^^^^^^^^ can't be applied to `Foo`
+ | ^^^^^^^ can't be applied to `Foo`
|
help: mark `Foo` as `#[const_trait]` to allow it to have `const` implementations
|
@@ -10,10 +10,10 @@
| ++++++++++++++
error: `[const]` can only be applied to `#[const_trait]` traits
- --> $DIR/super-traits-fail-3.rs:23:10
+ --> $DIR/super-traits-fail-3.rs:23:12
|
LL | trait Bar: [const] Foo {}
- | ^^^^^^^^^ can't be applied to `Foo`
+ | ^^^^^^^ can't be applied to `Foo`
|
= note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
help: mark `Foo` as `#[const_trait]` to allow it to have `const` implementations
@@ -22,10 +22,10 @@
| ++++++++++++++
error: `[const]` can only be applied to `#[const_trait]` traits
- --> $DIR/super-traits-fail-3.rs:23:10
+ --> $DIR/super-traits-fail-3.rs:23:12
|
LL | trait Bar: [const] Foo {}
- | ^^^^^^^^^ can't be applied to `Foo`
+ | ^^^^^^^ can't be applied to `Foo`
|
= note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
help: mark `Foo` as `#[const_trait]` to allow it to have `const` implementations
@@ -34,10 +34,10 @@
| ++++++++++++++
error: `[const]` can only be applied to `#[const_trait]` traits
- --> $DIR/super-traits-fail-3.rs:23:10
+ --> $DIR/super-traits-fail-3.rs:23:12
|
LL | trait Bar: [const] Foo {}
- | ^^^^^^^^^ can't be applied to `Foo`
+ | ^^^^^^^ can't be applied to `Foo`
|
= note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
help: mark `Foo` as `#[const_trait]` to allow it to have `const` implementations
@@ -46,10 +46,10 @@
| ++++++++++++++
error: `[const]` can only be applied to `#[const_trait]` traits
- --> $DIR/super-traits-fail-3.rs:23:10
+ --> $DIR/super-traits-fail-3.rs:23:12
|
LL | trait Bar: [const] Foo {}
- | ^^^^^^^^^ can't be applied to `Foo`
+ | ^^^^^^^ can't be applied to `Foo`
|
= note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
help: mark `Foo` as `#[const_trait]` to allow it to have `const` implementations
diff --git a/tests/ui/traits/const-traits/super-traits-fail-3.yyn.stderr b/tests/ui/traits/const-traits/super-traits-fail-3.yyn.stderr
index d714118..39cfdfe 100644
--- a/tests/ui/traits/const-traits/super-traits-fail-3.yyn.stderr
+++ b/tests/ui/traits/const-traits/super-traits-fail-3.yyn.stderr
@@ -1,8 +1,8 @@
error: `[const]` is not allowed here
- --> $DIR/super-traits-fail-3.rs:23:10
+ --> $DIR/super-traits-fail-3.rs:23:12
|
LL | trait Bar: [const] Foo {}
- | ^^^^^^^^^
+ | ^^^^^^^
|
note: this trait is not a `#[const_trait]`, so it cannot have `[const]` trait bounds
--> $DIR/super-traits-fail-3.rs:23:1
@@ -11,10 +11,10 @@
| ^^^^^^^^^^^^^^^^^^^^^^^^^
error: `[const]` can only be applied to `#[const_trait]` traits
- --> $DIR/super-traits-fail-3.rs:32:15
+ --> $DIR/super-traits-fail-3.rs:32:17
|
LL | const fn foo<T: [const] Bar>(x: &T) {
- | ^^^^^^^^^ can't be applied to `Bar`
+ | ^^^^^^^ can't be applied to `Bar`
|
help: mark `Bar` as `#[const_trait]` to allow it to have `const` implementations
|
@@ -22,10 +22,10 @@
| ++++++++++++++
error: `[const]` can only be applied to `#[const_trait]` traits
- --> $DIR/super-traits-fail-3.rs:32:15
+ --> $DIR/super-traits-fail-3.rs:32:17
|
LL | const fn foo<T: [const] Bar>(x: &T) {
- | ^^^^^^^^^ can't be applied to `Bar`
+ | ^^^^^^^ can't be applied to `Bar`
|
= note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
help: mark `Bar` as `#[const_trait]` to allow it to have `const` implementations
diff --git a/tests/ui/traits/const-traits/syntactical-unstable.stderr b/tests/ui/traits/const-traits/syntactical-unstable.stderr
index 657773d..b8cc8e6 100644
--- a/tests/ui/traits/const-traits/syntactical-unstable.stderr
+++ b/tests/ui/traits/const-traits/syntactical-unstable.stderr
@@ -2,9 +2,9 @@
--> $DIR/syntactical-unstable.rs:13:20
|
LL | trait Foo: [const] MyTrait {
- | --------- ^^^^^^^
- | |
- | trait is not stable as const yet
+ | ------- ^^^^^^^
+ | |
+ | trait is not stable as const yet
|
= help: add `#![feature(unstable)]` to the crate attributes to enable
= note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
@@ -13,9 +13,9 @@
--> $DIR/syntactical-unstable.rs:19:45
|
LL | const fn where_clause<T>() where T: [const] MyTrait {}
- | --------- ^^^^^^^
- | |
- | trait is not stable as const yet
+ | ------- ^^^^^^^
+ | |
+ | trait is not stable as const yet
|
= help: add `#![feature(unstable)]` to the crate attributes to enable
= note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
@@ -24,9 +24,9 @@
--> $DIR/syntactical-unstable.rs:22:53
|
LL | const fn nested<T>() where T: Deref<Target: [const] MyTrait> {}
- | --------- ^^^^^^^
- | |
- | trait is not stable as const yet
+ | ------- ^^^^^^^
+ | |
+ | trait is not stable as const yet
|
= help: add `#![feature(unstable)]` to the crate attributes to enable
= note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
@@ -35,9 +35,9 @@
--> $DIR/syntactical-unstable.rs:25:33
|
LL | const fn rpit() -> impl [const] MyTrait { Local }
- | ------------ ^^^^^^^
- | |
- | trait is not stable as const yet
+ | ------- ^^^^^^^
+ | |
+ | trait is not stable as const yet
|
= help: add `#![feature(unstable)]` to the crate attributes to enable
= note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
@@ -55,9 +55,9 @@
--> $DIR/syntactical-unstable.rs:15:24
|
LL | type Item: [const] MyTrait;
- | --------- ^^^^^^^
- | |
- | trait is not stable as const yet
+ | ------- ^^^^^^^
+ | |
+ | trait is not stable as const yet
|
= help: add `#![feature(unstable)]` to the crate attributes to enable
= note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
diff --git a/tests/ui/traits/const-traits/trait-where-clause.stderr b/tests/ui/traits/const-traits/trait-where-clause.stderr
index 04c6790..dda91e6 100644
--- a/tests/ui/traits/const-traits/trait-where-clause.stderr
+++ b/tests/ui/traits/const-traits/trait-where-clause.stderr
@@ -1,8 +1,8 @@
error: `[const]` is not allowed here
- --> $DIR/trait-where-clause.rs:8:22
+ --> $DIR/trait-where-clause.rs:8:24
|
LL | fn b() where Self: [const] Bar;
- | ^^^^^^^^^
+ | ^^^^^^^
|
note: this function is not `const`, so it cannot have `[const]` trait bounds
--> $DIR/trait-where-clause.rs:8:8
@@ -11,10 +11,10 @@
| ^
error: `[const]` is not allowed here
- --> $DIR/trait-where-clause.rs:10:11
+ --> $DIR/trait-where-clause.rs:10:13
|
LL | fn c<T: [const] Bar>();
- | ^^^^^^^^^
+ | ^^^^^^^
|
note: this function is not `const`, so it cannot have `[const]` trait bounds
--> $DIR/trait-where-clause.rs:10:8
diff --git a/tests/ui/traits/constrained-type-params-trait-impl.rs b/tests/ui/traits/constrained-type-params-trait-impl.rs
new file mode 100644
index 0000000..301bbdb
--- /dev/null
+++ b/tests/ui/traits/constrained-type-params-trait-impl.rs
@@ -0,0 +1,75 @@
+//! Comprehensive test for type parameter constraints in trait implementations
+//!
+//! This tests various scenarios of type parameter usage in trait implementations:
+//! - Properly constrained parameters through trait bounds
+//! - Unconstrained parameters that should cause compilation errors
+//! - Complex constraint scenarios with `where` clauses and associated types
+//! - Conflicting implementations detection
+
+trait Foo<A> {
+ fn get(&self, A: &A) {}
+}
+
+trait Bar {
+ type Out;
+}
+
+impl<T> Foo<T> for [isize; 0] {
+ // OK: T is used in the trait bound `Foo<T>`
+}
+
+impl<T, U> Foo<T> for [isize; 1] {
+ //~^ ERROR the type parameter `U` is not constrained
+ // T is constrained by `Foo<T>`, but U is completely unused
+}
+
+impl<T, U> Foo<T> for [isize; 2]
+where
+ T: Bar<Out = U>,
+{
+ // OK: T is constrained by `Foo<T>`, U is constrained by the where clause
+}
+
+impl<T: Bar<Out = U>, U> Foo<T> for [isize; 3] {
+ // OK: Same as above but using bound syntax instead of where clause
+}
+
+impl<T, U> Foo<T> for U {
+ //~^ ERROR conflicting implementations of trait `Foo<_>` for type `[isize; 0]`
+ // This conflicts with the first impl when U = [isize; 0]
+}
+
+impl<T, U> Bar for T {
+ //~^ ERROR the type parameter `U` is not constrained
+ type Out = U;
+ // Using U only in associated type definition is insufficient for constraint
+}
+
+impl<T, U> Bar for T
+where
+ T: Bar<Out = U>,
+{
+ //~^^^^ ERROR the type parameter `U` is not constrained by the impl trait, self type, or predicates
+ //~| ERROR conflicting implementations of trait `Bar`
+ // Self-referential constraint doesn't properly constrain U
+}
+
+impl<T, U, V> Foo<T> for T
+where
+ (T, U): Bar<Out = V>,
+{
+ //~^^^^ ERROR the type parameter `U` is not constrained
+ //~| ERROR the type parameter `V` is not constrained
+ //~| ERROR conflicting implementations of trait `Foo<[isize; 0]>` for type `[isize; 0]`
+ // V is bound through output type, but U and V are not properly constrained as inputs
+}
+
+impl<T, U, V> Foo<(T, U)> for T
+where
+ (T, U): Bar<Out = V>,
+{
+ //~^^^^ ERROR conflicting implementations of trait `Foo<([isize; 0], _)>` for type `[isize; 0]`
+ // Both T and U are constrained through `Foo<(T, U)>`, but creates conflicting impl
+}
+
+fn main() {}
diff --git a/tests/ui/impl-unused-tps.stderr b/tests/ui/traits/constrained-type-params-trait-impl.stderr
similarity index 82%
rename from tests/ui/impl-unused-tps.stderr
rename to tests/ui/traits/constrained-type-params-trait-impl.stderr
index eff5fff..2175129 100644
--- a/tests/ui/impl-unused-tps.stderr
+++ b/tests/ui/traits/constrained-type-params-trait-impl.stderr
@@ -1,5 +1,5 @@
error[E0119]: conflicting implementations of trait `Foo<_>` for type `[isize; 0]`
- --> $DIR/impl-unused-tps.rs:28:1
+ --> $DIR/constrained-type-params-trait-impl.rs:37:1
|
LL | impl<T> Foo<T> for [isize; 0] {
| ----------------------------- first implementation here
@@ -8,7 +8,7 @@
| ^^^^^^^^^^^^^^^^^^^^^^^ conflicting implementation for `[isize; 0]`
error[E0119]: conflicting implementations of trait `Foo<[isize; 0]>` for type `[isize; 0]`
- --> $DIR/impl-unused-tps.rs:49:1
+ --> $DIR/constrained-type-params-trait-impl.rs:57:1
|
LL | impl<T> Foo<T> for [isize; 0] {
| ----------------------------- first implementation here
@@ -19,7 +19,7 @@
| |_________________________^ conflicting implementation for `[isize; 0]`
error[E0119]: conflicting implementations of trait `Foo<([isize; 0], _)>` for type `[isize; 0]`
- --> $DIR/impl-unused-tps.rs:61:1
+ --> $DIR/constrained-type-params-trait-impl.rs:67:1
|
LL | impl<T> Foo<T> for [isize; 0] {
| ----------------------------- first implementation here
@@ -30,37 +30,37 @@
| |_________________________^ conflicting implementation for `[isize; 0]`
error[E0207]: the type parameter `U` is not constrained by the impl trait, self type, or predicates
- --> $DIR/impl-unused-tps.rs:13:9
+ --> $DIR/constrained-type-params-trait-impl.rs:21:9
|
LL | impl<T, U> Foo<T> for [isize; 1] {
| ^ unconstrained type parameter
error[E0207]: the type parameter `U` is not constrained by the impl trait, self type, or predicates
- --> $DIR/impl-unused-tps.rs:32:9
+ --> $DIR/constrained-type-params-trait-impl.rs:42:9
|
LL | impl<T, U> Bar for T {
| ^ unconstrained type parameter
error[E0207]: the type parameter `U` is not constrained by the impl trait, self type, or predicates
- --> $DIR/impl-unused-tps.rs:40:9
+ --> $DIR/constrained-type-params-trait-impl.rs:48:9
|
LL | impl<T, U> Bar for T
| ^ unconstrained type parameter
error[E0207]: the type parameter `U` is not constrained by the impl trait, self type, or predicates
- --> $DIR/impl-unused-tps.rs:49:9
+ --> $DIR/constrained-type-params-trait-impl.rs:57:9
|
LL | impl<T, U, V> Foo<T> for T
| ^ unconstrained type parameter
error[E0207]: the type parameter `V` is not constrained by the impl trait, self type, or predicates
- --> $DIR/impl-unused-tps.rs:49:12
+ --> $DIR/constrained-type-params-trait-impl.rs:57:12
|
LL | impl<T, U, V> Foo<T> for T
| ^ unconstrained type parameter
error[E0119]: conflicting implementations of trait `Bar`
- --> $DIR/impl-unused-tps.rs:40:1
+ --> $DIR/constrained-type-params-trait-impl.rs:48:1
|
LL | impl<T, U> Bar for T {
| -------------------- first implementation here
diff --git a/tests/ui/traits/dispatch-from-dyn-invalid-impls.rs b/tests/ui/traits/dispatch-from-dyn-invalid-impls.rs
new file mode 100644
index 0000000..f5f66ca6
--- /dev/null
+++ b/tests/ui/traits/dispatch-from-dyn-invalid-impls.rs
@@ -0,0 +1,71 @@
+//! Test various invalid implementations of DispatchFromDyn trait.
+//!
+//! DispatchFromDyn is a special trait used by the compiler for dyn-compatible dynamic dispatch.
+//! This checks that the compiler correctly rejects invalid implementations:
+//! - Structs with extra non-coercible fields
+//! - Structs with multiple pointer fields
+//! - Structs with no coercible fields
+//! - Structs with repr(C) or other incompatible representations
+//! - Structs with over-aligned fields
+
+#![feature(unsize, dispatch_from_dyn)]
+
+use std::marker::{PhantomData, Unsize};
+use std::ops::DispatchFromDyn;
+
+// Extra field prevents DispatchFromDyn
+struct WrapperWithExtraField<T>(T, i32);
+
+impl<T, U> DispatchFromDyn<WrapperWithExtraField<U>> for WrapperWithExtraField<T>
+//~^ ERROR [E0378]
+where
+ T: DispatchFromDyn<U>
+{
+}
+
+// Multiple pointer fields create ambiguous coercion
+struct MultiplePointers<T: ?Sized> {
+ ptr1: *const T,
+ ptr2: *const T,
+}
+
+impl<T: ?Sized, U: ?Sized> DispatchFromDyn<MultiplePointers<U>> for MultiplePointers<T>
+//~^ ERROR implementing `DispatchFromDyn` does not allow multiple fields to be coerced
+where
+ T: Unsize<U>
+{
+}
+
+// No coercible fields (only PhantomData)
+struct NothingToCoerce<T: ?Sized> {
+ data: PhantomData<T>,
+}
+
+impl<T: ?Sized, U: ?Sized> DispatchFromDyn<NothingToCoerce<T>> for NothingToCoerce<U> {}
+//~^ ERROR implementing `DispatchFromDyn` requires a field to be coerced
+
+// repr(C) is incompatible with DispatchFromDyn
+#[repr(C)]
+struct HasReprC<T: ?Sized>(Box<T>);
+
+impl<T: ?Sized, U: ?Sized> DispatchFromDyn<HasReprC<U>> for HasReprC<T>
+//~^ ERROR [E0378]
+where
+ T: Unsize<U>
+{
+}
+
+// Over-aligned fields are incompatible
+#[repr(align(64))]
+struct OverAlignedZst;
+
+struct OverAligned<T: ?Sized>(Box<T>, OverAlignedZst);
+
+impl<T: ?Sized, U: ?Sized> DispatchFromDyn<OverAligned<U>> for OverAligned<T>
+//~^ ERROR [E0378]
+where
+ T: Unsize<U>
+{
+}
+
+fn main() {}
diff --git a/tests/ui/invalid_dispatch_from_dyn_impls.stderr b/tests/ui/traits/dispatch-from-dyn-invalid-impls.stderr
similarity index 76%
rename from tests/ui/invalid_dispatch_from_dyn_impls.stderr
rename to tests/ui/traits/dispatch-from-dyn-invalid-impls.stderr
index 93ec6bb..676da0c 100644
--- a/tests/ui/invalid_dispatch_from_dyn_impls.stderr
+++ b/tests/ui/traits/dispatch-from-dyn-invalid-impls.stderr
@@ -1,25 +1,25 @@
error[E0378]: the trait `DispatchFromDyn` may only be implemented for structs containing the field being coerced, ZST fields with 1 byte alignment that don't mention type/const generics, and nothing else
- --> $DIR/invalid_dispatch_from_dyn_impls.rs:10:1
+ --> $DIR/dispatch-from-dyn-invalid-impls.rs:19:1
|
LL | / impl<T, U> DispatchFromDyn<WrapperWithExtraField<U>> for WrapperWithExtraField<T>
LL | |
LL | | where
-LL | | T: DispatchFromDyn<U>,
- | |__________________________^
+LL | | T: DispatchFromDyn<U>
+ | |_________________________^
|
= note: extra field `1` of type `i32` is not allowed
error[E0375]: implementing `DispatchFromDyn` does not allow multiple fields to be coerced
- --> $DIR/invalid_dispatch_from_dyn_impls.rs:22:1
+ --> $DIR/dispatch-from-dyn-invalid-impls.rs:32:1
|
LL | / impl<T: ?Sized, U: ?Sized> DispatchFromDyn<MultiplePointers<U>> for MultiplePointers<T>
LL | |
LL | | where
-LL | | T: Unsize<U>,
- | |_________________^
+LL | | T: Unsize<U>
+ | |________________^
|
note: the trait `DispatchFromDyn` may only be implemented when a single field is being coerced
- --> $DIR/invalid_dispatch_from_dyn_impls.rs:18:5
+ --> $DIR/dispatch-from-dyn-invalid-impls.rs:28:5
|
LL | ptr1: *const T,
| ^^^^^^^^^^^^^^
@@ -27,7 +27,7 @@
| ^^^^^^^^^^^^^^
error[E0374]: implementing `DispatchFromDyn` requires a field to be coerced
- --> $DIR/invalid_dispatch_from_dyn_impls.rs:33:1
+ --> $DIR/dispatch-from-dyn-invalid-impls.rs:44:1
|
LL | impl<T: ?Sized, U: ?Sized> DispatchFromDyn<NothingToCoerce<T>> for NothingToCoerce<U> {}
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -35,22 +35,22 @@
= note: expected a single field to be coerced, none found
error[E0378]: structs implementing `DispatchFromDyn` may not have `#[repr(packed)]` or `#[repr(C)]`
- --> $DIR/invalid_dispatch_from_dyn_impls.rs:39:1
+ --> $DIR/dispatch-from-dyn-invalid-impls.rs:51:1
|
LL | / impl<T: ?Sized, U: ?Sized> DispatchFromDyn<HasReprC<U>> for HasReprC<T>
LL | |
LL | | where
-LL | | T: Unsize<U>,
- | |_________________^
+LL | | T: Unsize<U>
+ | |________________^
error[E0378]: the trait `DispatchFromDyn` may only be implemented for structs containing the field being coerced, ZST fields with 1 byte alignment that don't mention type/const generics, and nothing else
- --> $DIR/invalid_dispatch_from_dyn_impls.rs:49:1
+ --> $DIR/dispatch-from-dyn-invalid-impls.rs:64:1
|
LL | / impl<T: ?Sized, U: ?Sized> DispatchFromDyn<OverAligned<U>> for OverAligned<T>
LL | |
-LL | | where
-LL | | T: Unsize<U>,
- | |_____________________^
+LL | | where
+LL | | T: Unsize<U>
+ | |________________^
|
= note: extra field `1` of type `OverAlignedZst` is not allowed
diff --git a/tests/ui/issue-11881.rs b/tests/ui/traits/encoder-trait-bounds-regression.rs
similarity index 76%
rename from tests/ui/issue-11881.rs
rename to tests/ui/traits/encoder-trait-bounds-regression.rs
index 1abe079..292b921 100644
--- a/tests/ui/issue-11881.rs
+++ b/tests/ui/traits/encoder-trait-bounds-regression.rs
@@ -1,14 +1,23 @@
+//! Regression test for issue #11881
+//!
+//! Originally, the compiler would ICE when trying to parameterize on certain encoder types
+//! due to issues with higher-ranked trait bounds and lifetime inference. This test checks
+//! that various encoder patterns work correctly:
+//! - Generic encoders with associated error types
+//! - Higher-ranked trait bounds (for<'r> Encodable<JsonEncoder<'r>>)
+//! - Multiple encoder implementations for the same type
+//! - Polymorphic encoding functions
+
//@ run-pass
#![allow(unused_must_use)]
#![allow(dead_code)]
#![allow(unused_imports)]
-use std::fmt;
-use std::io::prelude::*;
use std::io::Cursor;
-use std::slice;
+use std::io::prelude::*;
use std::marker::PhantomData;
+use std::{fmt, slice};
trait Encoder {
type Error;
@@ -45,7 +54,6 @@ impl Encoder for OpaqueEncoder {
type Error = ();
}
-
struct Foo {
baz: bool,
}
@@ -69,7 +77,6 @@ fn encode(&self, _s: &mut S) -> Result<(), S::Error> {
enum WireProtocol {
JSON,
Opaque,
- // ...
}
fn encode_json<T: for<'a> Encodable<JsonEncoder<'a>>>(val: &T, wr: &mut Cursor<Vec<u8>>) {
diff --git a/tests/ui/traits/eval-caching-error-region.rs b/tests/ui/traits/eval-caching-error-region.rs
new file mode 100644
index 0000000..831b5ab
--- /dev/null
+++ b/tests/ui/traits/eval-caching-error-region.rs
@@ -0,0 +1,23 @@
+// Regression test for #132882.
+
+use std::ops::Add;
+
+pub trait Numoid: Sized
+where
+ &'missing Self: Add<Self>,
+ //~^ ERROR use of undeclared lifetime name `'missing`
+{
+}
+
+// Proving `N: Numoid`'s well-formedness causes us to have to prove `&'missing N: Add<N>`.
+// Since `'missing` is a region error, that will lead to us consider the predicate to hold,
+// since it references errors. Since the freshener turns error regions into fresh regions,
+// this means that subsequent lookups of `&'?0 N: Add<N>` will also hit this cache entry
+// even if candidate assembly can't assemble anything for `&'?0 N: Add<?1>` anyways. This
+// led to an ICE.
+pub fn compute<N: Numoid>(a: N) {
+ let _ = &a + a;
+ //~^ ERROR cannot add `N` to `&N`
+}
+
+fn main() {}
diff --git a/tests/ui/traits/eval-caching-error-region.stderr b/tests/ui/traits/eval-caching-error-region.stderr
new file mode 100644
index 0000000..6365d24
--- /dev/null
+++ b/tests/ui/traits/eval-caching-error-region.stderr
@@ -0,0 +1,33 @@
+error[E0261]: use of undeclared lifetime name `'missing`
+ --> $DIR/eval-caching-error-region.rs:7:6
+ |
+LL | &'missing Self: Add<Self>,
+ | ^^^^^^^^ undeclared lifetime
+ |
+ = note: for more information on higher-ranked polymorphism, visit https://doc.rust-lang.org/nomicon/hrtb.html
+help: consider making the bound lifetime-generic with a new `'missing` lifetime
+ |
+LL | for<'missing> &'missing Self: Add<Self>,
+ | +++++++++++++
+help: consider introducing lifetime `'missing` here
+ |
+LL | pub trait Numoid<'missing>: Sized
+ | ++++++++++
+
+error[E0369]: cannot add `N` to `&N`
+ --> $DIR/eval-caching-error-region.rs:19:16
+ |
+LL | let _ = &a + a;
+ | -- ^ - N
+ | |
+ | &N
+ |
+help: consider introducing a `where` clause, but there might be an alternative better way to express this requirement
+ |
+LL | pub fn compute<N: Numoid>(a: N) where &N: Add<N> {
+ | ++++++++++++++++
+
+error: aborting due to 2 previous errors
+
+Some errors have detailed explanations: E0261, E0369.
+For more information about an error, try `rustc --explain E0261`.
diff --git a/tests/ui/transmute/diverging-fn-transmute.rs b/tests/ui/transmute/diverging-fn-transmute.rs
new file mode 100644
index 0000000..aca8203
--- /dev/null
+++ b/tests/ui/transmute/diverging-fn-transmute.rs
@@ -0,0 +1,10 @@
+//! Regression test for issue #35849: transmute with panic in diverging function
+
+fn assert_sizeof() -> ! {
+ unsafe {
+ ::std::mem::transmute::<f64, [u8; 8]>(panic!())
+ //~^ ERROR mismatched types
+ }
+}
+
+fn main() {}
diff --git a/tests/ui/diverging-fn-tail-35849.stderr b/tests/ui/transmute/diverging-fn-transmute.stderr
similarity index 91%
rename from tests/ui/diverging-fn-tail-35849.stderr
rename to tests/ui/transmute/diverging-fn-transmute.stderr
index 614f9b9..b9aeae7 100644
--- a/tests/ui/diverging-fn-tail-35849.stderr
+++ b/tests/ui/transmute/diverging-fn-transmute.stderr
@@ -1,5 +1,5 @@
error[E0308]: mismatched types
- --> $DIR/diverging-fn-tail-35849.rs:3:9
+ --> $DIR/diverging-fn-transmute.rs:5:9
|
LL | fn assert_sizeof() -> ! {
| - expected `!` because of return type
