Rollup merge of #145026 - rustbot:docs-update, r=ehuss
Update books
## rust-lang/book
5 commits in b2d1a0821e12a676b496d61891b8e3d374a8e832..3e9dc46aa563ca0c53ec826c41b05f10c5915925
2025-08-02 01:33:29 UTC to 2025-07-14 21:23:38 UTC
- Appendix B and Appendix D from tech review (rust-lang/book#4466)
- Chapter 21 from tech review (rust-lang/book#4464)
- Chapter 20 from tech review (rust-lang/book#4460)
- Chapter 19 from tech review (rust-lang/book#4446)
- Chapter 18 from tech review (rust-lang/book#4445)
## rust-lang/reference
12 commits in 1f45bd41fa6c17b7c048ed6bfe5f168c4311206a..1be151c051a082b542548c62cafbcb055fa8944f
2025-08-05 19:51:40 UTC to 2025-07-14 19:49:01 UTC
- Fix build output directory in README (rust-lang/reference#1950)
- Update `link_name` to use the attribute template (rust-lang/reference#1896)
- Update `no_link` to use the attribute template (rust-lang/reference#1898)
- Update `proc_macro_derive` to use the attribute template (rust-lang/reference#1888)
- Update `automatically_derived` to use the attribute template (rust-lang/reference#1884)
- Update `derive` to use the attribute template (rust-lang/reference#1883)
- Fix and clarify CR LF normalization and CR in string literals (rust-lang/reference#1944)
- glossary.md: tweak description of "dispatch" (rust-lang/reference#1938)
- add missing id, r[asm.operand-type.supported-operands.const] (rust-lang/reference#1939)
- &str and &[u8] have the same layout (rust-lang/reference#1848)
- Rename and rewrite the "question mark operator" (rust-lang/reference#1931)
- Change "allocated object" to "allocation". (rust-lang/reference#1930)
## rust-lang/rust-by-example
3 commits in e386be5f44af711854207c11fdd61bb576270b04..bd1279cdc9865bfff605e741fb76a0b2f07314a7
2025-08-04 13:41:04 UTC to 2025-08-02 15:41:59 UTC
- Improve the activity instructions in `print_display` (rust-lang/rust-by-example#1948)
- Minor fixes (whitespace, typo, i32->u32) (rust-lang/rust-by-example#1947)
- Document drawbacks of alternatives to match binding (rust-lang/rust-by-example#1946)
diff --git a/RELEASES.md b/RELEASES.md
index 1ae2217..b6dc062 100644
--- a/RELEASES.md
+++ b/RELEASES.md
@@ -1,3 +1,140 @@
+Version 1.89.0 (2025-08-07)
+==========================
+
+<a id="1.89.0-Language"></a>
+
+Language
+--------
+- [Stabilize explicitly inferred const arguments (`feature(generic_arg_infer)`)](https://github.com/rust-lang/rust/pull/141610)
+- [Add a warn-by-default `mismatched_lifetime_syntaxes` lint.](https://github.com/rust-lang/rust/pull/138677)
+ This lint detects when the same lifetime is referred to by different syntax categories between function arguments and return values, which can be confusing to read, especially in unsafe code.
+ This lint supersedes the warn-by-default `elided_named_lifetimes` lint.
+- [Expand `unpredictable_function_pointer_comparisons` to also lint on function pointer comparisons in external macros](https://github.com/rust-lang/rust/pull/134536)
+- [Make the `dangerous_implicit_autorefs` lint deny-by-default](https://github.com/rust-lang/rust/pull/141661)
+- [Stabilize the avx512 target features](https://github.com/rust-lang/rust/pull/138940)
+- [Stabilize `kl` and `widekl` target features for x86](https://github.com/rust-lang/rust/pull/140766)
+- [Stabilize `sha512`, `sm3` and `sm4` target features for x86](https://github.com/rust-lang/rust/pull/140767)
+- [Stabilize LoongArch target features `f`, `d`, `frecipe`, `lasx`, `lbt`, `lsx`, and `lvz`](https://github.com/rust-lang/rust/pull/135015)
+- [Remove `i128` and `u128` from `improper_ctypes_definitions`](https://github.com/rust-lang/rust/pull/137306)
+- [Stabilize `repr128` (`#[repr(u128)]`, `#[repr(i128)]`)](https://github.com/rust-lang/rust/pull/138285)
+- [Allow `#![doc(test(attr(..)))]` everywhere](https://github.com/rust-lang/rust/pull/140560)
+- [Extend temporary lifetime extension to also go through tuple struct and tuple variant constructors](https://github.com/rust-lang/rust/pull/140593)
+- [`extern "C"` functions on the `wasm32-unknown-unknown` target now have a standards compliant ABI](https://blog.rust-lang.org/2025/04/04/c-abi-changes-for-wasm32-unknown-unknown/)
+
+<a id="1.89.0-Compiler"></a>
+
+Compiler
+--------
+- [Default to non-leaf frame pointers on aarch64-linux](https://github.com/rust-lang/rust/pull/140832)
+- [Enable non-leaf frame pointers for Arm64EC Windows](https://github.com/rust-lang/rust/pull/140862)
+- [Set Apple frame pointers by architecture](https://github.com/rust-lang/rust/pull/141797)
+
+
+<a id="1.89.0-Platform-Support"></a>
+
+Platform Support
+----------------
+- [Add new Tier-3 targets `loongarch32-unknown-none` and `loongarch32-unknown-none-softfloat`](https://github.com/rust-lang/rust/pull/142053)
+- [`x86_64-apple-darwin` is in the process of being demoted to Tier 2 with host tools](https://github.com/rust-lang/rfcs/pull/3841)
+
+Refer to Rust's [platform support page][platform-support-doc]
+for more information on Rust's tiered platform support.
+
+[platform-support-doc]: https://doc.rust-lang.org/rustc/platform-support.html
+
+<a id="1.89.0-Libraries"></a>
+
+Libraries
+---------
+- [Specify the base path for `file!`](https://github.com/rust-lang/rust/pull/134442)
+- [Allow storing `format_args!()` in a variable](https://github.com/rust-lang/rust/pull/140748)
+- [Add `#[must_use]` to `[T; N]::map`](https://github.com/rust-lang/rust/pull/140957)
+- [Implement `DerefMut` for `Lazy{Cell,Lock}`](https://github.com/rust-lang/rust/pull/129334)
+- [Implement `Default` for `array::IntoIter`](https://github.com/rust-lang/rust/pull/141574)
+- [Implement `Clone` for `slice::ChunkBy`](https://github.com/rust-lang/rust/pull/138016)
+- [Implement `io::Seek` for `io::Take`](https://github.com/rust-lang/rust/pull/138023)
+
+
+<a id="1.89.0-Stabilized-APIs"></a>
+
+Stabilized APIs
+---------------
+
+- [`NonZero<char>`](https://doc.rust-lang.org/stable/std/num/struct.NonZero.html)
+- Many intrinsics for x86, not enumerated here
+ - [AVX512 intrinsics](https://github.com/rust-lang/rust/issues/111137)
+ - [`SHA512`, `SM3` and `SM4` intrinsics](https://github.com/rust-lang/rust/issues/126624)
+- [`File::lock`](https://doc.rust-lang.org/stable/std/fs/struct.File.html#method.lock)
+- [`File::lock_shared`](https://doc.rust-lang.org/stable/std/fs/struct.File.html#method.lock_shared)
+- [`File::try_lock`](https://doc.rust-lang.org/stable/std/fs/struct.File.html#method.try_lock)
+- [`File::try_lock_shared`](https://doc.rust-lang.org/stable/std/fs/struct.File.html#method.try_lock_shared)
+- [`File::unlock`](https://doc.rust-lang.org/stable/std/fs/struct.File.html#method.unlock)
+- [`NonNull::from_ref`](https://doc.rust-lang.org/stable/std/ptr/struct.NonNull.html#method.from_ref)
+- [`NonNull::from_mut`](https://doc.rust-lang.org/stable/std/ptr/struct.NonNull.html#method.from_mut)
+- [`NonNull::without_provenance`](https://doc.rust-lang.org/stable/std/ptr/struct.NonNull.html#method.without_provenance)
+- [`NonNull::with_exposed_provenance`](https://doc.rust-lang.org/stable/std/ptr/struct.NonNull.html#method.with_exposed_provenance)
+- [`NonNull::expose_provenance`](https://doc.rust-lang.org/stable/std/ptr/struct.NonNull.html#method.expose_provenance)
+- [`OsString::leak`](https://doc.rust-lang.org/stable/std/ffi/struct.OsString.html#method.leak)
+- [`PathBuf::leak`](https://doc.rust-lang.org/stable/std/path/struct.PathBuf.html#method.leak)
+- [`Result::flatten`](https://doc.rust-lang.org/stable/std/result/enum.Result.html#method.flatten)
+- [`std::os::linux::net::TcpStreamExt::quickack`](https://doc.rust-lang.org/stable/std/os/linux/net/trait.TcpStreamExt.html#tymethod.quickack)
+- [`std::os::linux::net::TcpStreamExt::set_quickack`](https://doc.rust-lang.org/stable/std/os/linux/net/trait.TcpStreamExt.html#tymethod.set_quickack)
+
+These previously stable APIs are now stable in const contexts:
+
+- [`<[T; N]>::as_mut_slice`](https://doc.rust-lang.org/stable/std/primitive.array.html#method.as_mut_slice)
+- [`<[u8]>::eq_ignore_ascii_case`](https://doc.rust-lang.org/stable/std/primitive.slice.html#impl-%5Bu8%5D/method.eq_ignore_ascii_case)
+- [`str::eq_ignore_ascii_case`](https://doc.rust-lang.org/stable/std/primitive.str.html#impl-str/method.eq_ignore_ascii_case)
+
+
+<a id="1.89.0-Cargo"></a>
+
+Cargo
+-----
+- [`cargo fix` and `cargo clippy --fix` now default to the same Cargo target selection as other build commands.](https://github.com/rust-lang/cargo/pull/15192/) Previously it would apply to all targets (like binaries, examples, tests, etc.). The `--edition` flag still applies to all targets.
+- [Stabilize doctest-xcompile.](https://github.com/rust-lang/cargo/pull/15462/) Doctests are now tested when cross-compiling. Just like other tests, it will use the [`runner` setting](https://doc.rust-lang.org/cargo/reference/config.html#targettriplerunner) to run the tests. If you need to disable tests for a target, you can use the [ignore doctest attribute](https://doc.rust-lang.org/rustdoc/write-documentation/documentation-tests.html#ignoring-targets) to specify the targets to ignore.
+
+
+<a id="1.89.0-Rustdoc"></a>
+
+Rustdoc
+-----
+- [On mobile, make the sidebar full width and linewrap](https://github.com/rust-lang/rust/pull/139831). This makes long section and item names much easier to deal with on mobile.
+
+
+<a id="1.89.0-Compatibility-Notes"></a>
+
+Compatibility Notes
+-------------------
+- [Make `missing_fragment_specifier` an unconditional error](https://github.com/rust-lang/rust/pull/128425)
+- [Enabling the `neon` target feature on `aarch64-unknown-none-softfloat` causes a warning](https://github.com/rust-lang/rust/pull/135160) because mixing code with and without that target feature is not properly supported by LLVM
+- [Sized Hierarchy: Part I](https://github.com/rust-lang/rust/pull/137944)
+ - Introduces a small breaking change affecting `?Sized` bounds on impls on recursive types which contain associated type projections. It is not expected to affect any existing published crates. Can be fixed by refactoring the involved types or opting into the `sized_hierarchy` unstable feature. See the [FCP report](https://github.com/rust-lang/rust/pull/137944#issuecomment-2912207485) for a code example.
+- The warn-by-default `elided_named_lifetimes` lint is [superseded by the warn-by-default `mismatched_lifetime_syntaxes` lint.](https://github.com/rust-lang/rust/pull/138677)
+- [Error on recursive opaque types earlier in the type checker](https://github.com/rust-lang/rust/pull/139419)
+- [Type inference side effects from requiring element types of array repeat expressions are `Copy` are now only available at the end of type checking](https://github.com/rust-lang/rust/pull/139635)
+- [The deprecated accidentally-stable `std::intrinsics::{copy,copy_nonoverlapping,write_bytes}` are now proper intrinsics](https://github.com/rust-lang/rust/pull/139916). There are no debug assertions guarding against UB, and they cannot be coerced to function pointers.
+- [Remove long-deprecated `std::intrinsics::drop_in_place`](https://github.com/rust-lang/rust/pull/140151)
+- [Make well-formedness predicates no longer coinductive](https://github.com/rust-lang/rust/pull/140208)
+- [Remove hack when checking impl method compatibility](https://github.com/rust-lang/rust/pull/140557)
+- [Remove unnecessary type inference due to built-in trait object impls](https://github.com/rust-lang/rust/pull/141352)
+- [Lint against "stdcall", "fastcall", and "cdecl" on non-x86-32 targets](https://github.com/rust-lang/rust/pull/141435)
+- [Future incompatibility warnings relating to the never type (`!`) are now reported in dependencies](https://github.com/rust-lang/rust/pull/141937)
+- [Ensure `std::ptr::copy_*` intrinsics also perform the static self-init checks](https://github.com/rust-lang/rust/pull/142575)
+- [`extern "C"` functions on the `wasm32-unknown-unknown` target now have a standards compliant ABI](https://blog.rust-lang.org/2025/04/04/c-abi-changes-for-wasm32-unknown-unknown/)
+
+<a id="1.89.0-Internal-Changes"></a>
+
+Internal Changes
+----------------
+
+These changes do not affect any public interfaces of Rust, but they represent
+significant improvements to the performance or internals of rustc and related
+tools.
+
+- [Correctly un-remap compiler sources paths with the `rustc-dev` component](https://github.com/rust-lang/rust/pull/142377)
+
+
Version 1.88.0 (2025-06-26)
==========================
diff --git a/compiler/rustc_ast_lowering/src/expr.rs b/compiler/rustc_ast_lowering/src/expr.rs
index 1245d48..fb42cfe 100644
--- a/compiler/rustc_ast_lowering/src/expr.rs
+++ b/compiler/rustc_ast_lowering/src/expr.rs
@@ -98,7 +98,7 @@ pub(super) fn lower_expr_mut(&mut self, e: &Expr) -> hir::Expr<'hir> {
}
let expr_hir_id = self.lower_node_id(e.id);
- self.lower_attrs(expr_hir_id, &e.attrs, e.span);
+ let attrs = self.lower_attrs(expr_hir_id, &e.attrs, e.span);
let kind = match &e.kind {
ExprKind::Array(exprs) => hir::ExprKind::Array(self.lower_exprs(exprs)),
@@ -232,10 +232,10 @@ pub(super) fn lower_expr_mut(&mut self, e: &Expr) -> hir::Expr<'hir> {
*fn_arg_span,
),
None => self.lower_expr_closure(
+ attrs,
binder,
*capture_clause,
e.id,
- expr_hir_id,
*constness,
*movability,
fn_decl,
@@ -1052,10 +1052,10 @@ fn lower_expr_use(&mut self, use_kw_span: Span, expr: &Expr) -> hir::ExprKind<'h
fn lower_expr_closure(
&mut self,
+ attrs: &[rustc_hir::Attribute],
binder: &ClosureBinder,
capture_clause: CaptureBy,
closure_id: NodeId,
- closure_hir_id: hir::HirId,
constness: Const,
movability: Movability,
decl: &FnDecl,
@@ -1067,15 +1067,9 @@ fn lower_expr_closure(
let (binder_clause, generic_params) = self.lower_closure_binder(binder);
let (body_id, closure_kind) = self.with_new_scopes(fn_decl_span, move |this| {
- let mut coroutine_kind = if this
- .attrs
- .get(&closure_hir_id.local_id)
- .is_some_and(|attrs| attrs.iter().any(|attr| attr.has_name(sym::coroutine)))
- {
- Some(hir::CoroutineKind::Coroutine(Movability::Movable))
- } else {
- None
- };
+
+ let mut coroutine_kind = find_attr!(attrs, AttributeKind::Coroutine(_) => hir::CoroutineKind::Coroutine(Movability::Movable));
+
// FIXME(contracts): Support contracts on closures?
let body_id = this.lower_fn_body(decl, None, |this| {
this.coroutine_kind = coroutine_kind;
diff --git a/compiler/rustc_ast_passes/messages.ftl b/compiler/rustc_ast_passes/messages.ftl
index 42f3569..53e6443 100644
--- a/compiler/rustc_ast_passes/messages.ftl
+++ b/compiler/rustc_ast_passes/messages.ftl
@@ -40,7 +40,7 @@
ast_passes_auto_items = auto traits cannot have associated items
.label = {ast_passes_auto_items}
- .suggestion = remove these associated items
+ .suggestion = remove the associated items
ast_passes_auto_super_lifetime = auto traits cannot have super traits or lifetime bounds
.label = {ast_passes_auto_super_lifetime}
diff --git a/compiler/rustc_ast_passes/src/ast_validation.rs b/compiler/rustc_ast_passes/src/ast_validation.rs
index ae482ce..1c1c5f8 100644
--- a/compiler/rustc_ast_passes/src/ast_validation.rs
+++ b/compiler/rustc_ast_passes/src/ast_validation.rs
@@ -699,19 +699,23 @@ fn deny_generic_params(&self, generics: &Generics, ident_span: Span) {
}
}
- fn deny_super_traits(&self, bounds: &GenericBounds, ident_span: Span) {
+ fn deny_super_traits(&self, bounds: &GenericBounds, ident: Span) {
if let [.., last] = &bounds[..] {
- let span = ident_span.shrink_to_hi().to(last.span());
- self.dcx().emit_err(errors::AutoTraitBounds { span, ident: ident_span });
+ let span = bounds.iter().map(|b| b.span()).collect();
+ let removal = ident.shrink_to_hi().to(last.span());
+ self.dcx().emit_err(errors::AutoTraitBounds { span, removal, ident });
}
}
- fn deny_where_clause(&self, where_clause: &WhereClause, ident_span: Span) {
+ fn deny_where_clause(&self, where_clause: &WhereClause, ident: Span) {
if !where_clause.predicates.is_empty() {
// FIXME: The current diagnostic is misleading since it only talks about
// super trait and lifetime bounds while we should just say “bounds”.
- self.dcx()
- .emit_err(errors::AutoTraitBounds { span: where_clause.span, ident: ident_span });
+ self.dcx().emit_err(errors::AutoTraitBounds {
+ span: vec![where_clause.span],
+ removal: where_clause.span,
+ ident,
+ });
}
}
diff --git a/compiler/rustc_ast_passes/src/errors.rs b/compiler/rustc_ast_passes/src/errors.rs
index 8b5873a..60f4749 100644
--- a/compiler/rustc_ast_passes/src/errors.rs
+++ b/compiler/rustc_ast_passes/src/errors.rs
@@ -344,7 +344,7 @@ pub(crate) struct ModuleNonAscii {
#[diag(ast_passes_auto_generic, code = E0567)]
pub(crate) struct AutoTraitGeneric {
#[primary_span]
- #[suggestion(code = "", applicability = "machine-applicable")]
+ #[suggestion(code = "", applicability = "machine-applicable", style = "tool-only")]
pub span: Span,
#[label]
pub ident: Span,
@@ -354,8 +354,9 @@ pub(crate) struct AutoTraitGeneric {
#[diag(ast_passes_auto_super_lifetime, code = E0568)]
pub(crate) struct AutoTraitBounds {
#[primary_span]
- #[suggestion(code = "", applicability = "machine-applicable")]
- pub span: Span,
+ pub span: Vec<Span>,
+ #[suggestion(code = "", applicability = "machine-applicable", style = "tool-only")]
+ pub removal: Span,
#[label]
pub ident: Span,
}
@@ -365,7 +366,7 @@ pub(crate) struct AutoTraitBounds {
pub(crate) struct AutoTraitItems {
#[primary_span]
pub spans: Vec<Span>,
- #[suggestion(code = "", applicability = "machine-applicable")]
+ #[suggestion(code = "", applicability = "machine-applicable", style = "tool-only")]
pub total: Span,
#[label]
pub ident: Span,
diff --git a/compiler/rustc_attr_parsing/src/attributes/body.rs b/compiler/rustc_attr_parsing/src/attributes/body.rs
new file mode 100644
index 0000000..ab93302
--- /dev/null
+++ b/compiler/rustc_attr_parsing/src/attributes/body.rs
@@ -0,0 +1,15 @@
+//! Attributes that can be found in function body.
+
+use rustc_hir::attrs::AttributeKind;
+use rustc_span::{Symbol, sym};
+
+use super::{NoArgsAttributeParser, OnDuplicate};
+use crate::context::Stage;
+
+pub(crate) struct CoroutineParser;
+
+impl<S: Stage> NoArgsAttributeParser<S> for CoroutineParser {
+ const PATH: &[Symbol] = &[sym::coroutine];
+ const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Error;
+ const CREATE: fn(rustc_span::Span) -> AttributeKind = |span| AttributeKind::Coroutine(span);
+}
diff --git a/compiler/rustc_attr_parsing/src/attributes/mod.rs b/compiler/rustc_attr_parsing/src/attributes/mod.rs
index c574ef7..f7946ad 100644
--- a/compiler/rustc_attr_parsing/src/attributes/mod.rs
+++ b/compiler/rustc_attr_parsing/src/attributes/mod.rs
@@ -26,6 +26,7 @@
use crate::session_diagnostics::UnusedMultiple;
pub(crate) mod allow_unstable;
+pub(crate) mod body;
pub(crate) mod cfg;
pub(crate) mod cfg_old;
pub(crate) mod codegen_attrs;
diff --git a/compiler/rustc_attr_parsing/src/attributes/test_attrs.rs b/compiler/rustc_attr_parsing/src/attributes/test_attrs.rs
index a90ed83..77b4943 100644
--- a/compiler/rustc_attr_parsing/src/attributes/test_attrs.rs
+++ b/compiler/rustc_attr_parsing/src/attributes/test_attrs.rs
@@ -44,3 +44,55 @@ fn convert(cx: &mut AcceptContext<'_, '_, S>, args: &ArgParser<'_>) -> Option<At
})
}
}
+
+pub(crate) struct ShouldPanicParser;
+
+impl<S: Stage> SingleAttributeParser<S> for ShouldPanicParser {
+ const PATH: &[Symbol] = &[sym::should_panic];
+ const ATTRIBUTE_ORDER: AttributeOrder = AttributeOrder::KeepOutermost;
+ const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::WarnButFutureError;
+ const TEMPLATE: AttributeTemplate =
+ template!(Word, List: r#"expected = "reason""#, NameValueStr: "reason");
+
+ fn convert(cx: &mut AcceptContext<'_, '_, S>, args: &ArgParser<'_>) -> Option<AttributeKind> {
+ Some(AttributeKind::ShouldPanic {
+ span: cx.attr_span,
+ reason: match args {
+ ArgParser::NoArgs => None,
+ ArgParser::NameValue(name_value) => {
+ let Some(str_value) = name_value.value_as_str() else {
+ cx.expected_string_literal(
+ name_value.value_span,
+ Some(name_value.value_as_lit()),
+ );
+ return None;
+ };
+ Some(str_value)
+ }
+ ArgParser::List(list) => {
+ let Some(single) = list.single() else {
+ cx.expected_single_argument(list.span);
+ return None;
+ };
+ let Some(single) = single.meta_item() else {
+ cx.expected_name_value(single.span(), Some(sym::expected));
+ return None;
+ };
+ if !single.path().word_is(sym::expected) {
+ cx.expected_specific_argument_strings(list.span, vec!["expected"]);
+ return None;
+ }
+ let Some(nv) = single.args().name_value() else {
+ cx.expected_name_value(single.span(), Some(sym::expected));
+ return None;
+ };
+ let Some(expected) = nv.value_as_str() else {
+ cx.expected_string_literal(nv.value_span, Some(nv.value_as_lit()));
+ return None;
+ };
+ Some(expected)
+ }
+ },
+ })
+ }
+}
diff --git a/compiler/rustc_attr_parsing/src/context.rs b/compiler/rustc_attr_parsing/src/context.rs
index c6599f2..80dfdff 100644
--- a/compiler/rustc_attr_parsing/src/context.rs
+++ b/compiler/rustc_attr_parsing/src/context.rs
@@ -16,6 +16,7 @@
use crate::attributes::allow_unstable::{
AllowConstFnUnstableParser, AllowInternalUnstableParser, UnstableFeatureBoundParser,
};
+use crate::attributes::body::CoroutineParser;
use crate::attributes::codegen_attrs::{
ColdParser, CoverageParser, ExportNameParser, NakedParser, NoMangleParser, OptimizeParser,
TargetFeatureParser, TrackCallerParser, UsedParser,
@@ -49,7 +50,7 @@
use crate::attributes::stability::{
BodyStabilityParser, ConstStabilityIndirectParser, ConstStabilityParser, StabilityParser,
};
-use crate::attributes::test_attrs::IgnoreParser;
+use crate::attributes::test_attrs::{IgnoreParser, ShouldPanicParser};
use crate::attributes::traits::{
AllowIncoherentImplParser, CoherenceIsCoreParser, CoinductiveParser, ConstTraitParser,
DenyExplicitImplParser, DoNotImplementViaObjectParser, FundamentalParser, MarkerParser,
@@ -173,6 +174,7 @@ mod late {
Single<RustcLayoutScalarValidRangeEnd>,
Single<RustcLayoutScalarValidRangeStart>,
Single<RustcObjectLifetimeDefaultParser>,
+ Single<ShouldPanicParser>,
Single<SkipDuringMethodDispatchParser>,
Single<TransparencyParser>,
Single<WithoutArgs<AllowIncoherentImplParser>>,
@@ -184,6 +186,7 @@ mod late {
Single<WithoutArgs<ConstContinueParser>>,
Single<WithoutArgs<ConstStabilityIndirectParser>>,
Single<WithoutArgs<ConstTraitParser>>,
+ Single<WithoutArgs<CoroutineParser>>,
Single<WithoutArgs<DenyExplicitImplParser>>,
Single<WithoutArgs<DoNotImplementViaObjectParser>>,
Single<WithoutArgs<ExportStableParser>>,
diff --git a/compiler/rustc_borrowck/src/type_check/mod.rs b/compiler/rustc_borrowck/src/type_check/mod.rs
index f5fedbf..148d0de 100644
--- a/compiler/rustc_borrowck/src/type_check/mod.rs
+++ b/compiler/rustc_borrowck/src/type_check/mod.rs
@@ -769,9 +769,13 @@ fn visit_terminator(&mut self, term: &Terminator<'tcx>, term_location: Location)
}
TerminatorKind::Call { func, args, .. }
| TerminatorKind::TailCall { func, args, .. } => {
- let call_source = match term.kind {
- TerminatorKind::Call { call_source, .. } => call_source,
- TerminatorKind::TailCall { .. } => CallSource::Normal,
+ let (call_source, destination, is_diverging) = match term.kind {
+ TerminatorKind::Call { call_source, destination, target, .. } => {
+ (call_source, destination, target.is_none())
+ }
+ TerminatorKind::TailCall { .. } => {
+ (CallSource::Normal, RETURN_PLACE.into(), false)
+ }
_ => unreachable!(),
};
@@ -845,9 +849,7 @@ fn visit_terminator(&mut self, term: &Terminator<'tcx>, term_location: Location)
);
}
- if let TerminatorKind::Call { destination, target, .. } = term.kind {
- self.check_call_dest(term, &sig, destination, target, term_location);
- }
+ self.check_call_dest(term, &sig, destination, is_diverging, term_location);
// The ordinary liveness rules will ensure that all
// regions in the type of the callee are live here. We
@@ -1874,65 +1876,61 @@ fn check_call_dest(
term: &Terminator<'tcx>,
sig: &ty::FnSig<'tcx>,
destination: Place<'tcx>,
- target: Option<BasicBlock>,
+ is_diverging: bool,
term_location: Location,
) {
let tcx = self.tcx();
- match target {
- Some(_) => {
- let dest_ty = destination.ty(self.body, tcx).ty;
- let dest_ty = self.normalize(dest_ty, term_location);
- let category = match destination.as_local() {
- Some(RETURN_PLACE) => {
- if let DefiningTy::Const(def_id, _) | DefiningTy::InlineConst(def_id, _) =
- self.universal_regions.defining_ty
- {
- if tcx.is_static(def_id) {
- ConstraintCategory::UseAsStatic
- } else {
- ConstraintCategory::UseAsConst
- }
- } else {
- ConstraintCategory::Return(ReturnConstraint::Normal)
- }
- }
- Some(l) if !self.body.local_decls[l].is_user_variable() => {
- ConstraintCategory::Boring
- }
- // The return type of a call is interesting for diagnostics.
- _ => ConstraintCategory::Assignment,
- };
-
- let locations = term_location.to_locations();
-
- if let Err(terr) = self.sub_types(sig.output(), dest_ty, locations, category) {
- span_mirbug!(
- self,
- term,
- "call dest mismatch ({:?} <- {:?}): {:?}",
- dest_ty,
- sig.output(),
- terr
- );
- }
-
- // When `unsized_fn_params` is not enabled,
- // this check is done at `check_local`.
- if self.unsized_feature_enabled() {
- let span = term.source_info.span;
- self.ensure_place_sized(dest_ty, span);
- }
+ if is_diverging {
+ // The signature in this call can reference region variables,
+ // so erase them before calling a query.
+ let output_ty = self.tcx().erase_regions(sig.output());
+ if !output_ty
+ .is_privately_uninhabited(self.tcx(), self.infcx.typing_env(self.infcx.param_env))
+ {
+ span_mirbug!(self, term, "call to converging function {:?} w/o dest", sig);
}
- None => {
- // The signature in this call can reference region variables,
- // so erase them before calling a query.
- let output_ty = self.tcx().erase_regions(sig.output());
- if !output_ty.is_privately_uninhabited(
- self.tcx(),
- self.infcx.typing_env(self.infcx.param_env),
- ) {
- span_mirbug!(self, term, "call to converging function {:?} w/o dest", sig);
+ } else {
+ let dest_ty = destination.ty(self.body, tcx).ty;
+ let dest_ty = self.normalize(dest_ty, term_location);
+ let category = match destination.as_local() {
+ Some(RETURN_PLACE) => {
+ if let DefiningTy::Const(def_id, _) | DefiningTy::InlineConst(def_id, _) =
+ self.universal_regions.defining_ty
+ {
+ if tcx.is_static(def_id) {
+ ConstraintCategory::UseAsStatic
+ } else {
+ ConstraintCategory::UseAsConst
+ }
+ } else {
+ ConstraintCategory::Return(ReturnConstraint::Normal)
+ }
}
+ Some(l) if !self.body.local_decls[l].is_user_variable() => {
+ ConstraintCategory::Boring
+ }
+ // The return type of a call is interesting for diagnostics.
+ _ => ConstraintCategory::Assignment,
+ };
+
+ let locations = term_location.to_locations();
+
+ if let Err(terr) = self.sub_types(sig.output(), dest_ty, locations, category) {
+ span_mirbug!(
+ self,
+ term,
+ "call dest mismatch ({:?} <- {:?}): {:?}",
+ dest_ty,
+ sig.output(),
+ terr
+ );
+ }
+
+ // When `unsized_fn_params` is not enabled,
+ // this check is done at `check_local`.
+ if self.unsized_feature_enabled() {
+ let span = term.source_info.span;
+ self.ensure_place_sized(dest_ty, span);
}
}
}
diff --git a/compiler/rustc_builtin_macros/src/test.rs b/compiler/rustc_builtin_macros/src/test.rs
index ba3d836..7b57c02 100644
--- a/compiler/rustc_builtin_macros/src/test.rs
+++ b/compiler/rustc_builtin_macros/src/test.rs
@@ -5,10 +5,13 @@
use std::iter;
use rustc_ast::ptr::P;
-use rustc_ast::{self as ast, GenericParamKind, attr, join_path_idents};
+use rustc_ast::{self as ast, GenericParamKind, HasNodeId, attr, join_path_idents};
use rustc_ast_pretty::pprust;
+use rustc_attr_parsing::AttributeParser;
use rustc_errors::{Applicability, Diag, Level};
use rustc_expand::base::*;
+use rustc_hir::Attribute;
+use rustc_hir::attrs::AttributeKind;
use rustc_span::{ErrorGuaranteed, FileNameDisplayPreference, Ident, Span, Symbol, sym};
use thin_vec::{ThinVec, thin_vec};
use tracing::debug;
@@ -473,39 +476,19 @@ fn should_ignore_message(i: &ast::Item) -> Option<Symbol> {
}
fn should_panic(cx: &ExtCtxt<'_>, i: &ast::Item) -> ShouldPanic {
- match attr::find_by_name(&i.attrs, sym::should_panic) {
- Some(attr) => {
- match attr.meta_item_list() {
- // Handle #[should_panic(expected = "foo")]
- Some(list) => {
- let msg = list
- .iter()
- .find(|mi| mi.has_name(sym::expected))
- .and_then(|mi| mi.meta_item())
- .and_then(|mi| mi.value_str());
- if list.len() != 1 || msg.is_none() {
- cx.dcx()
- .struct_span_warn(
- attr.span,
- "argument must be of the form: \
- `expected = \"error message\"`",
- )
- .with_note(
- "errors in this attribute were erroneously \
- allowed and will become a hard error in a \
- future release",
- )
- .emit();
- ShouldPanic::Yes(None)
- } else {
- ShouldPanic::Yes(msg)
- }
- }
- // Handle #[should_panic] and #[should_panic = "expected"]
- None => ShouldPanic::Yes(attr.value_str()),
- }
- }
- None => ShouldPanic::No,
+ if let Some(Attribute::Parsed(AttributeKind::ShouldPanic { reason, .. })) =
+ AttributeParser::parse_limited(
+ cx.sess,
+ &i.attrs,
+ sym::should_panic,
+ i.span,
+ i.node_id(),
+ None,
+ )
+ {
+ ShouldPanic::Yes(reason)
+ } else {
+ ShouldPanic::No
}
}
diff --git a/compiler/rustc_codegen_llvm/src/llvm_util.rs b/compiler/rustc_codegen_llvm/src/llvm_util.rs
index 53899da..3b290e5 100644
--- a/compiler/rustc_codegen_llvm/src/llvm_util.rs
+++ b/compiler/rustc_codegen_llvm/src/llvm_util.rs
@@ -262,6 +262,15 @@ pub(crate) fn to_llvm_features<'a>(sess: &Session, s: &'a str) -> Option<LLVMFea
// Filter out features that are not supported by the current LLVM version
("aarch64", "fpmr") => None, // only existed in 18
("arm", "fp16") => Some(LLVMFeature::new("fullfp16")),
+ // NVPTX targets added in LLVM 20
+ ("nvptx64", "sm_100") if get_version().0 < 20 => None,
+ ("nvptx64", "sm_100a") if get_version().0 < 20 => None,
+ ("nvptx64", "sm_101") if get_version().0 < 20 => None,
+ ("nvptx64", "sm_101a") if get_version().0 < 20 => None,
+ ("nvptx64", "sm_120") if get_version().0 < 20 => None,
+ ("nvptx64", "sm_120a") if get_version().0 < 20 => None,
+ ("nvptx64", "ptx86") if get_version().0 < 20 => None,
+ ("nvptx64", "ptx87") if get_version().0 < 20 => None,
// Filter out features that are not supported by the current LLVM version
("loongarch64", "div32" | "lam-bh" | "lamcas" | "ld-seq-sa" | "scq")
if get_version().0 < 20 =>
@@ -324,15 +333,12 @@ pub(crate) fn to_llvm_features<'a>(sess: &Session, s: &'a str) -> Option<LLVMFea
///
/// We do not have to worry about RUSTC_SPECIFIC_FEATURES here, those are handled outside codegen.
pub(crate) fn target_config(sess: &Session) -> TargetConfig {
- // Add base features for the target.
- // We do *not* add the -Ctarget-features there, and instead duplicate the logic for that below.
- // The reason is that if LLVM considers a feature implied but we do not, we don't want that to
- // show up in `cfg`. That way, `cfg` is entirely under our control -- except for the handling of
- // the target CPU, that is still expanded to target features (with all their implied features)
- // by LLVM.
let target_machine = create_informational_target_machine(sess, true);
let (unstable_target_features, target_features) = cfg_target_feature(sess, |feature| {
+ // This closure determines whether the target CPU has the feature according to LLVM. We do
+ // *not* consider the `-Ctarget-feature`s here, as that will be handled later in
+ // `cfg_target_feature`.
if let Some(feat) = to_llvm_features(sess, feature) {
// All the LLVM features this expands to must be enabled.
for llvm_feature in feat {
diff --git a/compiler/rustc_codegen_ssa/src/target_features.rs b/compiler/rustc_codegen_ssa/src/target_features.rs
index d984156..7e4341a 100644
--- a/compiler/rustc_codegen_ssa/src/target_features.rs
+++ b/compiler/rustc_codegen_ssa/src/target_features.rs
@@ -197,7 +197,10 @@ fn parse_rust_feature_flag<'a>(
/// 2nd component of the return value, respectively).
///
/// `target_base_has_feature` should check whether the given feature (a Rust feature name!) is
-/// enabled in the "base" target machine, i.e., without applying `-Ctarget-feature`.
+/// enabled in the "base" target machine, i.e., without applying `-Ctarget-feature`. Note that LLVM
+/// may consider features to be implied that we do not and vice-versa. We want `cfg` to be entirely
+/// consistent with Rust feature implications, and thus only consult LLVM to expand the target CPU
+/// to target features.
///
/// We do not have to worry about RUSTC_SPECIFIC_FEATURES here, those are handled elsewhere.
pub fn cfg_target_feature(
@@ -211,7 +214,15 @@ pub fn cfg_target_feature(
.rust_target_features()
.iter()
.filter(|(feature, _, _)| target_base_has_feature(feature))
- .map(|(feature, _, _)| Symbol::intern(feature))
+ .flat_map(|(base_feature, _, _)| {
+ // Expand the direct base feature into all transitively-implied features. Note that we
+ // cannot simply use the `implied` field of the tuple since that only contains
+ // directly-implied features.
+ //
+ // Iteration order is irrelevant because we're collecting into an `UnordSet`.
+ #[allow(rustc::potential_query_instability)]
+ sess.target.implied_target_features(base_feature).into_iter().map(|f| Symbol::intern(f))
+ })
.collect();
// Add enabled and remove disabled features.
diff --git a/compiler/rustc_const_eval/src/lib.rs b/compiler/rustc_const_eval/src/lib.rs
index 3840cdf..8ace560 100644
--- a/compiler/rustc_const_eval/src/lib.rs
+++ b/compiler/rustc_const_eval/src/lib.rs
@@ -1,6 +1,7 @@
// tidy-alphabetical-start
#![allow(internal_features)]
#![allow(rustc::diagnostic_outside_of_impl)]
+#![cfg_attr(bootstrap, feature(strict_overflow_ops))]
#![doc(rust_logo)]
#![feature(array_try_map)]
#![feature(assert_matches)]
@@ -10,7 +11,6 @@
#![feature(never_type)]
#![feature(rustdoc_internals)]
#![feature(slice_ptr_get)]
-#![feature(strict_overflow_ops)]
#![feature(trait_alias)]
#![feature(try_blocks)]
#![feature(unqualified_local_imports)]
diff --git a/compiler/rustc_feature/src/unstable.rs b/compiler/rustc_feature/src/unstable.rs
index 1303b33..266a940 100644
--- a/compiler/rustc_feature/src/unstable.rs
+++ b/compiler/rustc_feature/src/unstable.rs
@@ -327,6 +327,7 @@ pub fn internal(&self, feature: Symbol) -> bool {
(unstable, m68k_target_feature, "1.85.0", Some(134328)),
(unstable, mips_target_feature, "1.27.0", Some(44839)),
(unstable, movrs_target_feature, "1.88.0", Some(137976)),
+ (unstable, nvptx_target_feature, "CURRENT_RUSTC_VERSION", Some(44839)),
(unstable, powerpc_target_feature, "1.27.0", Some(44839)),
(unstable, prfchw_target_feature, "1.78.0", Some(44839)),
(unstable, riscv_target_feature, "1.45.0", Some(44839)),
diff --git a/compiler/rustc_hir/src/attrs/data_structures.rs b/compiler/rustc_hir/src/attrs/data_structures.rs
index 8061842..5f41931 100644
--- a/compiler/rustc_hir/src/attrs/data_structures.rs
+++ b/compiler/rustc_hir/src/attrs/data_structures.rs
@@ -297,6 +297,9 @@ pub enum AttributeKind {
/// Represents `#[const_trait]`.
ConstTrait(Span),
+ /// Represents `#[coroutine]`.
+ Coroutine(Span),
+
/// Represents `#[coverage(..)]`.
Coverage(Span, CoverageAttrKind),
@@ -433,6 +436,9 @@ pub enum AttributeKind {
/// Represents `#[rustc_object_lifetime_default]`.
RustcObjectLifetimeDefault,
+ /// Represents `#[should_panic]`
+ ShouldPanic { reason: Option<Symbol>, span: Span },
+
/// Represents `#[rustc_skip_during_method_dispatch]`.
SkipDuringMethodDispatch { array: bool, boxed_slice: bool, span: Span },
diff --git a/compiler/rustc_hir/src/attrs/encode_cross_crate.rs b/compiler/rustc_hir/src/attrs/encode_cross_crate.rs
index 9644a59..e3a7f0b 100644
--- a/compiler/rustc_hir/src/attrs/encode_cross_crate.rs
+++ b/compiler/rustc_hir/src/attrs/encode_cross_crate.rs
@@ -28,6 +28,7 @@ pub fn encode_cross_crate(&self) -> EncodeCrossCrate {
ConstStability { .. } => Yes,
ConstStabilityIndirect => No,
ConstTrait(..) => No,
+ Coroutine(..) => No,
Coverage(..) => No,
DenyExplicitImpl(..) => No,
Deprecation { .. } => Yes,
@@ -69,6 +70,7 @@ pub fn encode_cross_crate(&self) -> EncodeCrossCrate {
RustcLayoutScalarValidRangeEnd(..) => Yes,
RustcLayoutScalarValidRangeStart(..) => Yes,
RustcObjectLifetimeDefault => No,
+ ShouldPanic { .. } => No,
SkipDuringMethodDispatch { .. } => No,
SpecializationTrait(..) => No,
Stability { .. } => Yes,
diff --git a/compiler/rustc_hir/src/hir.rs b/compiler/rustc_hir/src/hir.rs
index c30c830..34db6f9 100644
--- a/compiler/rustc_hir/src/hir.rs
+++ b/compiler/rustc_hir/src/hir.rs
@@ -1308,6 +1308,7 @@ fn span(&self) -> Span {
Attribute::Parsed(AttributeKind::MacroUse { span, .. }) => *span,
Attribute::Parsed(AttributeKind::MayDangle(span)) => *span,
Attribute::Parsed(AttributeKind::Ignore { span, .. }) => *span,
+ Attribute::Parsed(AttributeKind::ShouldPanic { span, .. }) => *span,
Attribute::Parsed(AttributeKind::AutomaticallyDerived(span)) => *span,
a => panic!("can't get the span of an arbitrary parsed attribute: {a:?}"),
}
diff --git a/compiler/rustc_hir_analysis/src/collect/generics_of.rs b/compiler/rustc_hir_analysis/src/collect/generics_of.rs
index e2462c2..ce0e51f 100644
--- a/compiler/rustc_hir_analysis/src/collect/generics_of.rs
+++ b/compiler/rustc_hir_analysis/src/collect/generics_of.rs
@@ -223,60 +223,27 @@ pub(super) fn generics_of(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::Generics {
"synthetic HIR should have its `generics_of` explicitly fed"
),
- _ => span_bug!(tcx.def_span(def_id), "unhandled node {node:?}"),
+ _ => span_bug!(tcx.def_span(def_id), "generics_of: unexpected node kind {node:?}"),
};
- enum Defaults {
- Allowed,
- // See #36887
- FutureCompatDisallowed,
- Deny,
- }
+ // Add in the self type parameter.
+ let opt_self = if let Node::Item(item) = node
+ && let ItemKind::Trait(..) | ItemKind::TraitAlias(..) = item.kind
+ {
+ // Something of a hack: We reuse the node ID of the trait for the self type parameter.
+ Some(ty::GenericParamDef {
+ index: 0,
+ name: kw::SelfUpper,
+ def_id: def_id.to_def_id(),
+ pure_wrt_drop: false,
+ kind: ty::GenericParamDefKind::Type { has_default: false, synthetic: false },
+ })
+ } else {
+ None
+ };
+ let param_default_policy = param_default_policy(node);
let hir_generics = node.generics().unwrap_or(hir::Generics::empty());
- let (opt_self, allow_defaults) = match node {
- Node::Item(item) => {
- match item.kind {
- ItemKind::Trait(..) | ItemKind::TraitAlias(..) => {
- // Add in the self type parameter.
- //
- // Something of a hack: use the node id for the trait, also as
- // the node id for the Self type parameter.
- let opt_self = Some(ty::GenericParamDef {
- index: 0,
- name: kw::SelfUpper,
- def_id: def_id.to_def_id(),
- pure_wrt_drop: false,
- kind: ty::GenericParamDefKind::Type {
- has_default: false,
- synthetic: false,
- },
- });
-
- (opt_self, Defaults::Allowed)
- }
- ItemKind::TyAlias(..)
- | ItemKind::Enum(..)
- | ItemKind::Struct(..)
- | ItemKind::Union(..) => (None, Defaults::Allowed),
- ItemKind::Const(..) => (None, Defaults::Deny),
- _ => (None, Defaults::FutureCompatDisallowed),
- }
- }
-
- Node::OpaqueTy(..) => (None, Defaults::Allowed),
-
- // GATs
- Node::TraitItem(item) if matches!(item.kind, TraitItemKind::Type(..)) => {
- (None, Defaults::Deny)
- }
- Node::ImplItem(item) if matches!(item.kind, ImplItemKind::Type(..)) => {
- (None, Defaults::Deny)
- }
-
- _ => (None, Defaults::FutureCompatDisallowed),
- };
-
let has_self = opt_self.is_some();
let mut parent_has_self = false;
let mut own_start = has_self as u32;
@@ -312,60 +279,53 @@ enum Defaults {
prev + type_start
};
- const TYPE_DEFAULT_NOT_ALLOWED: &'static str = "defaults for type parameters are only allowed in \
- `struct`, `enum`, `type`, or `trait` definitions";
-
- own_params.extend(hir_generics.params.iter().filter_map(|param| match param.kind {
- GenericParamKind::Lifetime { .. } => None,
- GenericParamKind::Type { default, synthetic, .. } => {
- if default.is_some() {
- match allow_defaults {
- Defaults::Allowed => {}
- Defaults::FutureCompatDisallowed => {
- tcx.node_span_lint(
- lint::builtin::INVALID_TYPE_PARAM_DEFAULT,
- param.hir_id,
- param.span,
- |lint| {
- lint.primary_message(TYPE_DEFAULT_NOT_ALLOWED);
- },
- );
- }
- Defaults::Deny => {
- tcx.dcx().span_err(param.span, TYPE_DEFAULT_NOT_ALLOWED);
+ own_params.extend(hir_generics.params.iter().filter_map(|param| {
+ const MESSAGE: &str = "defaults for generic parameters are not allowed here";
+ let kind = match param.kind {
+ GenericParamKind::Lifetime { .. } => return None,
+ GenericParamKind::Type { default, synthetic } => {
+ if default.is_some() {
+ match param_default_policy.expect("no policy for generic param default") {
+ ParamDefaultPolicy::Allowed => {}
+ ParamDefaultPolicy::FutureCompatForbidden => {
+ tcx.node_span_lint(
+ lint::builtin::INVALID_TYPE_PARAM_DEFAULT,
+ param.hir_id,
+ param.span,
+ |lint| {
+ lint.primary_message(MESSAGE);
+ },
+ );
+ }
+ ParamDefaultPolicy::Forbidden => {
+ tcx.dcx().span_err(param.span, MESSAGE);
+ }
}
}
+
+ ty::GenericParamDefKind::Type { has_default: default.is_some(), synthetic }
}
+ GenericParamKind::Const { ty: _, default, synthetic } => {
+ if default.is_some() {
+ match param_default_policy.expect("no policy for generic param default") {
+ ParamDefaultPolicy::Allowed => {}
+ ParamDefaultPolicy::FutureCompatForbidden
+ | ParamDefaultPolicy::Forbidden => {
+ tcx.dcx().span_err(param.span, MESSAGE);
+ }
+ }
+ }
- let kind = ty::GenericParamDefKind::Type { has_default: default.is_some(), synthetic };
-
- Some(ty::GenericParamDef {
- index: next_index(),
- name: param.name.ident().name,
- def_id: param.def_id.to_def_id(),
- pure_wrt_drop: param.pure_wrt_drop,
- kind,
- })
- }
- GenericParamKind::Const { ty: _, default, synthetic } => {
- if !matches!(allow_defaults, Defaults::Allowed) && default.is_some() {
- tcx.dcx().span_err(
- param.span,
- "defaults for const parameters are only allowed in \
- `struct`, `enum`, `type`, or `trait` definitions",
- );
+ ty::GenericParamDefKind::Const { has_default: default.is_some(), synthetic }
}
-
- let index = next_index();
-
- Some(ty::GenericParamDef {
- index,
- name: param.name.ident().name,
- def_id: param.def_id.to_def_id(),
- pure_wrt_drop: param.pure_wrt_drop,
- kind: ty::GenericParamDefKind::Const { has_default: default.is_some(), synthetic },
- })
- }
+ };
+ Some(ty::GenericParamDef {
+ index: next_index(),
+ name: param.name.ident().name,
+ def_id: param.def_id.to_def_id(),
+ pure_wrt_drop: param.pure_wrt_drop,
+ kind,
+ })
}));
// provide junk type parameter defs - the only place that
@@ -438,6 +398,48 @@ enum Defaults {
}
}
+#[derive(Clone, Copy)]
+enum ParamDefaultPolicy {
+ Allowed,
+ /// Tracked in <https://github.com/rust-lang/rust/issues/36887>.
+ FutureCompatForbidden,
+ Forbidden,
+}
+
+fn param_default_policy(node: Node<'_>) -> Option<ParamDefaultPolicy> {
+ use rustc_hir::*;
+
+ Some(match node {
+ Node::Item(item) => match item.kind {
+ ItemKind::Trait(..)
+ | ItemKind::TraitAlias(..)
+ | ItemKind::TyAlias(..)
+ | ItemKind::Enum(..)
+ | ItemKind::Struct(..)
+ | ItemKind::Union(..) => ParamDefaultPolicy::Allowed,
+ ItemKind::Fn { .. } | ItemKind::Impl(_) => ParamDefaultPolicy::FutureCompatForbidden,
+ // Re. GCI, we're not bound by backward compatibility.
+ ItemKind::Const(..) => ParamDefaultPolicy::Forbidden,
+ _ => return None,
+ },
+ Node::TraitItem(item) => match item.kind {
+ // Re. GATs and GACs (generic_const_items), we're not bound by backward compatibility.
+ TraitItemKind::Const(..) | TraitItemKind::Type(..) => ParamDefaultPolicy::Forbidden,
+ TraitItemKind::Fn(..) => ParamDefaultPolicy::FutureCompatForbidden,
+ },
+ Node::ImplItem(item) => match item.kind {
+ // Re. GATs and GACs (generic_const_items), we're not bound by backward compatibility.
+ ImplItemKind::Const(..) | ImplItemKind::Type(..) => ParamDefaultPolicy::Forbidden,
+ ImplItemKind::Fn(..) => ParamDefaultPolicy::FutureCompatForbidden,
+ },
+ // Generic params are (semantically) invalid on foreign items. Still, for maximum forward
+ // compatibility, let's hard-reject defaults on them.
+ Node::ForeignItem(_) => ParamDefaultPolicy::Forbidden,
+ Node::OpaqueTy(..) => ParamDefaultPolicy::Allowed,
+ _ => return None,
+ })
+}
+
fn has_late_bound_regions<'tcx>(tcx: TyCtxt<'tcx>, node: Node<'tcx>) -> Option<Span> {
struct LateBoundRegionsDetector<'tcx> {
tcx: TyCtxt<'tcx>,
diff --git a/compiler/rustc_lint/src/lifetime_syntax.rs b/compiler/rustc_lint/src/lifetime_syntax.rs
index 2a5a34c..464f4fc 100644
--- a/compiler/rustc_lint/src/lifetime_syntax.rs
+++ b/compiler/rustc_lint/src/lifetime_syntax.rs
@@ -434,7 +434,7 @@ fn emit_mismatch_diagnostic<'tcx>(
lints::MismatchedLifetimeSyntaxesSuggestion::Mixed {
implicit_suggestions,
explicit_anonymous_suggestions,
- tool_only: false,
+ optional_alternative: false,
}
});
@@ -455,7 +455,10 @@ fn emit_mismatch_diagnostic<'tcx>(
let implicit_suggestion = should_suggest_implicit.then(|| {
let suggestions = make_implicit_suggestions(&suggest_change_to_implicit);
- lints::MismatchedLifetimeSyntaxesSuggestion::Implicit { suggestions, tool_only: false }
+ lints::MismatchedLifetimeSyntaxesSuggestion::Implicit {
+ suggestions,
+ optional_alternative: false,
+ }
});
tracing::debug!(
@@ -508,7 +511,7 @@ fn build_mismatch_suggestion(
lints::MismatchedLifetimeSyntaxesSuggestion::Explicit {
lifetime_name,
suggestions,
- tool_only: false,
+ optional_alternative: false,
}
}
diff --git a/compiler/rustc_lint/src/lints.rs b/compiler/rustc_lint/src/lints.rs
index ef63c0d..ac6147b 100644
--- a/compiler/rustc_lint/src/lints.rs
+++ b/compiler/rustc_lint/src/lints.rs
@@ -3292,7 +3292,7 @@ fn decorate_lint<'b>(self, diag: &'b mut Diag<'a, G>) {
diag.subdiagnostic(s);
for mut s in suggestions {
- s.make_tool_only();
+ s.make_optional_alternative();
diag.subdiagnostic(s);
}
}
@@ -3303,33 +3303,33 @@ fn decorate_lint<'b>(self, diag: &'b mut Diag<'a, G>) {
pub(crate) enum MismatchedLifetimeSyntaxesSuggestion {
Implicit {
suggestions: Vec<Span>,
- tool_only: bool,
+ optional_alternative: bool,
},
Mixed {
implicit_suggestions: Vec<Span>,
explicit_anonymous_suggestions: Vec<(Span, String)>,
- tool_only: bool,
+ optional_alternative: bool,
},
Explicit {
lifetime_name: String,
suggestions: Vec<(Span, String)>,
- tool_only: bool,
+ optional_alternative: bool,
},
}
impl MismatchedLifetimeSyntaxesSuggestion {
- fn make_tool_only(&mut self) {
+ fn make_optional_alternative(&mut self) {
use MismatchedLifetimeSyntaxesSuggestion::*;
- let tool_only = match self {
- Implicit { tool_only, .. } | Mixed { tool_only, .. } | Explicit { tool_only, .. } => {
- tool_only
- }
+ let optional_alternative = match self {
+ Implicit { optional_alternative, .. }
+ | Mixed { optional_alternative, .. }
+ | Explicit { optional_alternative, .. } => optional_alternative,
};
- *tool_only = true;
+ *optional_alternative = true;
}
}
@@ -3337,22 +3337,40 @@ impl Subdiagnostic for MismatchedLifetimeSyntaxesSuggestion {
fn add_to_diag<G: EmissionGuarantee>(self, diag: &mut Diag<'_, G>) {
use MismatchedLifetimeSyntaxesSuggestion::*;
- let style = |tool_only| {
- if tool_only { SuggestionStyle::CompletelyHidden } else { SuggestionStyle::ShowAlways }
+ let style = |optional_alternative| {
+ if optional_alternative {
+ SuggestionStyle::CompletelyHidden
+ } else {
+ SuggestionStyle::ShowAlways
+ }
+ };
+
+ let applicability = |optional_alternative| {
+ // `cargo fix` can't handle more than one fix for the same issue,
+ // so hide alternative suggestions from it by marking them as maybe-incorrect
+ if optional_alternative {
+ Applicability::MaybeIncorrect
+ } else {
+ Applicability::MachineApplicable
+ }
};
match self {
- Implicit { suggestions, tool_only } => {
+ Implicit { suggestions, optional_alternative } => {
let suggestions = suggestions.into_iter().map(|s| (s, String::new())).collect();
diag.multipart_suggestion_with_style(
fluent::lint_mismatched_lifetime_syntaxes_suggestion_implicit,
suggestions,
- Applicability::MaybeIncorrect,
- style(tool_only),
+ applicability(optional_alternative),
+ style(optional_alternative),
);
}
- Mixed { implicit_suggestions, explicit_anonymous_suggestions, tool_only } => {
+ Mixed {
+ implicit_suggestions,
+ explicit_anonymous_suggestions,
+ optional_alternative,
+ } => {
let message = if implicit_suggestions.is_empty() {
fluent::lint_mismatched_lifetime_syntaxes_suggestion_mixed_only_paths
} else {
@@ -3368,12 +3386,12 @@ fn add_to_diag<G: EmissionGuarantee>(self, diag: &mut Diag<'_, G>) {
diag.multipart_suggestion_with_style(
message,
suggestions,
- Applicability::MaybeIncorrect,
- style(tool_only),
+ applicability(optional_alternative),
+ style(optional_alternative),
);
}
- Explicit { lifetime_name, suggestions, tool_only } => {
+ Explicit { lifetime_name, suggestions, optional_alternative } => {
diag.arg("lifetime_name", lifetime_name);
let msg = diag.eagerly_translate(
fluent::lint_mismatched_lifetime_syntaxes_suggestion_explicit,
@@ -3382,8 +3400,8 @@ fn add_to_diag<G: EmissionGuarantee>(self, diag: &mut Diag<'_, G>) {
diag.multipart_suggestion_with_style(
msg,
suggestions,
- Applicability::MaybeIncorrect,
- style(tool_only),
+ applicability(optional_alternative),
+ style(optional_alternative),
);
}
}
diff --git a/compiler/rustc_lint_defs/src/builtin.rs b/compiler/rustc_lint_defs/src/builtin.rs
index 3b84c6b..e660b95 100644
--- a/compiler/rustc_lint_defs/src/builtin.rs
+++ b/compiler/rustc_lint_defs/src/builtin.rs
@@ -2156,6 +2156,7 @@
@future_incompatible = FutureIncompatibleInfo {
reason: FutureIncompatibilityReason::FutureReleaseError,
reference: "issue #52234 <https://github.com/rust-lang/rust/issues/52234>",
+ report_in_deps: true,
};
crate_level_only
}
@@ -2839,7 +2840,7 @@
/// [issue #79813]: https://github.com/rust-lang/rust/issues/79813
/// [future-incompatible]: ../index.md#future-incompatible-lints
pub SEMICOLON_IN_EXPRESSIONS_FROM_MACROS,
- Warn,
+ Deny,
"trailing semicolon in macro body used as expression",
@future_incompatible = FutureIncompatibleInfo {
reason: FutureIncompatibilityReason::FutureReleaseError,
@@ -2887,11 +2888,12 @@
/// struct S { /* fields */ }
/// ```
pub LEGACY_DERIVE_HELPERS,
- Warn,
+ Deny,
"detects derive helper attributes that are used before they are introduced",
@future_incompatible = FutureIncompatibleInfo {
reason: FutureIncompatibilityReason::FutureReleaseError,
reference: "issue #79202 <https://github.com/rust-lang/rust/issues/79202>",
+ report_in_deps: true,
};
}
@@ -4624,11 +4626,12 @@
///
/// [future-incompatible]: ../index.md#future-incompatible-lints
pub PRIVATE_MACRO_USE,
- Warn,
+ Deny,
"detects certain macro bindings that should not be re-exported",
@future_incompatible = FutureIncompatibleInfo {
reason: FutureIncompatibilityReason::FutureReleaseError,
reference: "issue #120192 <https://github.com/rust-lang/rust/issues/120192>",
+ report_in_deps: true,
};
}
@@ -4828,7 +4831,7 @@
///
/// ### Example
///
- /// ```rust
+ /// ```rust,compile_fail
/// #![doc = in_root!()]
///
/// macro_rules! in_root { () => { "" } }
@@ -4853,11 +4856,12 @@
///
/// [future-incompatible]: ../index.md#future-incompatible-lints
pub OUT_OF_SCOPE_MACRO_CALLS,
- Warn,
+ Deny,
"detects out of scope calls to `macro_rules` in key-value attributes",
@future_incompatible = FutureIncompatibleInfo {
reason: FutureIncompatibilityReason::FutureReleaseError,
reference: "issue #124535 <https://github.com/rust-lang/rust/issues/124535>",
+ report_in_deps: true,
};
}
diff --git a/compiler/rustc_middle/src/mir/visit.rs b/compiler/rustc_middle/src/mir/visit.rs
index 929ebe1..42a68b2 100644
--- a/compiler/rustc_middle/src/mir/visit.rs
+++ b/compiler/rustc_middle/src/mir/visit.rs
@@ -1205,18 +1205,19 @@ fn visit_projection_elem(
self.super_projection_elem(place_ref, elem, context, location);
}
- fn super_place(&mut self, place: &Place<'tcx>, context: PlaceContext, location: Location) {
- let mut context = context;
-
- if !place.projection.is_empty() {
- if context.is_use() {
- // ^ Only change the context if it is a real use, not a "use" in debuginfo.
- context = if context.is_mutating_use() {
- PlaceContext::MutatingUse(MutatingUseContext::Projection)
- } else {
- PlaceContext::NonMutatingUse(NonMutatingUseContext::Projection)
- };
- }
+ fn super_place(
+ &mut self,
+ place: &Place<'tcx>,
+ mut context: PlaceContext,
+ location: Location,
+ ) {
+ if !place.projection.is_empty() && context.is_use() {
+ // ^ Only change the context if it is a real use, not a "use" in debuginfo.
+ context = if context.is_mutating_use() {
+ PlaceContext::MutatingUse(MutatingUseContext::Projection)
+ } else {
+ PlaceContext::NonMutatingUse(NonMutatingUseContext::Projection)
+ };
}
self.visit_local(place.local, context, location);
@@ -1239,7 +1240,7 @@ fn super_projection_elem(
&mut self,
_place_ref: PlaceRef<'tcx>,
elem: PlaceElem<'tcx>,
- _context: PlaceContext,
+ context: PlaceContext,
location: Location,
) {
match elem {
@@ -1252,7 +1253,12 @@ fn super_projection_elem(
ProjectionElem::Index(local) => {
self.visit_local(
local,
- PlaceContext::NonMutatingUse(NonMutatingUseContext::Copy),
+ if context.is_use() {
+ // ^ Only change the context if it is a real use, not a "use" in debuginfo.
+ PlaceContext::NonMutatingUse(NonMutatingUseContext::Copy)
+ } else {
+ context
+ },
location,
);
}
diff --git a/compiler/rustc_mir_build/src/builder/block.rs b/compiler/rustc_mir_build/src/builder/block.rs
index a71196f..566d89f 100644
--- a/compiler/rustc_mir_build/src/builder/block.rs
+++ b/compiler/rustc_mir_build/src/builder/block.rs
@@ -6,7 +6,7 @@
use tracing::debug;
use crate::builder::ForGuard::OutsideGuard;
-use crate::builder::matches::{DeclareLetBindings, EmitStorageLive, ScheduleDrops};
+use crate::builder::matches::{DeclareLetBindings, ScheduleDrops};
use crate::builder::{BlockAnd, BlockAndExtension, BlockFrame, Builder};
impl<'a, 'tcx> Builder<'a, 'tcx> {
@@ -199,15 +199,6 @@ fn ast_block_stmts(
None,
Some((Some(&destination), initializer_span)),
);
- this.visit_primary_bindings(pattern, &mut |this, node, span| {
- this.storage_live_binding(
- block,
- node,
- span,
- OutsideGuard,
- ScheduleDrops::Yes,
- );
- });
let else_block_span = this.thir[*else_block].span;
let (matching, failure) =
this.in_if_then_scope(last_remainder_scope, else_block_span, |this| {
@@ -218,7 +209,6 @@ fn ast_block_stmts(
None,
initializer_span,
DeclareLetBindings::No,
- EmitStorageLive::No,
)
});
matching.and(failure)
diff --git a/compiler/rustc_mir_build/src/builder/matches/match_pair.rs b/compiler/rustc_mir_build/src/builder/matches/match_pair.rs
index 3a7854a..7a84853 100644
--- a/compiler/rustc_mir_build/src/builder/matches/match_pair.rs
+++ b/compiler/rustc_mir_build/src/builder/matches/match_pair.rs
@@ -124,9 +124,19 @@ pub(super) fn for_pattern(
let test_case = match pattern.kind {
PatKind::Missing | PatKind::Wild | PatKind::Error(_) => None,
- PatKind::Or { ref pats } => Some(TestCase::Or {
- pats: pats.iter().map(|pat| FlatPat::new(place_builder.clone(), pat, cx)).collect(),
- }),
+ PatKind::Or { ref pats } => {
+ let pats: Box<[FlatPat<'tcx>]> =
+ pats.iter().map(|pat| FlatPat::new(place_builder.clone(), pat, cx)).collect();
+ if !pats[0].extra_data.bindings.is_empty() {
+ // Hold a place for any bindings established in (possibly-nested) or-patterns.
+ // By only holding a place when bindings are present, we skip over any
+ // or-patterns that will be simplified by `merge_trivial_subcandidates`. In
+ // other words, we can assume this expands into subcandidates.
+ // FIXME(@dianne): this needs updating/removing if we always merge or-patterns
+ extra_data.bindings.push(super::SubpatternBindings::FromOrPattern);
+ }
+ Some(TestCase::Or { pats })
+ }
PatKind::Range(ref range) => {
if range.is_full_range(cx.tcx) == Some(true) {
@@ -194,12 +204,12 @@ pub(super) fn for_pattern(
// Then push this binding, after any bindings in the subpattern.
if let Some(source) = place {
- extra_data.bindings.push(super::Binding {
+ extra_data.bindings.push(super::SubpatternBindings::One(super::Binding {
span: pattern.span,
source,
var_id: var,
binding_mode: mode,
- });
+ }));
}
None
diff --git a/compiler/rustc_mir_build/src/builder/matches/mod.rs b/compiler/rustc_mir_build/src/builder/matches/mod.rs
index 2c29b86..aebd785 100644
--- a/compiler/rustc_mir_build/src/builder/matches/mod.rs
+++ b/compiler/rustc_mir_build/src/builder/matches/mod.rs
@@ -5,11 +5,11 @@
//! This also includes code for pattern bindings in `let` statements and
//! function parameters.
-use std::assert_matches::assert_matches;
use std::borrow::Borrow;
use std::mem;
use std::sync::Arc;
+use itertools::{Itertools, Position};
use rustc_abi::VariantIdx;
use rustc_data_structures::fx::FxIndexMap;
use rustc_data_structures::stack::ensure_sufficient_stack;
@@ -69,18 +69,6 @@ pub(crate) enum DeclareLetBindings {
LetNotPermitted,
}
-/// Used by [`Builder::bind_matched_candidate_for_arm_body`] to determine
-/// whether or not to call [`Builder::storage_live_binding`] to emit
-/// [`StatementKind::StorageLive`].
-#[derive(Clone, Copy)]
-pub(crate) enum EmitStorageLive {
- /// Yes, emit `StorageLive` as normal.
- Yes,
- /// No, don't emit `StorageLive`. The caller has taken responsibility for
- /// emitting `StorageLive` as appropriate.
- No,
-}
-
/// Used by [`Builder::storage_live_binding`] and [`Builder::bind_matched_candidate_for_arm_body`]
/// to decide whether to schedule drops.
#[derive(Clone, Copy, Debug)]
@@ -207,7 +195,6 @@ fn then_else_break_inner(
Some(args.variable_source_info.scope),
args.variable_source_info.span,
args.declare_let_bindings,
- EmitStorageLive::Yes,
),
_ => {
let mut block = block;
@@ -479,7 +466,6 @@ pub(crate) fn lower_match_arms(
&built_match_tree.fake_borrow_temps,
scrutinee_span,
Some((arm, match_scope)),
- EmitStorageLive::Yes,
);
this.fixed_temps_scope = old_dedup_scope;
@@ -533,7 +519,6 @@ fn bind_pattern(
fake_borrow_temps: &[(Place<'tcx>, Local, FakeBorrowKind)],
scrutinee_span: Span,
arm_match_scope: Option<(&Arm<'tcx>, region::Scope)>,
- emit_storage_live: EmitStorageLive,
) -> BasicBlock {
if branch.sub_branches.len() == 1 {
let [sub_branch] = branch.sub_branches.try_into().unwrap();
@@ -544,7 +529,6 @@ fn bind_pattern(
scrutinee_span,
arm_match_scope,
ScheduleDrops::Yes,
- emit_storage_live,
)
} else {
// It's helpful to avoid scheduling drops multiple times to save
@@ -561,27 +545,20 @@ fn bind_pattern(
// return: it isn't bound by move until right before enter the arm.
// To handle this we instead unschedule it's drop after each time
// we lower the guard.
+ // As a result, we end up with the drop order of the last sub-branch we lower. To use
+ // the drop order for the first sub-branch, we lower sub-branches in reverse (#142163).
let target_block = self.cfg.start_new_block();
- let mut schedule_drops = ScheduleDrops::Yes;
- let arm = arm_match_scope.unzip().0;
- // We keep a stack of all of the bindings and type ascriptions
- // from the parent candidates that we visit, that also need to
- // be bound for each candidate.
- for sub_branch in branch.sub_branches {
- if let Some(arm) = arm {
- self.clear_top_scope(arm.scope);
- }
+ for (pos, sub_branch) in branch.sub_branches.into_iter().rev().with_position() {
+ debug_assert!(pos != Position::Only);
+ let schedule_drops =
+ if pos == Position::Last { ScheduleDrops::Yes } else { ScheduleDrops::No };
let binding_end = self.bind_and_guard_matched_candidate(
sub_branch,
fake_borrow_temps,
scrutinee_span,
arm_match_scope,
schedule_drops,
- emit_storage_live,
);
- if arm.is_none() {
- schedule_drops = ScheduleDrops::No;
- }
self.cfg.goto(binding_end, outer_source_info, target_block);
}
@@ -741,7 +718,6 @@ pub(crate) fn place_into_pattern(
&[],
irrefutable_pat.span,
None,
- EmitStorageLive::Yes,
)
.unit()
}
@@ -996,7 +972,7 @@ struct PatternExtraData<'tcx> {
span: Span,
/// Bindings that must be established.
- bindings: Vec<Binding<'tcx>>,
+ bindings: Vec<SubpatternBindings<'tcx>>,
/// Types that must be asserted.
ascriptions: Vec<Ascription<'tcx>>,
@@ -1011,6 +987,15 @@ fn is_empty(&self) -> bool {
}
}
+#[derive(Debug, Clone)]
+enum SubpatternBindings<'tcx> {
+ /// A single binding.
+ One(Binding<'tcx>),
+ /// Holds the place for an or-pattern's bindings. This ensures their drops are scheduled in the
+ /// order the primary bindings appear. See rust-lang/rust#142163 for more information.
+ FromOrPattern,
+}
+
/// A pattern in a form suitable for lowering the match tree, with all irrefutable
/// patterns simplified away.
///
@@ -1226,7 +1211,7 @@ fn traverse_candidate<'tcx, C, T, I>(
}
}
-#[derive(Clone, Debug)]
+#[derive(Clone, Copy, Debug)]
struct Binding<'tcx> {
span: Span,
source: Place<'tcx>,
@@ -1452,12 +1437,7 @@ fn from_sub_candidate(
span: candidate.extra_data.span,
success_block: candidate.pre_binding_block.unwrap(),
otherwise_block: candidate.otherwise_block.unwrap(),
- bindings: parent_data
- .iter()
- .flat_map(|d| &d.bindings)
- .chain(&candidate.extra_data.bindings)
- .cloned()
- .collect(),
+ bindings: sub_branch_bindings(parent_data, &candidate.extra_data.bindings),
ascriptions: parent_data
.iter()
.flat_map(|d| &d.ascriptions)
@@ -1490,6 +1470,68 @@ fn from_candidate(candidate: Candidate<'tcx>) -> Self {
}
}
+/// Collects the bindings for a [`MatchTreeSubBranch`], preserving the order they appear in the
+/// pattern, as though the or-alternatives chosen in this sub-branch were inlined.
+fn sub_branch_bindings<'tcx>(
+ parents: &[PatternExtraData<'tcx>],
+ leaf_bindings: &[SubpatternBindings<'tcx>],
+) -> Vec<Binding<'tcx>> {
+ // In the common case, all bindings will be in leaves. Allocate to fit the leaf's bindings.
+ let mut all_bindings = Vec::with_capacity(leaf_bindings.len());
+ let mut remainder = parents
+ .iter()
+ .map(|parent| parent.bindings.as_slice())
+ .chain([leaf_bindings])
+ // Skip over unsimplified or-patterns without bindings.
+ .filter(|bindings| !bindings.is_empty());
+ if let Some(candidate_bindings) = remainder.next() {
+ push_sub_branch_bindings(&mut all_bindings, candidate_bindings, &mut remainder);
+ }
+ // Make sure we've included all bindings. For ill-formed patterns like `(x, _ | y)`, we may not
+ // have collected all bindings yet, since we only check the first alternative when determining
+ // whether to inline subcandidates' bindings.
+ // FIXME(@dianne): prevent ill-formed patterns from getting here
+ while let Some(candidate_bindings) = remainder.next() {
+ ty::tls::with(|tcx| {
+ tcx.dcx().delayed_bug("mismatched or-pattern bindings but no error emitted")
+ });
+ // To recover, we collect the rest in an arbitrary order.
+ push_sub_branch_bindings(&mut all_bindings, candidate_bindings, &mut remainder);
+ }
+ all_bindings
+}
+
+/// Helper for [`sub_branch_bindings`]. Collects bindings from `candidate_bindings` into
+/// `flattened`. Bindings in or-patterns are collected recursively from `remainder`.
+fn push_sub_branch_bindings<'c, 'tcx: 'c>(
+ flattened: &mut Vec<Binding<'tcx>>,
+ candidate_bindings: &'c [SubpatternBindings<'tcx>],
+ remainder: &mut impl Iterator<Item = &'c [SubpatternBindings<'tcx>]>,
+) {
+ for subpat_bindings in candidate_bindings {
+ match subpat_bindings {
+ SubpatternBindings::One(binding) => flattened.push(*binding),
+ SubpatternBindings::FromOrPattern => {
+ // Inline bindings from an or-pattern. By construction, this always
+ // corresponds to a subcandidate and its closest descendants (i.e. those
+ // from nested or-patterns, but not adjacent or-patterns). To handle
+ // adjacent or-patterns, e.g. `(x | x, y | y)`, we update the `remainder` to
+ // point to the first descendant candidate from outside this or-pattern.
+ if let Some(subcandidate_bindings) = remainder.next() {
+ push_sub_branch_bindings(flattened, subcandidate_bindings, remainder);
+ } else {
+ // For ill-formed patterns like `x | _`, we may not have any subcandidates left
+ // to inline bindings from.
+ // FIXME(@dianne): prevent ill-formed patterns from getting here
+ ty::tls::with(|tcx| {
+ tcx.dcx().delayed_bug("mismatched or-pattern bindings but no error emitted")
+ });
+ };
+ }
+ }
+ }
+}
+
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(crate) enum HasMatchGuard {
Yes,
@@ -2364,7 +2406,6 @@ pub(crate) fn lower_let_expr(
source_scope: Option<SourceScope>,
scope_span: Span,
declare_let_bindings: DeclareLetBindings,
- emit_storage_live: EmitStorageLive,
) -> BlockAnd<()> {
let expr_span = self.thir[expr_id].span;
let scrutinee = unpack!(block = self.lower_scrutinee(block, expr_id, expr_span));
@@ -2398,14 +2439,7 @@ pub(crate) fn lower_let_expr(
}
}
- let success = self.bind_pattern(
- self.source_info(pat.span),
- branch,
- &[],
- expr_span,
- None,
- emit_storage_live,
- );
+ let success = self.bind_pattern(self.source_info(pat.span), branch, &[], expr_span, None);
// If branch coverage is enabled, record this branch.
self.visit_coverage_conditional_let(pat, success, built_tree.otherwise_block);
@@ -2428,7 +2462,6 @@ fn bind_and_guard_matched_candidate(
scrutinee_span: Span,
arm_match_scope: Option<(&Arm<'tcx>, region::Scope)>,
schedule_drops: ScheduleDrops,
- emit_storage_live: EmitStorageLive,
) -> BasicBlock {
debug!("bind_and_guard_matched_candidate(subbranch={:?})", sub_branch);
@@ -2453,11 +2486,8 @@ fn bind_and_guard_matched_candidate(
// Bindings for guards require some extra handling to automatically
// insert implicit references/dereferences.
- self.bind_matched_candidate_for_guard(
- block,
- schedule_drops,
- sub_branch.bindings.iter(),
- );
+ // This always schedules storage drops, so we may need to unschedule them below.
+ self.bind_matched_candidate_for_guard(block, sub_branch.bindings.iter());
let guard_frame = GuardFrame {
locals: sub_branch
.bindings
@@ -2489,6 +2519,13 @@ fn bind_and_guard_matched_candidate(
)
});
+ // If this isn't the final sub-branch being lowered, we need to unschedule drops of
+ // bindings and temporaries created for and by the guard. As a result, the drop order
+ // for the arm will correspond to the binding order of the final sub-branch lowered.
+ if matches!(schedule_drops, ScheduleDrops::No) {
+ self.clear_top_scope(arm.scope);
+ }
+
let source_info = self.source_info(guard_span);
let guard_end = self.source_info(tcx.sess.source_map().end_point(guard_span));
let guard_frame = self.guard_context.pop().unwrap();
@@ -2538,16 +2575,11 @@ fn bind_and_guard_matched_candidate(
let cause = FakeReadCause::ForGuardBinding;
self.cfg.push_fake_read(post_guard_block, guard_end, cause, Place::from(local_id));
}
- assert_matches!(
- schedule_drops,
- ScheduleDrops::Yes,
- "patterns with guards must schedule drops"
- );
+ // Only schedule drops for the last sub-branch we lower.
self.bind_matched_candidate_for_arm_body(
post_guard_block,
- ScheduleDrops::Yes,
+ schedule_drops,
by_value_bindings,
- emit_storage_live,
);
post_guard_block
@@ -2559,7 +2591,6 @@ fn bind_and_guard_matched_candidate(
block,
schedule_drops,
sub_branch.bindings.iter(),
- emit_storage_live,
);
block
}
@@ -2671,7 +2702,6 @@ fn ascribe_types(
fn bind_matched_candidate_for_guard<'b>(
&mut self,
block: BasicBlock,
- schedule_drops: ScheduleDrops,
bindings: impl IntoIterator<Item = &'b Binding<'tcx>>,
) where
'tcx: 'b,
@@ -2690,12 +2720,13 @@ fn bind_matched_candidate_for_guard<'b>(
// a reference R: &T pointing to the location matched by
// the pattern, and every occurrence of P within a guard
// denotes *R.
+ // Drops must be scheduled to emit `StorageDead` on the guard's failure/break branches.
let ref_for_guard = self.storage_live_binding(
block,
binding.var_id,
binding.span,
RefWithinGuard,
- schedule_drops,
+ ScheduleDrops::Yes,
);
match binding.binding_mode.0 {
ByRef::No => {
@@ -2705,13 +2736,14 @@ fn bind_matched_candidate_for_guard<'b>(
self.cfg.push_assign(block, source_info, ref_for_guard, rvalue);
}
ByRef::Yes(mutbl) => {
- // The arm binding will be by reference, so eagerly create it now.
+ // The arm binding will be by reference, so eagerly create it now. Drops must
+ // be scheduled to emit `StorageDead` on the guard's failure/break branches.
let value_for_arm = self.storage_live_binding(
block,
binding.var_id,
binding.span,
OutsideGuard,
- schedule_drops,
+ ScheduleDrops::Yes,
);
let rvalue =
@@ -2730,7 +2762,6 @@ fn bind_matched_candidate_for_arm_body<'b>(
block: BasicBlock,
schedule_drops: ScheduleDrops,
bindings: impl IntoIterator<Item = &'b Binding<'tcx>>,
- emit_storage_live: EmitStorageLive,
) where
'tcx: 'b,
{
@@ -2740,19 +2771,13 @@ fn bind_matched_candidate_for_arm_body<'b>(
// Assign each of the bindings. This may trigger moves out of the candidate.
for binding in bindings {
let source_info = self.source_info(binding.span);
- let local = match emit_storage_live {
- // Here storages are already alive, probably because this is a binding
- // from let-else.
- // We just need to schedule drop for the value.
- EmitStorageLive::No => self.var_local_id(binding.var_id, OutsideGuard).into(),
- EmitStorageLive::Yes => self.storage_live_binding(
- block,
- binding.var_id,
- binding.span,
- OutsideGuard,
- schedule_drops,
- ),
- };
+ let local = self.storage_live_binding(
+ block,
+ binding.var_id,
+ binding.span,
+ OutsideGuard,
+ schedule_drops,
+ );
if matches!(schedule_drops, ScheduleDrops::Yes) {
self.schedule_drop_for_binding(binding.var_id, binding.span, OutsideGuard);
}
diff --git a/compiler/rustc_mir_build/src/builder/matches/util.rs b/compiler/rustc_mir_build/src/builder/matches/util.rs
index 589e350..2c8ad95 100644
--- a/compiler/rustc_mir_build/src/builder/matches/util.rs
+++ b/compiler/rustc_mir_build/src/builder/matches/util.rs
@@ -138,7 +138,9 @@ fn fake_borrow_deref_prefixes(&mut self, place: Place<'tcx>, kind: FakeBorrowKin
fn visit_candidate(&mut self, candidate: &Candidate<'tcx>) {
for binding in &candidate.extra_data.bindings {
- self.visit_binding(binding);
+ if let super::SubpatternBindings::One(binding) = binding {
+ self.visit_binding(binding);
+ }
}
for match_pair in &candidate.match_pairs {
self.visit_match_pair(match_pair);
@@ -147,7 +149,9 @@ fn visit_candidate(&mut self, candidate: &Candidate<'tcx>) {
fn visit_flat_pat(&mut self, flat_pat: &FlatPat<'tcx>) {
for binding in &flat_pat.extra_data.bindings {
- self.visit_binding(binding);
+ if let super::SubpatternBindings::One(binding) = binding {
+ self.visit_binding(binding);
+ }
}
for match_pair in &flat_pat.match_pairs {
self.visit_match_pair(match_pair);
diff --git a/compiler/rustc_mir_build/src/check_tail_calls.rs b/compiler/rustc_mir_build/src/check_tail_calls.rs
index b4c8b20..3ecccb4 100644
--- a/compiler/rustc_mir_build/src/check_tail_calls.rs
+++ b/compiler/rustc_mir_build/src/check_tail_calls.rs
@@ -60,9 +60,13 @@ fn check_tail_call(&mut self, call: &Expr<'_>, expr: &Expr<'_>) {
let BodyTy::Fn(caller_sig) = self.thir.body_type else {
span_bug!(
call.span,
- "`become` outside of functions should have been disallowed by hit_typeck"
+ "`become` outside of functions should have been disallowed by hir_typeck"
)
};
+ // While the `caller_sig` does have its regions erased, it does not have its
+ // binders anonymized. We call `erase_regions` once again to anonymize any binders
+ // within the signature, such as in function pointer or `dyn Trait` args.
+ let caller_sig = self.tcx.erase_regions(caller_sig);
let ExprKind::Scope { value, .. } = call.kind else {
span_bug!(call.span, "expected scope, found: {call:?}")
diff --git a/compiler/rustc_mir_transform/src/simplify.rs b/compiler/rustc_mir_transform/src/simplify.rs
index db933da..468ef74 100644
--- a/compiler/rustc_mir_transform/src/simplify.rs
+++ b/compiler/rustc_mir_transform/src/simplify.rs
@@ -225,6 +225,7 @@ fn collapse_goto_chain(&mut self, start: &mut BasicBlock, changed: &mut bool) {
current = target;
}
let last = current;
+ *changed |= *start != last;
*start = last;
while let Some((current, mut terminator)) = terminators.pop() {
let Terminator { kind: TerminatorKind::Goto { ref mut target }, .. } = terminator
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 231fb3e..5e08c3a 100644
--- a/compiler/rustc_next_trait_solver/src/solve/assembly/mod.rs
+++ b/compiler/rustc_next_trait_solver/src/solve/assembly/mod.rs
@@ -959,36 +959,23 @@ pub(super) fn assemble_and_merge_candidates<G: GoalKind<D>>(
// Even when a trait bound has been proven using a where-bound, we
// still need to consider alias-bounds for normalization, see
// `tests/ui/next-solver/alias-bound-shadowed-by-env.rs`.
- let candidates_from_env_and_bounds: Vec<_> = self
+ let mut candidates: Vec<_> = self
.assemble_and_evaluate_candidates(goal, AssembleCandidatesFrom::EnvAndBounds);
// We still need to prefer where-bounds over alias-bounds however.
// See `tests/ui/winnowing/norm-where-bound-gt-alias-bound.rs`.
- let mut considered_candidates: Vec<_> = if candidates_from_env_and_bounds
- .iter()
- .any(|c| matches!(c.source, CandidateSource::ParamEnv(_)))
- {
- candidates_from_env_and_bounds
- .into_iter()
- .filter(|c| matches!(c.source, CandidateSource::ParamEnv(_)))
- .map(|c| c.result)
- .collect()
- } else {
- candidates_from_env_and_bounds.into_iter().map(|c| c.result).collect()
- };
-
- // If the trait goal has been proven by using the environment, we want to treat
- // aliases as rigid if there are no applicable projection bounds in the environment.
- if considered_candidates.is_empty() {
- if let Ok(response) = inject_normalize_to_rigid_candidate(self) {
- considered_candidates.push(response);
- }
+ if candidates.iter().any(|c| matches!(c.source, CandidateSource::ParamEnv(_))) {
+ candidates.retain(|c| matches!(c.source, CandidateSource::ParamEnv(_)));
+ } else if candidates.is_empty() {
+ // If the trait goal has been proven by using the environment, we want to treat
+ // aliases as rigid if there are no applicable projection bounds in the environment.
+ return inject_normalize_to_rigid_candidate(self);
}
- if let Some(response) = self.try_merge_responses(&considered_candidates) {
+ if let Some(response) = self.try_merge_candidates(&candidates) {
Ok(response)
} else {
- self.flounder(&considered_candidates)
+ self.flounder(&candidates)
}
}
TraitGoalProvenVia::Misc => {
@@ -998,11 +985,9 @@ pub(super) fn assemble_and_merge_candidates<G: GoalKind<D>>(
// Prefer "orphaned" param-env normalization predicates, which are used
// (for example, and ideally only) when proving item bounds for an impl.
let candidates_from_env: Vec<_> = candidates
- .iter()
- .filter(|c| matches!(c.source, CandidateSource::ParamEnv(_)))
- .map(|c| c.result)
+ .extract_if(.., |c| matches!(c.source, CandidateSource::ParamEnv(_)))
.collect();
- if let Some(response) = self.try_merge_responses(&candidates_from_env) {
+ if let Some(response) = self.try_merge_candidates(&candidates_from_env) {
return Ok(response);
}
@@ -1012,12 +997,10 @@ pub(super) fn assemble_and_merge_candidates<G: GoalKind<D>>(
// means we can just ignore inference constraints and don't have to special-case
// constraining the normalized-to `term`.
self.filter_specialized_impls(AllowInferenceConstraints::Yes, &mut candidates);
-
- let responses: Vec<_> = candidates.iter().map(|c| c.result).collect();
- if let Some(response) = self.try_merge_responses(&responses) {
+ if let Some(response) = self.try_merge_candidates(&candidates) {
Ok(response)
} else {
- self.flounder(&responses)
+ self.flounder(&candidates)
}
}
}
diff --git a/compiler/rustc_next_trait_solver/src/solve/mod.rs b/compiler/rustc_next_trait_solver/src/solve/mod.rs
index aec9594..2feebe2 100644
--- a/compiler/rustc_next_trait_solver/src/solve/mod.rs
+++ b/compiler/rustc_next_trait_solver/src/solve/mod.rs
@@ -29,6 +29,7 @@
pub use self::eval_ctxt::{EvalCtxt, GenerateProofTree, SolverDelegateEvalExt};
use crate::delegate::SolverDelegate;
+use crate::solve::assembly::Candidate;
/// How many fixpoint iterations we should attempt inside of the solver before bailing
/// with overflow.
@@ -244,50 +245,51 @@ impl<D, I> EvalCtxt<'_, D>
///
/// In this case we tend to flounder and return ambiguity by calling `[EvalCtxt::flounder]`.
#[instrument(level = "trace", skip(self), ret)]
- fn try_merge_responses(
+ fn try_merge_candidates(
&mut self,
- responses: &[CanonicalResponse<I>],
+ candidates: &[Candidate<I>],
) -> Option<CanonicalResponse<I>> {
- if responses.is_empty() {
+ if candidates.is_empty() {
return None;
}
- let one = responses[0];
- if responses[1..].iter().all(|&resp| resp == one) {
+ let one: CanonicalResponse<I> = candidates[0].result;
+ if candidates[1..].iter().all(|candidate| candidate.result == one) {
return Some(one);
}
- responses
+ candidates
.iter()
- .find(|response| {
- response.value.certainty == Certainty::Yes
- && has_no_inference_or_external_constraints(**response)
+ .find(|candidate| {
+ candidate.result.value.certainty == Certainty::Yes
+ && has_no_inference_or_external_constraints(candidate.result)
})
- .copied()
+ .map(|candidate| candidate.result)
}
- fn bail_with_ambiguity(&mut self, responses: &[CanonicalResponse<I>]) -> CanonicalResponse<I> {
- debug_assert!(responses.len() > 1);
- let maybe_cause = responses.iter().fold(MaybeCause::Ambiguity, |maybe_cause, response| {
- // Pull down the certainty of `Certainty::Yes` to ambiguity when combining
- // these responses, b/c we're combining more than one response and this we
- // don't know which one applies.
- let candidate = match response.value.certainty {
- Certainty::Yes => MaybeCause::Ambiguity,
- Certainty::Maybe(candidate) => candidate,
- };
- maybe_cause.or(candidate)
- });
+ fn bail_with_ambiguity(&mut self, candidates: &[Candidate<I>]) -> CanonicalResponse<I> {
+ debug_assert!(candidates.len() > 1);
+ let maybe_cause =
+ candidates.iter().fold(MaybeCause::Ambiguity, |maybe_cause, candidates| {
+ // Pull down the certainty of `Certainty::Yes` to ambiguity when combining
+ // these responses, b/c we're combining more than one response and this we
+ // don't know which one applies.
+ let candidate = match candidates.result.value.certainty {
+ Certainty::Yes => MaybeCause::Ambiguity,
+ Certainty::Maybe(candidate) => candidate,
+ };
+ maybe_cause.or(candidate)
+ });
self.make_ambiguous_response_no_constraints(maybe_cause)
}
/// If we fail to merge responses we flounder and return overflow or ambiguity.
#[instrument(level = "trace", skip(self), ret)]
- fn flounder(&mut self, responses: &[CanonicalResponse<I>]) -> QueryResult<I> {
- if responses.is_empty() {
+ fn flounder(&mut self, candidates: &[Candidate<I>]) -> QueryResult<I> {
+ if candidates.is_empty() {
return Err(NoSolution);
} else {
- Ok(self.bail_with_ambiguity(responses))
+ Ok(self.bail_with_ambiguity(candidates))
}
}
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 f760c2c..60bae73 100644
--- a/compiler/rustc_next_trait_solver/src/solve/trait_goals.rs
+++ b/compiler/rustc_next_trait_solver/src/solve/trait_goals.rs
@@ -1346,11 +1346,10 @@ pub(super) fn merge_trait_candidates(
mut candidates: Vec<Candidate<I>>,
) -> Result<(CanonicalResponse<I>, Option<TraitGoalProvenVia>), NoSolution> {
if let TypingMode::Coherence = self.typing_mode() {
- let all_candidates: Vec<_> = candidates.into_iter().map(|c| c.result).collect();
- return if let Some(response) = self.try_merge_responses(&all_candidates) {
+ return if let Some(response) = self.try_merge_candidates(&candidates) {
Ok((response, Some(TraitGoalProvenVia::Misc)))
} else {
- self.flounder(&all_candidates).map(|r| (r, None))
+ self.flounder(&candidates).map(|r| (r, None))
};
}
@@ -1375,11 +1374,9 @@ pub(super) fn merge_trait_candidates(
.any(|c| matches!(c.source, CandidateSource::ParamEnv(ParamEnvSource::NonGlobal)));
if has_non_global_where_bounds {
let where_bounds: Vec<_> = candidates
- .iter()
- .filter(|c| matches!(c.source, CandidateSource::ParamEnv(_)))
- .map(|c| c.result)
+ .extract_if(.., |c| matches!(c.source, CandidateSource::ParamEnv(_)))
.collect();
- return if let Some(response) = self.try_merge_responses(&where_bounds) {
+ return if let Some(response) = self.try_merge_candidates(&where_bounds) {
Ok((response, Some(TraitGoalProvenVia::ParamEnv)))
} else {
Ok((self.bail_with_ambiguity(&where_bounds), None))
@@ -1388,11 +1385,9 @@ pub(super) fn merge_trait_candidates(
if candidates.iter().any(|c| matches!(c.source, CandidateSource::AliasBound)) {
let alias_bounds: Vec<_> = candidates
- .iter()
- .filter(|c| matches!(c.source, CandidateSource::AliasBound))
- .map(|c| c.result)
+ .extract_if(.., |c| matches!(c.source, CandidateSource::AliasBound))
.collect();
- return if let Some(response) = self.try_merge_responses(&alias_bounds) {
+ return if let Some(response) = self.try_merge_candidates(&alias_bounds) {
Ok((response, Some(TraitGoalProvenVia::AliasBound)))
} else {
Ok((self.bail_with_ambiguity(&alias_bounds), None))
@@ -1417,11 +1412,10 @@ pub(super) fn merge_trait_candidates(
TraitGoalProvenVia::Misc
};
- let all_candidates: Vec<_> = candidates.into_iter().map(|c| c.result).collect();
- if let Some(response) = self.try_merge_responses(&all_candidates) {
+ if let Some(response) = self.try_merge_candidates(&candidates) {
Ok((response, Some(proven_via)))
} else {
- self.flounder(&all_candidates).map(|r| (r, None))
+ self.flounder(&candidates).map(|r| (r, None))
}
}
diff --git a/compiler/rustc_parse/messages.ftl b/compiler/rustc_parse/messages.ftl
index 859118a..7059ffb 100644
--- a/compiler/rustc_parse/messages.ftl
+++ b/compiler/rustc_parse/messages.ftl
@@ -71,6 +71,17 @@
parse_attribute_on_param_type = attributes cannot be applied to a function parameter's type
.label = attributes are not allowed here
+parse_attribute_on_type = attributes cannot be applied to types
+ .label = attributes are not allowed here
+ .suggestion = remove attribute from here
+
+parse_attribute_on_generic_arg = attributes cannot be applied to generic arguments
+ .label = attributes are not allowed here
+ .suggestion = remove attribute from here
+
+parse_attribute_on_empty_type = attributes cannot be applied here
+ .label = attributes are not allowed here
+
parse_bad_assoc_type_bounds = bounds on associated types do not belong here
.label = belongs in `where` clause
diff --git a/compiler/rustc_parse/src/errors.rs b/compiler/rustc_parse/src/errors.rs
index 4aaaba0..48ff039 100644
--- a/compiler/rustc_parse/src/errors.rs
+++ b/compiler/rustc_parse/src/errors.rs
@@ -1490,6 +1490,34 @@ pub(crate) struct AttributeOnParamType {
}
#[derive(Diagnostic)]
+#[diag(parse_attribute_on_type)]
+pub(crate) struct AttributeOnType {
+ #[primary_span]
+ #[label]
+ pub span: Span,
+ #[suggestion(code = "", applicability = "machine-applicable", style = "tool-only")]
+ pub fix_span: Span,
+}
+
+#[derive(Diagnostic)]
+#[diag(parse_attribute_on_generic_arg)]
+pub(crate) struct AttributeOnGenericArg {
+ #[primary_span]
+ #[label]
+ pub span: Span,
+ #[suggestion(code = "", applicability = "machine-applicable", style = "tool-only")]
+ pub fix_span: Span,
+}
+
+#[derive(Diagnostic)]
+#[diag(parse_attribute_on_empty_type)]
+pub(crate) struct AttributeOnEmptyType {
+ #[primary_span]
+ #[label]
+ pub span: Span,
+}
+
+#[derive(Diagnostic)]
#[diag(parse_pattern_method_param_without_body, code = E0642)]
pub(crate) struct PatternMethodParamWithoutBody {
#[primary_span]
diff --git a/compiler/rustc_parse/src/parser/item.rs b/compiler/rustc_parse/src/parser/item.rs
index 65d84b3..cb7c564 100644
--- a/compiler/rustc_parse/src/parser/item.rs
+++ b/compiler/rustc_parse/src/parser/item.rs
@@ -885,6 +885,9 @@ fn check_trait_front_matter(&mut self) -> bool {
/// Parses `unsafe? auto? trait Foo { ... }` or `trait Foo = Bar;`.
fn parse_item_trait(&mut self, attrs: &mut AttrVec, lo: Span) -> PResult<'a, ItemKind> {
let constness = self.parse_constness(Case::Sensitive);
+ if let Const::Yes(span) = constness {
+ self.psess.gated_spans.gate(sym::const_trait_impl, span);
+ }
let safety = self.parse_safety(Case::Sensitive);
// Parse optional `auto` prefix.
let is_auto = if self.eat_keyword(exp!(Auto)) {
diff --git a/compiler/rustc_parse/src/parser/path.rs b/compiler/rustc_parse/src/parser/path.rs
index 1f4049f..8e65ab9 100644
--- a/compiler/rustc_parse/src/parser/path.rs
+++ b/compiler/rustc_parse/src/parser/path.rs
@@ -17,11 +17,11 @@
use super::{Parser, Restrictions, TokenType};
use crate::ast::{PatKind, TyKind};
use crate::errors::{
- self, FnPathFoundNamedParams, PathFoundAttributeInParams, PathFoundCVariadicParams,
- PathSingleColon, PathTripleColon,
+ self, AttributeOnEmptyType, AttributeOnGenericArg, FnPathFoundNamedParams,
+ PathFoundAttributeInParams, PathFoundCVariadicParams, PathSingleColon, PathTripleColon,
};
use crate::exp;
-use crate::parser::{CommaRecoveryMode, RecoverColon, RecoverComma};
+use crate::parser::{CommaRecoveryMode, ExprKind, RecoverColon, RecoverComma};
/// Specifies how to parse a path.
#[derive(Copy, Clone, PartialEq)]
@@ -880,6 +880,12 @@ pub(super) fn parse_generic_arg(
&mut self,
ty_generics: Option<&Generics>,
) -> PResult<'a, Option<GenericArg>> {
+ let mut attr_span: Option<Span> = None;
+ if self.token == token::Pound && self.look_ahead(1, |t| *t == token::OpenBracket) {
+ let attrs_wrapper = self.parse_outer_attributes()?;
+ let raw_attrs = attrs_wrapper.take_for_recovery(self.psess);
+ attr_span = Some(raw_attrs[0].span.to(raw_attrs.last().unwrap().span));
+ }
let start = self.token.span;
let arg = if self.check_lifetime() && self.look_ahead(1, |t| !t.is_like_plus()) {
// Parse lifetime argument.
@@ -934,6 +940,9 @@ pub(super) fn parse_generic_arg(
}
} else if self.token.is_keyword(kw::Const) {
return self.recover_const_param_declaration(ty_generics);
+ } else if let Some(attr_span) = attr_span {
+ let diag = self.dcx().create_err(AttributeOnEmptyType { span: attr_span });
+ return Err(diag);
} else {
// Fall back by trying to parse a const-expr expression. If we successfully do so,
// then we should report an error that it needs to be wrapped in braces.
@@ -953,6 +962,22 @@ pub(super) fn parse_generic_arg(
}
}
};
+
+ if let Some(attr_span) = attr_span {
+ let guar = self.dcx().emit_err(AttributeOnGenericArg {
+ span: attr_span,
+ fix_span: attr_span.until(arg.span()),
+ });
+ return Ok(Some(match arg {
+ GenericArg::Type(_) => GenericArg::Type(self.mk_ty(attr_span, TyKind::Err(guar))),
+ GenericArg::Const(_) => {
+ let error_expr = self.mk_expr(attr_span, ExprKind::Err(guar));
+ GenericArg::Const(AnonConst { id: ast::DUMMY_NODE_ID, value: error_expr })
+ }
+ GenericArg::Lifetime(lt) => GenericArg::Lifetime(lt),
+ }));
+ }
+
Ok(Some(arg))
}
diff --git a/compiler/rustc_parse/src/parser/ty.rs b/compiler/rustc_parse/src/parser/ty.rs
index 740dd10..59048e4 100644
--- a/compiler/rustc_parse/src/parser/ty.rs
+++ b/compiler/rustc_parse/src/parser/ty.rs
@@ -14,10 +14,10 @@
use super::{Parser, PathStyle, SeqSep, TokenType, Trailing};
use crate::errors::{
- self, DynAfterMut, ExpectedFnPathFoundFnKeyword, ExpectedMutOrConstInRawPointerType,
- FnPtrWithGenerics, FnPtrWithGenericsSugg, HelpUseLatestEdition, InvalidDynKeyword,
- LifetimeAfterMut, NeedPlusAfterTraitObjectLifetime, NestedCVariadicType,
- ReturnTypesUseThinArrow,
+ self, AttributeOnEmptyType, AttributeOnType, DynAfterMut, ExpectedFnPathFoundFnKeyword,
+ ExpectedMutOrConstInRawPointerType, FnPtrWithGenerics, FnPtrWithGenericsSugg,
+ HelpUseLatestEdition, InvalidDynKeyword, LifetimeAfterMut, NeedPlusAfterTraitObjectLifetime,
+ NestedCVariadicType, ReturnTypesUseThinArrow,
};
use crate::parser::item::FrontMatterParsingMode;
use crate::{exp, maybe_recover_from_interpolated_ty_qpath};
@@ -253,7 +253,27 @@ fn parse_ty_common(
) -> PResult<'a, P<Ty>> {
let allow_qpath_recovery = recover_qpath == RecoverQPath::Yes;
maybe_recover_from_interpolated_ty_qpath!(self, allow_qpath_recovery);
+ if self.token == token::Pound && self.look_ahead(1, |t| *t == token::OpenBracket) {
+ let attrs_wrapper = self.parse_outer_attributes()?;
+ let raw_attrs = attrs_wrapper.take_for_recovery(self.psess);
+ let attr_span = raw_attrs[0].span.to(raw_attrs.last().unwrap().span);
+ let (full_span, guar) = match self.parse_ty() {
+ Ok(ty) => {
+ let full_span = attr_span.until(ty.span);
+ let guar = self
+ .dcx()
+ .emit_err(AttributeOnType { span: attr_span, fix_span: full_span });
+ (attr_span, guar)
+ }
+ Err(err) => {
+ err.cancel();
+ let guar = self.dcx().emit_err(AttributeOnEmptyType { span: attr_span });
+ (attr_span, guar)
+ }
+ };
+ return Ok(self.mk_ty(full_span, TyKind::Err(guar)));
+ }
if let Some(ty) = self.eat_metavar_seq_with_matcher(
|mv_kind| matches!(mv_kind, MetaVarKind::Ty { .. }),
|this| this.parse_ty_no_question_mark_recover(),
diff --git a/compiler/rustc_passes/src/check_attr.rs b/compiler/rustc_passes/src/check_attr.rs
index 2663d5f..10c532b 100644
--- a/compiler/rustc_passes/src/check_attr.rs
+++ b/compiler/rustc_passes/src/check_attr.rs
@@ -315,6 +315,8 @@ fn check_attributes(
Attribute::Parsed(AttributeKind::Used { span: attr_span, .. }) => {
self.check_used(*attr_span, target, span);
}
+ Attribute::Parsed(AttributeKind::ShouldPanic { span: attr_span, .. }) => self
+ .check_generic_attr(hir_id, sym::should_panic, *attr_span, target, Target::Fn),
&Attribute::Parsed(AttributeKind::PassByValue(attr_span)) => {
self.check_pass_by_value(attr_span, span, target)
}
@@ -324,6 +326,9 @@ fn check_attributes(
&Attribute::Parsed(AttributeKind::Coverage(attr_span, _)) => {
self.check_coverage(attr_span, span, target)
}
+ &Attribute::Parsed(AttributeKind::Coroutine(attr_span)) => {
+ self.check_coroutine(attr_span, target)
+ }
Attribute::Unparsed(attr_item) => {
style = Some(attr_item.style);
match attr.path().as_slice() {
@@ -384,15 +389,9 @@ fn check_attributes(
[sym::link, ..] => self.check_link(hir_id, attr, span, target),
[sym::path, ..] => self.check_generic_attr_unparsed(hir_id, attr, target, Target::Mod),
[sym::macro_export, ..] => self.check_macro_export(hir_id, attr, target),
- [sym::should_panic, ..] => {
- self.check_generic_attr_unparsed(hir_id, attr, target, Target::Fn)
- }
[sym::autodiff_forward, ..] | [sym::autodiff_reverse, ..] => {
self.check_autodiff(hir_id, attr, span, target)
}
- [sym::coroutine, ..] => {
- self.check_coroutine(attr, target);
- }
[sym::linkage, ..] => self.check_linkage(attr, span, target),
[
// ok
@@ -2651,11 +2650,11 @@ fn check_proc_macro(&self, hir_id: HirId, target: Target, kind: ProcMacroKind) {
}
}
- fn check_coroutine(&self, attr: &Attribute, target: Target) {
+ fn check_coroutine(&self, attr_span: Span, target: Target) {
match target {
Target::Closure => return,
_ => {
- self.dcx().emit_err(errors::CoroutineOnNonClosure { span: attr.span() });
+ self.dcx().emit_err(errors::CoroutineOnNonClosure { span: attr_span });
}
}
}
diff --git a/compiler/rustc_resolve/src/build_reduced_graph.rs b/compiler/rustc_resolve/src/build_reduced_graph.rs
index d9671c4..a7f52be 100644
--- a/compiler/rustc_resolve/src/build_reduced_graph.rs
+++ b/compiler/rustc_resolve/src/build_reduced_graph.rs
@@ -27,7 +27,7 @@
use rustc_middle::ty::{Feed, Visibility};
use rustc_middle::{bug, span_bug};
use rustc_span::hygiene::{ExpnId, LocalExpnId, MacroKind};
-use rustc_span::{Ident, Span, Symbol, kw, sym};
+use rustc_span::{Ident, Macros20NormalizedIdent, Span, Symbol, kw, sym};
use thin_vec::ThinVec;
use tracing::debug;
@@ -969,8 +969,8 @@ fn build_reduced_graph_for_extern_crate(
self.r.potentially_unused_imports.push(import);
let imported_binding = self.r.import(binding, import);
if ident.name != kw::Underscore && parent == self.r.graph_root {
- let ident = ident.normalize_to_macros_2_0();
- if let Some(entry) = self.r.extern_prelude.get(&ident)
+ let norm_ident = Macros20NormalizedIdent::new(ident);
+ if let Some(entry) = self.r.extern_prelude.get(&norm_ident)
&& expansion != LocalExpnId::ROOT
&& orig_name.is_some()
&& !entry.is_import()
@@ -986,7 +986,7 @@ fn build_reduced_graph_for_extern_crate(
}
use indexmap::map::Entry;
- match self.r.extern_prelude.entry(ident) {
+ match self.r.extern_prelude.entry(norm_ident) {
Entry::Occupied(mut occupied) => {
let entry = occupied.get_mut();
if let Some(old_binding) = entry.binding.get()
diff --git a/compiler/rustc_resolve/src/check_unused.rs b/compiler/rustc_resolve/src/check_unused.rs
index b85a814..11d93a5 100644
--- a/compiler/rustc_resolve/src/check_unused.rs
+++ b/compiler/rustc_resolve/src/check_unused.rs
@@ -33,7 +33,7 @@
use rustc_session::lint::builtin::{
MACRO_USE_EXTERN_CRATE, UNUSED_EXTERN_CRATES, UNUSED_IMPORTS, UNUSED_QUALIFICATIONS,
};
-use rustc_span::{DUMMY_SP, Ident, Span, kw};
+use rustc_span::{DUMMY_SP, Ident, Macros20NormalizedIdent, Span, kw};
use crate::imports::{Import, ImportKind};
use crate::{LexicalScopeBinding, NameBindingKind, Resolver, module_to_string};
@@ -203,7 +203,7 @@ fn report_unused_extern_crate_items(
if self
.r
.extern_prelude
- .get(&extern_crate.ident)
+ .get(&Macros20NormalizedIdent::new(extern_crate.ident))
.is_none_or(|entry| entry.introduced_by_item)
{
continue;
diff --git a/compiler/rustc_resolve/src/diagnostics.rs b/compiler/rustc_resolve/src/diagnostics.rs
index d18554b..4da39b8 100644
--- a/compiler/rustc_resolve/src/diagnostics.rs
+++ b/compiler/rustc_resolve/src/diagnostics.rs
@@ -30,7 +30,7 @@
use rustc_span::edition::Edition;
use rustc_span::hygiene::MacroKind;
use rustc_span::source_map::SourceMap;
-use rustc_span::{BytePos, Ident, Span, Symbol, SyntaxContext, kw, sym};
+use rustc_span::{BytePos, Ident, Macros20NormalizedIdent, Span, Symbol, SyntaxContext, kw, sym};
use thin_vec::{ThinVec, thin_vec};
use tracing::{debug, instrument};
@@ -320,8 +320,10 @@ pub(crate) fn report_conflict(
// Check if the target of the use for both bindings is the same.
let duplicate = new_binding.res().opt_def_id() == old_binding.res().opt_def_id();
let has_dummy_span = new_binding.span.is_dummy() || old_binding.span.is_dummy();
- let from_item =
- self.extern_prelude.get(&ident).is_none_or(|entry| entry.introduced_by_item);
+ let from_item = self
+ .extern_prelude
+ .get(&Macros20NormalizedIdent::new(ident))
+ .is_none_or(|entry| entry.introduced_by_item);
// Only suggest removing an import if both bindings are to the same def, if both spans
// aren't dummy spans. Further, if both bindings are imports, then the ident must have
// been introduced by an item.
@@ -530,7 +532,7 @@ pub(crate) fn add_module_candidates(
module.for_each_child(self, |_this, ident, _ns, binding| {
let res = binding.res();
if filter_fn(res) && ctxt.is_none_or(|ctxt| ctxt == ident.span.ctxt()) {
- names.push(TypoSuggestion::typo_from_ident(ident, res));
+ names.push(TypoSuggestion::typo_from_ident(ident.0, res));
}
});
}
@@ -1100,7 +1102,7 @@ fn early_lookup_typo_candidate(
Scope::ExternPrelude => {
suggestions.extend(this.extern_prelude.keys().filter_map(|ident| {
let res = Res::Def(DefKind::Mod, CRATE_DEF_ID.to_def_id());
- filter_fn(res).then_some(TypoSuggestion::typo_from_ident(*ident, res))
+ filter_fn(res).then_some(TypoSuggestion::typo_from_ident(ident.0, res))
}));
}
Scope::ToolPrelude => {
@@ -1246,7 +1248,7 @@ fn lookup_import_candidates_from_module<FilterFn>(
};
segms.append(&mut path_segments.clone());
- segms.push(ast::PathSegment::from_ident(ident));
+ segms.push(ast::PathSegment::from_ident(ident.0));
let path = Path { span: name_binding.span, segments: segms, tokens: None };
if child_accessible
@@ -1319,7 +1321,7 @@ fn lookup_import_candidates_from_module<FilterFn>(
if let Some(def_id) = name_binding.res().module_like_def_id() {
// form the path
let mut path_segments = path_segments.clone();
- path_segments.push(ast::PathSegment::from_ident(ident));
+ path_segments.push(ast::PathSegment::from_ident(ident.0));
let alias_import = if let NameBindingKind::Import { import, .. } =
name_binding.kind
@@ -1453,7 +1455,7 @@ pub(crate) fn lookup_import_candidates<FilterFn>(
if needs_disambiguation {
crate_path.push(ast::PathSegment::path_root(rustc_span::DUMMY_SP));
}
- crate_path.push(ast::PathSegment::from_ident(ident));
+ crate_path.push(ast::PathSegment::from_ident(ident.0));
suggestions.extend(self.lookup_import_candidates_from_module(
lookup_ident,
diff --git a/compiler/rustc_resolve/src/imports.rs b/compiler/rustc_resolve/src/imports.rs
index 156df45..93d7b6b 100644
--- a/compiler/rustc_resolve/src/imports.rs
+++ b/compiler/rustc_resolve/src/imports.rs
@@ -489,7 +489,7 @@ fn update_local_resolution<T, F>(
// Define or update `binding` in `module`s glob importers.
for import in glob_importers.iter() {
let mut ident = key.ident;
- let scope = match ident.span.reverse_glob_adjust(module.expansion, import.span) {
+ let scope = match ident.0.span.reverse_glob_adjust(module.expansion, import.span) {
Some(Some(def)) => self.expn_def_scope(def),
Some(None) => import.parent_scope.module,
None => continue,
@@ -498,7 +498,7 @@ fn update_local_resolution<T, F>(
let imported_binding = self.import(binding, *import);
let _ = self.try_define_local(
import.parent_scope.module,
- ident,
+ ident.0,
key.ns,
imported_binding,
warn_ambiguity,
@@ -1504,7 +1504,7 @@ fn resolve_glob_import(&mut self, import: Import<'ra>) {
})
.collect::<Vec<_>>();
for (mut key, binding) in bindings {
- let scope = match key.ident.span.reverse_glob_adjust(module.expansion, import.span) {
+ let scope = match key.ident.0.span.reverse_glob_adjust(module.expansion, import.span) {
Some(Some(def)) => self.expn_def_scope(def),
Some(None) => import.parent_scope.module,
None => continue,
@@ -1517,7 +1517,7 @@ fn resolve_glob_import(&mut self, import: Import<'ra>) {
.is_some_and(|binding| binding.warn_ambiguity_recursive());
let _ = self.try_define_local(
import.parent_scope.module,
- key.ident,
+ key.ident.0,
key.ns,
imported_binding,
warn_ambiguity,
@@ -1550,7 +1550,7 @@ fn finalize_resolutions_in(&mut self, module: Module<'ra>) {
next_binding = binding;
}
- children.push(ModChild { ident, res, vis: binding.vis, reexport_chain });
+ children.push(ModChild { ident: ident.0, res, vis: binding.vis, reexport_chain });
}
});
diff --git a/compiler/rustc_resolve/src/late/diagnostics.rs b/compiler/rustc_resolve/src/late/diagnostics.rs
index c8ca57a..165a0eb 100644
--- a/compiler/rustc_resolve/src/late/diagnostics.rs
+++ b/compiler/rustc_resolve/src/late/diagnostics.rs
@@ -1472,7 +1472,10 @@ fn get_single_associated_item(
})
.collect();
if let [target] = targets.as_slice() {
- return Some(TypoSuggestion::single_item_from_ident(target.0.ident, target.1));
+ return Some(TypoSuggestion::single_item_from_ident(
+ target.0.ident.0,
+ target.1,
+ ));
}
}
}
@@ -2479,7 +2482,7 @@ fn lookup_typo_candidate(
names.extend(self.r.extern_prelude.keys().flat_map(|ident| {
let res = Res::Def(DefKind::Mod, CRATE_DEF_ID.to_def_id());
filter_fn(res)
- .then_some(TypoSuggestion::typo_from_ident(*ident, res))
+ .then_some(TypoSuggestion::typo_from_ident(ident.0, res))
}));
if let Some(prelude) = self.r.prelude {
@@ -2639,7 +2642,7 @@ fn find_module(&self, def_id: DefId) -> Option<(Module<'ra>, ImportSuggestion)>
if let Some(module_def_id) = name_binding.res().module_like_def_id() {
// form the path
let mut path_segments = path_segments.clone();
- path_segments.push(ast::PathSegment::from_ident(ident));
+ path_segments.push(ast::PathSegment::from_ident(ident.0));
let doc_visible = doc_visible
&& (module_def_id.is_local() || !r.tcx.is_doc_hidden(module_def_id));
if module_def_id == def_id {
@@ -2678,7 +2681,7 @@ fn collect_enum_ctors(&self, def_id: DefId) -> Option<Vec<(Path, DefId, CtorKind
enum_module.for_each_child(self.r, |_, ident, _, name_binding| {
if let Res::Def(DefKind::Ctor(CtorOf::Variant, kind), def_id) = name_binding.res() {
let mut segms = enum_import_suggestion.path.segments.clone();
- segms.push(ast::PathSegment::from_ident(ident));
+ segms.push(ast::PathSegment::from_ident(ident.0));
let path = Path { span: name_binding.span, segments: segms, tokens: None };
variants.push((path, def_id, kind));
}
diff --git a/compiler/rustc_resolve/src/lib.rs b/compiler/rustc_resolve/src/lib.rs
index 6b034c5..2a75070 100644
--- a/compiler/rustc_resolve/src/lib.rs
+++ b/compiler/rustc_resolve/src/lib.rs
@@ -71,7 +71,7 @@
use rustc_session::lint::builtin::PRIVATE_MACRO_USE;
use rustc_session::lint::{BuiltinLintDiag, LintBuffer};
use rustc_span::hygiene::{ExpnId, LocalExpnId, MacroKind, SyntaxContext, Transparency};
-use rustc_span::{DUMMY_SP, Ident, Span, Symbol, kw, sym};
+use rustc_span::{DUMMY_SP, Ident, Macros20NormalizedIdent, Span, Symbol, kw, sym};
use smallvec::{SmallVec, smallvec};
use tracing::debug;
@@ -531,7 +531,7 @@ fn name(&self) -> Option<Symbol> {
struct BindingKey {
/// The identifier for the binding, always the `normalize_to_macros_2_0` version of the
/// identifier.
- ident: Ident,
+ ident: Macros20NormalizedIdent,
ns: Namespace,
/// When we add an underscore binding (with ident `_`) to some module, this field has
/// a non-zero value that uniquely identifies this binding in that module.
@@ -543,7 +543,7 @@ struct BindingKey {
impl BindingKey {
fn new(ident: Ident, ns: Namespace) -> Self {
- BindingKey { ident: ident.normalize_to_macros_2_0(), ns, disambiguator: 0 }
+ BindingKey { ident: Macros20NormalizedIdent::new(ident), ns, disambiguator: 0 }
}
fn new_disambiguated(
@@ -552,7 +552,7 @@ fn new_disambiguated(
disambiguator: impl FnOnce() -> u32,
) -> BindingKey {
let disambiguator = if ident.name == kw::Underscore { disambiguator() } else { 0 };
- BindingKey { ident: ident.normalize_to_macros_2_0(), ns, disambiguator }
+ BindingKey { ident: Macros20NormalizedIdent::new(ident), ns, disambiguator }
}
}
@@ -593,7 +593,8 @@ struct ModuleData<'ra> {
globs: RefCell<Vec<Import<'ra>>>,
/// Used to memoize the traits in this module for faster searches through all traits in scope.
- traits: RefCell<Option<Box<[(Ident, NameBinding<'ra>, Option<Module<'ra>>)]>>>,
+ traits:
+ RefCell<Option<Box<[(Macros20NormalizedIdent, NameBinding<'ra>, Option<Module<'ra>>)]>>>,
/// Span of the module itself. Used for error reporting.
span: Span,
@@ -659,7 +660,7 @@ impl<'ra> Module<'ra> {
fn for_each_child<'tcx, R: AsRef<Resolver<'ra, 'tcx>>>(
self,
resolver: &R,
- mut f: impl FnMut(&R, Ident, Namespace, NameBinding<'ra>),
+ mut f: impl FnMut(&R, Macros20NormalizedIdent, Namespace, NameBinding<'ra>),
) {
for (key, name_resolution) in resolver.as_ref().resolutions(self).borrow().iter() {
if let Some(binding) = name_resolution.borrow().best_binding() {
@@ -671,7 +672,7 @@ fn for_each_child<'tcx, R: AsRef<Resolver<'ra, 'tcx>>>(
fn for_each_child_mut<'tcx, R: AsMut<Resolver<'ra, 'tcx>>>(
self,
resolver: &mut R,
- mut f: impl FnMut(&mut R, Ident, Namespace, NameBinding<'ra>),
+ mut f: impl FnMut(&mut R, Macros20NormalizedIdent, Namespace, NameBinding<'ra>),
) {
for (key, name_resolution) in resolver.as_mut().resolutions(self).borrow().iter() {
if let Some(binding) = name_resolution.borrow().best_binding() {
@@ -1054,7 +1055,7 @@ pub struct Resolver<'ra, 'tcx> {
graph_root: Module<'ra>,
prelude: Option<Module<'ra>>,
- extern_prelude: FxIndexMap<Ident, ExternPreludeEntry<'ra>>,
+ extern_prelude: FxIndexMap<Macros20NormalizedIdent, ExternPreludeEntry<'ra>>,
/// N.B., this is used only for better diagnostics, not name resolution itself.
field_names: LocalDefIdMap<Vec<Ident>>,
@@ -1499,7 +1500,7 @@ pub fn new(
&& let name = Symbol::intern(name)
&& name.can_be_raw()
{
- Some((Ident::with_dummy_span(name), Default::default()))
+ Some((Macros20NormalizedIdent::with_dummy_span(name), Default::default()))
} else {
None
}
@@ -1507,9 +1508,11 @@ pub fn new(
.collect();
if !attr::contains_name(attrs, sym::no_core) {
- extern_prelude.insert(Ident::with_dummy_span(sym::core), Default::default());
+ extern_prelude
+ .insert(Macros20NormalizedIdent::with_dummy_span(sym::core), Default::default());
if !attr::contains_name(attrs, sym::no_std) {
- extern_prelude.insert(Ident::with_dummy_span(sym::std), Default::default());
+ extern_prelude
+ .insert(Macros20NormalizedIdent::with_dummy_span(sym::std), Default::default());
}
}
@@ -1879,7 +1882,7 @@ fn traits_in_module(
for &(trait_name, trait_binding, trait_module) in traits.as_ref().unwrap().iter() {
if self.trait_may_have_item(trait_module, assoc_item) {
let def_id = trait_binding.res().def_id();
- let import_ids = self.find_transitive_imports(&trait_binding.kind, trait_name);
+ let import_ids = self.find_transitive_imports(&trait_binding.kind, trait_name.0);
found_traits.push(TraitCandidate { def_id, import_ids });
}
}
@@ -2020,7 +2023,7 @@ fn record_use_inner(
// Avoid marking `extern crate` items that refer to a name from extern prelude,
// but not introduce it, as used if they are accessed from lexical scope.
if used == Used::Scope {
- if let Some(entry) = self.extern_prelude.get(&ident.normalize_to_macros_2_0()) {
+ if let Some(entry) = self.extern_prelude.get(&Macros20NormalizedIdent::new(ident)) {
if !entry.introduced_by_item && entry.binding.get() == Some(used_binding) {
return;
}
@@ -2179,7 +2182,7 @@ fn disambiguate_macro_rules_vs_modularized(
fn extern_prelude_get(&mut self, ident: Ident, finalize: bool) -> Option<NameBinding<'ra>> {
let mut record_use = None;
- let entry = self.extern_prelude.get(&ident.normalize_to_macros_2_0());
+ let entry = self.extern_prelude.get(&Macros20NormalizedIdent::new(ident));
let binding = entry.and_then(|entry| match entry.binding.get() {
Some(binding) if binding.is_import() => {
if finalize {
diff --git a/compiler/rustc_resolve/src/macros.rs b/compiler/rustc_resolve/src/macros.rs
index 4e3c0cd..ecf4f79 100644
--- a/compiler/rustc_resolve/src/macros.rs
+++ b/compiler/rustc_resolve/src/macros.rs
@@ -536,11 +536,11 @@ fn glob_delegation_suffixes(
target_trait.for_each_child(self, |this, ident, ns, _binding| {
// FIXME: Adjust hygiene for idents from globs, like for glob imports.
if let Some(overriding_keys) = this.impl_binding_keys.get(&impl_def_id)
- && overriding_keys.contains(&BindingKey::new(ident, ns))
+ && overriding_keys.contains(&BindingKey::new(ident.0, ns))
{
// The name is overridden, do not produce it from the glob delegation.
} else {
- idents.push((ident, None));
+ idents.push((ident.0, None));
}
});
Ok(idents)
diff --git a/compiler/rustc_span/src/lib.rs b/compiler/rustc_span/src/lib.rs
index 3f72ccd..d647ec2 100644
--- a/compiler/rustc_span/src/lib.rs
+++ b/compiler/rustc_span/src/lib.rs
@@ -66,7 +66,8 @@
pub mod symbol;
pub use symbol::{
- ByteSymbol, Ident, MacroRulesNormalizedIdent, STDLIB_STABLE_CRATES, Symbol, kw, sym,
+ ByteSymbol, Ident, MacroRulesNormalizedIdent, Macros20NormalizedIdent, STDLIB_STABLE_CRATES,
+ Symbol, kw, sym,
};
mod analyze_source_file;
diff --git a/compiler/rustc_span/src/symbol.rs b/compiler/rustc_span/src/symbol.rs
index d541755..3619795 100644
--- a/compiler/rustc_span/src/symbol.rs
+++ b/compiler/rustc_span/src/symbol.rs
@@ -3,6 +3,7 @@
//! type, and vice versa.
use std::hash::{Hash, Hasher};
+use std::ops::Deref;
use std::{fmt, str};
use rustc_arena::DroplessArena;
@@ -1512,6 +1513,7 @@
not,
notable_trait,
note,
+ nvptx_target_feature,
object_safe_for_dispatch,
of,
off,
@@ -2562,16 +2564,17 @@ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
}
/// An newtype around `Ident` that calls [Ident::normalize_to_macro_rules] on
-/// construction.
-// FIXME(matthewj, petrochenkov) Use this more often, add a similar
-// `ModernIdent` struct and use that as well.
+/// construction for "local variable hygiene" comparisons.
+///
+/// Use this type when you need to compare identifiers according to macro_rules hygiene.
+/// This ensures compile-time safety and avoids manual normalization calls.
#[derive(Copy, Clone, Eq, PartialEq, Hash)]
pub struct MacroRulesNormalizedIdent(Ident);
impl MacroRulesNormalizedIdent {
#[inline]
pub fn new(ident: Ident) -> Self {
- Self(ident.normalize_to_macro_rules())
+ MacroRulesNormalizedIdent(ident.normalize_to_macro_rules())
}
}
@@ -2587,6 +2590,48 @@ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
}
}
+/// An newtype around `Ident` that calls [Ident::normalize_to_macros_2_0] on
+/// construction for "item hygiene" comparisons.
+///
+/// Identifiers with same string value become same if they came from the same macro 2.0 macro
+/// (e.g., `macro` item, but not `macro_rules` item) and stay different if they came from
+/// different macro 2.0 macros.
+#[derive(Copy, Clone, Eq, PartialEq, Hash)]
+pub struct Macros20NormalizedIdent(pub Ident);
+
+impl Macros20NormalizedIdent {
+ #[inline]
+ pub fn new(ident: Ident) -> Self {
+ Macros20NormalizedIdent(ident.normalize_to_macros_2_0())
+ }
+
+ // dummy_span does not need to be normalized, so we can use `Ident` directly
+ pub fn with_dummy_span(name: Symbol) -> Self {
+ Macros20NormalizedIdent(Ident::with_dummy_span(name))
+ }
+}
+
+impl fmt::Debug for Macros20NormalizedIdent {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ fmt::Debug::fmt(&self.0, f)
+ }
+}
+
+impl fmt::Display for Macros20NormalizedIdent {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ fmt::Display::fmt(&self.0, f)
+ }
+}
+
+/// By impl Deref, we can access the wrapped Ident as if it were a normal Ident
+/// such as `norm_ident.name` instead of `norm_ident.0.name`.
+impl Deref for Macros20NormalizedIdent {
+ type Target = Ident;
+ fn deref(&self) -> &Self::Target {
+ &self.0
+ }
+}
+
/// An interned UTF-8 string.
///
/// Internally, a `Symbol` is implemented as an index, and all operations
diff --git a/compiler/rustc_target/src/target_features.rs b/compiler/rustc_target/src/target_features.rs
index b2af992..297d9ed 100644
--- a/compiler/rustc_target/src/target_features.rs
+++ b/compiler/rustc_target/src/target_features.rs
@@ -517,6 +517,71 @@ pub fn toggle_allowed(&self) -> Result<(), &'static str> {
// tidy-alphabetical-end
];
+const NVPTX_FEATURES: &[(&str, Stability, ImpliedFeatures)] = &[
+ // tidy-alphabetical-start
+ ("sm_20", Unstable(sym::nvptx_target_feature), &[]),
+ ("sm_21", Unstable(sym::nvptx_target_feature), &["sm_20"]),
+ ("sm_30", Unstable(sym::nvptx_target_feature), &["sm_21"]),
+ ("sm_32", Unstable(sym::nvptx_target_feature), &["sm_30"]),
+ ("sm_35", Unstable(sym::nvptx_target_feature), &["sm_32"]),
+ ("sm_37", Unstable(sym::nvptx_target_feature), &["sm_35"]),
+ ("sm_50", Unstable(sym::nvptx_target_feature), &["sm_37"]),
+ ("sm_52", Unstable(sym::nvptx_target_feature), &["sm_50"]),
+ ("sm_53", Unstable(sym::nvptx_target_feature), &["sm_52"]),
+ ("sm_60", Unstable(sym::nvptx_target_feature), &["sm_53"]),
+ ("sm_61", Unstable(sym::nvptx_target_feature), &["sm_60"]),
+ ("sm_62", Unstable(sym::nvptx_target_feature), &["sm_61"]),
+ ("sm_70", Unstable(sym::nvptx_target_feature), &["sm_62"]),
+ ("sm_72", Unstable(sym::nvptx_target_feature), &["sm_70"]),
+ ("sm_75", Unstable(sym::nvptx_target_feature), &["sm_72"]),
+ ("sm_80", Unstable(sym::nvptx_target_feature), &["sm_75"]),
+ ("sm_86", Unstable(sym::nvptx_target_feature), &["sm_80"]),
+ ("sm_87", Unstable(sym::nvptx_target_feature), &["sm_86"]),
+ ("sm_89", Unstable(sym::nvptx_target_feature), &["sm_87"]),
+ ("sm_90", Unstable(sym::nvptx_target_feature), &["sm_89"]),
+ ("sm_90a", Unstable(sym::nvptx_target_feature), &["sm_90"]),
+ // tidy-alphabetical-end
+ // tidy-alphabetical-start
+ ("sm_100", Unstable(sym::nvptx_target_feature), &["sm_90"]),
+ ("sm_100a", Unstable(sym::nvptx_target_feature), &["sm_100"]),
+ ("sm_101", Unstable(sym::nvptx_target_feature), &["sm_100"]),
+ ("sm_101a", Unstable(sym::nvptx_target_feature), &["sm_101"]),
+ ("sm_120", Unstable(sym::nvptx_target_feature), &["sm_101"]),
+ ("sm_120a", Unstable(sym::nvptx_target_feature), &["sm_120"]),
+ // tidy-alphabetical-end
+ // tidy-alphabetical-start
+ ("ptx32", Unstable(sym::nvptx_target_feature), &[]),
+ ("ptx40", Unstable(sym::nvptx_target_feature), &["ptx32"]),
+ ("ptx41", Unstable(sym::nvptx_target_feature), &["ptx40"]),
+ ("ptx42", Unstable(sym::nvptx_target_feature), &["ptx41"]),
+ ("ptx43", Unstable(sym::nvptx_target_feature), &["ptx42"]),
+ ("ptx50", Unstable(sym::nvptx_target_feature), &["ptx43"]),
+ ("ptx60", Unstable(sym::nvptx_target_feature), &["ptx50"]),
+ ("ptx61", Unstable(sym::nvptx_target_feature), &["ptx60"]),
+ ("ptx62", Unstable(sym::nvptx_target_feature), &["ptx61"]),
+ ("ptx63", Unstable(sym::nvptx_target_feature), &["ptx62"]),
+ ("ptx64", Unstable(sym::nvptx_target_feature), &["ptx63"]),
+ ("ptx65", Unstable(sym::nvptx_target_feature), &["ptx64"]),
+ ("ptx70", Unstable(sym::nvptx_target_feature), &["ptx65"]),
+ ("ptx71", Unstable(sym::nvptx_target_feature), &["ptx70"]),
+ ("ptx72", Unstable(sym::nvptx_target_feature), &["ptx71"]),
+ ("ptx73", Unstable(sym::nvptx_target_feature), &["ptx72"]),
+ ("ptx74", Unstable(sym::nvptx_target_feature), &["ptx73"]),
+ ("ptx75", Unstable(sym::nvptx_target_feature), &["ptx74"]),
+ ("ptx76", Unstable(sym::nvptx_target_feature), &["ptx75"]),
+ ("ptx77", Unstable(sym::nvptx_target_feature), &["ptx76"]),
+ ("ptx78", Unstable(sym::nvptx_target_feature), &["ptx77"]),
+ ("ptx80", Unstable(sym::nvptx_target_feature), &["ptx78"]),
+ ("ptx81", Unstable(sym::nvptx_target_feature), &["ptx80"]),
+ ("ptx82", Unstable(sym::nvptx_target_feature), &["ptx81"]),
+ ("ptx83", Unstable(sym::nvptx_target_feature), &["ptx82"]),
+ ("ptx84", Unstable(sym::nvptx_target_feature), &["ptx83"]),
+ ("ptx85", Unstable(sym::nvptx_target_feature), &["ptx84"]),
+ ("ptx86", Unstable(sym::nvptx_target_feature), &["ptx85"]),
+ ("ptx87", Unstable(sym::nvptx_target_feature), &["ptx86"]),
+ // tidy-alphabetical-end
+];
+
static RISCV_FEATURES: &[(&str, Stability, ImpliedFeatures)] = &[
// tidy-alphabetical-start
("a", Stable, &["zaamo", "zalrsc"]),
@@ -782,6 +847,7 @@ pub fn all_rust_features() -> impl Iterator<Item = (&'static str, Stability)> {
.chain(HEXAGON_FEATURES.iter())
.chain(POWERPC_FEATURES.iter())
.chain(MIPS_FEATURES.iter())
+ .chain(NVPTX_FEATURES.iter())
.chain(RISCV_FEATURES.iter())
.chain(WASM_FEATURES.iter())
.chain(BPF_FEATURES.iter())
@@ -847,6 +913,7 @@ pub fn rust_target_features(&self) -> &'static [(&'static str, Stability, Implie
"x86" | "x86_64" => X86_FEATURES,
"hexagon" => HEXAGON_FEATURES,
"mips" | "mips32r6" | "mips64" | "mips64r6" => MIPS_FEATURES,
+ "nvptx64" => NVPTX_FEATURES,
"powerpc" | "powerpc64" => POWERPC_FEATURES,
"riscv32" | "riscv64" => RISCV_FEATURES,
"wasm32" | "wasm64" => WASM_FEATURES,
@@ -873,7 +940,7 @@ pub fn features_for_correct_vector_abi(&self) -> &'static [(u64, &'static str)]
"sparc" | "sparc64" => SPARC_FEATURES_FOR_CORRECT_VECTOR_ABI,
"hexagon" => HEXAGON_FEATURES_FOR_CORRECT_VECTOR_ABI,
"mips" | "mips32r6" | "mips64" | "mips64r6" => MIPS_FEATURES_FOR_CORRECT_VECTOR_ABI,
- "bpf" | "m68k" => &[], // no vector ABI
+ "nvptx64" | "bpf" | "m68k" => &[], // no vector ABI
"csky" => CSKY_FEATURES_FOR_CORRECT_VECTOR_ABI,
// FIXME: for some tier3 targets, we are overly cautious and always give warnings
// when passing args in vector registers.
diff --git a/library/core/src/any.rs b/library/core/src/any.rs
index 3839337..ceb9748 100644
--- a/library/core/src/any.rs
+++ b/library/core/src/any.rs
@@ -725,7 +725,7 @@ unsafe impl Send for TypeId {}
unsafe impl Sync for TypeId {}
#[stable(feature = "rust1", since = "1.0.0")]
-#[rustc_const_unstable(feature = "const_type_id", issue = "77125")]
+#[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
impl const PartialEq for TypeId {
#[inline]
fn eq(&self, other: &Self) -> bool {
@@ -773,7 +773,7 @@ impl TypeId {
/// ```
#[must_use]
#[stable(feature = "rust1", since = "1.0.0")]
- #[rustc_const_unstable(feature = "const_type_id", issue = "77125")]
+ #[rustc_const_stable(feature = "const_type_id", since = "CURRENT_RUSTC_VERSION")]
pub const fn of<T: ?Sized + 'static>() -> TypeId {
const { intrinsics::type_id::<T>() }
}
diff --git a/library/core/src/lib.rs b/library/core/src/lib.rs
index 3c33f4b..d5bce6a 100644
--- a/library/core/src/lib.rs
+++ b/library/core/src/lib.rs
@@ -195,6 +195,7 @@
#![feature(hexagon_target_feature)]
#![feature(loongarch_target_feature)]
#![feature(mips_target_feature)]
+#![feature(nvptx_target_feature)]
#![feature(powerpc_target_feature)]
#![feature(riscv_target_feature)]
#![feature(rtm_target_feature)]
diff --git a/library/core/src/num/f32.rs b/library/core/src/num/f32.rs
index f8344da..6c7ba49 100644
--- a/library/core/src/num/f32.rs
+++ b/library/core/src/num/f32.rs
@@ -1936,8 +1936,8 @@ pub fn sqrt(x: f32) -> f32 {
/// let abs_difference_x = (f32::math::abs_sub(x, 1.0) - 2.0).abs();
/// let abs_difference_y = (f32::math::abs_sub(y, 1.0) - 0.0).abs();
///
- /// assert!(abs_difference_x <= f32::EPSILON);
- /// assert!(abs_difference_y <= f32::EPSILON);
+ /// assert!(abs_difference_x <= 1e-6);
+ /// assert!(abs_difference_y <= 1e-6);
/// ```
///
/// _This standalone function is for testing only.
@@ -1982,7 +1982,7 @@ pub fn abs_sub(x: f32, other: f32) -> f32 {
/// // x^(1/3) - 2 == 0
/// let abs_difference = (f32::math::cbrt(x) - 2.0).abs();
///
- /// assert!(abs_difference <= f32::EPSILON);
+ /// assert!(abs_difference <= 1e-6);
/// ```
///
/// _This standalone function is for testing only.
diff --git a/library/core/src/num/int_macros.rs b/library/core/src/num/int_macros.rs
index 10efb8a..bd2f744 100644
--- a/library/core/src/num/int_macros.rs
+++ b/library/core/src/num/int_macros.rs
@@ -469,17 +469,16 @@ pub const fn checked_add(self, rhs: Self) -> Option<Self> {
/// # Examples
///
/// ```
- /// #![feature(strict_overflow_ops)]
#[doc = concat!("assert_eq!((", stringify!($SelfT), "::MAX - 2).strict_add(1), ", stringify!($SelfT), "::MAX - 1);")]
/// ```
///
/// The following panics because of overflow:
///
/// ```should_panic
- /// #![feature(strict_overflow_ops)]
#[doc = concat!("let _ = (", stringify!($SelfT), "::MAX - 2).strict_add(3);")]
/// ```
- #[unstable(feature = "strict_overflow_ops", issue = "118260")]
+ #[stable(feature = "strict_overflow_ops", since = "CURRENT_RUSTC_VERSION")]
+ #[rustc_const_stable(feature = "strict_overflow_ops", since = "CURRENT_RUSTC_VERSION")]
#[must_use = "this returns the result of the operation, \
without modifying the original"]
#[inline]
@@ -560,17 +559,16 @@ pub const fn checked_add_unsigned(self, rhs: $UnsignedT) -> Option<Self> {
/// # Examples
///
/// ```
- /// #![feature(strict_overflow_ops)]
#[doc = concat!("assert_eq!(1", stringify!($SelfT), ".strict_add_unsigned(2), 3);")]
/// ```
///
/// The following panics because of overflow:
///
/// ```should_panic
- /// #![feature(strict_overflow_ops)]
#[doc = concat!("let _ = (", stringify!($SelfT), "::MAX - 2).strict_add_unsigned(3);")]
/// ```
- #[unstable(feature = "strict_overflow_ops", issue = "118260")]
+ #[stable(feature = "strict_overflow_ops", since = "CURRENT_RUSTC_VERSION")]
+ #[rustc_const_stable(feature = "strict_overflow_ops", since = "CURRENT_RUSTC_VERSION")]
#[must_use = "this returns the result of the operation, \
without modifying the original"]
#[inline]
@@ -611,17 +609,16 @@ pub const fn checked_sub(self, rhs: Self) -> Option<Self> {
/// # Examples
///
/// ```
- /// #![feature(strict_overflow_ops)]
#[doc = concat!("assert_eq!((", stringify!($SelfT), "::MIN + 2).strict_sub(1), ", stringify!($SelfT), "::MIN + 1);")]
/// ```
///
/// The following panics because of overflow:
///
/// ```should_panic
- /// #![feature(strict_overflow_ops)]
#[doc = concat!("let _ = (", stringify!($SelfT), "::MIN + 2).strict_sub(3);")]
/// ```
- #[unstable(feature = "strict_overflow_ops", issue = "118260")]
+ #[stable(feature = "strict_overflow_ops", since = "CURRENT_RUSTC_VERSION")]
+ #[rustc_const_stable(feature = "strict_overflow_ops", since = "CURRENT_RUSTC_VERSION")]
#[must_use = "this returns the result of the operation, \
without modifying the original"]
#[inline]
@@ -702,17 +699,16 @@ pub const fn checked_sub_unsigned(self, rhs: $UnsignedT) -> Option<Self> {
/// # Examples
///
/// ```
- /// #![feature(strict_overflow_ops)]
#[doc = concat!("assert_eq!(1", stringify!($SelfT), ".strict_sub_unsigned(2), -1);")]
/// ```
///
/// The following panics because of overflow:
///
/// ```should_panic
- /// #![feature(strict_overflow_ops)]
#[doc = concat!("let _ = (", stringify!($SelfT), "::MIN + 2).strict_sub_unsigned(3);")]
/// ```
- #[unstable(feature = "strict_overflow_ops", issue = "118260")]
+ #[stable(feature = "strict_overflow_ops", since = "CURRENT_RUSTC_VERSION")]
+ #[rustc_const_stable(feature = "strict_overflow_ops", since = "CURRENT_RUSTC_VERSION")]
#[must_use = "this returns the result of the operation, \
without modifying the original"]
#[inline]
@@ -753,17 +749,16 @@ pub const fn checked_mul(self, rhs: Self) -> Option<Self> {
/// # Examples
///
/// ```
- /// #![feature(strict_overflow_ops)]
#[doc = concat!("assert_eq!(", stringify!($SelfT), "::MAX.strict_mul(1), ", stringify!($SelfT), "::MAX);")]
/// ```
///
/// The following panics because of overflow:
///
/// ``` should_panic
- /// #![feature(strict_overflow_ops)]
#[doc = concat!("let _ = ", stringify!($SelfT), "::MAX.strict_mul(2);")]
/// ```
- #[unstable(feature = "strict_overflow_ops", issue = "118260")]
+ #[stable(feature = "strict_overflow_ops", since = "CURRENT_RUSTC_VERSION")]
+ #[rustc_const_stable(feature = "strict_overflow_ops", since = "CURRENT_RUSTC_VERSION")]
#[must_use = "this returns the result of the operation, \
without modifying the original"]
#[inline]
@@ -855,24 +850,22 @@ pub const fn checked_div(self, rhs: Self) -> Option<Self> {
/// # Examples
///
/// ```
- /// #![feature(strict_overflow_ops)]
#[doc = concat!("assert_eq!((", stringify!($SelfT), "::MIN + 1).strict_div(-1), ", stringify!($Max), ");")]
/// ```
///
/// The following panics because of overflow:
///
/// ```should_panic
- /// #![feature(strict_overflow_ops)]
#[doc = concat!("let _ = ", stringify!($SelfT), "::MIN.strict_div(-1);")]
/// ```
///
/// The following panics because of division by zero:
///
/// ```should_panic
- /// #![feature(strict_overflow_ops)]
#[doc = concat!("let _ = (1", stringify!($SelfT), ").strict_div(0);")]
/// ```
- #[unstable(feature = "strict_overflow_ops", issue = "118260")]
+ #[stable(feature = "strict_overflow_ops", since = "CURRENT_RUSTC_VERSION")]
+ #[rustc_const_stable(feature = "strict_overflow_ops", since = "CURRENT_RUSTC_VERSION")]
#[must_use = "this returns the result of the operation, \
without modifying the original"]
#[inline]
@@ -924,24 +917,22 @@ pub const fn checked_div_euclid(self, rhs: Self) -> Option<Self> {
/// # Examples
///
/// ```
- /// #![feature(strict_overflow_ops)]
#[doc = concat!("assert_eq!((", stringify!($SelfT), "::MIN + 1).strict_div_euclid(-1), ", stringify!($Max), ");")]
/// ```
///
/// The following panics because of overflow:
///
/// ```should_panic
- /// #![feature(strict_overflow_ops)]
#[doc = concat!("let _ = ", stringify!($SelfT), "::MIN.strict_div_euclid(-1);")]
/// ```
///
/// The following panics because of division by zero:
///
/// ```should_panic
- /// #![feature(strict_overflow_ops)]
#[doc = concat!("let _ = (1", stringify!($SelfT), ").strict_div_euclid(0);")]
/// ```
- #[unstable(feature = "strict_overflow_ops", issue = "118260")]
+ #[stable(feature = "strict_overflow_ops", since = "CURRENT_RUSTC_VERSION")]
+ #[rustc_const_stable(feature = "strict_overflow_ops", since = "CURRENT_RUSTC_VERSION")]
#[must_use = "this returns the result of the operation, \
without modifying the original"]
#[inline]
@@ -1092,24 +1083,22 @@ pub const fn checked_rem(self, rhs: Self) -> Option<Self> {
/// # Examples
///
/// ```
- /// #![feature(strict_overflow_ops)]
#[doc = concat!("assert_eq!(5", stringify!($SelfT), ".strict_rem(2), 1);")]
/// ```
///
/// The following panics because of division by zero:
///
/// ```should_panic
- /// #![feature(strict_overflow_ops)]
#[doc = concat!("let _ = 5", stringify!($SelfT), ".strict_rem(0);")]
/// ```
///
/// The following panics because of overflow:
///
/// ```should_panic
- /// #![feature(strict_overflow_ops)]
#[doc = concat!("let _ = ", stringify!($SelfT), "::MIN.strict_rem(-1);")]
/// ```
- #[unstable(feature = "strict_overflow_ops", issue = "118260")]
+ #[stable(feature = "strict_overflow_ops", since = "CURRENT_RUSTC_VERSION")]
+ #[rustc_const_stable(feature = "strict_overflow_ops", since = "CURRENT_RUSTC_VERSION")]
#[must_use = "this returns the result of the operation, \
without modifying the original"]
#[inline]
@@ -1160,24 +1149,22 @@ pub const fn checked_rem_euclid(self, rhs: Self) -> Option<Self> {
/// # Examples
///
/// ```
- /// #![feature(strict_overflow_ops)]
#[doc = concat!("assert_eq!(5", stringify!($SelfT), ".strict_rem_euclid(2), 1);")]
/// ```
///
/// The following panics because of division by zero:
///
/// ```should_panic
- /// #![feature(strict_overflow_ops)]
#[doc = concat!("let _ = 5", stringify!($SelfT), ".strict_rem_euclid(0);")]
/// ```
///
/// The following panics because of overflow:
///
/// ```should_panic
- /// #![feature(strict_overflow_ops)]
#[doc = concat!("let _ = ", stringify!($SelfT), "::MIN.strict_rem_euclid(-1);")]
/// ```
- #[unstable(feature = "strict_overflow_ops", issue = "118260")]
+ #[stable(feature = "strict_overflow_ops", since = "CURRENT_RUSTC_VERSION")]
+ #[rustc_const_stable(feature = "strict_overflow_ops", since = "CURRENT_RUSTC_VERSION")]
#[must_use = "this returns the result of the operation, \
without modifying the original"]
#[inline]
@@ -1249,17 +1236,16 @@ pub const fn checked_neg(self) -> Option<Self> {
/// # Examples
///
/// ```
- /// #![feature(strict_overflow_ops)]
#[doc = concat!("assert_eq!(5", stringify!($SelfT), ".strict_neg(), -5);")]
/// ```
///
/// The following panics because of overflow:
///
/// ```should_panic
- /// #![feature(strict_overflow_ops)]
#[doc = concat!("let _ = ", stringify!($SelfT), "::MIN.strict_neg();")]
///
- #[unstable(feature = "strict_overflow_ops", issue = "118260")]
+ #[stable(feature = "strict_overflow_ops", since = "CURRENT_RUSTC_VERSION")]
+ #[rustc_const_stable(feature = "strict_overflow_ops", since = "CURRENT_RUSTC_VERSION")]
#[must_use = "this returns the result of the operation, \
without modifying the original"]
#[inline]
@@ -1306,17 +1292,16 @@ pub const fn checked_shl(self, rhs: u32) -> Option<Self> {
/// # Examples
///
/// ```
- /// #![feature(strict_overflow_ops)]
#[doc = concat!("assert_eq!(0x1", stringify!($SelfT), ".strict_shl(4), 0x10);")]
/// ```
///
/// The following panics because of overflow:
///
/// ```should_panic
- /// #![feature(strict_overflow_ops)]
#[doc = concat!("let _ = 0x1", stringify!($SelfT), ".strict_shl(129);")]
/// ```
- #[unstable(feature = "strict_overflow_ops", issue = "118260")]
+ #[stable(feature = "strict_overflow_ops", since = "CURRENT_RUSTC_VERSION")]
+ #[rustc_const_stable(feature = "strict_overflow_ops", since = "CURRENT_RUSTC_VERSION")]
#[must_use = "this returns the result of the operation, \
without modifying the original"]
#[inline]
@@ -1422,17 +1407,16 @@ pub const fn checked_shr(self, rhs: u32) -> Option<Self> {
/// # Examples
///
/// ```
- /// #![feature(strict_overflow_ops)]
#[doc = concat!("assert_eq!(0x10", stringify!($SelfT), ".strict_shr(4), 0x1);")]
/// ```
///
/// The following panics because of overflow:
///
/// ```should_panic
- /// #![feature(strict_overflow_ops)]
#[doc = concat!("let _ = 0x10", stringify!($SelfT), ".strict_shr(128);")]
/// ```
- #[unstable(feature = "strict_overflow_ops", issue = "118260")]
+ #[stable(feature = "strict_overflow_ops", since = "CURRENT_RUSTC_VERSION")]
+ #[rustc_const_stable(feature = "strict_overflow_ops", since = "CURRENT_RUSTC_VERSION")]
#[must_use = "this returns the result of the operation, \
without modifying the original"]
#[inline]
@@ -1542,17 +1526,16 @@ pub const fn checked_abs(self) -> Option<Self> {
/// # Examples
///
/// ```
- /// #![feature(strict_overflow_ops)]
#[doc = concat!("assert_eq!((-5", stringify!($SelfT), ").strict_abs(), 5);")]
/// ```
///
/// The following panics because of overflow:
///
/// ```should_panic
- /// #![feature(strict_overflow_ops)]
#[doc = concat!("let _ = ", stringify!($SelfT), "::MIN.strict_abs();")]
/// ```
- #[unstable(feature = "strict_overflow_ops", issue = "118260")]
+ #[stable(feature = "strict_overflow_ops", since = "CURRENT_RUSTC_VERSION")]
+ #[rustc_const_stable(feature = "strict_overflow_ops", since = "CURRENT_RUSTC_VERSION")]
#[must_use = "this returns the result of the operation, \
without modifying the original"]
#[inline]
@@ -1612,17 +1595,16 @@ pub const fn checked_pow(self, mut exp: u32) -> Option<Self> {
/// # Examples
///
/// ```
- /// #![feature(strict_overflow_ops)]
#[doc = concat!("assert_eq!(8", stringify!($SelfT), ".strict_pow(2), 64);")]
/// ```
///
/// The following panics because of overflow:
///
/// ```should_panic
- /// #![feature(strict_overflow_ops)]
#[doc = concat!("let _ = ", stringify!($SelfT), "::MAX.strict_pow(2);")]
/// ```
- #[unstable(feature = "strict_overflow_ops", issue = "118260")]
+ #[stable(feature = "strict_overflow_ops", since = "CURRENT_RUSTC_VERSION")]
+ #[rustc_const_stable(feature = "strict_overflow_ops", since = "CURRENT_RUSTC_VERSION")]
#[must_use = "this returns the result of the operation, \
without modifying the original"]
#[inline]
diff --git a/library/core/src/num/uint_macros.rs b/library/core/src/num/uint_macros.rs
index 5a41a30..a898326 100644
--- a/library/core/src/num/uint_macros.rs
+++ b/library/core/src/num/uint_macros.rs
@@ -538,17 +538,16 @@ pub const fn checked_add(self, rhs: Self) -> Option<Self> {
/// # Examples
///
/// ```
- /// #![feature(strict_overflow_ops)]
#[doc = concat!("assert_eq!((", stringify!($SelfT), "::MAX - 2).strict_add(1), ", stringify!($SelfT), "::MAX - 1);")]
/// ```
///
/// The following panics because of overflow:
///
/// ```should_panic
- /// #![feature(strict_overflow_ops)]
#[doc = concat!("let _ = (", stringify!($SelfT), "::MAX - 2).strict_add(3);")]
/// ```
- #[unstable(feature = "strict_overflow_ops", issue = "118260")]
+ #[stable(feature = "strict_overflow_ops", since = "CURRENT_RUSTC_VERSION")]
+ #[rustc_const_stable(feature = "strict_overflow_ops", since = "CURRENT_RUSTC_VERSION")]
#[must_use = "this returns the result of the operation, \
without modifying the original"]
#[inline]
@@ -630,22 +629,20 @@ pub const fn checked_add_signed(self, rhs: $SignedT) -> Option<Self> {
/// # Examples
///
/// ```
- /// #![feature(strict_overflow_ops)]
#[doc = concat!("assert_eq!(1", stringify!($SelfT), ".strict_add_signed(2), 3);")]
/// ```
///
/// The following panic because of overflow:
///
/// ```should_panic
- /// #![feature(strict_overflow_ops)]
#[doc = concat!("let _ = 1", stringify!($SelfT), ".strict_add_signed(-2);")]
/// ```
///
/// ```should_panic
- /// #![feature(strict_overflow_ops)]
#[doc = concat!("let _ = (", stringify!($SelfT), "::MAX - 2).strict_add_signed(3);")]
/// ```
- #[unstable(feature = "strict_overflow_ops", issue = "118260")]
+ #[stable(feature = "strict_overflow_ops", since = "CURRENT_RUSTC_VERSION")]
+ #[rustc_const_stable(feature = "strict_overflow_ops", since = "CURRENT_RUSTC_VERSION")]
#[must_use = "this returns the result of the operation, \
without modifying the original"]
#[inline]
@@ -695,17 +692,16 @@ pub const fn checked_sub(self, rhs: Self) -> Option<Self> {
/// # Examples
///
/// ```
- /// #![feature(strict_overflow_ops)]
#[doc = concat!("assert_eq!(1", stringify!($SelfT), ".strict_sub(1), 0);")]
/// ```
///
/// The following panics because of overflow:
///
/// ```should_panic
- /// #![feature(strict_overflow_ops)]
#[doc = concat!("let _ = 0", stringify!($SelfT), ".strict_sub(1);")]
/// ```
- #[unstable(feature = "strict_overflow_ops", issue = "118260")]
+ #[stable(feature = "strict_overflow_ops", since = "CURRENT_RUSTC_VERSION")]
+ #[rustc_const_stable(feature = "strict_overflow_ops", since = "CURRENT_RUSTC_VERSION")]
#[must_use = "this returns the result of the operation, \
without modifying the original"]
#[inline]
@@ -817,22 +813,20 @@ pub const fn checked_sub_signed(self, rhs: $SignedT) -> Option<Self> {
/// # Examples
///
/// ```
- /// #![feature(strict_overflow_ops)]
#[doc = concat!("assert_eq!(3", stringify!($SelfT), ".strict_sub_signed(2), 1);")]
/// ```
///
/// The following panic because of overflow:
///
/// ```should_panic
- /// #![feature(strict_overflow_ops)]
#[doc = concat!("let _ = 1", stringify!($SelfT), ".strict_sub_signed(2);")]
/// ```
///
/// ```should_panic
- /// #![feature(strict_overflow_ops)]
#[doc = concat!("let _ = (", stringify!($SelfT), "::MAX).strict_sub_signed(-1);")]
/// ```
- #[unstable(feature = "strict_overflow_ops", issue = "118260")]
+ #[stable(feature = "strict_overflow_ops", since = "CURRENT_RUSTC_VERSION")]
+ #[rustc_const_stable(feature = "strict_overflow_ops", since = "CURRENT_RUSTC_VERSION")]
#[must_use = "this returns the result of the operation, \
without modifying the original"]
#[inline]
@@ -932,17 +926,16 @@ pub const fn checked_mul(self, rhs: Self) -> Option<Self> {
/// # Examples
///
/// ```
- /// #![feature(strict_overflow_ops)]
#[doc = concat!("assert_eq!(5", stringify!($SelfT), ".strict_mul(1), 5);")]
/// ```
///
/// The following panics because of overflow:
///
/// ``` should_panic
- /// #![feature(strict_overflow_ops)]
#[doc = concat!("let _ = ", stringify!($SelfT), "::MAX.strict_mul(2);")]
/// ```
- #[unstable(feature = "strict_overflow_ops", issue = "118260")]
+ #[stable(feature = "strict_overflow_ops", since = "CURRENT_RUSTC_VERSION")]
+ #[rustc_const_stable(feature = "strict_overflow_ops", since = "CURRENT_RUSTC_VERSION")]
#[must_use = "this returns the result of the operation, \
without modifying the original"]
#[inline]
@@ -1029,17 +1022,16 @@ pub const fn checked_div(self, rhs: Self) -> Option<Self> {
/// # Examples
///
/// ```
- /// #![feature(strict_overflow_ops)]
#[doc = concat!("assert_eq!(100", stringify!($SelfT), ".strict_div(10), 10);")]
/// ```
///
/// The following panics because of division by zero:
///
/// ```should_panic
- /// #![feature(strict_overflow_ops)]
#[doc = concat!("let _ = (1", stringify!($SelfT), ").strict_div(0);")]
/// ```
- #[unstable(feature = "strict_overflow_ops", issue = "118260")]
+ #[stable(feature = "strict_overflow_ops", since = "CURRENT_RUSTC_VERSION")]
+ #[rustc_const_stable(feature = "strict_overflow_ops", since = "CURRENT_RUSTC_VERSION")]
#[must_use = "this returns the result of the operation, \
without modifying the original"]
#[inline(always)]
@@ -1085,16 +1077,15 @@ pub const fn checked_div_euclid(self, rhs: Self) -> Option<Self> {
/// # Examples
///
/// ```
- /// #![feature(strict_overflow_ops)]
#[doc = concat!("assert_eq!(100", stringify!($SelfT), ".strict_div_euclid(10), 10);")]
/// ```
/// The following panics because of division by zero:
///
/// ```should_panic
- /// #![feature(strict_overflow_ops)]
#[doc = concat!("let _ = (1", stringify!($SelfT), ").strict_div_euclid(0);")]
/// ```
- #[unstable(feature = "strict_overflow_ops", issue = "118260")]
+ #[stable(feature = "strict_overflow_ops", since = "CURRENT_RUSTC_VERSION")]
+ #[rustc_const_stable(feature = "strict_overflow_ops", since = "CURRENT_RUSTC_VERSION")]
#[must_use = "this returns the result of the operation, \
without modifying the original"]
#[inline(always)]
@@ -1239,17 +1230,16 @@ pub const fn checked_rem(self, rhs: Self) -> Option<Self> {
/// # Examples
///
/// ```
- /// #![feature(strict_overflow_ops)]
#[doc = concat!("assert_eq!(100", stringify!($SelfT), ".strict_rem(10), 0);")]
/// ```
///
/// The following panics because of division by zero:
///
/// ```should_panic
- /// #![feature(strict_overflow_ops)]
#[doc = concat!("let _ = 5", stringify!($SelfT), ".strict_rem(0);")]
/// ```
- #[unstable(feature = "strict_overflow_ops", issue = "118260")]
+ #[stable(feature = "strict_overflow_ops", since = "CURRENT_RUSTC_VERSION")]
+ #[rustc_const_stable(feature = "strict_overflow_ops", since = "CURRENT_RUSTC_VERSION")]
#[must_use = "this returns the result of the operation, \
without modifying the original"]
#[inline(always)]
@@ -1296,17 +1286,16 @@ pub const fn checked_rem_euclid(self, rhs: Self) -> Option<Self> {
/// # Examples
///
/// ```
- /// #![feature(strict_overflow_ops)]
#[doc = concat!("assert_eq!(100", stringify!($SelfT), ".strict_rem_euclid(10), 0);")]
/// ```
///
/// The following panics because of division by zero:
///
/// ```should_panic
- /// #![feature(strict_overflow_ops)]
#[doc = concat!("let _ = 5", stringify!($SelfT), ".strict_rem_euclid(0);")]
/// ```
- #[unstable(feature = "strict_overflow_ops", issue = "118260")]
+ #[stable(feature = "strict_overflow_ops", since = "CURRENT_RUSTC_VERSION")]
+ #[rustc_const_stable(feature = "strict_overflow_ops", since = "CURRENT_RUSTC_VERSION")]
#[must_use = "this returns the result of the operation, \
without modifying the original"]
#[inline(always)]
@@ -1568,17 +1557,16 @@ pub const fn checked_neg(self) -> Option<Self> {
/// # Examples
///
/// ```
- /// #![feature(strict_overflow_ops)]
#[doc = concat!("assert_eq!(0", stringify!($SelfT), ".strict_neg(), 0);")]
/// ```
///
/// The following panics because of overflow:
///
/// ```should_panic
- /// #![feature(strict_overflow_ops)]
#[doc = concat!("let _ = 1", stringify!($SelfT), ".strict_neg();")]
///
- #[unstable(feature = "strict_overflow_ops", issue = "118260")]
+ #[stable(feature = "strict_overflow_ops", since = "CURRENT_RUSTC_VERSION")]
+ #[rustc_const_stable(feature = "strict_overflow_ops", since = "CURRENT_RUSTC_VERSION")]
#[must_use = "this returns the result of the operation, \
without modifying the original"]
#[inline]
@@ -1625,17 +1613,16 @@ pub const fn checked_shl(self, rhs: u32) -> Option<Self> {
/// # Examples
///
/// ```
- /// #![feature(strict_overflow_ops)]
#[doc = concat!("assert_eq!(0x1", stringify!($SelfT), ".strict_shl(4), 0x10);")]
/// ```
///
/// The following panics because of overflow:
///
/// ```should_panic
- /// #![feature(strict_overflow_ops)]
#[doc = concat!("let _ = 0x10", stringify!($SelfT), ".strict_shl(129);")]
/// ```
- #[unstable(feature = "strict_overflow_ops", issue = "118260")]
+ #[stable(feature = "strict_overflow_ops", since = "CURRENT_RUSTC_VERSION")]
+ #[rustc_const_stable(feature = "strict_overflow_ops", since = "CURRENT_RUSTC_VERSION")]
#[must_use = "this returns the result of the operation, \
without modifying the original"]
#[inline]
@@ -1741,17 +1728,16 @@ pub const fn checked_shr(self, rhs: u32) -> Option<Self> {
/// # Examples
///
/// ```
- /// #![feature(strict_overflow_ops)]
#[doc = concat!("assert_eq!(0x10", stringify!($SelfT), ".strict_shr(4), 0x1);")]
/// ```
///
/// The following panics because of overflow:
///
/// ```should_panic
- /// #![feature(strict_overflow_ops)]
#[doc = concat!("let _ = 0x10", stringify!($SelfT), ".strict_shr(129);")]
/// ```
- #[unstable(feature = "strict_overflow_ops", issue = "118260")]
+ #[stable(feature = "strict_overflow_ops", since = "CURRENT_RUSTC_VERSION")]
+ #[rustc_const_stable(feature = "strict_overflow_ops", since = "CURRENT_RUSTC_VERSION")]
#[must_use = "this returns the result of the operation, \
without modifying the original"]
#[inline]
@@ -1867,17 +1853,16 @@ pub const fn checked_pow(self, mut exp: u32) -> Option<Self> {
/// # Examples
///
/// ```
- /// #![feature(strict_overflow_ops)]
#[doc = concat!("assert_eq!(2", stringify!($SelfT), ".strict_pow(5), 32);")]
/// ```
///
/// The following panics because of overflow:
///
/// ```should_panic
- /// #![feature(strict_overflow_ops)]
#[doc = concat!("let _ = ", stringify!($SelfT), "::MAX.strict_pow(2);")]
/// ```
- #[unstable(feature = "strict_overflow_ops", issue = "118260")]
+ #[stable(feature = "strict_overflow_ops", since = "CURRENT_RUSTC_VERSION")]
+ #[rustc_const_stable(feature = "strict_overflow_ops", since = "CURRENT_RUSTC_VERSION")]
#[must_use = "this returns the result of the operation, \
without modifying the original"]
#[inline]
diff --git a/library/core/src/ops/control_flow.rs b/library/core/src/ops/control_flow.rs
index 26661b2..7489a8b 100644
--- a/library/core/src/ops/control_flow.rs
+++ b/library/core/src/ops/control_flow.rs
@@ -187,6 +187,80 @@ pub fn break_value(self) -> Option<B> {
}
}
+ /// Converts the `ControlFlow` into an `Result` which is `Ok` if the
+ /// `ControlFlow` was `Break` and `Err` if otherwise.
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// #![feature(control_flow_ok)]
+ ///
+ /// use std::ops::ControlFlow;
+ ///
+ /// struct TreeNode<T> {
+ /// value: T,
+ /// left: Option<Box<TreeNode<T>>>,
+ /// right: Option<Box<TreeNode<T>>>,
+ /// }
+ ///
+ /// impl<T> TreeNode<T> {
+ /// fn find<'a>(&'a self, mut predicate: impl FnMut(&T) -> bool) -> Result<&'a T, ()> {
+ /// let mut f = |t: &'a T| -> ControlFlow<&'a T> {
+ /// if predicate(t) {
+ /// ControlFlow::Break(t)
+ /// } else {
+ /// ControlFlow::Continue(())
+ /// }
+ /// };
+ ///
+ /// self.traverse_inorder(&mut f).break_ok()
+ /// }
+ ///
+ /// fn traverse_inorder<'a, B>(
+ /// &'a self,
+ /// f: &mut impl FnMut(&'a T) -> ControlFlow<B>,
+ /// ) -> ControlFlow<B> {
+ /// if let Some(left) = &self.left {
+ /// left.traverse_inorder(f)?;
+ /// }
+ /// f(&self.value)?;
+ /// if let Some(right) = &self.right {
+ /// right.traverse_inorder(f)?;
+ /// }
+ /// ControlFlow::Continue(())
+ /// }
+ ///
+ /// fn leaf(value: T) -> Option<Box<TreeNode<T>>> {
+ /// Some(Box::new(Self {
+ /// value,
+ /// left: None,
+ /// right: None,
+ /// }))
+ /// }
+ /// }
+ ///
+ /// let node = TreeNode {
+ /// value: 0,
+ /// left: TreeNode::leaf(1),
+ /// right: Some(Box::new(TreeNode {
+ /// value: -1,
+ /// left: TreeNode::leaf(5),
+ /// right: TreeNode::leaf(2),
+ /// })),
+ /// };
+ ///
+ /// let res = node.find(|val: &i32| *val > 3);
+ /// assert_eq!(res, Ok(&5));
+ /// ```
+ #[inline]
+ #[unstable(feature = "control_flow_ok", issue = "140266")]
+ pub fn break_ok(self) -> Result<B, C> {
+ match self {
+ ControlFlow::Continue(c) => Err(c),
+ ControlFlow::Break(b) => Ok(b),
+ }
+ }
+
/// Maps `ControlFlow<B, C>` to `ControlFlow<T, C>` by applying a function
/// to the break value in case it exists.
#[inline]
@@ -218,6 +292,79 @@ pub fn continue_value(self) -> Option<C> {
}
}
+ /// Converts the `ControlFlow` into an `Result` which is `Ok` if the
+ /// `ControlFlow` was `Continue` and `Err` if otherwise.
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// #![feature(control_flow_ok)]
+ ///
+ /// use std::ops::ControlFlow;
+ ///
+ /// struct TreeNode<T> {
+ /// value: T,
+ /// left: Option<Box<TreeNode<T>>>,
+ /// right: Option<Box<TreeNode<T>>>,
+ /// }
+ ///
+ /// impl<T> TreeNode<T> {
+ /// fn validate<B>(&self, f: &mut impl FnMut(&T) -> ControlFlow<B>) -> Result<(), B> {
+ /// self.traverse_inorder(f).continue_ok()
+ /// }
+ ///
+ /// fn traverse_inorder<B>(&self, f: &mut impl FnMut(&T) -> ControlFlow<B>) -> ControlFlow<B> {
+ /// if let Some(left) = &self.left {
+ /// left.traverse_inorder(f)?;
+ /// }
+ /// f(&self.value)?;
+ /// if let Some(right) = &self.right {
+ /// right.traverse_inorder(f)?;
+ /// }
+ /// ControlFlow::Continue(())
+ /// }
+ ///
+ /// fn leaf(value: T) -> Option<Box<TreeNode<T>>> {
+ /// Some(Box::new(Self {
+ /// value,
+ /// left: None,
+ /// right: None,
+ /// }))
+ /// }
+ /// }
+ ///
+ /// let node = TreeNode {
+ /// value: 0,
+ /// left: TreeNode::leaf(1),
+ /// right: Some(Box::new(TreeNode {
+ /// value: -1,
+ /// left: TreeNode::leaf(5),
+ /// right: TreeNode::leaf(2),
+ /// })),
+ /// };
+ ///
+ /// let res = node.validate(&mut |val| {
+ /// if *val < 0 {
+ /// return ControlFlow::Break("negative value detected");
+ /// }
+ ///
+ /// if *val > 4 {
+ /// return ControlFlow::Break("too big value detected");
+ /// }
+ ///
+ /// ControlFlow::Continue(())
+ /// });
+ /// assert_eq!(res, Err("too big value detected"));
+ /// ```
+ #[inline]
+ #[unstable(feature = "control_flow_ok", issue = "140266")]
+ pub fn continue_ok(self) -> Result<C, B> {
+ match self {
+ ControlFlow::Continue(c) => Ok(c),
+ ControlFlow::Break(b) => Err(b),
+ }
+ }
+
/// Maps `ControlFlow<B, C>` to `ControlFlow<B, T>` by applying a function
/// to the continue value in case it exists.
#[inline]
diff --git a/library/coretests/tests/lib.rs b/library/coretests/tests/lib.rs
index 0a9c0c6..a0c594d 100644
--- a/library/coretests/tests/lib.rs
+++ b/library/coretests/tests/lib.rs
@@ -22,6 +22,7 @@
#![feature(const_ref_cell)]
#![feature(const_result_trait_fn)]
#![feature(const_trait_impl)]
+#![feature(control_flow_ok)]
#![feature(core_float_math)]
#![feature(core_intrinsics)]
#![feature(core_intrinsics_fallbacks)]
diff --git a/library/coretests/tests/ops/control_flow.rs b/library/coretests/tests/ops/control_flow.rs
index eacfd63..1df6599 100644
--- a/library/coretests/tests/ops/control_flow.rs
+++ b/library/coretests/tests/ops/control_flow.rs
@@ -16,3 +16,15 @@ fn control_flow_discriminants_match_result() {
discriminant_value(&Result::<i32, i32>::Ok(3)),
);
}
+
+#[test]
+fn control_flow_break_ok() {
+ assert_eq!(ControlFlow::<char, i32>::Break('b').break_ok(), Ok('b'));
+ assert_eq!(ControlFlow::<char, i32>::Continue(3).break_ok(), Err(3));
+}
+
+#[test]
+fn control_flow_continue_ok() {
+ assert_eq!(ControlFlow::<char, i32>::Break('b').continue_ok(), Err('b'));
+ assert_eq!(ControlFlow::<char, i32>::Continue(3).continue_ok(), Ok(3));
+}
diff --git a/library/std/src/fs.rs b/library/std/src/fs.rs
index 72ad7c24..b3ca118 100644
--- a/library/std/src/fs.rs
+++ b/library/std/src/fs.rs
@@ -1111,6 +1111,11 @@ pub fn set_permissions(&self, perm: Permissions) -> io::Result<()> {
/// `futimes` on macOS before 10.13) and the `SetFileTime` function on Windows. Note that this
/// [may change in the future][changes].
///
+ /// On most platforms, including UNIX and Windows platforms, this function can also change the
+ /// timestamps of a directory. To get a `File` representing a directory in order to call
+ /// `set_times`, open the directory with `File::open` without attempting to obtain write
+ /// permission.
+ ///
/// [changes]: io#platform-specific-behavior
///
/// # Errors
@@ -1128,7 +1133,7 @@ pub fn set_permissions(&self, perm: Permissions) -> io::Result<()> {
/// use std::fs::{self, File, FileTimes};
///
/// let src = fs::metadata("src")?;
- /// let dest = File::options().write(true).open("dest")?;
+ /// let dest = File::open("dest")?;
/// let times = FileTimes::new()
/// .set_accessed(src.accessed()?)
/// .set_modified(src.modified()?);
diff --git a/library/std/src/num/f32.rs b/library/std/src/num/f32.rs
index 2bff73a..3176988 100644
--- a/library/std/src/num/f32.rs
+++ b/library/std/src/num/f32.rs
@@ -582,8 +582,8 @@ pub fn log10(self) -> f32 {
/// let abs_difference_x = (x.abs_sub(1.0) - 2.0).abs();
/// let abs_difference_y = (y.abs_sub(1.0) - 0.0).abs();
///
- /// assert!(abs_difference_x <= f32::EPSILON);
- /// assert!(abs_difference_y <= f32::EPSILON);
+ /// assert!(abs_difference_x <= 1e-6);
+ /// assert!(abs_difference_y <= 1e-6);
/// ```
#[rustc_allow_incoherent_impl]
#[must_use = "method returns a new number and does not mutate the original value"]
@@ -621,7 +621,7 @@ pub fn abs_sub(self, other: f32) -> f32 {
/// // x^(1/3) - 2 == 0
/// let abs_difference = (x.cbrt() - 2.0).abs();
///
- /// assert!(abs_difference <= f32::EPSILON);
+ /// assert!(abs_difference <= 1e-6);
/// ```
#[rustc_allow_incoherent_impl]
#[must_use = "method returns a new number and does not mutate the original value"]
@@ -652,7 +652,7 @@ pub fn cbrt(self) -> f32 {
/// // sqrt(x^2 + y^2)
/// let abs_difference = (x.hypot(y) - (x.powi(2) + y.powi(2)).sqrt()).abs();
///
- /// assert!(abs_difference <= 1e-6);
+ /// assert!(abs_difference <= 1e-5);
/// ```
#[rustc_allow_incoherent_impl]
#[must_use = "method returns a new number and does not mutate the original value"]
@@ -725,7 +725,7 @@ pub fn cos(self) -> f32 {
/// let x = std::f32::consts::FRAC_PI_4;
/// let abs_difference = (x.tan() - 1.0).abs();
///
- /// assert!(abs_difference <= f32::EPSILON);
+ /// assert!(abs_difference <= 1e-6);
/// ```
#[rustc_allow_incoherent_impl]
#[must_use = "method returns a new number and does not mutate the original value"]
@@ -749,12 +749,12 @@ pub fn tan(self) -> f32 {
/// # Examples
///
/// ```
- /// let f = std::f32::consts::FRAC_PI_2;
+ /// let f = std::f32::consts::FRAC_PI_4;
///
/// // asin(sin(pi/2))
- /// let abs_difference = (f.sin().asin() - std::f32::consts::FRAC_PI_2).abs();
+ /// let abs_difference = (f.sin().asin() - f).abs();
///
- /// assert!(abs_difference <= 1e-3);
+ /// assert!(abs_difference <= 1e-6);
/// ```
#[doc(alias = "arcsin")]
#[rustc_allow_incoherent_impl]
@@ -813,7 +813,7 @@ pub fn acos(self) -> f32 {
/// // atan(tan(1))
/// let abs_difference = (f.tan().atan() - 1.0).abs();
///
- /// assert!(abs_difference <= f32::EPSILON);
+ /// assert!(abs_difference <= 1e-6);
/// ```
#[doc(alias = "arctan")]
#[rustc_allow_incoherent_impl]
@@ -854,8 +854,8 @@ pub fn atan(self) -> f32 {
/// let abs_difference_1 = (y1.atan2(x1) - (-std::f32::consts::FRAC_PI_4)).abs();
/// let abs_difference_2 = (y2.atan2(x2) - (3.0 * std::f32::consts::FRAC_PI_4)).abs();
///
- /// assert!(abs_difference_1 <= f32::EPSILON);
- /// assert!(abs_difference_2 <= f32::EPSILON);
+ /// assert!(abs_difference_1 <= 1e-5);
+ /// assert!(abs_difference_2 <= 1e-5);
/// ```
#[rustc_allow_incoherent_impl]
#[must_use = "method returns a new number and does not mutate the original value"]
@@ -884,8 +884,8 @@ pub fn atan2(self, other: f32) -> f32 {
/// let abs_difference_0 = (f.0 - x.sin()).abs();
/// let abs_difference_1 = (f.1 - x.cos()).abs();
///
- /// assert!(abs_difference_0 <= 1e-6);
- /// assert!(abs_difference_1 <= 1e-6);
+ /// assert!(abs_difference_0 <= 1e-4);
+ /// assert!(abs_difference_1 <= 1e-4);
/// ```
#[doc(alias = "sincos")]
#[rustc_allow_incoherent_impl]
@@ -982,7 +982,7 @@ pub fn ln_1p(self) -> f32 {
/// let g = ((e * e) - 1.0) / (2.0 * e);
/// let abs_difference = (f - g).abs();
///
- /// assert!(abs_difference <= f32::EPSILON);
+ /// assert!(abs_difference <= 1e-6);
/// ```
#[rustc_allow_incoherent_impl]
#[must_use = "method returns a new number and does not mutate the original value"]
@@ -1012,7 +1012,7 @@ pub fn sinh(self) -> f32 {
/// let abs_difference = (f - g).abs();
///
/// // Same result
- /// assert!(abs_difference <= f32::EPSILON);
+ /// assert!(abs_difference <= 1e-6);
/// ```
#[rustc_allow_incoherent_impl]
#[must_use = "method returns a new number and does not mutate the original value"]
@@ -1042,7 +1042,7 @@ pub fn cosh(self) -> f32 {
/// let g = (1.0 - e.powi(-2)) / (1.0 + e.powi(-2));
/// let abs_difference = (f - g).abs();
///
- /// assert!(abs_difference <= f32::EPSILON);
+ /// assert!(abs_difference <= 1e-6);
/// ```
#[rustc_allow_incoherent_impl]
#[must_use = "method returns a new number and does not mutate the original value"]
@@ -1067,7 +1067,7 @@ pub fn tanh(self) -> f32 {
///
/// let abs_difference = (f - x).abs();
///
- /// assert!(abs_difference <= 1e-7);
+ /// assert!(abs_difference <= 1e-6);
/// ```
#[doc(alias = "arcsinh")]
#[rustc_allow_incoherent_impl]
@@ -1125,7 +1125,7 @@ pub fn acosh(self) -> f32 {
///
/// let abs_difference = (f - e).abs();
///
- /// assert!(abs_difference <= 1e-5);
+ /// assert!(abs_difference <= 1e-4);
/// ```
#[doc(alias = "arctanh")]
#[rustc_allow_incoherent_impl]
@@ -1153,7 +1153,7 @@ pub fn atanh(self) -> f32 {
///
/// let abs_difference = (x.gamma() - 24.0).abs();
///
- /// assert!(abs_difference <= f32::EPSILON);
+ /// assert!(abs_difference <= 1e-4);
/// ```
#[rustc_allow_incoherent_impl]
#[must_use = "method returns a new number and does not mutate the original value"]
@@ -1248,7 +1248,7 @@ pub fn erf(self) -> f32 {
/// let one = x.erf() + x.erfc();
/// let abs_difference = (one - 1.0).abs();
///
- /// assert!(abs_difference <= f32::EPSILON);
+ /// assert!(abs_difference <= 1e-6);
/// ```
#[rustc_allow_incoherent_impl]
#[must_use = "method returns a new number and does not mutate the original value"]
diff --git a/library/std/src/num/f64.rs b/library/std/src/num/f64.rs
index b71e319..b8f8840 100644
--- a/library/std/src/num/f64.rs
+++ b/library/std/src/num/f64.rs
@@ -749,12 +749,12 @@ pub fn tan(self) -> f64 {
/// # Examples
///
/// ```
- /// let f = std::f64::consts::FRAC_PI_2;
+ /// let f = std::f64::consts::FRAC_PI_4;
///
/// // asin(sin(pi/2))
- /// let abs_difference = (f.sin().asin() - std::f64::consts::FRAC_PI_2).abs();
+ /// let abs_difference = (f.sin().asin() - f).abs();
///
- /// assert!(abs_difference < 1e-7);
+ /// assert!(abs_difference < 1e-14);
/// ```
#[doc(alias = "arcsin")]
#[rustc_allow_incoherent_impl]
@@ -1153,7 +1153,7 @@ pub fn atanh(self) -> f64 {
///
/// let abs_difference = (x.gamma() - 24.0).abs();
///
- /// assert!(abs_difference <= f64::EPSILON);
+ /// assert!(abs_difference <= 1e-10);
/// ```
#[rustc_allow_incoherent_impl]
#[must_use = "method returns a new number and does not mutate the original value"]
@@ -1248,7 +1248,7 @@ pub fn erf(self) -> f64 {
/// let one = x.erf() + x.erfc();
/// let abs_difference = (one - 1.0).abs();
///
- /// assert!(abs_difference <= f64::EPSILON);
+ /// assert!(abs_difference <= 1e-10);
/// ```
#[rustc_allow_incoherent_impl]
#[must_use = "method returns a new number and does not mutate the original value"]
diff --git a/library/std/src/panic.rs b/library/std/src/panic.rs
index 913ef72..cff4f20 100644
--- a/library/std/src/panic.rs
+++ b/library/std/src/panic.rs
@@ -108,8 +108,6 @@ pub fn payload(&self) -> &(dyn Any + Send) {
/// # Example
///
/// ```should_panic
- /// #![feature(panic_payload_as_str)]
- ///
/// std::panic::set_hook(Box::new(|panic_info| {
/// if let Some(s) = panic_info.payload_as_str() {
/// println!("panic occurred: {s:?}");
@@ -122,7 +120,7 @@ pub fn payload(&self) -> &(dyn Any + Send) {
/// ```
#[must_use]
#[inline]
- #[unstable(feature = "panic_payload_as_str", issue = "125175")]
+ #[stable(feature = "panic_payload_as_str", since = "CURRENT_RUSTC_VERSION")]
pub fn payload_as_str(&self) -> Option<&str> {
if let Some(s) = self.payload.downcast_ref::<&str>() {
Some(s)
diff --git a/library/std/src/panicking.rs b/library/std/src/panicking.rs
index 224cd39..547906c 100644
--- a/library/std/src/panicking.rs
+++ b/library/std/src/panicking.rs
@@ -269,6 +269,7 @@ fn default_hook(info: &PanicHookInfo<'_>) {
thread::with_current_name(|name| {
let name = name.unwrap_or("<unnamed>");
+ let tid = thread::current_os_id();
// Try to write the panic message to a buffer first to prevent other concurrent outputs
// interleaving with it.
@@ -277,7 +278,7 @@ fn default_hook(info: &PanicHookInfo<'_>) {
let write_msg = |dst: &mut dyn crate::io::Write| {
// We add a newline to ensure the panic message appears at the start of a line.
- writeln!(dst, "\nthread '{name}' panicked at {location}:\n{msg}")
+ writeln!(dst, "\nthread '{name}' ({tid}) panicked at {location}:\n{msg}")
};
if write_msg(&mut cursor).is_ok() {
diff --git a/library/std/src/path.rs b/library/std/src/path.rs
index 055e7f8..e7ba693 100644
--- a/library/std/src/path.rs
+++ b/library/std/src/path.rs
@@ -2683,6 +2683,8 @@ pub fn file_stem(&self) -> Option<&OsStr> {
///
/// assert_eq!("foo", Path::new("foo.rs").file_prefix().unwrap());
/// assert_eq!("foo", Path::new("foo.tar.gz").file_prefix().unwrap());
+ /// assert_eq!(".config", Path::new(".config").file_prefix().unwrap());
+ /// assert_eq!(".config", Path::new(".config.toml").file_prefix().unwrap());
/// ```
///
/// # See Also
diff --git a/library/std/src/sys/pal/hermit/thread.rs b/library/std/src/sys/pal/hermit/thread.rs
index 95fe4f9..cc4734b 100644
--- a/library/std/src/sys/pal/hermit/thread.rs
+++ b/library/std/src/sys/pal/hermit/thread.rs
@@ -115,6 +115,10 @@ pub fn into_id(self) -> Tid {
}
}
+pub(crate) fn current_os_id() -> Option<u64> {
+ None
+}
+
pub fn available_parallelism() -> io::Result<NonZero<usize>> {
unsafe { Ok(NonZero::new_unchecked(hermit_abi::available_parallelism())) }
}
diff --git a/library/std/src/sys/pal/itron/thread.rs b/library/std/src/sys/pal/itron/thread.rs
index 0d28051..4e14cb3 100644
--- a/library/std/src/sys/pal/itron/thread.rs
+++ b/library/std/src/sys/pal/itron/thread.rs
@@ -361,6 +361,10 @@ unsafe fn terminate_and_delete_current_task() -> ! {
unsafe { crate::hint::unreachable_unchecked() };
}
+pub(crate) fn current_os_id() -> Option<u64> {
+ None
+}
+
pub fn available_parallelism() -> io::Result<NonZero<usize>> {
super::unsupported()
}
diff --git a/library/std/src/sys/pal/sgx/thread.rs b/library/std/src/sys/pal/sgx/thread.rs
index a236c362..1f613ba 100644
--- a/library/std/src/sys/pal/sgx/thread.rs
+++ b/library/std/src/sys/pal/sgx/thread.rs
@@ -1,6 +1,6 @@
#![cfg_attr(test, allow(dead_code))] // why is this necessary?
-use super::abi::usercalls;
+use super::abi::{thread, usercalls};
use super::unsupported;
use crate::ffi::CStr;
use crate::io;
@@ -149,6 +149,10 @@ pub fn join(self) {
}
}
+pub(crate) fn current_os_id() -> Option<u64> {
+ Some(thread::current().addr().get() as u64)
+}
+
pub fn available_parallelism() -> io::Result<NonZero<usize>> {
unsupported()
}
diff --git a/library/std/src/sys/pal/teeos/thread.rs b/library/std/src/sys/pal/teeos/thread.rs
index a91d956..1812d11 100644
--- a/library/std/src/sys/pal/teeos/thread.rs
+++ b/library/std/src/sys/pal/teeos/thread.rs
@@ -144,6 +144,10 @@ fn drop(&mut self) {
}
}
+pub(crate) fn current_os_id() -> Option<u64> {
+ None
+}
+
// Note: Both `sched_getaffinity` and `sysconf` are available but not functional on
// teeos, so this function always returns an Error!
pub fn available_parallelism() -> io::Result<NonZero<usize>> {
diff --git a/library/std/src/sys/pal/uefi/thread.rs b/library/std/src/sys/pal/uefi/thread.rs
index 75c3643..47a4800 100644
--- a/library/std/src/sys/pal/uefi/thread.rs
+++ b/library/std/src/sys/pal/uefi/thread.rs
@@ -56,6 +56,10 @@ pub fn join(self) {
}
}
+pub(crate) fn current_os_id() -> Option<u64> {
+ None
+}
+
pub fn available_parallelism() -> io::Result<NonZero<usize>> {
// UEFI is single threaded
Ok(NonZero::new(1).unwrap())
diff --git a/library/std/src/sys/pal/unix/stack_overflow.rs b/library/std/src/sys/pal/unix/stack_overflow.rs
index d89100e..0d2100d 100644
--- a/library/std/src/sys/pal/unix/stack_overflow.rs
+++ b/library/std/src/sys/pal/unix/stack_overflow.rs
@@ -119,7 +119,8 @@ mod imp {
&& thread_info.guard_page_range.contains(&fault_addr)
{
let name = thread_info.thread_name.as_deref().unwrap_or("<unknown>");
- rtprintpanic!("\nthread '{name}' has overflowed its stack\n");
+ let tid = crate::thread::current_os_id();
+ rtprintpanic!("\nthread '{name}' ({tid}) has overflowed its stack\n");
rtabort!("stack overflow");
}
})
@@ -696,7 +697,8 @@ fn reserve_stack() {
if code == c::EXCEPTION_STACK_OVERFLOW {
crate::thread::with_current_name(|name| {
let name = name.unwrap_or("<unknown>");
- rtprintpanic!("\nthread '{name}' has overflowed its stack\n");
+ let tid = crate::thread::current_os_id();
+ rtprintpanic!("\nthread '{name}' ({tid}) has overflowed its stack\n");
});
}
c::EXCEPTION_CONTINUE_SEARCH
diff --git a/library/std/src/sys/pal/unix/thread.rs b/library/std/src/sys/pal/unix/thread.rs
index 7f64401..36e53e7 100644
--- a/library/std/src/sys/pal/unix/thread.rs
+++ b/library/std/src/sys/pal/unix/thread.rs
@@ -398,6 +398,62 @@ fn drop(&mut self) {
}
}
+pub(crate) fn current_os_id() -> Option<u64> {
+ // Most Unix platforms have a way to query an integer ID of the current thread, all with
+ // slightly different spellings.
+ //
+ // The OS thread ID is used rather than `pthread_self` so as to match what will be displayed
+ // for process inspection (debuggers, trace, `top`, etc.).
+ cfg_if::cfg_if! {
+ // Most platforms have a function returning a `pid_t` or int, which is an `i32`.
+ if #[cfg(any(target_os = "android", target_os = "linux"))] {
+ use crate::sys::weak::syscall;
+
+ // `libc::gettid` is only available on glibc 2.30+, but the syscall is available
+ // since Linux 2.4.11.
+ syscall!(fn gettid() -> libc::pid_t;);
+
+ // SAFETY: FFI call with no preconditions.
+ let id: libc::pid_t = unsafe { gettid() };
+ Some(id as u64)
+ } else if #[cfg(target_os = "nto")] {
+ // SAFETY: FFI call with no preconditions.
+ let id: libc::pid_t = unsafe { libc::gettid() };
+ Some(id as u64)
+ } else if #[cfg(target_os = "openbsd")] {
+ // SAFETY: FFI call with no preconditions.
+ let id: libc::pid_t = unsafe { libc::getthrid() };
+ Some(id as u64)
+ } else if #[cfg(target_os = "freebsd")] {
+ // SAFETY: FFI call with no preconditions.
+ let id: libc::c_int = unsafe { libc::pthread_getthreadid_np() };
+ Some(id as u64)
+ } else if #[cfg(target_os = "netbsd")] {
+ // SAFETY: FFI call with no preconditions.
+ let id: libc::lwpid_t = unsafe { libc::_lwp_self() };
+ Some(id as u64)
+ } else if #[cfg(any(target_os = "illumos", target_os = "solaris"))] {
+ // On Illumos and Solaris, the `pthread_t` is the same as the OS thread ID.
+ // SAFETY: FFI call with no preconditions.
+ let id: libc::pthread_t = unsafe { libc::pthread_self() };
+ Some(id as u64)
+ } else if #[cfg(target_vendor = "apple")] {
+ // Apple allows querying arbitrary thread IDs, `thread=NULL` queries the current thread.
+ let mut id = 0u64;
+ // SAFETY: `thread_id` is a valid pointer, no other preconditions.
+ let status: libc::c_int = unsafe { libc::pthread_threadid_np(0, &mut id) };
+ if status == 0 {
+ Some(id)
+ } else {
+ None
+ }
+ } else {
+ // Other platforms don't have an OS thread ID or don't have a way to access it.
+ None
+ }
+ }
+}
+
#[cfg(any(
target_os = "linux",
target_os = "nto",
diff --git a/library/std/src/sys/pal/unsupported/thread.rs b/library/std/src/sys/pal/unsupported/thread.rs
index 5a1e3fd..34d9b5e 100644
--- a/library/std/src/sys/pal/unsupported/thread.rs
+++ b/library/std/src/sys/pal/unsupported/thread.rs
@@ -39,6 +39,10 @@ pub fn join(self) {
}
}
+pub(crate) fn current_os_id() -> Option<u64> {
+ None
+}
+
pub fn available_parallelism() -> io::Result<NonZero<usize>> {
unsupported()
}
diff --git a/library/std/src/sys/pal/wasi/thread.rs b/library/std/src/sys/pal/wasi/thread.rs
index a46c746..4755e2e 100644
--- a/library/std/src/sys/pal/wasi/thread.rs
+++ b/library/std/src/sys/pal/wasi/thread.rs
@@ -194,6 +194,10 @@ pub fn join(self) {
}
}
+pub(crate) fn current_os_id() -> Option<u64> {
+ None
+}
+
pub fn available_parallelism() -> io::Result<NonZero<usize>> {
cfg_if::cfg_if! {
if #[cfg(target_feature = "atomics")] {
diff --git a/library/std/src/sys/pal/windows/c/bindings.txt b/library/std/src/sys/pal/windows/c/bindings.txt
index 827d96e..c8e4dca 100644
--- a/library/std/src/sys/pal/windows/c/bindings.txt
+++ b/library/std/src/sys/pal/windows/c/bindings.txt
@@ -2185,6 +2185,7 @@
GetSystemTimeAsFileTime
GetSystemTimePreciseAsFileTime
GetTempPathW
+GetThreadId
GetUserProfileDirectoryW
GetWindowsDirectoryW
HANDLE
diff --git a/library/std/src/sys/pal/windows/c/windows_sys.rs b/library/std/src/sys/pal/windows/c/windows_sys.rs
index b2e3aab..45a273d 100644
--- a/library/std/src/sys/pal/windows/c/windows_sys.rs
+++ b/library/std/src/sys/pal/windows/c/windows_sys.rs
@@ -61,6 +61,7 @@
windows_targets::link!("kernel32.dll" "system" fn GetSystemTimeAsFileTime(lpsystemtimeasfiletime : *mut FILETIME));
windows_targets::link!("kernel32.dll" "system" fn GetSystemTimePreciseAsFileTime(lpsystemtimeasfiletime : *mut FILETIME));
windows_targets::link!("kernel32.dll" "system" fn GetTempPathW(nbufferlength : u32, lpbuffer : PWSTR) -> u32);
+windows_targets::link!("kernel32.dll" "system" fn GetThreadId(thread : HANDLE) -> u32);
windows_targets::link!("userenv.dll" "system" fn GetUserProfileDirectoryW(htoken : HANDLE, lpprofiledir : PWSTR, lpcchsize : *mut u32) -> BOOL);
windows_targets::link!("kernel32.dll" "system" fn GetWindowsDirectoryW(lpbuffer : PWSTR, usize : u32) -> u32);
windows_targets::link!("kernel32.dll" "system" fn InitOnceBeginInitialize(lpinitonce : *mut INIT_ONCE, dwflags : u32, fpending : *mut BOOL, lpcontext : *mut *mut core::ffi::c_void) -> BOOL);
diff --git a/library/std/src/sys/pal/windows/stack_overflow.rs b/library/std/src/sys/pal/windows/stack_overflow.rs
index 734cd30..9a40551 100644
--- a/library/std/src/sys/pal/windows/stack_overflow.rs
+++ b/library/std/src/sys/pal/windows/stack_overflow.rs
@@ -20,7 +20,8 @@ pub fn reserve_stack() {
if code == c::EXCEPTION_STACK_OVERFLOW {
thread::with_current_name(|name| {
let name = name.unwrap_or("<unknown>");
- rtprintpanic!("\nthread '{name}' has overflowed its stack\n");
+ let tid = thread::current_os_id();
+ rtprintpanic!("\nthread '{name}' ({tid}) has overflowed its stack\n");
});
}
c::EXCEPTION_CONTINUE_SEARCH
diff --git a/library/std/src/sys/pal/windows/thread.rs b/library/std/src/sys/pal/windows/thread.rs
index b45f76f..c708da5 100644
--- a/library/std/src/sys/pal/windows/thread.rs
+++ b/library/std/src/sys/pal/windows/thread.rs
@@ -127,6 +127,14 @@ pub fn into_handle(self) -> Handle {
}
}
+pub(crate) fn current_os_id() -> Option<u64> {
+ // SAFETY: FFI call with no preconditions.
+ let id: u32 = unsafe { c::GetThreadId(c::GetCurrentThread()) };
+
+ // A return value of 0 indicates failed lookup.
+ if id == 0 { None } else { Some(id.into()) }
+}
+
pub fn available_parallelism() -> io::Result<NonZero<usize>> {
let res = unsafe {
let mut sysinfo: c::SYSTEM_INFO = crate::mem::zeroed();
diff --git a/library/std/src/sys/pal/xous/thread.rs b/library/std/src/sys/pal/xous/thread.rs
index f2404a6..92803c9 100644
--- a/library/std/src/sys/pal/xous/thread.rs
+++ b/library/std/src/sys/pal/xous/thread.rs
@@ -145,6 +145,10 @@ pub fn join(self) {
}
}
+pub(crate) fn current_os_id() -> Option<u64> {
+ None
+}
+
pub fn available_parallelism() -> io::Result<NonZero<usize>> {
// We're unicore right now.
Ok(unsafe { NonZero::new_unchecked(1) })
diff --git a/library/std/src/thread/current.rs b/library/std/src/thread/current.rs
index 4147112..5c87990 100644
--- a/library/std/src/thread/current.rs
+++ b/library/std/src/thread/current.rs
@@ -1,4 +1,4 @@
-use super::{Thread, ThreadId};
+use super::{Thread, ThreadId, imp};
use crate::mem::ManuallyDrop;
use crate::ptr;
use crate::sys::thread_local::local_pointer;
@@ -148,6 +148,17 @@ pub(crate) fn current_id() -> ThreadId {
id::get_or_init()
}
+/// Gets the OS thread ID of the thread that invokes it, if available. If not, return the Rust
+/// thread ID.
+///
+/// We use a `u64` to all possible platform IDs without excess `cfg`; most use `int`, some use a
+/// pointer, and Apple uses `uint64_t`. This is a "best effort" approach for diagnostics and is
+/// allowed to fall back to a non-OS ID (such as the Rust thread ID) or a non-unique ID (such as a
+/// PID) if the thread ID cannot be retrieved.
+pub(crate) fn current_os_id() -> u64 {
+ imp::current_os_id().unwrap_or_else(|| current_id().as_u64().get())
+}
+
/// Gets a reference to the handle of the thread that invokes it, if the handle
/// has been initialized.
pub(super) fn try_with_current<F, R>(f: F) -> R
diff --git a/library/std/src/thread/mod.rs b/library/std/src/thread/mod.rs
index 8d3ab82..292323d 100644
--- a/library/std/src/thread/mod.rs
+++ b/library/std/src/thread/mod.rs
@@ -183,7 +183,7 @@
#[stable(feature = "rust1", since = "1.0.0")]
pub use current::current;
-pub(crate) use current::{current_id, current_or_unnamed, drop_current};
+pub(crate) use current::{current_id, current_or_unnamed, current_os_id, drop_current};
use current::{set_current, try_with_current};
mod spawnhook;
diff --git a/library/std/src/thread/tests.rs b/library/std/src/thread/tests.rs
index 59ec48a..ae889f1 100644
--- a/library/std/src/thread/tests.rs
+++ b/library/std/src/thread/tests.rs
@@ -347,6 +347,13 @@ fn test_thread_id_not_equal() {
}
#[test]
+fn test_thread_os_id_not_equal() {
+ let spawned_id = thread::spawn(|| thread::current_os_id()).join().unwrap();
+ let current_id = thread::current_os_id();
+ assert!(current_id != spawned_id);
+}
+
+#[test]
fn test_scoped_threads_drop_result_before_join() {
let actually_finished = &AtomicBool::new(false);
struct X<'scope, 'env>(&'scope Scope<'scope, 'env>, &'env AtomicBool);
diff --git a/library/std/tests/floats/f32.rs b/library/std/tests/floats/f32.rs
index 38c906c..bea9e82 100644
--- a/library/std/tests/floats/f32.rs
+++ b/library/std/tests/floats/f32.rs
@@ -79,7 +79,7 @@ fn test_log() {
let nan: f32 = f32::NAN;
let inf: f32 = f32::INFINITY;
let neg_inf: f32 = f32::NEG_INFINITY;
- assert_approx_eq!(10.0f32.log(10.0), 1.0);
+ assert_approx_eq!(10.0f32.log(10.0), 1.0, APPROX_DELTA);
assert_approx_eq!(2.3f32.log(3.5), 0.664858);
assert_approx_eq!(1.0f32.exp().log(1.0f32.exp()), 1.0, APPROX_DELTA);
assert!(1.0f32.log(1.0).is_nan());
@@ -140,10 +140,10 @@ fn test_asinh() {
assert_approx_eq!(2.0f32.asinh(), 1.443635475178810342493276740273105f32);
assert_approx_eq!((-2.0f32).asinh(), -1.443635475178810342493276740273105f32);
// regression test for the catastrophic cancellation fixed in 72486
- assert_approx_eq!((-3000.0f32).asinh(), -8.699514775987968673236893537700647f32);
+ assert_approx_eq!((-3000.0f32).asinh(), -8.699514775987968673236893537700647f32, APPROX_DELTA);
// test for low accuracy from issue 104548
- assert_approx_eq!(60.0f32, 60.0f32.sinh().asinh());
+ assert_approx_eq!(60.0f32, 60.0f32.sinh().asinh(), APPROX_DELTA);
// mul needed for approximate comparison to be meaningful
assert_approx_eq!(1.0f32, 1e-15f32.sinh().asinh() * 1e15f32);
}
@@ -196,10 +196,10 @@ fn test_gamma() {
assert_approx_eq!(1.0f32.gamma(), 1.0f32);
assert_approx_eq!(2.0f32.gamma(), 1.0f32);
assert_approx_eq!(3.0f32.gamma(), 2.0f32);
- assert_approx_eq!(4.0f32.gamma(), 6.0f32);
- assert_approx_eq!(5.0f32.gamma(), 24.0f32);
+ assert_approx_eq!(4.0f32.gamma(), 6.0f32, APPROX_DELTA);
+ assert_approx_eq!(5.0f32.gamma(), 24.0f32, APPROX_DELTA);
assert_approx_eq!(0.5f32.gamma(), consts::PI.sqrt());
- assert_approx_eq!((-0.5f32).gamma(), -2.0 * consts::PI.sqrt());
+ assert_approx_eq!((-0.5f32).gamma(), -2.0 * consts::PI.sqrt(), APPROX_DELTA);
assert_eq!(0.0f32.gamma(), f32::INFINITY);
assert_eq!((-0.0f32).gamma(), f32::NEG_INFINITY);
assert!((-1.0f32).gamma().is_nan());
@@ -218,7 +218,7 @@ fn test_ln_gamma() {
assert_eq!(2.0f32.ln_gamma().1, 1);
assert_approx_eq!(3.0f32.ln_gamma().0, 2.0f32.ln());
assert_eq!(3.0f32.ln_gamma().1, 1);
- assert_approx_eq!((-0.5f32).ln_gamma().0, (2.0 * consts::PI.sqrt()).ln());
+ assert_approx_eq!((-0.5f32).ln_gamma().0, (2.0 * consts::PI.sqrt()).ln(), APPROX_DELTA);
assert_eq!((-0.5f32).ln_gamma().1, -1);
}
diff --git a/src/bootstrap/src/core/build_steps/check.rs b/src/bootstrap/src/core/build_steps/check.rs
index f6653ed..f931aae 100644
--- a/src/bootstrap/src/core/build_steps/check.rs
+++ b/src/bootstrap/src/core/build_steps/check.rs
@@ -84,7 +84,7 @@ fn run(self, builder: &Builder<'_>) {
Kind::Check,
);
- std_cargo(builder, target, stage, &mut cargo);
+ std_cargo(builder, target, &mut cargo);
if matches!(builder.config.cmd, Subcommand::Fix) {
// By default, cargo tries to fix all targets. Tell it not to fix tests until we've added `test` to the sysroot.
cargo.arg("--lib");
@@ -125,7 +125,7 @@ fn run(self, builder: &Builder<'_>) {
Kind::Check,
);
- std_cargo(builder, target, build_compiler.stage, &mut cargo);
+ std_cargo(builder, target, &mut cargo);
// Explicitly pass -p for all dependencies krates -- this will force cargo
// to also check the tests/benches/examples for these crates, rather
diff --git a/src/bootstrap/src/core/build_steps/clippy.rs b/src/bootstrap/src/core/build_steps/clippy.rs
index b119f2d..93c767b 100644
--- a/src/bootstrap/src/core/build_steps/clippy.rs
+++ b/src/bootstrap/src/core/build_steps/clippy.rs
@@ -154,7 +154,7 @@ fn run(self, builder: &Builder<'_>) {
Kind::Clippy,
);
- std_cargo(builder, target, compiler.stage, &mut cargo);
+ std_cargo(builder, target, &mut cargo);
for krate in &*self.crates {
cargo.arg("-p").arg(krate);
diff --git a/src/bootstrap/src/core/build_steps/compile.rs b/src/bootstrap/src/core/build_steps/compile.rs
index 95707e3..e1ee077 100644
--- a/src/bootstrap/src/core/build_steps/compile.rs
+++ b/src/bootstrap/src/core/build_steps/compile.rs
@@ -269,7 +269,7 @@ fn run(self, builder: &Builder<'_>) {
target,
Kind::Build,
);
- std_cargo(builder, target, compiler.stage, &mut cargo);
+ std_cargo(builder, target, &mut cargo);
for krate in &*self.crates {
cargo.arg("-p").arg(krate);
}
@@ -497,7 +497,7 @@ fn compiler_rt_for_profiler(builder: &Builder<'_>) -> PathBuf {
/// Configure cargo to compile the standard library, adding appropriate env vars
/// and such.
-pub fn std_cargo(builder: &Builder<'_>, target: TargetSelection, stage: u32, cargo: &mut Cargo) {
+pub fn std_cargo(builder: &Builder<'_>, target: TargetSelection, cargo: &mut Cargo) {
// rustc already ensures that it builds with the minimum deployment
// target, so ideally we shouldn't need to do anything here.
//
@@ -645,12 +645,8 @@ pub fn std_cargo(builder: &Builder<'_>, target: TargetSelection, stage: u32, car
// built with bitcode so that the produced rlibs can be used for both LTO
// builds (which use bitcode) and non-LTO builds (which use object code).
// So we override the override here!
- //
- // But we don't bother for the stage 0 compiler because it's never used
- // with LTO.
- if stage >= 1 {
- cargo.rustflag("-Cembed-bitcode=yes");
- }
+ cargo.rustflag("-Cembed-bitcode=yes");
+
if builder.config.rust_lto == RustcLto::Off {
cargo.rustflag("-Clto=off");
}
@@ -2388,15 +2384,19 @@ pub fn run_cargo(
let mut deps = Vec::new();
let mut toplevel = Vec::new();
let ok = stream_cargo(builder, cargo, tail_args, &mut |msg| {
- let (filenames, crate_types) = match msg {
+ let (filenames_vec, crate_types) = match msg {
CargoMessage::CompilerArtifact {
filenames,
target: CargoTarget { crate_types },
..
- } => (filenames, crate_types),
+ } => {
+ let mut f: Vec<String> = filenames.into_iter().map(|s| s.into_owned()).collect();
+ f.sort(); // Sort the filenames
+ (f, crate_types)
+ }
_ => return,
};
- for filename in filenames {
+ for filename in filenames_vec {
// Skip files like executables
let mut keep = false;
if filename.ends_with(".lib")
diff --git a/src/bootstrap/src/core/build_steps/dist.rs b/src/bootstrap/src/core/build_steps/dist.rs
index 0465a07..cbbfb6b 100644
--- a/src/bootstrap/src/core/build_steps/dist.rs
+++ b/src/bootstrap/src/core/build_steps/dist.rs
@@ -174,36 +174,12 @@ fn find_files(files: &[&str], path: &[PathBuf]) -> Vec<PathBuf> {
found
}
-fn make_win_dist(
- rust_root: &Path,
- plat_root: &Path,
- target: TargetSelection,
- builder: &Builder<'_>,
-) {
+fn make_win_dist(plat_root: &Path, target: TargetSelection, builder: &Builder<'_>) {
if builder.config.dry_run() {
return;
}
- //Ask gcc where it keeps its stuff
- let mut cmd = command(builder.cc(target));
- cmd.arg("-print-search-dirs");
- let gcc_out = cmd.run_capture_stdout(builder).stdout();
-
- let mut bin_path: Vec<_> = env::split_paths(&env::var_os("PATH").unwrap_or_default()).collect();
- let mut lib_path = Vec::new();
-
- for line in gcc_out.lines() {
- let idx = line.find(':').unwrap();
- let key = &line[..idx];
- let trim_chars: &[_] = &[' ', '='];
- let value = env::split_paths(line[(idx + 1)..].trim_start_matches(trim_chars));
-
- if key == "programs" {
- bin_path.extend(value);
- } else if key == "libraries" {
- lib_path.extend(value);
- }
- }
+ let (bin_path, lib_path) = get_cc_search_dirs(target, builder);
let compiler = if target == "i686-pc-windows-gnu" {
"i686-w64-mingw32-gcc.exe"
@@ -213,12 +189,6 @@ fn make_win_dist(
"gcc.exe"
};
let target_tools = [compiler, "ld.exe", "dlltool.exe", "libwinpthread-1.dll"];
- let mut rustc_dlls = vec!["libwinpthread-1.dll"];
- if target.starts_with("i686-") {
- rustc_dlls.push("libgcc_s_dw2-1.dll");
- } else {
- rustc_dlls.push("libgcc_s_seh-1.dll");
- }
// Libraries necessary to link the windows-gnu toolchains.
// System libraries will be preferred if they are available (see #67429).
@@ -274,25 +244,8 @@ fn make_win_dist(
//Find mingw artifacts we want to bundle
let target_tools = find_files(&target_tools, &bin_path);
- let rustc_dlls = find_files(&rustc_dlls, &bin_path);
let target_libs = find_files(&target_libs, &lib_path);
- // Copy runtime dlls next to rustc.exe
- let rust_bin_dir = rust_root.join("bin/");
- fs::create_dir_all(&rust_bin_dir).expect("creating rust_bin_dir failed");
- for src in &rustc_dlls {
- builder.copy_link_to_folder(src, &rust_bin_dir);
- }
-
- if builder.config.lld_enabled {
- // rust-lld.exe also needs runtime dlls
- let rust_target_bin_dir = rust_root.join("lib/rustlib").join(target).join("bin");
- fs::create_dir_all(&rust_target_bin_dir).expect("creating rust_target_bin_dir failed");
- for src in &rustc_dlls {
- builder.copy_link_to_folder(src, &rust_target_bin_dir);
- }
- }
-
//Copy platform tools to platform-specific bin directory
let plat_target_bin_self_contained_dir =
plat_root.join("lib/rustlib").join(target).join("bin/self-contained");
@@ -320,6 +273,82 @@ fn make_win_dist(
}
}
+fn runtime_dll_dist(rust_root: &Path, target: TargetSelection, builder: &Builder<'_>) {
+ if builder.config.dry_run() {
+ return;
+ }
+
+ let (bin_path, libs_path) = get_cc_search_dirs(target, builder);
+
+ let mut rustc_dlls = vec![];
+ // windows-gnu and windows-gnullvm require different runtime libs
+ if target.ends_with("windows-gnu") {
+ rustc_dlls.push("libwinpthread-1.dll");
+ if target.starts_with("i686-") {
+ rustc_dlls.push("libgcc_s_dw2-1.dll");
+ } else {
+ rustc_dlls.push("libgcc_s_seh-1.dll");
+ }
+ } else if target.ends_with("windows-gnullvm") {
+ rustc_dlls.push("libunwind.dll");
+ } else {
+ panic!("Vendoring of runtime DLLs for `{target}` is not supported`");
+ }
+ // FIXME(#144656): Remove this whole `let ...`
+ let bin_path = if target.ends_with("windows-gnullvm") && builder.host_target != target {
+ bin_path
+ .into_iter()
+ .chain(libs_path.iter().map(|path| path.with_file_name("bin")))
+ .collect()
+ } else {
+ bin_path
+ };
+ let rustc_dlls = find_files(&rustc_dlls, &bin_path);
+
+ // Copy runtime dlls next to rustc.exe
+ let rust_bin_dir = rust_root.join("bin/");
+ fs::create_dir_all(&rust_bin_dir).expect("creating rust_bin_dir failed");
+ for src in &rustc_dlls {
+ builder.copy_link_to_folder(src, &rust_bin_dir);
+ }
+
+ if builder.config.lld_enabled {
+ // rust-lld.exe also needs runtime dlls
+ let rust_target_bin_dir = rust_root.join("lib/rustlib").join(target).join("bin");
+ fs::create_dir_all(&rust_target_bin_dir).expect("creating rust_target_bin_dir failed");
+ for src in &rustc_dlls {
+ builder.copy_link_to_folder(src, &rust_target_bin_dir);
+ }
+ }
+}
+
+fn get_cc_search_dirs(
+ target: TargetSelection,
+ builder: &Builder<'_>,
+) -> (Vec<PathBuf>, Vec<PathBuf>) {
+ //Ask gcc where it keeps its stuff
+ let mut cmd = command(builder.cc(target));
+ cmd.arg("-print-search-dirs");
+ let gcc_out = cmd.run_capture_stdout(builder).stdout();
+
+ let mut bin_path: Vec<_> = env::split_paths(&env::var_os("PATH").unwrap_or_default()).collect();
+ let mut lib_path = Vec::new();
+
+ for line in gcc_out.lines() {
+ let idx = line.find(':').unwrap();
+ let key = &line[..idx];
+ let trim_chars: &[_] = &[' ', '='];
+ let value = env::split_paths(line[(idx + 1)..].trim_start_matches(trim_chars));
+
+ if key == "programs" {
+ bin_path.extend(value);
+ } else if key == "libraries" {
+ lib_path.extend(value);
+ }
+ }
+ (bin_path, lib_path)
+}
+
#[derive(Debug, PartialOrd, Ord, Clone, Hash, PartialEq, Eq)]
pub struct Mingw {
pub host: TargetSelection,
@@ -350,11 +379,7 @@ fn run(self, builder: &Builder<'_>) -> Option<GeneratedTarball> {
let mut tarball = Tarball::new(builder, "rust-mingw", &host.triple);
tarball.set_product_name("Rust MinGW");
- // The first argument is a "temporary directory" which is just
- // thrown away (this contains the runtime DLLs included in the rustc package
- // above) and the second argument is where to place all the MinGW components
- // (which is what we want).
- make_win_dist(&tmpdir(builder), tarball.image_dir(), host, builder);
+ make_win_dist(tarball.image_dir(), host, builder);
Some(tarball.generate())
}
@@ -394,17 +419,14 @@ fn run(self, builder: &Builder<'_>) -> GeneratedTarball {
prepare_image(builder, compiler, tarball.image_dir());
// On MinGW we've got a few runtime DLL dependencies that we need to
- // include. The first argument to this script is where to put these DLLs
- // (the image we're creating), and the second argument is a junk directory
- // to ignore all other MinGW stuff the script creates.
- //
+ // include.
// On 32-bit MinGW we're always including a DLL which needs some extra
// licenses to distribute. On 64-bit MinGW we don't actually distribute
// anything requiring us to distribute a license, but it's likely the
// install will *also* include the rust-mingw package, which also needs
// licenses, so to be safe we just include it here in all MinGW packages.
- if host.ends_with("pc-windows-gnu") && builder.config.dist_include_mingw_linker {
- make_win_dist(tarball.image_dir(), &tmpdir(builder), host, builder);
+ if host.contains("pc-windows-gnu") && builder.config.dist_include_mingw_linker {
+ runtime_dll_dist(tarball.image_dir(), host, builder);
tarball.add_dir(builder.src.join("src/etc/third-party"), "share/doc");
}
diff --git a/src/bootstrap/src/core/build_steps/doc.rs b/src/bootstrap/src/core/build_steps/doc.rs
index d4539a0..9f35249 100644
--- a/src/bootstrap/src/core/build_steps/doc.rs
+++ b/src/bootstrap/src/core/build_steps/doc.rs
@@ -722,7 +722,7 @@ fn doc_std(
let mut cargo =
builder::Cargo::new(builder, compiler, Mode::Std, SourceType::InTree, target, Kind::Doc);
- compile::std_cargo(builder, target, compiler.stage, &mut cargo);
+ compile::std_cargo(builder, target, &mut cargo);
cargo
.arg("--no-deps")
.arg("--target-dir")
diff --git a/src/bootstrap/src/core/build_steps/llvm.rs b/src/bootstrap/src/core/build_steps/llvm.rs
index b2056f5..721ba6c 100644
--- a/src/bootstrap/src/core/build_steps/llvm.rs
+++ b/src/bootstrap/src/core/build_steps/llvm.rs
@@ -1528,8 +1528,12 @@ fn run(self, builder: &Builder<'_>) -> Self::Output {
// FIXME: https://github.com/alexcrichton/cc-rs/issues/545#issuecomment-679242845
let mut count = 0;
- for entry in fs::read_dir(&out_dir).unwrap() {
- let file = entry.unwrap().path().canonicalize().unwrap();
+ let mut files = fs::read_dir(&out_dir)
+ .unwrap()
+ .map(|entry| entry.unwrap().path().canonicalize().unwrap())
+ .collect::<Vec<_>>();
+ files.sort();
+ for file in files {
if file.is_file() && file.extension() == Some(OsStr::new("o")) {
// Object file name without the hash prefix is "Unwind-EHABI", "Unwind-seh" or "libunwind".
let base_name = unhashed_basename(&file);
diff --git a/src/bootstrap/src/core/build_steps/test.rs b/src/bootstrap/src/core/build_steps/test.rs
index 09d2657..b6199c7 100644
--- a/src/bootstrap/src/core/build_steps/test.rs
+++ b/src/bootstrap/src/core/build_steps/test.rs
@@ -2858,7 +2858,7 @@ fn run(self, builder: &Builder<'_>) {
.arg("--manifest-path")
.arg(builder.src.join("library/sysroot/Cargo.toml"));
} else {
- compile::std_cargo(builder, target, compiler.stage, &mut cargo);
+ compile::std_cargo(builder, target, &mut cargo);
}
}
Mode::Rustc => {
diff --git a/src/doc/rustc/src/platform-support/nvptx64-nvidia-cuda.md b/src/doc/rustc/src/platform-support/nvptx64-nvidia-cuda.md
index 106ec56..3659898 100644
--- a/src/doc/rustc/src/platform-support/nvptx64-nvidia-cuda.md
+++ b/src/doc/rustc/src/platform-support/nvptx64-nvidia-cuda.md
@@ -10,6 +10,46 @@
[@RDambrosio016](https://github.com/RDambrosio016)
[@kjetilkjeka](https://github.com/kjetilkjeka)
+## Requirements
+
+This target is `no_std` and will typically be built with crate-type `cdylib` and `-C linker-flavor=llbc`, which generates PTX.
+The necessary components for this workflow are:
+
+- `rustup toolchain add nightly`
+- `rustup component add llvm-tools --toolchain nightly`
+- `rustup component add llvm-bitcode-linker --toolchain nightly`
+
+There are two options for using the core library:
+
+- `rustup component add rust-src --toolchain nightly` and build using `-Z build-std=core`.
+- `rustup target add nvptx64-nvidia-cuda --toolchain nightly`
+
+### Target and features
+
+It is generally necessary to specify the target, such as `-C target-cpu=sm_89`, because the default is very old. This implies two target features: `sm_89` and `ptx78` (and all preceding features within `sm_*` and `ptx*`). Rust will default to using the oldest PTX version that supports the target processor (see [this table](https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#release-notes-ptx-release-history)), which maximizes driver compatibility.
+One can use `-C target-feature=+ptx80` to choose a later PTX version without changing the target (the default in this case, `ptx78`, requires CUDA driver version 11.8, while `ptx80` would require driver version 12.0).
+Later PTX versions may allow more efficient code generation.
+
+Although Rust follows LLVM in representing `ptx*` and `sm_*` as target features, they should be thought of as having crate granularity, set via (either via `-Ctarget-cpu` and optionally `-Ctarget-feature`).
+While the compiler accepts `#[target_feature(enable = "ptx80", enable = "sm_89")]`, it is not supported, may not behave as intended, and may become erroneous in the future.
+
+## Building Rust kernels
+
+A `no_std` crate containing one or more functions with `extern "ptx-kernel"` can be compiled to PTX using a command like the following.
+
+```console
+$ RUSTFLAGS='-Ctarget-cpu=sm_89' cargo +nightly rustc --target=nvptx64-nvidia-cuda -Zbuild-std=core --crate-type=cdylib -- -Clinker-flavor=llbc -Zunstable-options
+```
+
+Intrinsics in `core::arch::nvptx` may use `#[cfg(target_feature = "...")]`, thus it's necessary to use `-Zbuild-std=core` with appropriate `RUSTFLAGS`. The following components are needed for this workflow:
+
+```console
+$ rustup component add rust-src --toolchain nightly
+$ rustup component add llvm-tools --toolchain nightly
+$ rustup component add llvm-bitcode-linker --toolchain nightly
+```
+
+
<!-- FIXME: fill this out
## Requirements
diff --git a/src/librustdoc/clean/types.rs b/src/librustdoc/clean/types.rs
index 782311e..26b087f 100644
--- a/src/librustdoc/clean/types.rs
+++ b/src/librustdoc/clean/types.rs
@@ -480,10 +480,28 @@ pub(crate) fn from_def_id_and_attrs_and_parts(
}
}
+ /// If the item has doc comments from a reexport, returns the item id of that reexport,
+ /// otherwise returns returns the item id.
+ ///
+ /// This is used as a key for caching intra-doc link resolution,
+ /// to prevent two reexports of the same item from using the same cache.
+ pub(crate) fn item_or_reexport_id(&self) -> ItemId {
+ // added documentation on a reexport is always prepended.
+ self.attrs
+ .doc_strings
+ .first()
+ .map(|x| x.item_id)
+ .flatten()
+ .map(ItemId::from)
+ .unwrap_or(self.item_id)
+ }
+
pub(crate) fn links(&self, cx: &Context<'_>) -> Vec<RenderedLink> {
use crate::html::format::{href, link_tooltip};
- let Some(links) = cx.cache().intra_doc_links.get(&self.item_id) else { return vec![] };
+ let Some(links) = cx.cache().intra_doc_links.get(&self.item_or_reexport_id()) else {
+ return vec![];
+ };
links
.iter()
.filter_map(|ItemLink { link: s, link_text, page_id: id, fragment }| {
diff --git a/src/librustdoc/config.rs b/src/librustdoc/config.rs
index fed4296..c52c723 100644
--- a/src/librustdoc/config.rs
+++ b/src/librustdoc/config.rs
@@ -804,8 +804,7 @@ fn println_condition(condition: Condition) {
let scrape_examples_options = ScrapeExamplesOptions::new(matches, dcx);
let with_examples = matches.opt_strs("with-examples");
- let call_locations =
- crate::scrape_examples::load_call_locations(with_examples, dcx, &mut loaded_paths);
+ let call_locations = crate::scrape_examples::load_call_locations(with_examples, dcx);
let doctest_build_args = matches.opt_strs("doctest-build-arg");
let unstable_features =
diff --git a/src/librustdoc/passes/collect_intra_doc_links.rs b/src/librustdoc/passes/collect_intra_doc_links.rs
index c9fa3a4..bcb676c 100644
--- a/src/librustdoc/passes/collect_intra_doc_links.rs
+++ b/src/librustdoc/passes/collect_intra_doc_links.rs
@@ -1082,7 +1082,12 @@ fn resolve_links(&mut self, item: &Item) {
for md_link in preprocessed_markdown_links(&doc) {
let link = self.resolve_link(&doc, item, item_id, module_id, &md_link);
if let Some(link) = link {
- self.cx.cache.intra_doc_links.entry(item.item_id).or_default().insert(link);
+ self.cx
+ .cache
+ .intra_doc_links
+ .entry(item.item_or_reexport_id())
+ .or_default()
+ .insert(link);
}
}
}
diff --git a/src/librustdoc/scrape_examples.rs b/src/librustdoc/scrape_examples.rs
index 4d29c74..9f71d6a 100644
--- a/src/librustdoc/scrape_examples.rs
+++ b/src/librustdoc/scrape_examples.rs
@@ -333,11 +333,14 @@ pub(crate) fn run(
pub(crate) fn load_call_locations(
with_examples: Vec<String>,
dcx: DiagCtxtHandle<'_>,
- loaded_paths: &mut Vec<PathBuf>,
) -> AllCallLocations {
let mut all_calls: AllCallLocations = FxIndexMap::default();
for path in with_examples {
- loaded_paths.push(path.clone().into());
+ // FIXME: Figure out why this line is causing this feature to crash in specific contexts.
+ // Full issue backlog is available here: <https://github.com/rust-lang/rust/pull/144600>.
+ //
+ // Can be checked with `tests/run-make/rustdoc-scrape-examples-paths`.
+ // loaded_paths.push(path.clone().into());
let bytes = match fs::read(&path) {
Ok(bytes) => bytes,
Err(e) => dcx.fatal(format!("failed to load examples: {e}")),
diff --git a/src/tools/compiletest/src/runtest.rs b/src/tools/compiletest/src/runtest.rs
index 84c6df5..f283a62 100644
--- a/src/tools/compiletest/src/runtest.rs
+++ b/src/tools/compiletest/src/runtest.rs
@@ -2567,6 +2567,11 @@ fn normalize_output(&self, output: &str, custom_rules: &[(String, String)]) -> S
})
.into_owned();
+ // Normalize thread IDs in panic messages
+ normalized = static_regex!(r"thread '(?P<name>.*?)' \((rtid )?\d+\) panicked")
+ .replace_all(&normalized, "thread '$name' ($$TID) panicked")
+ .into_owned();
+
normalized = normalized.replace("\t", "\\t"); // makes tabs visible
// Remove test annotations like `//~ ERROR text` from the output,
diff --git a/src/tools/miri/src/intrinsics/mod.rs b/src/tools/miri/src/intrinsics/mod.rs
index b5e8146..e0e09ac 100644
--- a/src/tools/miri/src/intrinsics/mod.rs
+++ b/src/tools/miri/src/intrinsics/mod.rs
@@ -3,20 +3,16 @@
mod atomic;
mod simd;
-use std::ops::Neg;
-
use rand::Rng;
use rustc_abi::Size;
-use rustc_apfloat::ieee::{IeeeFloat, Semantics};
use rustc_apfloat::{self, Float, Round};
use rustc_middle::mir;
-use rustc_middle::ty::{self, FloatTy, ScalarInt};
+use rustc_middle::ty::{self, FloatTy};
use rustc_span::{Symbol, sym};
use self::atomic::EvalContextExt as _;
use self::helpers::{ToHost, ToSoft};
use self::simd::EvalContextExt as _;
-use crate::math::{IeeeExt, apply_random_float_error_ulp};
use crate::*;
/// Check that the number of args is what we expect.
@@ -209,7 +205,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(this, intrinsic_name, &[f]).unwrap_or_else(|| {
+ let res = math::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();
@@ -227,7 +223,7 @@ fn emulate_intrinsic_by_name(
// Apply a relative error of 4ULP to introduce some non-determinism
// simulating imprecise implementations and optimizations.
- let res = apply_random_float_error_ulp(
+ let res = math::apply_random_float_error_ulp(
this,
res,
2, // log2(4)
@@ -235,7 +231,7 @@ fn emulate_intrinsic_by_name(
// Clamp the result to the guaranteed range of this function according to the C standard,
// if any.
- clamp_float_value(intrinsic_name, res)
+ math::clamp_float_value(intrinsic_name, res)
});
let res = this.adjust_nan(res, &[f]);
this.write_scalar(res, dest)?;
@@ -253,7 +249,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(this, intrinsic_name, &[f]).unwrap_or_else(|| {
+ let res = math::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();
@@ -271,7 +267,7 @@ fn emulate_intrinsic_by_name(
// Apply a relative error of 4ULP to introduce some non-determinism
// simulating imprecise implementations and optimizations.
- let res = apply_random_float_error_ulp(
+ let res = math::apply_random_float_error_ulp(
this,
res,
2, // log2(4)
@@ -279,7 +275,7 @@ fn emulate_intrinsic_by_name(
// Clamp the result to the guaranteed range of this function according to the C standard,
// if any.
- clamp_float_value(intrinsic_name, res)
+ math::clamp_float_value(intrinsic_name, res)
});
let res = this.adjust_nan(res, &[f]);
this.write_scalar(res, dest)?;
@@ -330,16 +326,17 @@ 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(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();
+ let res =
+ math::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();
- // Apply a relative error of 4ULP to introduce some non-determinism
- // simulating imprecise implementations and optimizations.
- apply_random_float_error_ulp(
- this, res, 2, // log2(4)
- )
- });
+ // Apply a relative error of 4ULP to introduce some non-determinism
+ // simulating imprecise implementations and optimizations.
+ math::apply_random_float_error_ulp(
+ this, res, 2, // log2(4)
+ )
+ });
let res = this.adjust_nan(res, &[f1, f2]);
this.write_scalar(res, dest)?;
}
@@ -348,16 +345,17 @@ 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(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();
+ let res =
+ math::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();
- // Apply a relative error of 4ULP to introduce some non-determinism
- // simulating imprecise implementations and optimizations.
- apply_random_float_error_ulp(
- this, res, 2, // log2(4)
- )
- });
+ // Apply a relative error of 4ULP to introduce some non-determinism
+ // simulating imprecise implementations and optimizations.
+ math::apply_random_float_error_ulp(
+ this, res, 2, // log2(4)
+ )
+ });
let res = this.adjust_nan(res, &[f1, f2]);
this.write_scalar(res, dest)?;
}
@@ -367,13 +365,13 @@ 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(this, f, i).unwrap_or_else(|| {
+ let res = math::fixed_powi_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();
// Apply a relative error of 4ULP to introduce some non-determinism
// simulating imprecise implementations and optimizations.
- apply_random_float_error_ulp(
+ math::apply_random_float_error_ulp(
this, res, 2, // log2(4)
)
});
@@ -385,13 +383,13 @@ 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(this, f, i).unwrap_or_else(|| {
+ let res = math::fixed_powi_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();
// Apply a relative error of 4ULP to introduce some non-determinism
// simulating imprecise implementations and optimizations.
- apply_random_float_error_ulp(
+ math::apply_random_float_error_ulp(
this, res, 2, // log2(4)
)
});
@@ -448,7 +446,7 @@ fn emulate_intrinsic_by_name(
}
// Apply a relative error of 4ULP to simulate non-deterministic precision loss
// due to optimizations.
- let res = apply_random_float_error_to_imm(this, res, 2 /* log2(4) */)?;
+ let res = math::apply_random_float_error_to_imm(this, res, 2 /* log2(4) */)?;
this.write_immediate(*res, dest)?;
}
@@ -485,133 +483,3 @@ fn emulate_intrinsic_by_name(
interp_ok(EmulateItemResult::NeedsReturn)
}
}
-
-/// Applies a random ULP floating point error to `val` and returns the new value.
-/// So if you want an X ULP error, `ulp_exponent` should be log2(X).
-///
-/// Will fail if `val` is not a floating point number.
-fn apply_random_float_error_to_imm<'tcx>(
- ecx: &mut MiriInterpCx<'tcx>,
- val: ImmTy<'tcx>,
- ulp_exponent: u32,
-) -> InterpResult<'tcx, ImmTy<'tcx>> {
- let scalar = val.to_scalar_int()?;
- let res: ScalarInt = match val.layout.ty.kind() {
- ty::Float(FloatTy::F16) =>
- apply_random_float_error_ulp(ecx, scalar.to_f16(), ulp_exponent).into(),
- ty::Float(FloatTy::F32) =>
- apply_random_float_error_ulp(ecx, scalar.to_f32(), ulp_exponent).into(),
- ty::Float(FloatTy::F64) =>
- apply_random_float_error_ulp(ecx, scalar.to_f64(), ulp_exponent).into(),
- ty::Float(FloatTy::F128) =>
- apply_random_float_error_ulp(ecx, scalar.to_f128(), ulp_exponent).into(),
- _ => bug!("intrinsic called with non-float input type"),
- };
-
- interp_ok(ImmTy::from_scalar_int(res, val.layout))
-}
-
-/// For the intrinsics:
-/// - sinf32, sinf64
-/// - cosf32, cosf64
-/// - expf32, expf64, exp2f32, exp2f64
-/// - 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();
- Some(match (intrinsic_name, args) {
- // cos(+- 0) = 1
- ("cosf32" | "cosf64", [input]) if input.is_zero() => one,
-
- // e^0 = 1
- ("expf32" | "expf64" | "exp2f32" | "exp2f64", [input]) if input.is_zero() => one,
-
- // (-1)^(±INF) = 1
- ("powf32" | "powf64", [base, exp]) if *base == -one && exp.is_infinite() => one,
-
- // 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", [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.
- _ => 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>(
- 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 }
- }
-
- _ => return None,
- })
-}
-
-/// Given an floating-point operation and a floating-point value, clamps the result to the output
-/// range of the given operation.
-fn clamp_float_value<S: Semantics>(intrinsic_name: &str, val: IeeeFloat<S>) -> IeeeFloat<S> {
- match intrinsic_name {
- // sin and cos: [-1, 1]
- "sinf32" | "cosf32" | "sinf64" | "cosf64" =>
- val.clamp(IeeeFloat::<S>::one().neg(), IeeeFloat::<S>::one()),
- // exp: [0, +INF]
- "expf32" | "exp2f32" | "expf64" | "exp2f64" =>
- IeeeFloat::<S>::maximum(val, IeeeFloat::<S>::ZERO),
- _ => val,
- }
-}
diff --git a/src/tools/miri/src/lib.rs b/src/tools/miri/src/lib.rs
index 2b92c25..9272cd2 100644
--- a/src/tools/miri/src/lib.rs
+++ b/src/tools/miri/src/lib.rs
@@ -1,3 +1,4 @@
+#![cfg_attr(bootstrap, feature(strict_overflow_ops))]
#![feature(abort_unwind)]
#![feature(cfg_select)]
#![feature(rustc_private)]
@@ -11,13 +12,14 @@
#![feature(variant_count)]
#![feature(yeet_expr)]
#![feature(nonzero_ops)]
-#![feature(strict_overflow_ops)]
#![feature(pointer_is_aligned_to)]
#![feature(ptr_metadata)]
#![feature(unqualified_local_imports)]
#![feature(derive_coerce_pointee)]
#![feature(arbitrary_self_types)]
#![feature(iter_advance_by)]
+#![feature(f16)]
+#![feature(f128)]
// Configure clippy and other lints
#![allow(
clippy::collapsible_else_if,
diff --git a/src/tools/miri/src/math.rs b/src/tools/miri/src/math.rs
index e9e5a107..3eee6b8 100644
--- a/src/tools/miri/src/math.rs
+++ b/src/tools/miri/src/math.rs
@@ -1,6 +1,9 @@
+use std::ops::Neg;
+use std::{f16, f32, f64, f128};
+
use rand::Rng as _;
use rustc_apfloat::Float as _;
-use rustc_apfloat::ieee::IeeeFloat;
+use rustc_apfloat::ieee::{DoubleS, HalfS, IeeeFloat, QuadS, Semantics, SingleS};
use rustc_middle::ty::{self, FloatTy, ScalarInt};
use crate::*;
@@ -50,29 +53,236 @@ pub(crate) fn apply_random_float_error_ulp<F: rustc_apfloat::Float>(
apply_random_float_error(ecx, val, err_scale)
}
-/// Applies a random 16ULP floating point error to `val` and returns the new value.
+/// Applies a random ULP floating point error to `val` and returns the new value.
+/// So if you want an X ULP error, `ulp_exponent` should be log2(X).
+///
/// Will fail if `val` is not a floating point number.
pub(crate) fn apply_random_float_error_to_imm<'tcx>(
ecx: &mut MiriInterpCx<'tcx>,
val: ImmTy<'tcx>,
ulp_exponent: u32,
) -> InterpResult<'tcx, ImmTy<'tcx>> {
+ let this = ecx.eval_context_mut();
let scalar = val.to_scalar_int()?;
let res: ScalarInt = match val.layout.ty.kind() {
ty::Float(FloatTy::F16) =>
- apply_random_float_error_ulp(ecx, scalar.to_f16(), ulp_exponent).into(),
+ apply_random_float_error_ulp(this, scalar.to_f16(), ulp_exponent).into(),
ty::Float(FloatTy::F32) =>
- apply_random_float_error_ulp(ecx, scalar.to_f32(), ulp_exponent).into(),
+ apply_random_float_error_ulp(this, scalar.to_f32(), ulp_exponent).into(),
ty::Float(FloatTy::F64) =>
- apply_random_float_error_ulp(ecx, scalar.to_f64(), ulp_exponent).into(),
+ apply_random_float_error_ulp(this, scalar.to_f64(), ulp_exponent).into(),
ty::Float(FloatTy::F128) =>
- apply_random_float_error_ulp(ecx, scalar.to_f128(), ulp_exponent).into(),
+ apply_random_float_error_ulp(this, scalar.to_f128(), ulp_exponent).into(),
_ => bug!("intrinsic called with non-float input type"),
};
interp_ok(ImmTy::from_scalar_int(res, val.layout))
}
+/// Given a floating-point operation and a floating-point value, clamps the result to the output
+/// range of the given operation according to the C standard, if any.
+pub(crate) fn clamp_float_value<S: Semantics>(
+ intrinsic_name: &str,
+ val: IeeeFloat<S>,
+) -> IeeeFloat<S>
+where
+ IeeeFloat<S>: IeeeExt,
+{
+ let zero = IeeeFloat::<S>::ZERO;
+ let one = IeeeFloat::<S>::one();
+ let two = IeeeFloat::<S>::two();
+ let pi = IeeeFloat::<S>::pi();
+ let pi_over_2 = (pi / two).value;
+
+ match intrinsic_name {
+ // sin, cos, tanh: [-1, 1]
+ #[rustfmt::skip]
+ | "sinf32"
+ | "sinf64"
+ | "cosf32"
+ | "cosf64"
+ | "tanhf"
+ | "tanh"
+ => val.clamp(one.neg(), one),
+
+ // exp: [0, +INF)
+ "expf32" | "exp2f32" | "expf64" | "exp2f64" => val.maximum(zero),
+
+ // cosh: [1, +INF)
+ "coshf" | "cosh" => val.maximum(one),
+
+ // acos: [0, π]
+ "acosf" | "acos" => val.clamp(zero, pi),
+
+ // asin: [-π, +π]
+ "asinf" | "asin" => val.clamp(pi.neg(), pi),
+
+ // atan: (-π/2, +π/2)
+ "atanf" | "atan" => val.clamp(pi_over_2.neg(), pi_over_2),
+
+ // erfc: (-1, 1)
+ "erff" | "erf" => val.clamp(one.neg(), one),
+
+ // erfc: (0, 2)
+ "erfcf" | "erfc" => val.clamp(zero, two),
+
+ // atan2(y, x): arctan(y/x) in [−π, +π]
+ "atan2f" | "atan2" => val.clamp(pi.neg(), pi),
+
+ _ => val,
+ }
+}
+
+/// For the intrinsics:
+/// - sinf32, sinf64, sinhf, sinh
+/// - cosf32, cosf64, coshf, cosh
+/// - tanhf, tanh, atanf, atan, atan2f, atan2
+/// - expf32, expf64, exp2f32, exp2f64
+/// - logf32, logf64, log2f32, log2f64, log10f32, log10f64
+/// - powf32, powf64
+/// - erff, erf, erfcf, erfc
+/// - hypotf, hypot
+///
+/// # 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.
+pub(crate) fn fixed_float_value<S: Semantics>(
+ ecx: &mut MiriInterpCx<'_>,
+ intrinsic_name: &str,
+ args: &[IeeeFloat<S>],
+) -> Option<IeeeFloat<S>>
+where
+ IeeeFloat<S>: IeeeExt,
+{
+ let this = ecx.eval_context_mut();
+ let one = IeeeFloat::<S>::one();
+ let two = IeeeFloat::<S>::two();
+ let three = IeeeFloat::<S>::three();
+ let pi = IeeeFloat::<S>::pi();
+ let pi_over_2 = (pi / two).value;
+ let pi_over_4 = (pi_over_2 / two).value;
+
+ Some(match (intrinsic_name, args) {
+ // cos(±0) and cosh(±0)= 1
+ ("cosf32" | "cosf64" | "coshf" | "cosh", [input]) if input.is_zero() => one,
+
+ // e^0 = 1
+ ("expf32" | "expf64" | "exp2f32" | "exp2f64", [input]) if input.is_zero() => one,
+
+ // tanh(±INF) = ±1
+ ("tanhf" | "tanh", [input]) if input.is_infinite() => one.copy_sign(*input),
+
+ // atan(±INF) = ±π/2
+ ("atanf" | "atan", [input]) if input.is_infinite() => pi_over_2.copy_sign(*input),
+
+ // erf(±INF) = ±1
+ ("erff" | "erf", [input]) if input.is_infinite() => one.copy_sign(*input),
+
+ // erfc(-INF) = 2
+ ("erfcf" | "erfc", [input]) if input.is_neg_infinity() => (one + one).value,
+
+ // hypot(x, ±0) = abs(x), if x is not a NaN.
+ ("_hypotf" | "hypotf" | "_hypot" | "hypot", [x, y]) if !x.is_nan() && y.is_zero() =>
+ x.abs(),
+
+ // atan2(±0,−0) = ±π.
+ // atan2(±0, y) = ±π for y < 0.
+ // Must check for non NaN because `y.is_negative()` also applies to NaN.
+ ("atan2f" | "atan2", [x, y]) if (x.is_zero() && (y.is_negative() && !y.is_nan())) =>
+ pi.copy_sign(*x),
+
+ // atan2(±x,−∞) = ±π for finite x > 0.
+ ("atan2f" | "atan2", [x, y])
+ if (!x.is_zero() && !x.is_infinite()) && y.is_neg_infinity() =>
+ pi.copy_sign(*x),
+
+ // atan2(x, ±0) = −π/2 for x < 0.
+ // atan2(x, ±0) = π/2 for x > 0.
+ ("atan2f" | "atan2", [x, y]) if !x.is_zero() && y.is_zero() => pi_over_2.copy_sign(*x),
+
+ //atan2(±∞, −∞) = ±3π/4
+ ("atan2f" | "atan2", [x, y]) if x.is_infinite() && y.is_neg_infinity() =>
+ (pi_over_4 * three).value.copy_sign(*x),
+
+ //atan2(±∞, +∞) = ±π/4
+ ("atan2f" | "atan2", [x, y]) if x.is_infinite() && y.is_pos_infinity() =>
+ pi_over_4.copy_sign(*x),
+
+ // atan2(±∞, y) returns ±π/2 for finite y.
+ ("atan2f" | "atan2", [x, y]) if x.is_infinite() && (!y.is_infinite() && !y.is_nan()) =>
+ pi_over_2.copy_sign(*x),
+
+ // (-1)^(±INF) = 1
+ ("powf32" | "powf64", [base, exp]) if *base == -one && exp.is_infinite() => one,
+
+ // 1^y = 1 for any y, even a NaN
+ ("powf32" | "powf64", [base, exp]) if *base == one => {
+ let rng = this.machine.rng.get_mut();
+ // SNaN exponents get special treatment: they might return 1, or a NaN.
+ let return_nan = exp.is_signaling() && this.machine.float_nondet && rng.random();
+ // Handle both the musl and glibc cases non-deterministically.
+ if return_nan { this.generate_nan(args) } else { one }
+ }
+
+ // x^(±0) = 1 for any x, even a NaN
+ ("powf32" | "powf64", [base, exp]) if exp.is_zero() => {
+ let rng = this.machine.rng.get_mut();
+ // SNaN bases get special treatment: they might return 1, or a NaN.
+ let return_nan = base.is_signaling() && this.machine.float_nondet && rng.random();
+ // Handle both the musl and glibc cases non-deterministically.
+ if return_nan { this.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.
+ _ => 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`.
+pub(crate) fn fixed_powi_value<S: Semantics>(
+ ecx: &mut MiriInterpCx<'_>,
+ base: IeeeFloat<S>,
+ exp: i32,
+) -> Option<IeeeFloat<S>>
+where
+ IeeeFloat<S>: IeeeExt,
+{
+ 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.)
+ Some(if return_nan { ecx.generate_nan(&[base]) } else { one })
+ }
+
+ _ => return None,
+ }
+}
+
pub(crate) fn sqrt<S: rustc_apfloat::ieee::Semantics>(x: IeeeFloat<S>) -> IeeeFloat<S> {
match x.category() {
// preserve zero sign
@@ -155,19 +365,49 @@ pub(crate) fn sqrt<S: rustc_apfloat::ieee::Semantics>(x: IeeeFloat<S>) -> IeeeFl
}
}
-/// Extend functionality of rustc_apfloat softfloats
+/// Extend functionality of `rustc_apfloat` softfloats for IEEE float types.
pub trait IeeeExt: rustc_apfloat::Float {
+ // Some values we use:
+
#[inline]
fn one() -> Self {
Self::from_u128(1).value
}
#[inline]
+ fn two() -> Self {
+ Self::from_u128(2).value
+ }
+
+ #[inline]
+ fn three() -> Self {
+ Self::from_u128(3).value
+ }
+
+ fn pi() -> Self;
+
+ #[inline]
fn clamp(self, min: Self, max: Self) -> Self {
self.maximum(min).minimum(max)
}
}
-impl<S: rustc_apfloat::ieee::Semantics> IeeeExt for IeeeFloat<S> {}
+
+macro_rules! impl_ieee_pi {
+ ($float_ty:ident, $semantic:ty) => {
+ impl IeeeExt for IeeeFloat<$semantic> {
+ #[inline]
+ fn pi() -> Self {
+ // We take the value from the standard library as the most reasonable source for an exact π here.
+ Self::from_bits($float_ty::consts::PI.to_bits() as _)
+ }
+ }
+ };
+}
+
+impl_ieee_pi!(f16, HalfS);
+impl_ieee_pi!(f32, SingleS);
+impl_ieee_pi!(f64, DoubleS);
+impl_ieee_pi!(f128, QuadS);
#[cfg(test)]
mod tests {
diff --git a/src/tools/miri/src/shims/foreign_items.rs b/src/tools/miri/src/shims/foreign_items.rs
index 21545b6..bf4db2d 100644
--- a/src/tools/miri/src/shims/foreign_items.rs
+++ b/src/tools/miri/src/shims/foreign_items.rs
@@ -17,6 +17,7 @@
use self::helpers::{ToHost, ToSoft};
use super::alloc::EvalContextExt as _;
use super::backtrace::EvalContextExt as _;
+use crate::helpers::EvalContextExt as _;
use crate::*;
/// Type of dynamic symbols (for `dlsym` et al)
@@ -779,33 +780,38 @@ fn emulate_foreign_item_inner(
=> {
let [f] = this.check_shim_sig_lenient(abi, CanonAbi::C , link_name, args)?;
let f = this.read_scalar(f)?.to_f32()?;
- // Using host floats (but it's fine, these operations do not have guaranteed precision).
- let f_host = f.to_host();
- let res = match link_name.as_str() {
- "cbrtf" => f_host.cbrt(),
- "coshf" => f_host.cosh(),
- "sinhf" => f_host.sinh(),
- "tanf" => f_host.tan(),
- "tanhf" => f_host.tanh(),
- "acosf" => f_host.acos(),
- "asinf" => f_host.asin(),
- "atanf" => f_host.atan(),
- "log1pf" => f_host.ln_1p(),
- "expm1f" => f_host.exp_m1(),
- "tgammaf" => f_host.gamma(),
- "erff" => f_host.erf(),
- "erfcf" => f_host.erfc(),
- _ => bug!(),
- };
- let res = res.to_soft();
- // Apply a relative error of 16ULP to introduce some non-determinism
- // simulating imprecise implementations and optimizations.
- // FIXME: temporarily disabled as it breaks std tests.
- // let res = math::apply_random_float_error_ulp(
- // this,
- // res,
- // 4, // log2(16)
- // );
+
+ let res = math::fixed_float_value(this, link_name.as_str(), &[f]).unwrap_or_else(|| {
+ // Using host floats (but it's fine, these operations do not have
+ // guaranteed precision).
+ let f_host = f.to_host();
+ let res = match link_name.as_str() {
+ "cbrtf" => f_host.cbrt(),
+ "coshf" => f_host.cosh(),
+ "sinhf" => f_host.sinh(),
+ "tanf" => f_host.tan(),
+ "tanhf" => f_host.tanh(),
+ "acosf" => f_host.acos(),
+ "asinf" => f_host.asin(),
+ "atanf" => f_host.atan(),
+ "log1pf" => f_host.ln_1p(),
+ "expm1f" => f_host.exp_m1(),
+ "tgammaf" => f_host.gamma(),
+ "erff" => f_host.erf(),
+ "erfcf" => f_host.erfc(),
+ _ => bug!(),
+ };
+ let res = res.to_soft();
+ // Apply a relative error of 4ULP to introduce some non-determinism
+ // simulating imprecise implementations and optimizations.
+ let res = math::apply_random_float_error_ulp(
+ this, res, 2, // log2(4)
+ );
+
+ // Clamp the result to the guaranteed range of this function according to the C standard,
+ // if any.
+ math::clamp_float_value(link_name.as_str(), res)
+ });
let res = this.adjust_nan(res, &[f]);
this.write_scalar(res, dest)?;
}
@@ -818,24 +824,28 @@ fn emulate_foreign_item_inner(
let [f1, f2] = this.check_shim_sig_lenient(abi, CanonAbi::C , link_name, args)?;
let f1 = this.read_scalar(f1)?.to_f32()?;
let f2 = this.read_scalar(f2)?.to_f32()?;
- // underscore case for windows, here and below
- // (see https://docs.microsoft.com/en-us/cpp/c-runtime-library/reference/floating-point-primitives?view=vs-2019)
- // Using host floats (but it's fine, these operations do not have guaranteed precision).
- let res = match link_name.as_str() {
- "_hypotf" | "hypotf" => f1.to_host().hypot(f2.to_host()).to_soft(),
- "atan2f" => f1.to_host().atan2(f2.to_host()).to_soft(),
- #[allow(deprecated)]
- "fdimf" => f1.to_host().abs_sub(f2.to_host()).to_soft(),
- _ => bug!(),
- };
- // Apply a relative error of 16ULP to introduce some non-determinism
- // simulating imprecise implementations and optimizations.
- // FIXME: temporarily disabled as it breaks std tests.
- // let res = math::apply_random_float_error_ulp(
- // this,
- // res,
- // 4, // log2(16)
- // );
+
+ let res = math::fixed_float_value(this, link_name.as_str(), &[f1, f2]).unwrap_or_else(|| {
+ let res = match link_name.as_str() {
+ // underscore case for windows, here and below
+ // (see https://docs.microsoft.com/en-us/cpp/c-runtime-library/reference/floating-point-primitives?view=vs-2019)
+ // Using host floats (but it's fine, these operations do not have guaranteed precision).
+ "_hypotf" | "hypotf" => f1.to_host().hypot(f2.to_host()).to_soft(),
+ "atan2f" => f1.to_host().atan2(f2.to_host()).to_soft(),
+ #[allow(deprecated)]
+ "fdimf" => f1.to_host().abs_sub(f2.to_host()).to_soft(),
+ _ => bug!(),
+ };
+ // Apply a relative error of 4ULP to introduce some non-determinism
+ // simulating imprecise implementations and optimizations.
+ let res = math::apply_random_float_error_ulp(
+ this, res, 2, // log2(4)
+ );
+
+ // Clamp the result to the guaranteed range of this function according to the C standard,
+ // if any.
+ math::clamp_float_value(link_name.as_str(), res)
+ });
let res = this.adjust_nan(res, &[f1, f2]);
this.write_scalar(res, dest)?;
}
@@ -856,33 +866,38 @@ fn emulate_foreign_item_inner(
=> {
let [f] = this.check_shim_sig_lenient(abi, CanonAbi::C , link_name, args)?;
let f = this.read_scalar(f)?.to_f64()?;
- // Using host floats (but it's fine, these operations do not have guaranteed precision).
- let f_host = f.to_host();
- let res = match link_name.as_str() {
- "cbrt" => f_host.cbrt(),
- "cosh" => f_host.cosh(),
- "sinh" => f_host.sinh(),
- "tan" => f_host.tan(),
- "tanh" => f_host.tanh(),
- "acos" => f_host.acos(),
- "asin" => f_host.asin(),
- "atan" => f_host.atan(),
- "log1p" => f_host.ln_1p(),
- "expm1" => f_host.exp_m1(),
- "tgamma" => f_host.gamma(),
- "erf" => f_host.erf(),
- "erfc" => f_host.erfc(),
- _ => bug!(),
- };
- let res = res.to_soft();
- // Apply a relative error of 16ULP to introduce some non-determinism
- // simulating imprecise implementations and optimizations.
- // FIXME: temporarily disabled as it breaks std tests.
- // let res = math::apply_random_float_error_ulp(
- // this,
- // res.to_soft(),
- // 4, // log2(16)
- // );
+
+ let res = math::fixed_float_value(this, link_name.as_str(), &[f]).unwrap_or_else(|| {
+ // Using host floats (but it's fine, these operations do not have
+ // guaranteed precision).
+ let f_host = f.to_host();
+ let res = match link_name.as_str() {
+ "cbrt" => f_host.cbrt(),
+ "cosh" => f_host.cosh(),
+ "sinh" => f_host.sinh(),
+ "tan" => f_host.tan(),
+ "tanh" => f_host.tanh(),
+ "acos" => f_host.acos(),
+ "asin" => f_host.asin(),
+ "atan" => f_host.atan(),
+ "log1p" => f_host.ln_1p(),
+ "expm1" => f_host.exp_m1(),
+ "tgamma" => f_host.gamma(),
+ "erf" => f_host.erf(),
+ "erfc" => f_host.erfc(),
+ _ => bug!(),
+ };
+ let res = res.to_soft();
+ // Apply a relative error of 4ULP to introduce some non-determinism
+ // simulating imprecise implementations and optimizations.
+ let res = math::apply_random_float_error_ulp(
+ this, res, 2, // log2(4)
+ );
+
+ // Clamp the result to the guaranteed range of this function according to the C standard,
+ // if any.
+ math::clamp_float_value(link_name.as_str(), res)
+ });
let res = this.adjust_nan(res, &[f]);
this.write_scalar(res, dest)?;
}
@@ -895,24 +910,28 @@ fn emulate_foreign_item_inner(
let [f1, f2] = this.check_shim_sig_lenient(abi, CanonAbi::C , link_name, args)?;
let f1 = this.read_scalar(f1)?.to_f64()?;
let f2 = this.read_scalar(f2)?.to_f64()?;
- // underscore case for windows, here and below
- // (see https://docs.microsoft.com/en-us/cpp/c-runtime-library/reference/floating-point-primitives?view=vs-2019)
- // Using host floats (but it's fine, these operations do not have guaranteed precision).
- let res = match link_name.as_str() {
- "_hypot" | "hypot" => f1.to_host().hypot(f2.to_host()).to_soft(),
- "atan2" => f1.to_host().atan2(f2.to_host()).to_soft(),
- #[allow(deprecated)]
- "fdim" => f1.to_host().abs_sub(f2.to_host()).to_soft(),
- _ => bug!(),
- };
- // Apply a relative error of 16ULP to introduce some non-determinism
- // simulating imprecise implementations and optimizations.
- // FIXME: temporarily disabled as it breaks std tests.
- // let res = math::apply_random_float_error_ulp(
- // this,
- // res,
- // 4, // log2(16)
- // );
+
+ let res = math::fixed_float_value(this, link_name.as_str(), &[f1, f2]).unwrap_or_else(|| {
+ let res = match link_name.as_str() {
+ // underscore case for windows, here and below
+ // (see https://docs.microsoft.com/en-us/cpp/c-runtime-library/reference/floating-point-primitives?view=vs-2019)
+ // Using host floats (but it's fine, these operations do not have guaranteed precision).
+ "_hypot" | "hypot" => f1.to_host().hypot(f2.to_host()).to_soft(),
+ "atan2" => f1.to_host().atan2(f2.to_host()).to_soft(),
+ #[allow(deprecated)]
+ "fdim" => f1.to_host().abs_sub(f2.to_host()).to_soft(),
+ _ => bug!(),
+ };
+ // Apply a relative error of 4ULP to introduce some non-determinism
+ // simulating imprecise implementations and optimizations.
+ let res = math::apply_random_float_error_ulp(
+ this, res, 2, // log2(4)
+ );
+
+ // Clamp the result to the guaranteed range of this function according to the C standard,
+ // if any.
+ math::clamp_float_value(link_name.as_str(), res)
+ });
let res = this.adjust_nan(res, &[f1, f2]);
this.write_scalar(res, dest)?;
}
@@ -938,11 +957,14 @@ fn emulate_foreign_item_inner(
// Using host floats (but it's fine, these operations do not have guaranteed precision).
let (res, sign) = x.to_host().ln_gamma();
this.write_int(sign, &signp)?;
+
let res = res.to_soft();
- // Apply a relative error of 16ULP to introduce some non-determinism
+ // Apply a relative error of 4ULP to introduce some non-determinism
// simulating imprecise implementations and optimizations.
- // FIXME: temporarily disabled as it breaks std tests.
- // let res = math::apply_random_float_error_ulp(this, res, 4 /* log2(16) */);
+ let res = math::apply_random_float_error_ulp(this, res, 2 /* log2(4) */);
+ // Clamp the result to the guaranteed range of this function according to the C standard,
+ // if any.
+ let res = math::clamp_float_value(link_name.as_str(), res);
let res = this.adjust_nan(res, &[x]);
this.write_scalar(res, dest)?;
}
@@ -954,11 +976,14 @@ fn emulate_foreign_item_inner(
// Using host floats (but it's fine, these operations do not have guaranteed precision).
let (res, sign) = x.to_host().ln_gamma();
this.write_int(sign, &signp)?;
+
let res = res.to_soft();
- // Apply a relative error of 16ULP to introduce some non-determinism
+ // Apply a relative error of 4ULP to introduce some non-determinism
// simulating imprecise implementations and optimizations.
- // FIXME: temporarily disabled as it breaks std tests.
- // let res = math::apply_random_float_error_ulp(this, res, 4 /* log2(16) */);
+ let res = math::apply_random_float_error_ulp(this, res, 2 /* log2(4) */);
+ // Clamp the result to the guaranteed range of this function according to the C standard,
+ // if any.
+ let res = math::clamp_float_value(link_name.as_str(), res);
let res = this.adjust_nan(res, &[x]);
this.write_scalar(res, dest)?;
}
diff --git a/src/tools/miri/tests/fail/function_calls/exported_symbol_bad_unwind1.stderr b/src/tools/miri/tests/fail/function_calls/exported_symbol_bad_unwind1.stderr
index 9e6abf2..afabb85 100644
--- a/src/tools/miri/tests/fail/function_calls/exported_symbol_bad_unwind1.stderr
+++ b/src/tools/miri/tests/fail/function_calls/exported_symbol_bad_unwind1.stderr
@@ -1,5 +1,5 @@
-thread 'main' panicked at tests/fail/function_calls/exported_symbol_bad_unwind1.rs:LL:CC:
+thread 'main' ($TID) panicked at tests/fail/function_calls/exported_symbol_bad_unwind1.rs:LL:CC:
explicit panic
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
note: in Miri, you may have to set `MIRIFLAGS=-Zmiri-env-forward=RUST_BACKTRACE` for the environment variable to have an effect
diff --git a/src/tools/miri/tests/fail/function_calls/exported_symbol_bad_unwind2.both.stderr b/src/tools/miri/tests/fail/function_calls/exported_symbol_bad_unwind2.both.stderr
index 14b3be0..1246ad5 100644
--- a/src/tools/miri/tests/fail/function_calls/exported_symbol_bad_unwind2.both.stderr
+++ b/src/tools/miri/tests/fail/function_calls/exported_symbol_bad_unwind2.both.stderr
@@ -1,10 +1,10 @@
-thread 'main' panicked at tests/fail/function_calls/exported_symbol_bad_unwind2.rs:LL:CC:
+thread 'main' ($TID) panicked at tests/fail/function_calls/exported_symbol_bad_unwind2.rs:LL:CC:
explicit panic
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
note: in Miri, you may have to set `MIRIFLAGS=-Zmiri-env-forward=RUST_BACKTRACE` for the environment variable to have an effect
-thread 'main' panicked at RUSTLIB/core/src/panicking.rs:LL:CC:
+thread 'main' ($TID) panicked at RUSTLIB/core/src/panicking.rs:LL:CC:
panic in a function that cannot unwind
stack backtrace:
thread caused non-unwinding panic. aborting.
diff --git a/src/tools/miri/tests/fail/function_calls/exported_symbol_bad_unwind2.definition.stderr b/src/tools/miri/tests/fail/function_calls/exported_symbol_bad_unwind2.definition.stderr
index 14b3be0..1246ad5 100644
--- a/src/tools/miri/tests/fail/function_calls/exported_symbol_bad_unwind2.definition.stderr
+++ b/src/tools/miri/tests/fail/function_calls/exported_symbol_bad_unwind2.definition.stderr
@@ -1,10 +1,10 @@
-thread 'main' panicked at tests/fail/function_calls/exported_symbol_bad_unwind2.rs:LL:CC:
+thread 'main' ($TID) panicked at tests/fail/function_calls/exported_symbol_bad_unwind2.rs:LL:CC:
explicit panic
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
note: in Miri, you may have to set `MIRIFLAGS=-Zmiri-env-forward=RUST_BACKTRACE` for the environment variable to have an effect
-thread 'main' panicked at RUSTLIB/core/src/panicking.rs:LL:CC:
+thread 'main' ($TID) panicked at RUSTLIB/core/src/panicking.rs:LL:CC:
panic in a function that cannot unwind
stack backtrace:
thread caused non-unwinding panic. aborting.
diff --git a/src/tools/miri/tests/fail/function_calls/exported_symbol_bad_unwind2.extern_block.stderr b/src/tools/miri/tests/fail/function_calls/exported_symbol_bad_unwind2.extern_block.stderr
index 5a3d5b4..e755b26 100644
--- a/src/tools/miri/tests/fail/function_calls/exported_symbol_bad_unwind2.extern_block.stderr
+++ b/src/tools/miri/tests/fail/function_calls/exported_symbol_bad_unwind2.extern_block.stderr
@@ -1,5 +1,5 @@
-thread 'main' panicked at tests/fail/function_calls/exported_symbol_bad_unwind2.rs:LL:CC:
+thread 'main' ($TID) panicked at tests/fail/function_calls/exported_symbol_bad_unwind2.rs:LL:CC:
explicit panic
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
note: in Miri, you may have to set `MIRIFLAGS=-Zmiri-env-forward=RUST_BACKTRACE` for the environment variable to have an effect
diff --git a/src/tools/miri/tests/fail/function_calls/return_pointer_on_unwind.stderr b/src/tools/miri/tests/fail/function_calls/return_pointer_on_unwind.stderr
index 93720ca..77dc2c6 100644
--- a/src/tools/miri/tests/fail/function_calls/return_pointer_on_unwind.stderr
+++ b/src/tools/miri/tests/fail/function_calls/return_pointer_on_unwind.stderr
@@ -1,5 +1,5 @@
-thread 'main' panicked at tests/fail/function_calls/return_pointer_on_unwind.rs:LL:CC:
+thread 'main' ($TID) panicked at tests/fail/function_calls/return_pointer_on_unwind.rs:LL:CC:
explicit panic
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
note: in Miri, you may have to set `MIRIFLAGS=-Zmiri-env-forward=RUST_BACKTRACE` for the environment variable to have an effect
diff --git a/src/tools/miri/tests/fail/panic/abort_unwind.stderr b/src/tools/miri/tests/fail/panic/abort_unwind.stderr
index 35052f3..09f19a6 100644
--- a/src/tools/miri/tests/fail/panic/abort_unwind.stderr
+++ b/src/tools/miri/tests/fail/panic/abort_unwind.stderr
@@ -1,10 +1,10 @@
-thread 'main' panicked at tests/fail/panic/abort_unwind.rs:LL:CC:
+thread 'main' ($TID) panicked at tests/fail/panic/abort_unwind.rs:LL:CC:
PANIC!!!
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
note: in Miri, you may have to set `MIRIFLAGS=-Zmiri-env-forward=RUST_BACKTRACE` for the environment variable to have an effect
-thread 'main' panicked at RUSTLIB/core/src/panicking.rs:LL:CC:
+thread 'main' ($TID) panicked at RUSTLIB/core/src/panicking.rs:LL:CC:
panic in a function that cannot unwind
stack backtrace:
thread caused non-unwinding panic. aborting.
diff --git a/src/tools/miri/tests/fail/panic/bad_unwind.stderr b/src/tools/miri/tests/fail/panic/bad_unwind.stderr
index b8404c4..b0a8492 100644
--- a/src/tools/miri/tests/fail/panic/bad_unwind.stderr
+++ b/src/tools/miri/tests/fail/panic/bad_unwind.stderr
@@ -1,5 +1,5 @@
-thread 'main' panicked at tests/fail/panic/bad_unwind.rs:LL:CC:
+thread 'main' ($TID) panicked at tests/fail/panic/bad_unwind.rs:LL:CC:
explicit panic
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
note: in Miri, you may have to set `MIRIFLAGS=-Zmiri-env-forward=RUST_BACKTRACE` for the environment variable to have an effect
diff --git a/src/tools/miri/tests/fail/panic/double_panic.stderr b/src/tools/miri/tests/fail/panic/double_panic.stderr
index 3f1fbfe..f6aa0a3 100644
--- a/src/tools/miri/tests/fail/panic/double_panic.stderr
+++ b/src/tools/miri/tests/fail/panic/double_panic.stderr
@@ -1,14 +1,14 @@
-thread 'main' panicked at tests/fail/panic/double_panic.rs:LL:CC:
+thread 'main' ($TID) panicked at tests/fail/panic/double_panic.rs:LL:CC:
first
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
note: in Miri, you may have to set `MIRIFLAGS=-Zmiri-env-forward=RUST_BACKTRACE` for the environment variable to have an effect
-thread 'main' panicked at tests/fail/panic/double_panic.rs:LL:CC:
+thread 'main' ($TID) panicked at tests/fail/panic/double_panic.rs:LL:CC:
second
stack backtrace:
-thread 'main' panicked at RUSTLIB/core/src/panicking.rs:LL:CC:
+thread 'main' ($TID) panicked at RUSTLIB/core/src/panicking.rs:LL:CC:
panic in a destructor during cleanup
thread caused non-unwinding panic. aborting.
error: abnormal termination: the program aborted execution
diff --git a/src/tools/miri/tests/fail/panic/panic_abort1.stderr b/src/tools/miri/tests/fail/panic/panic_abort1.stderr
index 9aca2ed..ebdf57f 100644
--- a/src/tools/miri/tests/fail/panic/panic_abort1.stderr
+++ b/src/tools/miri/tests/fail/panic/panic_abort1.stderr
@@ -1,5 +1,5 @@
-thread 'main' panicked at tests/fail/panic/panic_abort1.rs:LL:CC:
+thread 'main' ($TID) panicked at tests/fail/panic/panic_abort1.rs:LL:CC:
panicking from libstd
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
note: in Miri, you may have to set `MIRIFLAGS=-Zmiri-env-forward=RUST_BACKTRACE` for the environment variable to have an effect
diff --git a/src/tools/miri/tests/fail/panic/panic_abort2.stderr b/src/tools/miri/tests/fail/panic/panic_abort2.stderr
index 425817d..d63e4ed 100644
--- a/src/tools/miri/tests/fail/panic/panic_abort2.stderr
+++ b/src/tools/miri/tests/fail/panic/panic_abort2.stderr
@@ -1,5 +1,5 @@
-thread 'main' panicked at tests/fail/panic/panic_abort2.rs:LL:CC:
+thread 'main' ($TID) panicked at tests/fail/panic/panic_abort2.rs:LL:CC:
42-panicking from libstd
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
note: in Miri, you may have to set `MIRIFLAGS=-Zmiri-env-forward=RUST_BACKTRACE` for the environment variable to have an effect
diff --git a/src/tools/miri/tests/fail/panic/panic_abort3.stderr b/src/tools/miri/tests/fail/panic/panic_abort3.stderr
index a21e185..9751053 100644
--- a/src/tools/miri/tests/fail/panic/panic_abort3.stderr
+++ b/src/tools/miri/tests/fail/panic/panic_abort3.stderr
@@ -1,5 +1,5 @@
-thread 'main' panicked at tests/fail/panic/panic_abort3.rs:LL:CC:
+thread 'main' ($TID) panicked at tests/fail/panic/panic_abort3.rs:LL:CC:
panicking from libcore
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
note: in Miri, you may have to set `MIRIFLAGS=-Zmiri-env-forward=RUST_BACKTRACE` for the environment variable to have an effect
diff --git a/src/tools/miri/tests/fail/panic/panic_abort4.stderr b/src/tools/miri/tests/fail/panic/panic_abort4.stderr
index a3cf5d7..a84824f 100644
--- a/src/tools/miri/tests/fail/panic/panic_abort4.stderr
+++ b/src/tools/miri/tests/fail/panic/panic_abort4.stderr
@@ -1,5 +1,5 @@
-thread 'main' panicked at tests/fail/panic/panic_abort4.rs:LL:CC:
+thread 'main' ($TID) panicked at tests/fail/panic/panic_abort4.rs:LL:CC:
42-panicking from libcore
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
note: in Miri, you may have to set `MIRIFLAGS=-Zmiri-env-forward=RUST_BACKTRACE` for the environment variable to have an effect
diff --git a/src/tools/miri/tests/fail/panic/tls_macro_const_drop_panic.stderr b/src/tools/miri/tests/fail/panic/tls_macro_const_drop_panic.stderr
index 1dcdb4a..ef87e7f 100644
--- a/src/tools/miri/tests/fail/panic/tls_macro_const_drop_panic.stderr
+++ b/src/tools/miri/tests/fail/panic/tls_macro_const_drop_panic.stderr
@@ -1,5 +1,5 @@
-thread $NAME panicked at tests/fail/panic/tls_macro_const_drop_panic.rs:LL:CC:
+thread $NAME ($TID) panicked at tests/fail/panic/tls_macro_const_drop_panic.rs:LL:CC:
ow
fatal runtime error: thread local panicked on drop, aborting
error: abnormal termination: the program aborted execution
diff --git a/src/tools/miri/tests/fail/panic/tls_macro_drop_panic.stderr b/src/tools/miri/tests/fail/panic/tls_macro_drop_panic.stderr
index 7e4907a..4fdaa97 100644
--- a/src/tools/miri/tests/fail/panic/tls_macro_drop_panic.stderr
+++ b/src/tools/miri/tests/fail/panic/tls_macro_drop_panic.stderr
@@ -1,5 +1,5 @@
-thread $NAME panicked at tests/fail/panic/tls_macro_drop_panic.rs:LL:CC:
+thread $NAME ($TID) panicked at tests/fail/panic/tls_macro_drop_panic.rs:LL:CC:
ow
fatal runtime error: thread local panicked on drop, aborting
error: abnormal termination: the program aborted execution
diff --git a/src/tools/miri/tests/fail/ptr_swap_nonoverlapping.stderr b/src/tools/miri/tests/fail/ptr_swap_nonoverlapping.stderr
index 8295a58..d2b557f 100644
--- a/src/tools/miri/tests/fail/ptr_swap_nonoverlapping.stderr
+++ b/src/tools/miri/tests/fail/ptr_swap_nonoverlapping.stderr
@@ -1,5 +1,5 @@
-thread 'main' panicked at tests/fail/ptr_swap_nonoverlapping.rs:LL:CC:
+thread 'main' ($TID) panicked at tests/fail/ptr_swap_nonoverlapping.rs:LL:CC:
unsafe precondition(s) violated: ptr::swap_nonoverlapping requires that both pointer arguments are aligned and non-null and the specified memory ranges do not overlap
This indicates a bug in the program. This Undefined Behavior check is optional, and cannot be relied on for safety.
diff --git a/src/tools/miri/tests/fail/terminate-terminator.stderr b/src/tools/miri/tests/fail/terminate-terminator.stderr
index f0f305d..96df302 100644
--- a/src/tools/miri/tests/fail/terminate-terminator.stderr
+++ b/src/tools/miri/tests/fail/terminate-terminator.stderr
@@ -1,12 +1,12 @@
warning: You have explicitly enabled MIR optimizations, overriding Miri's default which is to completely disable them. Any optimizations may hide UB that Miri would otherwise detect, and it is not necessarily possible to predict what kind of UB will be missed. If you are enabling optimizations to make Miri run faster, we advise using cfg(miri) to shrink your workload instead. The performance benefit of enabling MIR optimizations is usually marginal at best.
-thread 'main' panicked at tests/fail/terminate-terminator.rs:LL:CC:
+thread 'main' ($TID) panicked at tests/fail/terminate-terminator.rs:LL:CC:
explicit panic
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
note: in Miri, you may have to set `MIRIFLAGS=-Zmiri-env-forward=RUST_BACKTRACE` for the environment variable to have an effect
-thread 'main' panicked at RUSTLIB/core/src/panicking.rs:LL:CC:
+thread 'main' ($TID) panicked at RUSTLIB/core/src/panicking.rs:LL:CC:
panic in a function that cannot unwind
stack backtrace:
thread caused non-unwinding panic. aborting.
diff --git a/src/tools/miri/tests/fail/unwind-action-terminate.stderr b/src/tools/miri/tests/fail/unwind-action-terminate.stderr
index 216ae84..06c63c7 100644
--- a/src/tools/miri/tests/fail/unwind-action-terminate.stderr
+++ b/src/tools/miri/tests/fail/unwind-action-terminate.stderr
@@ -1,10 +1,10 @@
-thread 'main' panicked at tests/fail/unwind-action-terminate.rs:LL:CC:
+thread 'main' ($TID) panicked at tests/fail/unwind-action-terminate.rs:LL:CC:
explicit panic
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
note: in Miri, you may have to set `MIRIFLAGS=-Zmiri-env-forward=RUST_BACKTRACE` for the environment variable to have an effect
-thread 'main' panicked at RUSTLIB/core/src/panicking.rs:LL:CC:
+thread 'main' ($TID) panicked at RUSTLIB/core/src/panicking.rs:LL:CC:
panic in a function that cannot unwind
stack backtrace:
thread caused non-unwinding panic. aborting.
diff --git a/src/tools/miri/tests/panic/alloc_error_handler_hook.stderr b/src/tools/miri/tests/panic/alloc_error_handler_hook.stderr
index 2be0696..ad2bfc3 100644
--- a/src/tools/miri/tests/panic/alloc_error_handler_hook.stderr
+++ b/src/tools/miri/tests/panic/alloc_error_handler_hook.stderr
@@ -1,5 +1,5 @@
-thread 'main' panicked at tests/panic/alloc_error_handler_hook.rs:LL:CC:
+thread 'main' ($TID) panicked at tests/panic/alloc_error_handler_hook.rs:LL:CC:
alloc error hook called
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
note: in Miri, you may have to set `MIRIFLAGS=-Zmiri-env-forward=RUST_BACKTRACE` for the environment variable to have an effect
diff --git a/src/tools/miri/tests/panic/alloc_error_handler_panic.stderr b/src/tools/miri/tests/panic/alloc_error_handler_panic.stderr
index ddee4fd..7c2d089 100644
--- a/src/tools/miri/tests/panic/alloc_error_handler_panic.stderr
+++ b/src/tools/miri/tests/panic/alloc_error_handler_panic.stderr
@@ -1,5 +1,5 @@
-thread 'main' panicked at RUSTLIB/std/src/alloc.rs:LL:CC:
+thread 'main' ($TID) panicked at RUSTLIB/std/src/alloc.rs:LL:CC:
memory allocation of 4 bytes failed
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
note: in Miri, you may have to set `MIRIFLAGS=-Zmiri-env-forward=RUST_BACKTRACE` for the environment variable to have an effect
diff --git a/src/tools/miri/tests/panic/div-by-zero-2.stderr b/src/tools/miri/tests/panic/div-by-zero-2.stderr
index 4d4b006..013f3cd 100644
--- a/src/tools/miri/tests/panic/div-by-zero-2.stderr
+++ b/src/tools/miri/tests/panic/div-by-zero-2.stderr
@@ -1,5 +1,5 @@
-thread 'main' panicked at tests/panic/div-by-zero-2.rs:LL:CC:
+thread 'main' ($TID) panicked at tests/panic/div-by-zero-2.rs:LL:CC:
attempt to divide by zero
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
note: in Miri, you may have to set `MIRIFLAGS=-Zmiri-env-forward=RUST_BACKTRACE` for the environment variable to have an effect
diff --git a/src/tools/miri/tests/panic/function_calls/exported_symbol_good_unwind.stderr b/src/tools/miri/tests/panic/function_calls/exported_symbol_good_unwind.stderr
index 8bcd635..dad9437 100644
--- a/src/tools/miri/tests/panic/function_calls/exported_symbol_good_unwind.stderr
+++ b/src/tools/miri/tests/panic/function_calls/exported_symbol_good_unwind.stderr
@@ -1,11 +1,11 @@
-thread 'main' panicked at tests/panic/function_calls/exported_symbol_good_unwind.rs:LL:CC:
+thread 'main' ($TID) panicked at tests/panic/function_calls/exported_symbol_good_unwind.rs:LL:CC:
explicit panic
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
note: in Miri, you may have to set `MIRIFLAGS=-Zmiri-env-forward=RUST_BACKTRACE` for the environment variable to have an effect
-thread 'main' panicked at tests/panic/function_calls/exported_symbol_good_unwind.rs:LL:CC:
+thread 'main' ($TID) panicked at tests/panic/function_calls/exported_symbol_good_unwind.rs:LL:CC:
explicit panic
-thread 'main' panicked at tests/panic/function_calls/exported_symbol_good_unwind.rs:LL:CC:
+thread 'main' ($TID) panicked at tests/panic/function_calls/exported_symbol_good_unwind.rs:LL:CC:
explicit panic
diff --git a/src/tools/miri/tests/panic/mir-validation.rs b/src/tools/miri/tests/panic/mir-validation.rs
index e4b75cc..b9097f2 100644
--- a/src/tools/miri/tests/panic/mir-validation.rs
+++ b/src/tools/miri/tests/panic/mir-validation.rs
@@ -8,6 +8,12 @@
// Somehow on rustc Windows CI, the "Miri caused an ICE" message is not shown
// and we don't even get a regular panic; rustc aborts with a different exit code instead.
//@ignore-host: windows
+
+// FIXME: this tests a crash in rustc. For stage1, rustc is built with the downloaded standard
+// library which doesn't yet print the thread ID. Normalization can be removed at the stage bump.
+// For the grep: cfg(bootstrap)
+//@normalize-stderr-test: "thread 'rustc' panicked" -> "thread 'rustc' ($$TID) panicked"
+
#![feature(custom_mir, core_intrinsics)]
use core::intrinsics::mir::*;
diff --git a/src/tools/miri/tests/panic/mir-validation.stderr b/src/tools/miri/tests/panic/mir-validation.stderr
index f801ac9..1d40c93 100644
--- a/src/tools/miri/tests/panic/mir-validation.stderr
+++ b/src/tools/miri/tests/panic/mir-validation.stderr
@@ -6,7 +6,7 @@
| ^^^^^^^^^^^^^^
-thread 'rustc' panicked at compiler/rustc_mir_transform/src/validate.rs:LL:CC:
+thread 'rustc' ($TID) panicked at compiler/rustc_mir_transform/src/validate.rs:LL:CC:
Box<dyn Any>
stack backtrace:
diff --git a/src/tools/miri/tests/panic/oob_subslice.stderr b/src/tools/miri/tests/panic/oob_subslice.stderr
index c0dabaf..f8270f4 100644
--- a/src/tools/miri/tests/panic/oob_subslice.stderr
+++ b/src/tools/miri/tests/panic/oob_subslice.stderr
@@ -1,5 +1,5 @@
-thread 'main' panicked at tests/panic/oob_subslice.rs:LL:CC:
+thread 'main' ($TID) panicked at tests/panic/oob_subslice.rs:LL:CC:
range end index 5 out of range for slice of length 4
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
note: in Miri, you may have to set `MIRIFLAGS=-Zmiri-env-forward=RUST_BACKTRACE` for the environment variable to have an effect
diff --git a/src/tools/miri/tests/panic/overflowing-lsh-neg.stderr b/src/tools/miri/tests/panic/overflowing-lsh-neg.stderr
index d674e2b..8e618b9 100644
--- a/src/tools/miri/tests/panic/overflowing-lsh-neg.stderr
+++ b/src/tools/miri/tests/panic/overflowing-lsh-neg.stderr
@@ -1,5 +1,5 @@
-thread 'main' panicked at tests/panic/overflowing-lsh-neg.rs:LL:CC:
+thread 'main' ($TID) panicked at tests/panic/overflowing-lsh-neg.rs:LL:CC:
attempt to shift left with overflow
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
note: in Miri, you may have to set `MIRIFLAGS=-Zmiri-env-forward=RUST_BACKTRACE` for the environment variable to have an effect
diff --git a/src/tools/miri/tests/panic/overflowing-rsh-1.stderr b/src/tools/miri/tests/panic/overflowing-rsh-1.stderr
index bb94f2e..471bc84 100644
--- a/src/tools/miri/tests/panic/overflowing-rsh-1.stderr
+++ b/src/tools/miri/tests/panic/overflowing-rsh-1.stderr
@@ -1,5 +1,5 @@
-thread 'main' panicked at tests/panic/overflowing-rsh-1.rs:LL:CC:
+thread 'main' ($TID) panicked at tests/panic/overflowing-rsh-1.rs:LL:CC:
attempt to shift right with overflow
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
note: in Miri, you may have to set `MIRIFLAGS=-Zmiri-env-forward=RUST_BACKTRACE` for the environment variable to have an effect
diff --git a/src/tools/miri/tests/panic/overflowing-rsh-2.stderr b/src/tools/miri/tests/panic/overflowing-rsh-2.stderr
index 0a29a57..94f5fb0 100644
--- a/src/tools/miri/tests/panic/overflowing-rsh-2.stderr
+++ b/src/tools/miri/tests/panic/overflowing-rsh-2.stderr
@@ -1,5 +1,5 @@
-thread 'main' panicked at tests/panic/overflowing-rsh-2.rs:LL:CC:
+thread 'main' ($TID) panicked at tests/panic/overflowing-rsh-2.rs:LL:CC:
attempt to shift right with overflow
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
note: in Miri, you may have to set `MIRIFLAGS=-Zmiri-env-forward=RUST_BACKTRACE` for the environment variable to have an effect
diff --git a/src/tools/miri/tests/panic/panic1.stderr b/src/tools/miri/tests/panic/panic1.stderr
index 130bc77..9ca5234 100644
--- a/src/tools/miri/tests/panic/panic1.stderr
+++ b/src/tools/miri/tests/panic/panic1.stderr
@@ -1,5 +1,5 @@
-thread 'main' panicked at tests/panic/panic1.rs:LL:CC:
+thread 'main' ($TID) panicked at tests/panic/panic1.rs:LL:CC:
panicking from libstd
stack backtrace:
0: std::panicking::begin_panic_handler
diff --git a/src/tools/miri/tests/panic/panic2.stderr b/src/tools/miri/tests/panic/panic2.stderr
index 157ffdb..c2e5517 100644
--- a/src/tools/miri/tests/panic/panic2.stderr
+++ b/src/tools/miri/tests/panic/panic2.stderr
@@ -1,5 +1,5 @@
-thread 'main' panicked at tests/panic/panic2.rs:LL:CC:
+thread 'main' ($TID) panicked at tests/panic/panic2.rs:LL:CC:
42-panicking from libstd
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
note: in Miri, you may have to set `MIRIFLAGS=-Zmiri-env-forward=RUST_BACKTRACE` for the environment variable to have an effect
diff --git a/src/tools/miri/tests/panic/panic3.stderr b/src/tools/miri/tests/panic/panic3.stderr
index 529ef70..2fc761a 100644
--- a/src/tools/miri/tests/panic/panic3.stderr
+++ b/src/tools/miri/tests/panic/panic3.stderr
@@ -1,5 +1,5 @@
-thread 'main' panicked at tests/panic/panic3.rs:LL:CC:
+thread 'main' ($TID) panicked at tests/panic/panic3.rs:LL:CC:
panicking from libcore
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
note: in Miri, you may have to set `MIRIFLAGS=-Zmiri-env-forward=RUST_BACKTRACE` for the environment variable to have an effect
diff --git a/src/tools/miri/tests/panic/panic4.stderr b/src/tools/miri/tests/panic/panic4.stderr
index ecd07dd..f2f4c03 100644
--- a/src/tools/miri/tests/panic/panic4.stderr
+++ b/src/tools/miri/tests/panic/panic4.stderr
@@ -1,5 +1,5 @@
-thread 'main' panicked at tests/panic/panic4.rs:LL:CC:
+thread 'main' ($TID) panicked at tests/panic/panic4.rs:LL:CC:
42-panicking from libcore
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
note: in Miri, you may have to set `MIRIFLAGS=-Zmiri-env-forward=RUST_BACKTRACE` for the environment variable to have an effect
diff --git a/src/tools/miri/tests/panic/transmute_fat2.stderr b/src/tools/miri/tests/panic/transmute_fat2.stderr
index 71e2d7a..8846c4c 100644
--- a/src/tools/miri/tests/panic/transmute_fat2.stderr
+++ b/src/tools/miri/tests/panic/transmute_fat2.stderr
@@ -1,5 +1,5 @@
-thread 'main' panicked at tests/panic/transmute_fat2.rs:LL:CC:
+thread 'main' ($TID) panicked at tests/panic/transmute_fat2.rs:LL:CC:
index out of bounds: the len is 0 but the index is 0
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
note: in Miri, you may have to set `MIRIFLAGS=-Zmiri-env-forward=RUST_BACKTRACE` for the environment variable to have an effect
diff --git a/src/tools/miri/tests/pass/float.rs b/src/tools/miri/tests/pass/float.rs
index fe7316c..96590b4 100644
--- a/src/tools/miri/tests/pass/float.rs
+++ b/src/tools/miri/tests/pass/float.rs
@@ -1088,6 +1088,8 @@ fn ldexp(a: f64, b: i32) -> f64 {
assert_approx_eq!(1f32.exp_m1(), f32::consts::E - 1.0);
assert_approx_eq!(1f64.exp_m1(), f64::consts::E - 1.0);
+ assert_approx_eq!(f32::NEG_INFINITY.exp_m1(), -1.0);
+ assert_approx_eq!(f64::NEG_INFINITY.exp_m1(), -1.0);
assert_approx_eq!(10f32.exp2(), 1024f32);
assert_approx_eq!(50f64.exp2(), 1125899906842624f64);
@@ -1123,6 +1125,7 @@ fn ldexp(a: f64, b: i32) -> f64 {
assert_eq!(ldexp(0.65f64, 3i32), 5.2f64);
assert_eq!(ldexp(1.42, 0xFFFF), f64::INFINITY);
assert_eq!(ldexp(1.42, -0xFFFF), 0f64);
+ assert_eq!(ldexp(42.0, 0), 42.0);
// Trigonometric functions.
@@ -1131,8 +1134,14 @@ fn ldexp(a: f64, b: i32) -> f64 {
assert_approx_eq!((f64::consts::PI / 2f64).sin(), 1f64);
assert_approx_eq!(f32::consts::FRAC_PI_6.sin(), 0.5);
assert_approx_eq!(f64::consts::FRAC_PI_6.sin(), 0.5);
- assert_approx_eq!(f32::consts::FRAC_PI_4.sin().asin(), f32::consts::FRAC_PI_4);
- assert_approx_eq!(f64::consts::FRAC_PI_4.sin().asin(), f64::consts::FRAC_PI_4);
+ // Increase error tolerance from 12ULP to 16ULP because of the extra operation.
+ assert_approx_eq!(f32::consts::FRAC_PI_4.sin().asin(), f32::consts::FRAC_PI_4, 16);
+ assert_approx_eq!(f64::consts::FRAC_PI_4.sin().asin(), f64::consts::FRAC_PI_4, 16);
+ assert_biteq(0.0f32.asin(), 0.0f32, "asin(+0) = +0");
+ assert_biteq((-0.0f32).asin(), -0.0, "asin(-0) = -0");
+ assert_biteq(0.0f64.asin(), 0.0, "asin(+0) = +0");
+ assert_biteq((-0.0f64).asin(), -0.0, "asin(-0) = -0");
+
assert_approx_eq!(1.0f32.sinh(), 1.1752012f32);
assert_approx_eq!(1.0f64.sinh(), 1.1752011936438014f64);
@@ -1159,11 +1168,18 @@ fn ldexp(a: f64, b: i32) -> f64 {
assert_approx_eq!((f64::consts::PI * 2f64).cos(), 1f64);
assert_approx_eq!(f32::consts::FRAC_PI_3.cos(), 0.5);
assert_approx_eq!(f64::consts::FRAC_PI_3.cos(), 0.5);
- assert_approx_eq!(f32::consts::FRAC_PI_4.cos().acos(), f32::consts::FRAC_PI_4);
- assert_approx_eq!(f64::consts::FRAC_PI_4.cos().acos(), f64::consts::FRAC_PI_4);
+ // Increase error tolerance from 12ULP to 16ULP because of the extra operation.
+ assert_approx_eq!(f32::consts::FRAC_PI_4.cos().acos(), f32::consts::FRAC_PI_4, 16);
+ assert_approx_eq!(f64::consts::FRAC_PI_4.cos().acos(), f64::consts::FRAC_PI_4, 16);
+ assert_biteq(1.0f32.acos(), 0.0, "acos(1) = 0");
+ assert_biteq(1.0f64.acos(), 0.0, "acos(1) = 0");
assert_approx_eq!(1.0f32.cosh(), 1.54308f32);
assert_approx_eq!(1.0f64.cosh(), 1.5430806348152437f64);
+ assert_eq!(0.0f32.cosh(), 1.0);
+ assert_eq!(0.0f64.cosh(), 1.0);
+ assert_eq!((-0.0f32).cosh(), 1.0);
+ assert_eq!((-0.0f64).cosh(), 1.0);
assert_approx_eq!(2.0f32.acosh(), 1.31695789692481670862504634730796844f32);
assert_approx_eq!(3.0f64.acosh(), 1.76274717403908605046521864995958461f64);
@@ -1173,6 +1189,47 @@ fn ldexp(a: f64, b: i32) -> f64 {
assert_approx_eq!(1.0_f64, 1.0_f64.tan().atan());
assert_approx_eq!(1.0f32.atan2(2.0f32), 0.46364761f32);
assert_approx_eq!(1.0f32.atan2(2.0f32), 0.46364761f32);
+ // C standard defines a bunch of fixed outputs for atan2
+ macro_rules! fixed_atan2_cases{
+ ($float_type:ident) => {{
+ use std::$float_type::consts::{PI, FRAC_PI_2, FRAC_PI_4};
+ use $float_type::{INFINITY, NEG_INFINITY};
+
+ // atan2(±0,−0) = ±π.
+ assert_eq!($float_type::atan2(0.0, -0.0), PI, "atan2(0,−0) = π");
+ assert_eq!($float_type::atan2(-0.0, -0.0), -PI, "atan2(-0,−0) = -π");
+
+ // atan2(±0, y) = ±π for y < 0.
+ assert_eq!($float_type::atan2(0.0, -1.0), PI, "atan2(0, y) = π for y < 0.");
+ assert_eq!($float_type::atan2(-0.0, -1.0), -PI, "atan2(-0, y) = -π for y < 0.");
+
+ // atan2(x, ±0) = −π/2 for x < 0.
+ assert_eq!($float_type::atan2(-1.0, 0.0), -FRAC_PI_2, "atan2(x, 0) = −π/2 for x < 0");
+ assert_eq!($float_type::atan2(-1.0, -0.0), -FRAC_PI_2, "atan2(x, -0) = −π/2 for x < 0");
+
+ // atan2(x, ±0) = π/2 for x > 0.
+ assert_eq!($float_type::atan2(1.0, 0.0), FRAC_PI_2, "atan2(x, 0) = π/2 for x > 0.");
+ assert_eq!($float_type::atan2(1.0, -0.0), FRAC_PI_2, "atan2(x, -0) = π/2 for x > 0.");
+
+ // atan2(±x,−∞) = ±π for finite x > 0.
+ assert_eq!($float_type::atan2(1.0, NEG_INFINITY), PI, "atan2(x, −∞) = π for finite x > 0");
+ assert_eq!($float_type::atan2(-1.0, NEG_INFINITY), -PI, "atan2(-x, −∞) = -π for finite x > 0");
+
+ // atan2(±∞, y) returns ±π/2 for finite y.
+ assert_eq!($float_type::atan2(INFINITY, 1.0), FRAC_PI_2, "atan2(+∞, y) returns π/2 for finite y");
+ assert_eq!($float_type::atan2(NEG_INFINITY, 1.0), -FRAC_PI_2, "atan2(-∞, y) returns -π/2 for finite y");
+
+ // atan2(±∞, −∞) = ±3π/4
+ assert_eq!($float_type::atan2(INFINITY, NEG_INFINITY), 3.0 * FRAC_PI_4, "atan2(+∞, −∞) = 3π/4");
+ assert_eq!($float_type::atan2(NEG_INFINITY, NEG_INFINITY), -3.0 * FRAC_PI_4, "atan2(-∞, −∞) = -3π/4");
+
+ // atan2(±∞, +∞) = ±π/4
+ assert_eq!($float_type::atan2(INFINITY, INFINITY), FRAC_PI_4, "atan2(+∞, +∞) = π/4");
+ assert_eq!($float_type::atan2(NEG_INFINITY, INFINITY), -FRAC_PI_4, "atan2(-∞, +∞) = -π/4");
+ }}
+ }
+ fixed_atan2_cases!(f32);
+ fixed_atan2_cases!(f64);
assert_approx_eq!(
1.0f32.tanh(),
@@ -1182,6 +1239,11 @@ fn ldexp(a: f64, b: i32) -> f64 {
1.0f64.tanh(),
(1.0 - f64::consts::E.powi(-2)) / (1.0 + f64::consts::E.powi(-2))
);
+ assert_eq!(f32::INFINITY.tanh(), 1.0);
+ assert_eq!(f32::NEG_INFINITY.tanh(), -1.0);
+ assert_eq!(f64::INFINITY.tanh(), 1.0);
+ assert_eq!(f64::NEG_INFINITY.tanh(), -1.0);
+
assert_approx_eq!(0.5f32.atanh(), 0.54930614433405484569762261846126285f32);
assert_approx_eq!(0.5f64.atanh(), 0.54930614433405484569762261846126285f64);
@@ -1202,8 +1264,14 @@ fn ldexp(a: f64, b: i32) -> f64 {
assert_approx_eq!(1.0f32.erf(), 0.84270079294971486934122063508260926f32);
assert_approx_eq!(1.0f64.erf(), 0.84270079294971486934122063508260926f64);
+ assert_eq!(f32::INFINITY.erf(), 1.0);
+ assert_eq!(f64::INFINITY.erf(), 1.0);
assert_approx_eq!(1.0f32.erfc(), 0.15729920705028513065877936491739074f32);
assert_approx_eq!(1.0f64.erfc(), 0.15729920705028513065877936491739074f64);
+ assert_eq!(f32::NEG_INFINITY.erfc(), 2.0);
+ assert_eq!(f64::NEG_INFINITY.erfc(), 2.0);
+ assert_eq!(f32::INFINITY.erfc(), 0.0);
+ assert_eq!(f64::INFINITY.erfc(), 0.0);
}
fn test_fast() {
@@ -1413,7 +1481,6 @@ pub fn test_operations_f16(a: f16, b: f16) {
}
pub fn test_operations_f32(a: f32, b: f32) {
test_operations_f!(a, b);
- // FIXME: some are temporarily disabled as it breaks std tests.
ensure_nondet(|| a.powf(b));
ensure_nondet(|| a.powi(2));
ensure_nondet(|| a.log(b));
@@ -1422,35 +1489,34 @@ pub fn test_operations_f32(a: f32, b: f32) {
ensure_nondet(|| f32::consts::E.ln());
ensure_nondet(|| 10f32.log10());
ensure_nondet(|| 8f32.log2());
- // ensure_nondet(|| 1f32.ln_1p());
- // ensure_nondet(|| 27.0f32.cbrt());
- // ensure_nondet(|| 3.0f32.hypot(4.0f32));
+ ensure_nondet(|| 1f32.ln_1p());
+ ensure_nondet(|| 27.0f32.cbrt());
+ ensure_nondet(|| 3.0f32.hypot(4.0f32));
ensure_nondet(|| 1f32.sin());
ensure_nondet(|| 1f32.cos());
// On i686-pc-windows-msvc , these functions are implemented by calling the `f64` version,
// which means the little rounding errors Miri introduces are discarded by the cast down to
// `f32`. Just skip the test for them.
- // if !cfg!(all(target_os = "windows", target_env = "msvc", target_arch = "x86")) {
- // ensure_nondet(|| 1.0f32.tan());
- // ensure_nondet(|| 1.0f32.asin());
- // ensure_nondet(|| 5.0f32.acos());
- // ensure_nondet(|| 1.0f32.atan());
- // ensure_nondet(|| 1.0f32.atan2(2.0f32));
- // ensure_nondet(|| 1.0f32.sinh());
- // ensure_nondet(|| 1.0f32.cosh());
- // ensure_nondet(|| 1.0f32.tanh());
- // }
- // ensure_nondet(|| 1.0f32.asinh());
- // ensure_nondet(|| 2.0f32.acosh());
- // ensure_nondet(|| 0.5f32.atanh());
- // ensure_nondet(|| 5.0f32.gamma());
- // ensure_nondet(|| 5.0f32.ln_gamma());
- // ensure_nondet(|| 5.0f32.erf());
- // ensure_nondet(|| 5.0f32.erfc());
+ if !cfg!(all(target_os = "windows", target_env = "msvc", target_arch = "x86")) {
+ ensure_nondet(|| 1.0f32.tan());
+ ensure_nondet(|| 1.0f32.asin());
+ ensure_nondet(|| 5.0f32.acos());
+ ensure_nondet(|| 1.0f32.atan());
+ ensure_nondet(|| 1.0f32.atan2(2.0f32));
+ ensure_nondet(|| 1.0f32.sinh());
+ ensure_nondet(|| 1.0f32.cosh());
+ ensure_nondet(|| 1.0f32.tanh());
+ }
+ ensure_nondet(|| 1.0f32.asinh());
+ ensure_nondet(|| 2.0f32.acosh());
+ ensure_nondet(|| 0.5f32.atanh());
+ ensure_nondet(|| 5.0f32.gamma());
+ ensure_nondet(|| 5.0f32.ln_gamma());
+ ensure_nondet(|| 5.0f32.erf());
+ ensure_nondet(|| 5.0f32.erfc());
}
pub fn test_operations_f64(a: f64, b: f64) {
test_operations_f!(a, b);
- // FIXME: some are temporarily disabled as it breaks std tests.
ensure_nondet(|| a.powf(b));
ensure_nondet(|| a.powi(2));
ensure_nondet(|| a.log(b));
@@ -1459,26 +1525,26 @@ pub fn test_operations_f64(a: f64, b: f64) {
ensure_nondet(|| 3f64.ln());
ensure_nondet(|| f64::consts::E.log10());
ensure_nondet(|| f64::consts::E.log2());
- // ensure_nondet(|| 1f64.ln_1p());
- // ensure_nondet(|| 27.0f64.cbrt());
- // ensure_nondet(|| 3.0f64.hypot(4.0f64));
+ ensure_nondet(|| 1f64.ln_1p());
+ ensure_nondet(|| 27.0f64.cbrt());
+ ensure_nondet(|| 3.0f64.hypot(4.0f64));
ensure_nondet(|| 1f64.sin());
ensure_nondet(|| 1f64.cos());
- // ensure_nondet(|| 1.0f64.tan());
- // ensure_nondet(|| 1.0f64.asin());
- // ensure_nondet(|| 5.0f64.acos());
- // ensure_nondet(|| 1.0f64.atan());
- // ensure_nondet(|| 1.0f64.atan2(2.0f64));
- // ensure_nondet(|| 1.0f64.sinh());
- // ensure_nondet(|| 1.0f64.cosh());
- // ensure_nondet(|| 1.0f64.tanh());
- // ensure_nondet(|| 1.0f64.asinh());
- // ensure_nondet(|| 3.0f64.acosh());
- // ensure_nondet(|| 0.5f64.atanh());
- // ensure_nondet(|| 5.0f64.gamma());
- // ensure_nondet(|| 5.0f64.ln_gamma());
- // ensure_nondet(|| 5.0f64.erf());
- // ensure_nondet(|| 5.0f64.erfc());
+ ensure_nondet(|| 1.0f64.tan());
+ ensure_nondet(|| 1.0f64.asin());
+ ensure_nondet(|| 5.0f64.acos());
+ ensure_nondet(|| 1.0f64.atan());
+ ensure_nondet(|| 1.0f64.atan2(2.0f64));
+ ensure_nondet(|| 1.0f64.sinh());
+ ensure_nondet(|| 1.0f64.cosh());
+ ensure_nondet(|| 1.0f64.tanh());
+ ensure_nondet(|| 1.0f64.asinh());
+ ensure_nondet(|| 3.0f64.acosh());
+ ensure_nondet(|| 0.5f64.atanh());
+ ensure_nondet(|| 5.0f64.gamma());
+ ensure_nondet(|| 5.0f64.ln_gamma());
+ ensure_nondet(|| 5.0f64.erf());
+ ensure_nondet(|| 5.0f64.erfc());
}
pub fn test_operations_f128(a: f128, b: f128) {
test_operations_f!(a, b);
diff --git a/src/tools/miri/tests/pass/panic/catch_panic.stderr b/src/tools/miri/tests/pass/panic/catch_panic.stderr
index bc745fc..cd7384f 100644
--- a/src/tools/miri/tests/pass/panic/catch_panic.stderr
+++ b/src/tools/miri/tests/pass/panic/catch_panic.stderr
@@ -1,47 +1,47 @@
-thread 'main' panicked at tests/pass/panic/catch_panic.rs:LL:CC:
+thread 'main' ($TID) panicked at tests/pass/panic/catch_panic.rs:LL:CC:
Hello from std::panic
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
note: in Miri, you may have to set `MIRIFLAGS=-Zmiri-env-forward=RUST_BACKTRACE` for the environment variable to have an effect
Caught panic message (&str): Hello from std::panic
-thread 'main' panicked at tests/pass/panic/catch_panic.rs:LL:CC:
+thread 'main' ($TID) panicked at tests/pass/panic/catch_panic.rs:LL:CC:
Hello from std::panic: 1
Caught panic message (String): Hello from std::panic: 1
-thread 'main' panicked at tests/pass/panic/catch_panic.rs:LL:CC:
+thread 'main' ($TID) panicked at tests/pass/panic/catch_panic.rs:LL:CC:
Hello from std::panic_any: 2
Caught panic message (String): Hello from std::panic_any: 2
-thread 'main' panicked at tests/pass/panic/catch_panic.rs:LL:CC:
+thread 'main' ($TID) panicked at tests/pass/panic/catch_panic.rs:LL:CC:
Box<dyn Any>
Failed to get caught panic message.
-thread 'main' panicked at tests/pass/panic/catch_panic.rs:LL:CC:
+thread 'main' ($TID) panicked at tests/pass/panic/catch_panic.rs:LL:CC:
Hello from core::panic
Caught panic message (&str): Hello from core::panic
-thread 'main' panicked at tests/pass/panic/catch_panic.rs:LL:CC:
+thread 'main' ($TID) panicked at tests/pass/panic/catch_panic.rs:LL:CC:
Hello from core::panic: 5
Caught panic message (String): Hello from core::panic: 5
-thread 'main' panicked at tests/pass/panic/catch_panic.rs:LL:CC:
+thread 'main' ($TID) panicked at tests/pass/panic/catch_panic.rs:LL:CC:
index out of bounds: the len is 3 but the index is 4
Caught panic message (String): index out of bounds: the len is 3 but the index is 4
-thread 'main' panicked at tests/pass/panic/catch_panic.rs:LL:CC:
+thread 'main' ($TID) panicked at tests/pass/panic/catch_panic.rs:LL:CC:
attempt to divide by zero
Caught panic message (&str): attempt to divide by zero
-thread 'main' panicked at RUSTLIB/core/src/ptr/const_ptr.rs:LL:CC:
+thread 'main' ($TID) panicked at RUSTLIB/core/src/ptr/const_ptr.rs:LL:CC:
align_offset: align is not a power-of-two
Caught panic message (&str): align_offset: align is not a power-of-two
-thread 'main' panicked at tests/pass/panic/catch_panic.rs:LL:CC:
+thread 'main' ($TID) panicked at tests/pass/panic/catch_panic.rs:LL:CC:
assertion failed: false
Caught panic message (&str): assertion failed: false
-thread 'main' panicked at tests/pass/panic/catch_panic.rs:LL:CC:
+thread 'main' ($TID) panicked at tests/pass/panic/catch_panic.rs:LL:CC:
assertion failed: false
Caught panic message (&str): assertion failed: false
Success!
diff --git a/src/tools/miri/tests/pass/panic/concurrent-panic.stderr b/src/tools/miri/tests/pass/panic/concurrent-panic.stderr
index 4a3ac16..b388a3b 100644
--- a/src/tools/miri/tests/pass/panic/concurrent-panic.stderr
+++ b/src/tools/miri/tests/pass/panic/concurrent-panic.stderr
@@ -1,7 +1,7 @@
Thread 1 starting, will block on mutex
Thread 1 reported it has started
-thread '<unnamed>' panicked at tests/pass/panic/concurrent-panic.rs:LL:CC:
+thread '<unnamed>' ($TID) panicked at tests/pass/panic/concurrent-panic.rs:LL:CC:
panic in thread 2
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
note: in Miri, you may have to set `MIRIFLAGS=-Zmiri-env-forward=RUST_BACKTRACE` for the environment variable to have an effect
@@ -9,7 +9,7 @@
Thread 2 reported it has started
Unlocking mutex
-thread '<unnamed>' panicked at tests/pass/panic/concurrent-panic.rs:LL:CC:
+thread '<unnamed>' ($TID) panicked at tests/pass/panic/concurrent-panic.rs:LL:CC:
panic in thread 1
Thread 1 has exited
Thread 2 has exited
diff --git a/src/tools/miri/tests/pass/panic/nested_panic_caught.stderr b/src/tools/miri/tests/pass/panic/nested_panic_caught.stderr
index 8aff8f6..7ae3920 100644
--- a/src/tools/miri/tests/pass/panic/nested_panic_caught.stderr
+++ b/src/tools/miri/tests/pass/panic/nested_panic_caught.stderr
@@ -1,9 +1,9 @@
-thread 'main' panicked at tests/pass/panic/nested_panic_caught.rs:LL:CC:
+thread 'main' ($TID) panicked at tests/pass/panic/nested_panic_caught.rs:LL:CC:
once
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
note: in Miri, you may have to set `MIRIFLAGS=-Zmiri-env-forward=RUST_BACKTRACE` for the environment variable to have an effect
-thread 'main' panicked at tests/pass/panic/nested_panic_caught.rs:LL:CC:
+thread 'main' ($TID) panicked at tests/pass/panic/nested_panic_caught.rs:LL:CC:
twice
stack backtrace:
diff --git a/src/tools/miri/tests/pass/panic/thread_panic.stderr b/src/tools/miri/tests/pass/panic/thread_panic.stderr
index 3bb2991..92403d5 100644
--- a/src/tools/miri/tests/pass/panic/thread_panic.stderr
+++ b/src/tools/miri/tests/pass/panic/thread_panic.stderr
@@ -1,8 +1,8 @@
-thread '<unnamed>' panicked at tests/pass/panic/thread_panic.rs:LL:CC:
+thread '<unnamed>' ($TID) panicked at tests/pass/panic/thread_panic.rs:LL:CC:
Hello!
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
note: in Miri, you may have to set `MIRIFLAGS=-Zmiri-env-forward=RUST_BACKTRACE` for the environment variable to have an effect
-thread 'childthread' panicked at tests/pass/panic/thread_panic.rs:LL:CC:
+thread 'childthread' ($TID) panicked at tests/pass/panic/thread_panic.rs:LL:CC:
Hello, world!
diff --git a/src/tools/miri/tests/ui.rs b/src/tools/miri/tests/ui.rs
index 73fbe2c..f021d51 100644
--- a/src/tools/miri/tests/ui.rs
+++ b/src/tools/miri/tests/ui.rs
@@ -248,7 +248,8 @@ fn $name() -> &'static [(Match, &'static [u8])] {
// erase alloc ids
"alloc[0-9]+" => "ALLOC",
// erase thread ids
- r"unnamed-[0-9]+" => "unnamed-ID",
+ r"unnamed-[0-9]+" => "unnamed-ID",
+ r"thread '(?P<name>.*?)' \(\d+\) panicked" => "thread '$name' ($$TID) panicked",
// erase borrow tags
"<[0-9]+>" => "<TAG>",
"<[0-9]+=" => "<TAG=",
diff --git a/src/tools/rust-analyzer/crates/ide-db/src/generated/lints.rs b/src/tools/rust-analyzer/crates/ide-db/src/generated/lints.rs
index f9eb44d..14bc380 100644
--- a/src/tools/rust-analyzer/crates/ide-db/src/generated/lints.rs
+++ b/src/tools/rust-analyzer/crates/ide-db/src/generated/lints.rs
@@ -10706,20 +10706,6 @@ fn start(_argc: isize, _argv: *const *const u8) -> isize {
deny_since: None,
},
Lint {
- label: "strict_overflow_ops",
- description: r##"# `strict_overflow_ops`
-
-The tracking issue for this feature is: [#118260]
-
-[#118260]: https://github.com/rust-lang/rust/issues/118260
-
-------------------------
-"##,
- default_severity: Severity::Allow,
- warn_since: None,
- deny_since: None,
- },
- Lint {
label: "strict_provenance_atomic_ptr",
description: r##"# `strict_provenance_atomic_ptr`
diff --git a/src/tools/rustfmt/tests/rustfmt/main.rs b/src/tools/rustfmt/tests/rustfmt/main.rs
index a9f58b9..4a93993 100644
--- a/src/tools/rustfmt/tests/rustfmt/main.rs
+++ b/src/tools/rustfmt/tests/rustfmt/main.rs
@@ -185,10 +185,11 @@ fn dont_emit_ICE() {
"tests/target/issue-6105.rs",
];
+ let panic_re = regex::Regex::new("thread.*panicked").unwrap();
for file in files {
let args = [file];
let (_stdout, stderr) = rustfmt(&args);
- assert!(!stderr.contains("thread 'main' panicked"));
+ assert!(!panic_re.is_match(&stderr));
}
}
diff --git a/tests/crashes/144293-indirect-ops-llvm.rs b/tests/crashes/144293-indirect-ops-llvm.rs
new file mode 100644
index 0000000..490a011
--- /dev/null
+++ b/tests/crashes/144293-indirect-ops-llvm.rs
@@ -0,0 +1,42 @@
+//@ known-bug: #144293
+// Same as recursion-etc but eggs LLVM emission into giving indirect arguments.
+#![expect(incomplete_features)]
+#![feature(explicit_tail_calls)]
+
+use std::hint::black_box;
+
+struct U64Wrapper {
+ pub x: u64,
+ pub arbitrary: String,
+}
+
+fn count(curr: U64Wrapper, top: U64Wrapper) -> U64Wrapper {
+ if black_box(curr.x) >= top.x {
+ curr
+ } else {
+ become count(
+ U64Wrapper {
+ x: curr.x + 1,
+ arbitrary: curr.arbitrary,
+ },
+ top,
+ )
+ }
+}
+
+fn main() {
+ println!(
+ "{}",
+ count(
+ U64Wrapper {
+ x: 0,
+ arbitrary: "hello!".into()
+ },
+ black_box(U64Wrapper {
+ x: 1000000,
+ arbitrary: "goodbye!".into()
+ })
+ )
+ .x
+ );
+}
diff --git a/tests/mir-opt/building/issue_101867.main.built.after.mir b/tests/mir-opt/building/issue_101867.main.built.after.mir
index e59b23f..8a36c90 100644
--- a/tests/mir-opt/building/issue_101867.main.built.after.mir
+++ b/tests/mir-opt/building/issue_101867.main.built.after.mir
@@ -24,7 +24,6 @@
_1 = Option::<u8>::Some(const 1_u8);
FakeRead(ForLet(None), _1);
AscribeUserType(_1, o, UserTypeProjection { base: UserType(1), projs: [] });
- StorageLive(_5);
PlaceMention(_1);
_6 = discriminant(_1);
switchInt(move _6) -> [1: bb4, otherwise: bb3];
@@ -55,6 +54,7 @@
}
bb6: {
+ StorageLive(_5);
_5 = copy ((_1 as Some).0: u8);
_0 = const ();
StorageDead(_5);
@@ -63,7 +63,6 @@
}
bb7: {
- StorageDead(_5);
goto -> bb1;
}
diff --git a/tests/mir-opt/building/user_type_annotations.let_else.built.after.mir b/tests/mir-opt/building/user_type_annotations.let_else.built.after.mir
index 6369dbe..3d26fe2 100644
--- a/tests/mir-opt/building/user_type_annotations.let_else.built.after.mir
+++ b/tests/mir-opt/building/user_type_annotations.let_else.built.after.mir
@@ -21,9 +21,6 @@
}
bb0: {
- StorageLive(_2);
- StorageLive(_3);
- StorageLive(_4);
StorageLive(_5);
StorageLive(_6);
StorageLive(_7);
@@ -51,16 +48,19 @@
bb4: {
AscribeUserType(_5, +, UserTypeProjection { base: UserType(1), projs: [] });
+ StorageLive(_2);
_2 = copy (_5.0: u32);
+ StorageLive(_3);
_3 = copy (_5.1: u64);
+ StorageLive(_4);
_4 = copy (_5.2: &char);
StorageDead(_7);
StorageDead(_5);
_0 = const ();
- StorageDead(_8);
StorageDead(_4);
StorageDead(_3);
StorageDead(_2);
+ StorageDead(_8);
return;
}
@@ -68,9 +68,6 @@
StorageDead(_7);
StorageDead(_5);
StorageDead(_8);
- StorageDead(_4);
- StorageDead(_3);
- StorageDead(_2);
goto -> bb1;
}
diff --git a/tests/mir-opt/match_arm_scopes.complicated_match.panic-abort.SimplifyCfg-initial.after-ElaborateDrops.after.diff b/tests/mir-opt/match_arm_scopes.complicated_match.panic-abort.SimplifyCfg-initial.after-ElaborateDrops.after.diff
index b3eb3e1..484bc7d 100644
--- a/tests/mir-opt/match_arm_scopes.complicated_match.panic-abort.SimplifyCfg-initial.after-ElaborateDrops.after.diff
+++ b/tests/mir-opt/match_arm_scopes.complicated_match.panic-abort.SimplifyCfg-initial.after-ElaborateDrops.after.diff
@@ -85,11 +85,11 @@
_8 = &(_2.2: std::string::String);
- _3 = &fake shallow (_2.0: bool);
- _4 = &fake shallow (_2.1: bool);
- StorageLive(_12);
- StorageLive(_13);
- _13 = copy _1;
-- switchInt(move _13) -> [0: bb16, otherwise: bb15];
-+ switchInt(move _13) -> [0: bb13, otherwise: bb12];
+ StorageLive(_9);
+ StorageLive(_10);
+ _10 = copy _1;
+- switchInt(move _10) -> [0: bb12, otherwise: bb11];
++ switchInt(move _10) -> [0: bb9, otherwise: bb8];
}
- bb9: {
@@ -100,11 +100,11 @@
_8 = &(_2.2: std::string::String);
- _3 = &fake shallow (_2.0: bool);
- _4 = &fake shallow (_2.1: bool);
- StorageLive(_9);
- StorageLive(_10);
- _10 = copy _1;
-- switchInt(move _10) -> [0: bb12, otherwise: bb11];
-+ switchInt(move _10) -> [0: bb9, otherwise: bb8];
+ StorageLive(_12);
+ StorageLive(_13);
+ _13 = copy _1;
+- switchInt(move _13) -> [0: bb16, otherwise: bb15];
++ switchInt(move _13) -> [0: bb13, otherwise: bb12];
}
- bb10: {
@@ -139,7 +139,7 @@
- FakeRead(ForGuardBinding, _6);
- FakeRead(ForGuardBinding, _8);
StorageLive(_5);
- _5 = copy (_2.1: bool);
+ _5 = copy (_2.0: bool);
StorageLive(_7);
_7 = move (_2.2: std::string::String);
- goto -> bb10;
@@ -152,8 +152,8 @@
StorageDead(_9);
StorageDead(_8);
StorageDead(_6);
-- falseEdge -> [real: bb1, imaginary: bb1];
-+ goto -> bb1;
+- falseEdge -> [real: bb3, imaginary: bb3];
++ goto -> bb2;
}
- bb15: {
@@ -181,7 +181,7 @@
- FakeRead(ForGuardBinding, _6);
- FakeRead(ForGuardBinding, _8);
StorageLive(_5);
- _5 = copy (_2.0: bool);
+ _5 = copy (_2.1: bool);
StorageLive(_7);
_7 = move (_2.2: std::string::String);
- goto -> bb10;
@@ -194,8 +194,8 @@
StorageDead(_12);
StorageDead(_8);
StorageDead(_6);
-- falseEdge -> [real: bb3, imaginary: bb3];
-+ goto -> bb2;
+- falseEdge -> [real: bb1, imaginary: bb1];
++ goto -> bb1;
}
- bb19: {
diff --git a/tests/mir-opt/match_arm_scopes.complicated_match.panic-unwind.SimplifyCfg-initial.after-ElaborateDrops.after.diff b/tests/mir-opt/match_arm_scopes.complicated_match.panic-unwind.SimplifyCfg-initial.after-ElaborateDrops.after.diff
index b3eb3e1..484bc7d 100644
--- a/tests/mir-opt/match_arm_scopes.complicated_match.panic-unwind.SimplifyCfg-initial.after-ElaborateDrops.after.diff
+++ b/tests/mir-opt/match_arm_scopes.complicated_match.panic-unwind.SimplifyCfg-initial.after-ElaborateDrops.after.diff
@@ -85,11 +85,11 @@
_8 = &(_2.2: std::string::String);
- _3 = &fake shallow (_2.0: bool);
- _4 = &fake shallow (_2.1: bool);
- StorageLive(_12);
- StorageLive(_13);
- _13 = copy _1;
-- switchInt(move _13) -> [0: bb16, otherwise: bb15];
-+ switchInt(move _13) -> [0: bb13, otherwise: bb12];
+ StorageLive(_9);
+ StorageLive(_10);
+ _10 = copy _1;
+- switchInt(move _10) -> [0: bb12, otherwise: bb11];
++ switchInt(move _10) -> [0: bb9, otherwise: bb8];
}
- bb9: {
@@ -100,11 +100,11 @@
_8 = &(_2.2: std::string::String);
- _3 = &fake shallow (_2.0: bool);
- _4 = &fake shallow (_2.1: bool);
- StorageLive(_9);
- StorageLive(_10);
- _10 = copy _1;
-- switchInt(move _10) -> [0: bb12, otherwise: bb11];
-+ switchInt(move _10) -> [0: bb9, otherwise: bb8];
+ StorageLive(_12);
+ StorageLive(_13);
+ _13 = copy _1;
+- switchInt(move _13) -> [0: bb16, otherwise: bb15];
++ switchInt(move _13) -> [0: bb13, otherwise: bb12];
}
- bb10: {
@@ -139,7 +139,7 @@
- FakeRead(ForGuardBinding, _6);
- FakeRead(ForGuardBinding, _8);
StorageLive(_5);
- _5 = copy (_2.1: bool);
+ _5 = copy (_2.0: bool);
StorageLive(_7);
_7 = move (_2.2: std::string::String);
- goto -> bb10;
@@ -152,8 +152,8 @@
StorageDead(_9);
StorageDead(_8);
StorageDead(_6);
-- falseEdge -> [real: bb1, imaginary: bb1];
-+ goto -> bb1;
+- falseEdge -> [real: bb3, imaginary: bb3];
++ goto -> bb2;
}
- bb15: {
@@ -181,7 +181,7 @@
- FakeRead(ForGuardBinding, _6);
- FakeRead(ForGuardBinding, _8);
StorageLive(_5);
- _5 = copy (_2.0: bool);
+ _5 = copy (_2.1: bool);
StorageLive(_7);
_7 = move (_2.2: std::string::String);
- goto -> bb10;
@@ -194,8 +194,8 @@
StorageDead(_12);
StorageDead(_8);
StorageDead(_6);
-- falseEdge -> [real: bb3, imaginary: bb3];
-+ goto -> bb2;
+- falseEdge -> [real: bb1, imaginary: bb1];
++ goto -> bb1;
}
- bb19: {
diff --git a/tests/run-make/libtest-json/output-default.json b/tests/run-make/libtest-json/output-default.json
index a6a8a9f..5371715 100644
--- a/tests/run-make/libtest-json/output-default.json
+++ b/tests/run-make/libtest-json/output-default.json
@@ -2,7 +2,7 @@
{ "type": "test", "event": "started", "name": "a" }
{ "type": "test", "name": "a", "event": "ok" }
{ "type": "test", "event": "started", "name": "b" }
-{ "type": "test", "name": "b", "event": "failed", "stdout": "\nthread 'b' panicked at f.rs:9:5:\nassertion failed: false\nnote: run with `RUST_BACKTRACE=1` environment variable to display a backtrace\n" }
+{ "type": "test", "name": "b", "event": "failed", "stdout": "\nthread 'b' ($TID) panicked at f.rs:9:5:\nassertion failed: false\nnote: run with `RUST_BACKTRACE=1` environment variable to display a backtrace\n" }
{ "type": "test", "event": "started", "name": "c" }
{ "type": "test", "name": "c", "event": "ok" }
{ "type": "test", "event": "started", "name": "d" }
diff --git a/tests/run-make/libtest-json/output-stdout-success.json b/tests/run-make/libtest-json/output-stdout-success.json
index a6c36e7..5caadcf 100644
--- a/tests/run-make/libtest-json/output-stdout-success.json
+++ b/tests/run-make/libtest-json/output-stdout-success.json
@@ -2,9 +2,9 @@
{ "type": "test", "event": "started", "name": "a" }
{ "type": "test", "name": "a", "event": "ok", "stdout": "print from successful test\n" }
{ "type": "test", "event": "started", "name": "b" }
-{ "type": "test", "name": "b", "event": "failed", "stdout": "\nthread 'b' panicked at f.rs:9:5:\nassertion failed: false\nnote: run with `RUST_BACKTRACE=1` environment variable to display a backtrace\n" }
+{ "type": "test", "name": "b", "event": "failed", "stdout": "\nthread 'b' ($TID) panicked at f.rs:9:5:\nassertion failed: false\nnote: run with `RUST_BACKTRACE=1` environment variable to display a backtrace\n" }
{ "type": "test", "event": "started", "name": "c" }
-{ "type": "test", "name": "c", "event": "ok", "stdout": "\nthread 'c' panicked at f.rs:15:5:\nassertion failed: false\n" }
+{ "type": "test", "name": "c", "event": "ok", "stdout": "\nthread 'c' ($TID) panicked at f.rs:15:5:\nassertion failed: false\n" }
{ "type": "test", "event": "started", "name": "d" }
{ "type": "test", "name": "d", "event": "ignored", "message": "msg" }
{ "type": "suite", "event": "failed", "passed": 2, "failed": 1, "ignored": 1, "measured": 0, "filtered_out": 0, "exec_time": "$EXEC_TIME" }
diff --git a/tests/run-make/libtest-json/rmake.rs b/tests/run-make/libtest-json/rmake.rs
index c31f4a7..034ba62 100644
--- a/tests/run-make/libtest-json/rmake.rs
+++ b/tests/run-make/libtest-json/rmake.rs
@@ -38,5 +38,6 @@ fn run_tests(extra_args: &[&str], expected_file: &str) {
.expected_file(expected_file)
.actual_text("stdout", test_stdout)
.normalize(r#"(?<prefix>"exec_time": )[0-9.]+"#, r#"${prefix}"$$EXEC_TIME""#)
+ .normalize(r"thread '(?P<name>.*?)' \(\d+\) panicked", "thread '$name' ($$TID) panicked")
.run();
}
diff --git a/tests/run-make/libtest-junit/output-default.xml b/tests/run-make/libtest-junit/output-default.xml
index aa1b8c8..2467d8d 100644
--- a/tests/run-make/libtest-junit/output-default.xml
+++ b/tests/run-make/libtest-junit/output-default.xml
@@ -1 +1 @@
-<?xml version="1.0" encoding="UTF-8"?><testsuites><testsuite name="test" package="test" id="0" errors="0" failures="1" tests="4" skipped="1" ><testcase classname="unknown" name="a" time="$TIME"/><testcase classname="unknown" name="b" time="$TIME"><failure type="assert"/><system-out><![CDATA[print from failing test]]>

<![CDATA[thread 'b' panicked at f.rs:10:5:]]>
<![CDATA[assertion failed: false]]>
<![CDATA[note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace]]>
<![CDATA[]]></system-out></testcase><testcase classname="unknown" name="c" time="$TIME"/><system-out/><system-err/></testsuite></testsuites>
+<?xml version="1.0" encoding="UTF-8"?><testsuites><testsuite name="test" package="test" id="0" errors="0" failures="1" tests="4" skipped="1" ><testcase classname="unknown" name="a" time="$TIME"/><testcase classname="unknown" name="b" time="$TIME"><failure type="assert"/><system-out><![CDATA[print from failing test]]>

<![CDATA[thread 'b' ($TID) panicked at f.rs:10:5:]]>
<![CDATA[assertion failed: false]]>
<![CDATA[note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace]]>
<![CDATA[]]></system-out></testcase><testcase classname="unknown" name="c" time="$TIME"/><system-out/><system-err/></testsuite></testsuites>
diff --git a/tests/run-make/libtest-junit/output-stdout-success.xml b/tests/run-make/libtest-junit/output-stdout-success.xml
index 2592ec7..6bf1d70 100644
--- a/tests/run-make/libtest-junit/output-stdout-success.xml
+++ b/tests/run-make/libtest-junit/output-stdout-success.xml
@@ -1 +1 @@
-<?xml version="1.0" encoding="UTF-8"?><testsuites><testsuite name="test" package="test" id="0" errors="0" failures="1" tests="4" skipped="1" ><testcase classname="unknown" name="a" time="$TIME"><system-out><![CDATA[print from successful test]]>
<![CDATA[]]></system-out></testcase><testcase classname="unknown" name="b" time="$TIME"><failure type="assert"/><system-out><![CDATA[print from failing test]]>

<![CDATA[thread 'b' panicked at f.rs:10:5:]]>
<![CDATA[assertion failed: false]]>
<![CDATA[note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace]]>
<![CDATA[]]></system-out></testcase><testcase classname="unknown" name="c" time="$TIME"><system-out><![CDATA[]]>
<![CDATA[thread 'c' panicked at f.rs:16:5:]]>
<![CDATA[assertion failed: false]]>
<![CDATA[]]></system-out></testcase><system-out/><system-err/></testsuite></testsuites>
+<?xml version="1.0" encoding="UTF-8"?><testsuites><testsuite name="test" package="test" id="0" errors="0" failures="1" tests="4" skipped="1" ><testcase classname="unknown" name="a" time="$TIME"><system-out><![CDATA[print from successful test]]>
<![CDATA[]]></system-out></testcase><testcase classname="unknown" name="b" time="$TIME"><failure type="assert"/><system-out><![CDATA[print from failing test]]>

<![CDATA[thread 'b' ($TID) panicked at f.rs:10:5:]]>
<![CDATA[assertion failed: false]]>
<![CDATA[note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace]]>
<![CDATA[]]></system-out></testcase><testcase classname="unknown" name="c" time="$TIME"><system-out><![CDATA[]]>
<![CDATA[thread 'c' ($TID) panicked at f.rs:16:5:]]>
<![CDATA[assertion failed: false]]>
<![CDATA[]]></system-out></testcase><system-out/><system-err/></testsuite></testsuites>
diff --git a/tests/run-make/libtest-junit/rmake.rs b/tests/run-make/libtest-junit/rmake.rs
index 5917660..6961be2 100644
--- a/tests/run-make/libtest-junit/rmake.rs
+++ b/tests/run-make/libtest-junit/rmake.rs
@@ -27,5 +27,6 @@ fn run_tests(extra_args: &[&str], expected_file: &str) {
.expected_file(expected_file)
.actual_text("stdout", test_stdout)
.normalize(r#"\btime="[0-9.]+""#, r#"time="$$TIME""#)
+ .normalize(r"thread '(?P<name>.*?)' \(\d+\) panicked", "thread '$name' ($$TID) panicked")
.run();
}
diff --git a/tests/run-make/rustdoc-scrape-examples-paths/foo/Cargo.toml b/tests/run-make/rustdoc-scrape-examples-paths/foo/Cargo.toml
new file mode 100644
index 0000000..6962028
--- /dev/null
+++ b/tests/run-make/rustdoc-scrape-examples-paths/foo/Cargo.toml
@@ -0,0 +1,8 @@
+[package]
+name = "foo"
+version = "0.0.1"
+edition = "2024"
+
+[[example]]
+name = "complex"
+doc-scrape-examples = true
diff --git a/tests/run-make/rustdoc-scrape-examples-paths/foo/examples/complex.rs b/tests/run-make/rustdoc-scrape-examples-paths/foo/examples/complex.rs
new file mode 100644
index 0000000..1cda7e0
--- /dev/null
+++ b/tests/run-make/rustdoc-scrape-examples-paths/foo/examples/complex.rs
@@ -0,0 +1,3 @@
+fn main() {
+ let mut x = foo::X::new();
+}
diff --git a/tests/run-make/rustdoc-scrape-examples-paths/foo/examples/tester.rs b/tests/run-make/rustdoc-scrape-examples-paths/foo/examples/tester.rs
new file mode 100644
index 0000000..fbd1906
--- /dev/null
+++ b/tests/run-make/rustdoc-scrape-examples-paths/foo/examples/tester.rs
@@ -0,0 +1 @@
+// This file MUST exist to trigger the original bug.
diff --git a/tests/run-make/rustdoc-scrape-examples-paths/foo/src/lib.rs b/tests/run-make/rustdoc-scrape-examples-paths/foo/src/lib.rs
new file mode 100644
index 0000000..a9bb027
--- /dev/null
+++ b/tests/run-make/rustdoc-scrape-examples-paths/foo/src/lib.rs
@@ -0,0 +1,7 @@
+pub struct X;
+
+impl X {
+ pub fn new() -> Self {
+ X
+ }
+}
diff --git a/tests/run-make/rustdoc-scrape-examples-paths/rmake.rs b/tests/run-make/rustdoc-scrape-examples-paths/rmake.rs
new file mode 100644
index 0000000..03888f6
--- /dev/null
+++ b/tests/run-make/rustdoc-scrape-examples-paths/rmake.rs
@@ -0,0 +1,16 @@
+//! Test to ensure that the rustdoc `scrape-examples` feature is not panicking.
+//! Regression test for <https://github.com/rust-lang/rust/issues/144752>.
+
+use run_make_support::{cargo, path, rfs};
+
+fn main() {
+ // We copy the crate to be documented "outside" to prevent documenting
+ // the whole compiler.
+ let tmp = std::env::temp_dir();
+ let test_crate = tmp.join("foo");
+ rfs::copy_dir_all(path("foo"), &test_crate);
+
+ // The `scrape-examples` feature is also implemented in `cargo` so instead of reproducing
+ // what `cargo` does, better to just let `cargo` do it.
+ cargo().current_dir(&test_crate).args(["doc", "-p", "foo", "-Zrustdoc-scrape-examples"]).run();
+}
diff --git a/tests/rustdoc-ui/doctest/edition-2024-error-output.stdout b/tests/rustdoc-ui/doctest/edition-2024-error-output.stdout
index ab6aca2..c8acbe4 100644
--- a/tests/rustdoc-ui/doctest/edition-2024-error-output.stdout
+++ b/tests/rustdoc-ui/doctest/edition-2024-error-output.stdout
@@ -9,7 +9,7 @@
stderr:
-thread 'main' panicked at $TMP:6:1:
+thread 'main' ($TID) panicked at $TMP:6:1:
assertion `left == right` failed
left: 4
right: 5
diff --git a/tests/rustdoc-ui/doctest/failed-doctest-output-windows.stdout b/tests/rustdoc-ui/doctest/failed-doctest-output-windows.stdout
index 7aa965d..12a59d4 100644
--- a/tests/rustdoc-ui/doctest/failed-doctest-output-windows.stdout
+++ b/tests/rustdoc-ui/doctest/failed-doctest-output-windows.stdout
@@ -27,7 +27,7 @@
stderr 1
stderr 2
-thread 'main' panicked at $DIR/failed-doctest-output-windows.rs:7:1:
+thread 'main' ($TID) panicked at $DIR/failed-doctest-output-windows.rs:7:1:
oh no
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
diff --git a/tests/rustdoc-ui/doctest/failed-doctest-output.stdout b/tests/rustdoc-ui/doctest/failed-doctest-output.stdout
index a333f34..3dbb217 100644
--- a/tests/rustdoc-ui/doctest/failed-doctest-output.stdout
+++ b/tests/rustdoc-ui/doctest/failed-doctest-output.stdout
@@ -27,7 +27,7 @@
stderr 1
stderr 2
-thread 'main' panicked at $DIR/failed-doctest-output.rs:7:1:
+thread 'main' ($TID) panicked at $DIR/failed-doctest-output.rs:7:1:
oh no
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
diff --git a/tests/rustdoc-ui/doctest/stdout-and-stderr.stdout b/tests/rustdoc-ui/doctest/stdout-and-stderr.stdout
index a35a4d7..dfdcd77 100644
--- a/tests/rustdoc-ui/doctest/stdout-and-stderr.stdout
+++ b/tests/rustdoc-ui/doctest/stdout-and-stderr.stdout
@@ -14,7 +14,7 @@
stderr:
-thread 'main' panicked at $TMP:7:1:
+thread 'main' ($TID) panicked at $TMP:7:1:
assertion `left == right` failed
left: "doc"
right: "test"
@@ -26,7 +26,7 @@
stderr:
-thread 'main' panicked at $TMP:15:1:
+thread 'main' ($TID) panicked at $TMP:15:1:
assertion `left == right` failed
left: "doc"
right: "test"
diff --git a/tests/rustdoc-ui/remap-path-prefix-failed-doctest-output.stdout b/tests/rustdoc-ui/remap-path-prefix-failed-doctest-output.stdout
index 87d1e77..08f7a4d 100644
--- a/tests/rustdoc-ui/remap-path-prefix-failed-doctest-output.stdout
+++ b/tests/rustdoc-ui/remap-path-prefix-failed-doctest-output.stdout
@@ -9,7 +9,7 @@
stderr:
-thread 'main' panicked at remapped_path/remap-path-prefix-failed-doctest-output.rs:3:1:
+thread 'main' ($TID) panicked at remapped_path/remap-path-prefix-failed-doctest-output.rs:3:1:
oh no
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
diff --git a/tests/rustdoc/intra-doc/macro-caching-144965.rs b/tests/rustdoc/intra-doc/macro-caching-144965.rs
new file mode 100644
index 0000000..e14b465
--- /dev/null
+++ b/tests/rustdoc/intra-doc/macro-caching-144965.rs
@@ -0,0 +1,35 @@
+// regression test for https://github.com/rust-lang/rust/issues/144965
+
+#![crate_name = "foo"]
+#![no_std]
+
+#[doc(hidden)]
+pub struct MyStruct;
+
+macro_rules! my_macro {
+ () => {
+ pub fn my_function() {}
+
+ /// Incorrect: [`my_function()`].
+ #[doc(inline)]
+ pub use $crate::MyStruct;
+
+ /// Correct: [`my_function`].
+ pub struct AnotherStruct;
+ };
+}
+
+
+pub mod one {
+ //@ has 'foo/one/index.html'
+ //@ has - '//dl[@class="item-table"]/dd[1]/a[@href="fn.my_function.html"]/code' 'my_function'
+ //@ has - '//dl[@class="item-table"]/dd[2]/a[@href="fn.my_function.html"]/code' 'my_function()'
+ my_macro!();
+}
+
+pub mod two {
+ //@ has 'foo/two/index.html'
+ //@ has - '//dl[@class="item-table"]/dd[1]/a[@href="fn.my_function.html"]/code' 'my_function'
+ //@ has - '//dl[@class="item-table"]/dd[2]/a[@href="fn.my_function.html"]/code' 'my_function()'
+ my_macro!();
+}
diff --git a/tests/ui/async-await/issues/issue-65419/issue-65419-async-fn-resume-after-completion.rs b/tests/ui/async-await/issues/issue-65419/issue-65419-async-fn-resume-after-completion.rs
index a8b05a4..ed99614 100644
--- a/tests/ui/async-await/issues/issue-65419/issue-65419-async-fn-resume-after-completion.rs
+++ b/tests/ui/async-await/issues/issue-65419/issue-65419-async-fn-resume-after-completion.rs
@@ -2,7 +2,7 @@
// be talking about `async fn`s instead.
//@ run-fail
-//@ error-pattern: thread 'main' panicked
+//@ regex-error-pattern: thread 'main'.*panicked
//@ error-pattern: `async fn` resumed after completion
//@ edition:2018
diff --git a/tests/ui/async-await/issues/issue-65419/issue-65419-async-fn-resume-after-panic.rs b/tests/ui/async-await/issues/issue-65419/issue-65419-async-fn-resume-after-panic.rs
index 94366e6..881fafb 100644
--- a/tests/ui/async-await/issues/issue-65419/issue-65419-async-fn-resume-after-panic.rs
+++ b/tests/ui/async-await/issues/issue-65419/issue-65419-async-fn-resume-after-panic.rs
@@ -3,7 +3,7 @@
//@ run-fail
//@ needs-unwind
-//@ error-pattern: thread 'main' panicked
+//@ regex-error-pattern: thread 'main'.*panicked
//@ error-pattern: `async fn` resumed after panicking
//@ edition:2018
diff --git a/tests/ui/attributes/check-builtin-attr-ice.rs b/tests/ui/attributes/check-builtin-attr-ice.rs
index 7745849..811210e 100644
--- a/tests/ui/attributes/check-builtin-attr-ice.rs
+++ b/tests/ui/attributes/check-builtin-attr-ice.rs
@@ -44,12 +44,10 @@
struct Foo {
#[should_panic::skip]
//~^ ERROR failed to resolve
- //~| ERROR `#[should_panic::skip]` only has an effect on functions
pub field: u8,
#[should_panic::a::b::c]
//~^ ERROR failed to resolve
- //~| ERROR `#[should_panic::a::b::c]` only has an effect on functions
pub field2: u8,
}
diff --git a/tests/ui/attributes/check-builtin-attr-ice.stderr b/tests/ui/attributes/check-builtin-attr-ice.stderr
index 4f26f71..07bbe01 100644
--- a/tests/ui/attributes/check-builtin-attr-ice.stderr
+++ b/tests/ui/attributes/check-builtin-attr-ice.stderr
@@ -5,35 +5,17 @@
| ^^^^^^^^^^^^ use of unresolved module or unlinked crate `should_panic`
error[E0433]: failed to resolve: use of unresolved module or unlinked crate `should_panic`
- --> $DIR/check-builtin-attr-ice.rs:50:7
+ --> $DIR/check-builtin-attr-ice.rs:49:7
|
LL | #[should_panic::a::b::c]
| ^^^^^^^^^^^^ use of unresolved module or unlinked crate `should_panic`
error[E0433]: failed to resolve: use of unresolved module or unlinked crate `deny`
- --> $DIR/check-builtin-attr-ice.rs:59:7
+ --> $DIR/check-builtin-attr-ice.rs:57:7
|
LL | #[deny::skip]
| ^^^^ use of unresolved module or unlinked crate `deny`
-error: `#[should_panic::skip]` only has an effect on functions
- --> $DIR/check-builtin-attr-ice.rs:45:5
- |
-LL | #[should_panic::skip]
- | ^^^^^^^^^^^^^^^^^^^^^
- |
-note: the lint level is defined here
- --> $DIR/check-builtin-attr-ice.rs:42:9
- |
-LL | #![deny(unused_attributes)]
- | ^^^^^^^^^^^^^^^^^
-
-error: `#[should_panic::a::b::c]` only has an effect on functions
- --> $DIR/check-builtin-attr-ice.rs:50:5
- |
-LL | #[should_panic::a::b::c]
- | ^^^^^^^^^^^^^^^^^^^^^^^^
-
-error: aborting due to 5 previous errors
+error: aborting due to 3 previous errors
For more information about this error, try `rustc --explain E0433`.
diff --git a/tests/ui/attributes/key-value-expansion-scope.rs b/tests/ui/attributes/key-value-expansion-scope.rs
index 49a5950..6688d69 100644
--- a/tests/ui/attributes/key-value-expansion-scope.rs
+++ b/tests/ui/attributes/key-value-expansion-scope.rs
@@ -1,7 +1,7 @@
-#![doc = in_root!()] //~ WARN cannot find macro `in_root`
+#![doc = in_root!()] //~ ERROR cannot find macro `in_root`
//~| WARN this was previously accepted by the compiler
#![doc = in_mod!()] //~ ERROR cannot find macro `in_mod` in this scope
-#![doc = in_mod_escape!()] //~ WARN cannot find macro `in_mod_escape`
+#![doc = in_mod_escape!()] //~ ERROR cannot find macro `in_mod_escape`
//~| WARN this was previously accepted by the compiler
#![doc = in_block!()] //~ ERROR cannot find macro `in_block` in this scope
@@ -18,10 +18,10 @@ fn before() {
macro_rules! in_root { () => { "" } }
-#[doc = in_mod!()] //~ WARN cannot find macro `in_mod`
+#[doc = in_mod!()] //~ ERROR cannot find macro `in_mod`
//~| WARN this was previously accepted by the compiler
mod macros_stay {
- #![doc = in_mod!()] //~ WARN cannot find macro `in_mod`
+ #![doc = in_mod!()] //~ ERROR cannot find macro `in_mod`
//~| WARN this was previously accepted by the compiler
macro_rules! in_mod { () => { "" } }
@@ -33,10 +33,10 @@ fn f() {
}
#[macro_use]
-#[doc = in_mod_escape!()] //~ WARN cannot find macro `in_mod_escape`
+#[doc = in_mod_escape!()] //~ ERROR cannot find macro `in_mod_escape`
//~| WARN this was previously accepted by the compiler
mod macros_escape {
- #![doc = in_mod_escape!()] //~ WARN cannot find macro `in_mod_escape`
+ #![doc = in_mod_escape!()] //~ ERROR cannot find macro `in_mod_escape`
//~| WARN this was previously accepted by the compiler
macro_rules! in_mod_escape { () => { "" } }
diff --git a/tests/ui/attributes/key-value-expansion-scope.stderr b/tests/ui/attributes/key-value-expansion-scope.stderr
index 91a602e..29b48ca 100644
--- a/tests/ui/attributes/key-value-expansion-scope.stderr
+++ b/tests/ui/attributes/key-value-expansion-scope.stderr
@@ -126,7 +126,7 @@
|
= help: have you added the `#[macro_use]` on the module/import?
-warning: cannot find macro `in_root` in the current scope when looking from the crate root
+error: cannot find macro `in_root` in the current scope when looking from the crate root
--> $DIR/key-value-expansion-scope.rs:1:10
|
LL | #![doc = in_root!()]
@@ -135,9 +135,9 @@
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
= note: for more information, see issue #124535 <https://github.com/rust-lang/rust/issues/124535>
= help: import `macro_rules` with `use` to make it callable above its definition
- = note: `#[warn(out_of_scope_macro_calls)]` on by default
+ = note: `#[deny(out_of_scope_macro_calls)]` on by default
-warning: cannot find macro `in_mod_escape` in the current scope when looking from the crate root
+error: cannot find macro `in_mod_escape` in the current scope when looking from the crate root
--> $DIR/key-value-expansion-scope.rs:4:10
|
LL | #![doc = in_mod_escape!()]
@@ -147,7 +147,7 @@
= note: for more information, see issue #124535 <https://github.com/rust-lang/rust/issues/124535>
= help: import `macro_rules` with `use` to make it callable above its definition
-warning: cannot find macro `in_mod` in the current scope when looking from module `macros_stay`
+error: cannot find macro `in_mod` in the current scope when looking from module `macros_stay`
--> $DIR/key-value-expansion-scope.rs:21:9
|
LL | #[doc = in_mod!()]
@@ -157,7 +157,7 @@
= note: for more information, see issue #124535 <https://github.com/rust-lang/rust/issues/124535>
= help: import `macro_rules` with `use` to make it callable above its definition
-warning: cannot find macro `in_mod` in the current scope when looking from module `macros_stay`
+error: cannot find macro `in_mod` in the current scope when looking from module `macros_stay`
--> $DIR/key-value-expansion-scope.rs:24:14
|
LL | #![doc = in_mod!()]
@@ -167,7 +167,7 @@
= note: for more information, see issue #124535 <https://github.com/rust-lang/rust/issues/124535>
= help: import `macro_rules` with `use` to make it callable above its definition
-warning: cannot find macro `in_mod_escape` in the current scope when looking from module `macros_escape`
+error: cannot find macro `in_mod_escape` in the current scope when looking from module `macros_escape`
--> $DIR/key-value-expansion-scope.rs:36:9
|
LL | #[doc = in_mod_escape!()]
@@ -177,7 +177,7 @@
= note: for more information, see issue #124535 <https://github.com/rust-lang/rust/issues/124535>
= help: import `macro_rules` with `use` to make it callable above its definition
-warning: cannot find macro `in_mod_escape` in the current scope when looking from module `macros_escape`
+error: cannot find macro `in_mod_escape` in the current scope when looking from module `macros_escape`
--> $DIR/key-value-expansion-scope.rs:39:14
|
LL | #![doc = in_mod_escape!()]
@@ -187,5 +187,77 @@
= note: for more information, see issue #124535 <https://github.com/rust-lang/rust/issues/124535>
= help: import `macro_rules` with `use` to make it callable above its definition
-error: aborting due to 16 previous errors; 6 warnings emitted
+error: aborting due to 22 previous errors
+
+Future incompatibility report: Future breakage diagnostic:
+error: cannot find macro `in_root` in the current scope when looking from the crate root
+ --> $DIR/key-value-expansion-scope.rs:1:10
+ |
+LL | #![doc = in_root!()]
+ | ^^^^^^^ not found from the crate root
+ |
+ = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
+ = note: for more information, see issue #124535 <https://github.com/rust-lang/rust/issues/124535>
+ = help: import `macro_rules` with `use` to make it callable above its definition
+ = note: `#[deny(out_of_scope_macro_calls)]` on by default
+
+Future breakage diagnostic:
+error: cannot find macro `in_mod_escape` in the current scope when looking from the crate root
+ --> $DIR/key-value-expansion-scope.rs:4:10
+ |
+LL | #![doc = in_mod_escape!()]
+ | ^^^^^^^^^^^^^ not found from the crate root
+ |
+ = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
+ = note: for more information, see issue #124535 <https://github.com/rust-lang/rust/issues/124535>
+ = help: import `macro_rules` with `use` to make it callable above its definition
+ = note: `#[deny(out_of_scope_macro_calls)]` on by default
+
+Future breakage diagnostic:
+error: cannot find macro `in_mod` in the current scope when looking from module `macros_stay`
+ --> $DIR/key-value-expansion-scope.rs:21:9
+ |
+LL | #[doc = in_mod!()]
+ | ^^^^^^ not found from module `macros_stay`
+ |
+ = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
+ = note: for more information, see issue #124535 <https://github.com/rust-lang/rust/issues/124535>
+ = help: import `macro_rules` with `use` to make it callable above its definition
+ = note: `#[deny(out_of_scope_macro_calls)]` on by default
+
+Future breakage diagnostic:
+error: cannot find macro `in_mod` in the current scope when looking from module `macros_stay`
+ --> $DIR/key-value-expansion-scope.rs:24:14
+ |
+LL | #![doc = in_mod!()]
+ | ^^^^^^ not found from module `macros_stay`
+ |
+ = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
+ = note: for more information, see issue #124535 <https://github.com/rust-lang/rust/issues/124535>
+ = help: import `macro_rules` with `use` to make it callable above its definition
+ = note: `#[deny(out_of_scope_macro_calls)]` on by default
+
+Future breakage diagnostic:
+error: cannot find macro `in_mod_escape` in the current scope when looking from module `macros_escape`
+ --> $DIR/key-value-expansion-scope.rs:36:9
+ |
+LL | #[doc = in_mod_escape!()]
+ | ^^^^^^^^^^^^^ not found from module `macros_escape`
+ |
+ = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
+ = note: for more information, see issue #124535 <https://github.com/rust-lang/rust/issues/124535>
+ = help: import `macro_rules` with `use` to make it callable above its definition
+ = note: `#[deny(out_of_scope_macro_calls)]` on by default
+
+Future breakage diagnostic:
+error: cannot find macro `in_mod_escape` in the current scope when looking from module `macros_escape`
+ --> $DIR/key-value-expansion-scope.rs:39:14
+ |
+LL | #![doc = in_mod_escape!()]
+ | ^^^^^^^^^^^^^ not found from module `macros_escape`
+ |
+ = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
+ = note: for more information, see issue #124535 <https://github.com/rust-lang/rust/issues/124535>
+ = help: import `macro_rules` with `use` to make it callable above its definition
+ = note: `#[deny(out_of_scope_macro_calls)]` on by default
diff --git a/tests/ui/attributes/malformed-attrs.stderr b/tests/ui/attributes/malformed-attrs.stderr
index 1b51075..e8ae471 100644
--- a/tests/ui/attributes/malformed-attrs.stderr
+++ b/tests/ui/attributes/malformed-attrs.stderr
@@ -55,12 +55,6 @@
LL | #[patchable_function_entry]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: must be of the form: `#[patchable_function_entry(prefix_nops = m, entry_nops = n)]`
-error: malformed `coroutine` attribute input
- --> $DIR/malformed-attrs.rs:108:5
- |
-LL | #[coroutine = 63] || {}
- | ^^^^^^^^^^^^^^^^^ help: must be of the form: `#[coroutine]`
-
error: malformed `must_not_suspend` attribute input
--> $DIR/malformed-attrs.rs:129:1
|
@@ -436,6 +430,15 @@
| | didn't expect any arguments here
| help: must be of the form: `#[proc_macro]`
+error[E0565]: malformed `coroutine` attribute input
+ --> $DIR/malformed-attrs.rs:108:5
+ |
+LL | #[coroutine = 63] || {}
+ | ^^^^^^^^^^^^----^
+ | | |
+ | | didn't expect any arguments here
+ | help: must be of the form: `#[coroutine]`
+
error[E0565]: malformed `proc_macro_attribute` attribute input
--> $DIR/malformed-attrs.rs:113:1
|
diff --git a/tests/ui/auto-traits/assoc-ty.current.stderr b/tests/ui/auto-traits/assoc-ty.current.stderr
index 77a1c8f..d793ae6 100644
--- a/tests/ui/auto-traits/assoc-ty.current.stderr
+++ b/tests/ui/auto-traits/assoc-ty.current.stderr
@@ -5,7 +5,7 @@
| ----- auto traits cannot have associated items
LL |
LL | type Output;
- | -----^^^^^^- help: remove these associated items
+ | ^^^^^^
error[E0658]: auto traits are experimental and possibly buggy
--> $DIR/assoc-ty.rs:8:1
diff --git a/tests/ui/auto-traits/assoc-ty.next.stderr b/tests/ui/auto-traits/assoc-ty.next.stderr
index 4ce00d1..a41f7d9 100644
--- a/tests/ui/auto-traits/assoc-ty.next.stderr
+++ b/tests/ui/auto-traits/assoc-ty.next.stderr
@@ -5,7 +5,7 @@
| ----- auto traits cannot have associated items
LL |
LL | type Output;
- | -----^^^^^^- help: remove these associated items
+ | ^^^^^^
error[E0658]: auto traits are experimental and possibly buggy
--> $DIR/assoc-ty.rs:8:1
diff --git a/tests/ui/auto-traits/auto-trait-validation.fixed b/tests/ui/auto-traits/auto-trait-validation.fixed
index 8a44544..b24dc1c 100644
--- a/tests/ui/auto-traits/auto-trait-validation.fixed
+++ b/tests/ui/auto-traits/auto-trait-validation.fixed
@@ -11,4 +11,15 @@
//~^ ERROR auto traits cannot have super traits or lifetime bounds [E0568]
auto trait MyTrait { }
//~^ ERROR auto traits cannot have associated items [E0380]
+auto trait AssocTy { }
+//~^ ERROR auto traits cannot have associated items [E0380]
+auto trait All {
+ //~^ ERROR auto traits cannot have generic parameters [E0567]
+
+}
+// We can't test both generic params and super-traits because the suggestion span overlaps.
+auto trait All2 {
+ //~^ ERROR auto traits cannot have super traits or lifetime bounds [E0568]
+
+}
fn main() {}
diff --git a/tests/ui/auto-traits/auto-trait-validation.rs b/tests/ui/auto-traits/auto-trait-validation.rs
index b5e7505..9665e5b 100644
--- a/tests/ui/auto-traits/auto-trait-validation.rs
+++ b/tests/ui/auto-traits/auto-trait-validation.rs
@@ -11,4 +11,19 @@
//~^ ERROR auto traits cannot have super traits or lifetime bounds [E0568]
auto trait MyTrait { fn foo() {} }
//~^ ERROR auto traits cannot have associated items [E0380]
+auto trait AssocTy { type Bar; }
+//~^ ERROR auto traits cannot have associated items [E0380]
+auto trait All<'a, T> {
+ //~^ ERROR auto traits cannot have generic parameters [E0567]
+ type Bar;
+ //~^ ERROR auto traits cannot have associated items [E0380]
+ fn foo() {}
+}
+// We can't test both generic params and super-traits because the suggestion span overlaps.
+auto trait All2: Copy + 'static {
+ //~^ ERROR auto traits cannot have super traits or lifetime bounds [E0568]
+ type Bar;
+ //~^ ERROR auto traits cannot have associated items [E0380]
+ fn foo() {}
+}
fn main() {}
diff --git a/tests/ui/auto-traits/auto-trait-validation.stderr b/tests/ui/auto-traits/auto-trait-validation.stderr
index a6e5ac5..60757db 100644
--- a/tests/ui/auto-traits/auto-trait-validation.stderr
+++ b/tests/ui/auto-traits/auto-trait-validation.stderr
@@ -2,23 +2,23 @@
--> $DIR/auto-trait-validation.rs:6:19
|
LL | auto trait Generic<T> {}
- | -------^^^ help: remove the parameters
+ | -------^^^
| |
| auto trait cannot have generic parameters
error[E0568]: auto traits cannot have super traits or lifetime bounds
- --> $DIR/auto-trait-validation.rs:8:17
+ --> $DIR/auto-trait-validation.rs:8:20
|
LL | auto trait Bound : Copy {}
- | -----^^^^^^^ help: remove the super traits or lifetime bounds
+ | ----- ^^^^
| |
| auto traits cannot have super traits or lifetime bounds
error[E0568]: auto traits cannot have super traits or lifetime bounds
- --> $DIR/auto-trait-validation.rs:10:25
+ --> $DIR/auto-trait-validation.rs:10:28
|
LL | auto trait LifetimeBound : 'static {}
- | -------------^^^^^^^^^^ help: remove the super traits or lifetime bounds
+ | ------------- ^^^^^^^
| |
| auto traits cannot have super traits or lifetime bounds
@@ -26,12 +26,59 @@
--> $DIR/auto-trait-validation.rs:12:25
|
LL | auto trait MyTrait { fn foo() {} }
- | ------- ---^^^-----
- | | |
- | | help: remove these associated items
+ | ------- ^^^
+ | |
| auto traits cannot have associated items
-error: aborting due to 4 previous errors
+error[E0380]: auto traits cannot have associated items
+ --> $DIR/auto-trait-validation.rs:14:27
+ |
+LL | auto trait AssocTy { type Bar; }
+ | ------- ^^^
+ | |
+ | auto traits cannot have associated items
+
+error[E0567]: auto traits cannot have generic parameters
+ --> $DIR/auto-trait-validation.rs:16:15
+ |
+LL | auto trait All<'a, T> {
+ | ---^^^^^^^
+ | |
+ | auto trait cannot have generic parameters
+
+error[E0380]: auto traits cannot have associated items
+ --> $DIR/auto-trait-validation.rs:18:10
+ |
+LL | auto trait All<'a, T> {
+ | --- auto traits cannot have associated items
+LL |
+LL | type Bar;
+ | ^^^
+LL |
+LL | fn foo() {}
+ | ^^^
+
+error[E0568]: auto traits cannot have super traits or lifetime bounds
+ --> $DIR/auto-trait-validation.rs:23:18
+ |
+LL | auto trait All2: Copy + 'static {
+ | ---- ^^^^ ^^^^^^^
+ | |
+ | auto traits cannot have super traits or lifetime bounds
+
+error[E0380]: auto traits cannot have associated items
+ --> $DIR/auto-trait-validation.rs:25:10
+ |
+LL | auto trait All2: Copy + 'static {
+ | ---- auto traits cannot have associated items
+LL |
+LL | type Bar;
+ | ^^^
+LL |
+LL | fn foo() {}
+ | ^^^
+
+error: aborting due to 9 previous errors
Some errors have detailed explanations: E0380, E0567, E0568.
For more information about an error, try `rustc --explain E0380`.
diff --git a/tests/ui/auto-traits/bad-generics-on-dyn.stderr b/tests/ui/auto-traits/bad-generics-on-dyn.stderr
index 06c7cbc..a6977c2 100644
--- a/tests/ui/auto-traits/bad-generics-on-dyn.stderr
+++ b/tests/ui/auto-traits/bad-generics-on-dyn.stderr
@@ -2,7 +2,7 @@
--> $DIR/bad-generics-on-dyn.rs:3:18
|
LL | auto trait Trait1<'a> {}
- | ------^^^^ help: remove the parameters
+ | ------^^^^
| |
| auto trait cannot have generic parameters
diff --git a/tests/ui/auto-traits/has-arguments.stderr b/tests/ui/auto-traits/has-arguments.stderr
index b8a680e..5228b6d 100644
--- a/tests/ui/auto-traits/has-arguments.stderr
+++ b/tests/ui/auto-traits/has-arguments.stderr
@@ -2,7 +2,7 @@
--> $DIR/has-arguments.rs:3:18
|
LL | auto trait Trait1<'outer> {}
- | ------^^^^^^^^ help: remove the parameters
+ | ------^^^^^^^^
| |
| auto trait cannot have generic parameters
diff --git a/tests/ui/auto-traits/issue-117789.stderr b/tests/ui/auto-traits/issue-117789.stderr
index 99efb21..1e047c7 100644
--- a/tests/ui/auto-traits/issue-117789.stderr
+++ b/tests/ui/auto-traits/issue-117789.stderr
@@ -2,7 +2,7 @@
--> $DIR/issue-117789.rs:1:17
|
LL | auto trait Trait<P> {}
- | -----^^^ help: remove the parameters
+ | -----^^^
| |
| auto trait cannot have generic parameters
diff --git a/tests/ui/auto-traits/issue-23080-2.current.stderr b/tests/ui/auto-traits/issue-23080-2.current.stderr
index 62c7b37..3af97f5 100644
--- a/tests/ui/auto-traits/issue-23080-2.current.stderr
+++ b/tests/ui/auto-traits/issue-23080-2.current.stderr
@@ -4,7 +4,7 @@
LL | unsafe auto trait Trait {
| ----- auto traits cannot have associated items
LL | type Output;
- | -----^^^^^^- help: remove these associated items
+ | ^^^^^^
error: aborting due to 1 previous error
diff --git a/tests/ui/auto-traits/issue-23080-2.next.stderr b/tests/ui/auto-traits/issue-23080-2.next.stderr
index 62c7b37..3af97f5 100644
--- a/tests/ui/auto-traits/issue-23080-2.next.stderr
+++ b/tests/ui/auto-traits/issue-23080-2.next.stderr
@@ -4,7 +4,7 @@
LL | unsafe auto trait Trait {
| ----- auto traits cannot have associated items
LL | type Output;
- | -----^^^^^^- help: remove these associated items
+ | ^^^^^^
error: aborting due to 1 previous error
diff --git a/tests/ui/auto-traits/issue-23080.stderr b/tests/ui/auto-traits/issue-23080.stderr
index 5cea450..02a7551 100644
--- a/tests/ui/auto-traits/issue-23080.stderr
+++ b/tests/ui/auto-traits/issue-23080.stderr
@@ -1,13 +1,10 @@
error[E0380]: auto traits cannot have associated items
--> $DIR/issue-23080.rs:5:8
|
-LL | unsafe auto trait Trait {
- | ----- auto traits cannot have associated items
-LL | fn method(&self) {
- | _____- ^^^^^^
-LL | | println!("Hello");
-LL | | }
- | |_____- help: remove these associated items
+LL | unsafe auto trait Trait {
+ | ----- auto traits cannot have associated items
+LL | fn method(&self) {
+ | ^^^^^^
error: aborting due to 1 previous error
diff --git a/tests/ui/auto-traits/issue-84075.stderr b/tests/ui/auto-traits/issue-84075.stderr
index 943d521..4edf2ec 100644
--- a/tests/ui/auto-traits/issue-84075.stderr
+++ b/tests/ui/auto-traits/issue-84075.stderr
@@ -2,7 +2,7 @@
--> $DIR/issue-84075.rs:5:18
|
LL | auto trait Magic where Self: Copy {}
- | ----- ^^^^^^^^^^^^^^^^ help: remove the super traits or lifetime bounds
+ | ----- ^^^^^^^^^^^^^^^^
| |
| auto traits cannot have super traits or lifetime bounds
diff --git a/tests/ui/auto-traits/typeck-auto-trait-no-supertraits-2.stderr b/tests/ui/auto-traits/typeck-auto-trait-no-supertraits-2.stderr
index 27e38ce..bc17fef 100644
--- a/tests/ui/auto-traits/typeck-auto-trait-no-supertraits-2.stderr
+++ b/tests/ui/auto-traits/typeck-auto-trait-no-supertraits-2.stderr
@@ -1,8 +1,8 @@
error[E0568]: auto traits cannot have super traits or lifetime bounds
- --> $DIR/typeck-auto-trait-no-supertraits-2.rs:4:17
+ --> $DIR/typeck-auto-trait-no-supertraits-2.rs:4:20
|
LL | auto trait Magic : Sized where Option<Self> : Magic {}
- | -----^^^^^^^^ help: remove the super traits or lifetime bounds
+ | ----- ^^^^^
| |
| auto traits cannot have super traits or lifetime bounds
@@ -10,7 +10,7 @@
--> $DIR/typeck-auto-trait-no-supertraits-2.rs:4:26
|
LL | auto trait Magic : Sized where Option<Self> : Magic {}
- | ----- ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: remove the super traits or lifetime bounds
+ | ----- ^^^^^^^^^^^^^^^^^^^^^^^^^^
| |
| auto traits cannot have super traits or lifetime bounds
diff --git a/tests/ui/auto-traits/typeck-auto-trait-no-supertraits.stderr b/tests/ui/auto-traits/typeck-auto-trait-no-supertraits.stderr
index 23aae13..bc9791a 100644
--- a/tests/ui/auto-traits/typeck-auto-trait-no-supertraits.stderr
+++ b/tests/ui/auto-traits/typeck-auto-trait-no-supertraits.stderr
@@ -1,8 +1,8 @@
error[E0568]: auto traits cannot have super traits or lifetime bounds
- --> $DIR/typeck-auto-trait-no-supertraits.rs:28:17
+ --> $DIR/typeck-auto-trait-no-supertraits.rs:28:19
|
LL | auto trait Magic: Copy {}
- | -----^^^^^^ help: remove the super traits or lifetime bounds
+ | ----- ^^^^
| |
| auto traits cannot have super traits or lifetime bounds
diff --git a/tests/ui/backtrace/synchronized-panic-handler.run.stderr b/tests/ui/backtrace/synchronized-panic-handler.run.stderr
index 7a60ef2..c604d49 100644
--- a/tests/ui/backtrace/synchronized-panic-handler.run.stderr
+++ b/tests/ui/backtrace/synchronized-panic-handler.run.stderr
@@ -1,7 +1,7 @@
-thread '<unnamed>' panicked at $DIR/synchronized-panic-handler.rs:11:5:
+thread '<unnamed>' ($TID) panicked at $DIR/synchronized-panic-handler.rs:11:5:
oops oh no woe is me
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
-thread '<unnamed>' panicked at $DIR/synchronized-panic-handler.rs:11:5:
+thread '<unnamed>' ($TID) panicked at $DIR/synchronized-panic-handler.rs:11:5:
oops oh no woe is me
diff --git a/tests/ui/check-cfg/target_feature.stderr b/tests/ui/check-cfg/target_feature.stderr
index f422919..44fc23b 100644
--- a/tests/ui/check-cfg/target_feature.stderr
+++ b/tests/ui/check-cfg/target_feature.stderr
@@ -198,6 +198,35 @@
`power9-altivec`
`power9-vector`
`prfchw`
+`ptx32`
+`ptx40`
+`ptx41`
+`ptx42`
+`ptx43`
+`ptx50`
+`ptx60`
+`ptx61`
+`ptx62`
+`ptx63`
+`ptx64`
+`ptx65`
+`ptx70`
+`ptx71`
+`ptx72`
+`ptx73`
+`ptx74`
+`ptx75`
+`ptx76`
+`ptx77`
+`ptx78`
+`ptx80`
+`ptx81`
+`ptx82`
+`ptx83`
+`ptx84`
+`ptx85`
+`ptx86`
+`ptx87`
`quadword-atomics`
`rand`
`ras`
@@ -222,6 +251,33 @@
`simd128`
`sm3`
`sm4`
+`sm_100`
+`sm_100a`
+`sm_101`
+`sm_101a`
+`sm_120`
+`sm_120a`
+`sm_20`
+`sm_21`
+`sm_30`
+`sm_32`
+`sm_35`
+`sm_37`
+`sm_50`
+`sm_52`
+`sm_53`
+`sm_60`
+`sm_61`
+`sm_62`
+`sm_70`
+`sm_72`
+`sm_75`
+`sm_80`
+`sm_86`
+`sm_87`
+`sm_89`
+`sm_90`
+`sm_90a`
`sme`
`sme-b16b16`
`sme-f16f16`
diff --git a/tests/ui/const-generics/defaults/default-on-impl.rs b/tests/ui/const-generics/defaults/default-on-impl.rs
index 9ce46aa..85d0c58 100644
--- a/tests/ui/const-generics/defaults/default-on-impl.rs
+++ b/tests/ui/const-generics/defaults/default-on-impl.rs
@@ -1,6 +1,6 @@
struct Foo<const N: usize>;
impl<const N: usize = 1> Foo<N> {}
-//~^ ERROR defaults for const parameters are only allowed
+//~^ ERROR defaults for generic parameters are not allowed here
fn main() {}
diff --git a/tests/ui/const-generics/defaults/default-on-impl.stderr b/tests/ui/const-generics/defaults/default-on-impl.stderr
index 691e035..eb5d57e 100644
--- a/tests/ui/const-generics/defaults/default-on-impl.stderr
+++ b/tests/ui/const-generics/defaults/default-on-impl.stderr
@@ -1,4 +1,4 @@
-error: defaults for const parameters are only allowed in `struct`, `enum`, `type`, or `trait` definitions
+error: defaults for generic parameters are not allowed here
--> $DIR/default-on-impl.rs:3:6
|
LL | impl<const N: usize = 1> Foo<N> {}
diff --git a/tests/ui/const-generics/generic_const_exprs/issue-105257.rs b/tests/ui/const-generics/generic_const_exprs/issue-105257.rs
index a107556..85a28f2 100644
--- a/tests/ui/const-generics/generic_const_exprs/issue-105257.rs
+++ b/tests/ui/const-generics/generic_const_exprs/issue-105257.rs
@@ -1,10 +1,10 @@
#![feature(generic_const_exprs)]
-#![allow(incomplete_features)]
+#![expect(incomplete_features)]
trait Trait<T> {
- fn fnc<const N: usize = "">(&self) {} //~ERROR defaults for const parameters are only allowed in `struct`, `enum`, `type`, or `trait` definitions
+ fn fnc<const N: usize = "">(&self) {} //~ERROR defaults for generic parameters are not allowed here
//~^ ERROR: mismatched types
- fn foo<const N: usize = { std::mem::size_of::<T>() }>(&self) {} //~ERROR defaults for const parameters are only allowed in `struct`, `enum`, `type`, or `trait` definitions
+ fn foo<const N: usize = { std::mem::size_of::<T>() }>(&self) {} //~ERROR defaults for generic parameters are not allowed here
}
fn main() {}
diff --git a/tests/ui/const-generics/generic_const_exprs/issue-105257.stderr b/tests/ui/const-generics/generic_const_exprs/issue-105257.stderr
index d7ded0f..1d0ab56 100644
--- a/tests/ui/const-generics/generic_const_exprs/issue-105257.stderr
+++ b/tests/ui/const-generics/generic_const_exprs/issue-105257.stderr
@@ -1,10 +1,10 @@
-error: defaults for const parameters are only allowed in `struct`, `enum`, `type`, or `trait` definitions
+error: defaults for generic parameters are not allowed here
--> $DIR/issue-105257.rs:5:12
|
LL | fn fnc<const N: usize = "">(&self) {}
| ^^^^^^^^^^^^^^^^^^^
-error: defaults for const parameters are only allowed in `struct`, `enum`, `type`, or `trait` definitions
+error: defaults for generic parameters are not allowed here
--> $DIR/issue-105257.rs:7:12
|
LL | fn foo<const N: usize = { std::mem::size_of::<T>() }>(&self) {}
diff --git a/tests/ui/const-generics/generic_const_exprs/issue-80742.rs b/tests/ui/const-generics/generic_const_exprs/issue-80742.rs
index 73357d2..ac4d9fc 100644
--- a/tests/ui/const-generics/generic_const_exprs/issue-80742.rs
+++ b/tests/ui/const-generics/generic_const_exprs/issue-80742.rs
@@ -2,7 +2,7 @@
//@ known-bug: #97477
//@ failure-status: 101
//@ normalize-stderr: "note: .*\n\n" -> ""
-//@ normalize-stderr: "thread 'rustc' panicked.*\n" -> ""
+//@ normalize-stderr: "thread 'rustc'.*panicked.*\n" -> ""
//@ normalize-stderr: "(error: internal compiler error: [^:]+):\d+:\d+: " -> "$1:LL:CC: "
//@ rustc-env:RUST_BACKTRACE=0
diff --git a/tests/ui/const-generics/issues/issue-90318.rs b/tests/ui/const-generics/issues/issue-90318.rs
index 2391712..35b0dd2 100644
--- a/tests/ui/const-generics/issues/issue-90318.rs
+++ b/tests/ui/const-generics/issues/issue-90318.rs
@@ -1,4 +1,3 @@
-#![feature(const_type_id)]
#![feature(generic_const_exprs)]
#![feature(const_trait_impl, const_cmp)]
#![feature(core_intrinsics)]
diff --git a/tests/ui/const-generics/issues/issue-90318.stderr b/tests/ui/const-generics/issues/issue-90318.stderr
index 7031230..f13fd79 100644
--- a/tests/ui/const-generics/issues/issue-90318.stderr
+++ b/tests/ui/const-generics/issues/issue-90318.stderr
@@ -1,5 +1,5 @@
error: overly complex generic constant
- --> $DIR/issue-90318.rs:15:8
+ --> $DIR/issue-90318.rs:14:8
|
LL | If<{ TypeId::of::<T>() != TypeId::of::<()>() }>: True,
| ^^-----------------^^^^^^^^^^^^^^^^^^^^^^^^
@@ -10,7 +10,7 @@
= note: this operation may be supported in the future
error: overly complex generic constant
- --> $DIR/issue-90318.rs:22:8
+ --> $DIR/issue-90318.rs:21:8
|
LL | If<{ TypeId::of::<T>() != TypeId::of::<()>() }>: True,
| ^^-----------------^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/tests/ui/const-generics/min_const_generics/default_function_param.rs b/tests/ui/const-generics/min_const_generics/default_function_param.rs
index 92d495e..153cd94 100644
--- a/tests/ui/const-generics/min_const_generics/default_function_param.rs
+++ b/tests/ui/const-generics/min_const_generics/default_function_param.rs
@@ -1,4 +1,4 @@
#![crate_type = "lib"]
fn foo<const SIZE: usize = 5usize>() {}
-//~^ ERROR defaults for const parameters are
+//~^ ERROR defaults for generic parameters are not allowed here
diff --git a/tests/ui/const-generics/min_const_generics/default_function_param.stderr b/tests/ui/const-generics/min_const_generics/default_function_param.stderr
index 247eea3..261298a 100644
--- a/tests/ui/const-generics/min_const_generics/default_function_param.stderr
+++ b/tests/ui/const-generics/min_const_generics/default_function_param.stderr
@@ -1,4 +1,4 @@
-error: defaults for const parameters are only allowed in `struct`, `enum`, `type`, or `trait` definitions
+error: defaults for generic parameters are not allowed here
--> $DIR/default_function_param.rs:3:8
|
LL | fn foo<const SIZE: usize = 5usize>() {}
diff --git a/tests/ui/consts/const-typeid-of-rpass.rs b/tests/ui/consts/const-typeid-of-rpass.rs
index 15ffdd1..30f4107 100644
--- a/tests/ui/consts/const-typeid-of-rpass.rs
+++ b/tests/ui/consts/const-typeid-of-rpass.rs
@@ -1,6 +1,4 @@
//@ run-pass
-#![feature(const_type_id)]
-#![feature(core_intrinsics)]
use std::any::TypeId;
diff --git a/tests/ui/consts/const_cmp_type_id.rs b/tests/ui/consts/const_cmp_type_id.rs
index 8c21f7b..ff44876c 100644
--- a/tests/ui/consts/const_cmp_type_id.rs
+++ b/tests/ui/consts/const_cmp_type_id.rs
@@ -1,6 +1,6 @@
//@ ignore-backends: gcc
//@ compile-flags: -Znext-solver
-#![feature(const_type_id, const_trait_impl, const_cmp)]
+#![feature(const_trait_impl, const_cmp)]
use std::any::TypeId;
diff --git a/tests/ui/consts/const_transmute_type_id.rs b/tests/ui/consts/const_transmute_type_id.rs
index a2d4cf3..98783ad 100644
--- a/tests/ui/consts/const_transmute_type_id.rs
+++ b/tests/ui/consts/const_transmute_type_id.rs
@@ -1,4 +1,4 @@
-#![feature(const_type_id, const_trait_impl, const_cmp)]
+#![feature(const_trait_impl, const_cmp)]
use std::any::TypeId;
diff --git a/tests/ui/consts/const_transmute_type_id2.rs b/tests/ui/consts/const_transmute_type_id2.rs
index 3ceb2b9..7e09947 100644
--- a/tests/ui/consts/const_transmute_type_id2.rs
+++ b/tests/ui/consts/const_transmute_type_id2.rs
@@ -1,6 +1,6 @@
//@ normalize-stderr: "0x(ff)+" -> "<u128::MAX>"
-#![feature(const_type_id, const_trait_impl, const_cmp)]
+#![feature( const_trait_impl, const_cmp)]
use std::any::TypeId;
diff --git a/tests/ui/consts/const_transmute_type_id3.rs b/tests/ui/consts/const_transmute_type_id3.rs
index f1bb8cd..77c469d 100644
--- a/tests/ui/consts/const_transmute_type_id3.rs
+++ b/tests/ui/consts/const_transmute_type_id3.rs
@@ -1,7 +1,7 @@
//! Test that all bytes of a TypeId must have the
//! TypeId marker provenance.
-#![feature(const_type_id, const_trait_impl, const_cmp)]
+#![feature( const_trait_impl, const_cmp)]
use std::any::TypeId;
diff --git a/tests/ui/consts/const_transmute_type_id4.rs b/tests/ui/consts/const_transmute_type_id4.rs
index 0ea75f2..bedd608 100644
--- a/tests/ui/consts/const_transmute_type_id4.rs
+++ b/tests/ui/consts/const_transmute_type_id4.rs
@@ -1,4 +1,4 @@
-#![feature(const_type_id, const_trait_impl, const_cmp)]
+#![feature(const_trait_impl, const_cmp)]
use std::any::TypeId;
diff --git a/tests/ui/consts/const_transmute_type_id5.rs b/tests/ui/consts/const_transmute_type_id5.rs
index ae0429f..7f9a341 100644
--- a/tests/ui/consts/const_transmute_type_id5.rs
+++ b/tests/ui/consts/const_transmute_type_id5.rs
@@ -1,7 +1,7 @@
//! Test that we require an equal TypeId to have an integer part that properly
//! reflects the type id hash.
-#![feature(const_type_id, const_trait_impl, const_cmp)]
+#![feature(const_trait_impl, const_cmp)]
use std::any::TypeId;
diff --git a/tests/ui/consts/issue-102117.rs b/tests/ui/consts/issue-102117.rs
index 6cb9832..b795528 100644
--- a/tests/ui/consts/issue-102117.rs
+++ b/tests/ui/consts/issue-102117.rs
@@ -1,5 +1,3 @@
-#![feature(const_type_id)]
-
use std::alloc::Layout;
use std::any::TypeId;
use std::mem::transmute;
diff --git a/tests/ui/consts/issue-102117.stderr b/tests/ui/consts/issue-102117.stderr
index da92db8..cea355d 100644
--- a/tests/ui/consts/issue-102117.stderr
+++ b/tests/ui/consts/issue-102117.stderr
@@ -1,5 +1,5 @@
error[E0310]: the parameter type `T` may not live long enough
- --> $DIR/issue-102117.rs:19:26
+ --> $DIR/issue-102117.rs:17:26
|
LL | type_id: TypeId::of::<T>(),
| ^^^^^^^^^^^^^^^^^
@@ -13,7 +13,7 @@
| +++++++++
error[E0310]: the parameter type `T` may not live long enough
- --> $DIR/issue-102117.rs:19:26
+ --> $DIR/issue-102117.rs:17:26
|
LL | type_id: TypeId::of::<T>(),
| ^^^^^^^^^^^^^^^^^
diff --git a/tests/ui/consts/issue-73976-monomorphic.rs b/tests/ui/consts/issue-73976-monomorphic.rs
index f43823f..6459150 100644
--- a/tests/ui/consts/issue-73976-monomorphic.rs
+++ b/tests/ui/consts/issue-73976-monomorphic.rs
@@ -6,7 +6,6 @@
// will be properly rejected. This test will ensure that monomorphic use of these
// would not be wrongly rejected in patterns.
-#![feature(const_type_id)]
#![feature(const_type_name)]
#![feature(const_trait_impl)]
#![feature(const_cmp)]
diff --git a/tests/ui/consts/issue-73976-polymorphic.rs b/tests/ui/consts/issue-73976-polymorphic.rs
index 98b4005..db06706 100644
--- a/tests/ui/consts/issue-73976-polymorphic.rs
+++ b/tests/ui/consts/issue-73976-polymorphic.rs
@@ -5,7 +5,6 @@
// This test case should either run-pass or be rejected at compile time.
// Currently we just disallow this usage and require pattern is monomorphic.
-#![feature(const_type_id)]
#![feature(const_type_name)]
use std::any::{self, TypeId};
diff --git a/tests/ui/consts/issue-73976-polymorphic.stderr b/tests/ui/consts/issue-73976-polymorphic.stderr
index ec9512a..41a5e80 100644
--- a/tests/ui/consts/issue-73976-polymorphic.stderr
+++ b/tests/ui/consts/issue-73976-polymorphic.stderr
@@ -1,5 +1,5 @@
error[E0158]: constant pattern cannot depend on generic parameters
- --> $DIR/issue-73976-polymorphic.rs:20:37
+ --> $DIR/issue-73976-polymorphic.rs:19:37
|
LL | impl<T: 'static> GetTypeId<T> {
| -----------------------------
@@ -12,7 +12,7 @@
| ^^^^^^^^^^^^^^^^^^^^^ `const` depends on a generic parameter
error[E0158]: constant pattern cannot depend on generic parameters
- --> $DIR/issue-73976-polymorphic.rs:31:42
+ --> $DIR/issue-73976-polymorphic.rs:30:42
|
LL | impl<T: 'static> GetTypeNameLen<T> {
| ----------------------------------
diff --git a/tests/ui/drop/or-pattern-drop-order.rs b/tests/ui/drop/or-pattern-drop-order.rs
index fdc2822..cca8167 100644
--- a/tests/ui/drop/or-pattern-drop-order.rs
+++ b/tests/ui/drop/or-pattern-drop-order.rs
@@ -1,6 +1,7 @@
//@ run-pass
//! Test drop order for different ways of declaring pattern bindings involving or-patterns.
-//! Currently, it's inconsistent between language constructs (#142163).
+//! In particular, are ordered based on the order in which the first occurrence of each binding
+//! appears (i.e. the "primary" bindings). Regression test for #142163.
use std::cell::RefCell;
use std::ops::Drop;
@@ -43,11 +44,10 @@ fn main() {
y = LogDrop(o, 1);
});
- // When bindings are declared with `let pat = expr;`, bindings within or-patterns are seen last,
- // thus they're dropped first.
+ // `let pat = expr;` should have the same drop order.
assert_drop_order(1..=3, |o| {
- // Drops are right-to-left, treating `y` as rightmost: `y`, `z`, `x`.
- let (x, Ok(y) | Err(y), z) = (LogDrop(o, 3), Ok(LogDrop(o, 1)), LogDrop(o, 2));
+ // Drops are right-to-left: `z`, `y`, `x`.
+ let (x, Ok(y) | Err(y), z) = (LogDrop(o, 3), Ok(LogDrop(o, 2)), LogDrop(o, 1));
});
assert_drop_order(1..=2, |o| {
// The first or-pattern alternative determines the bindings' drop order: `y`, `x`.
@@ -58,30 +58,29 @@ fn main() {
let ((true, x, y) | (false, y, x)) = (false, LogDrop(o, 1), LogDrop(o, 2));
});
- // `match` treats or-patterns as last like `let pat = expr;`, but also determines drop order
- // using the order of the bindings in the *last* or-pattern alternative.
+ // `match` should have the same drop order.
assert_drop_order(1..=3, |o| {
- // Drops are right-to-left, treating `y` as rightmost: `y`, `z`, `x`.
- match (LogDrop(o, 3), Ok(LogDrop(o, 1)), LogDrop(o, 2)) { (x, Ok(y) | Err(y), z) => {} }
+ // Drops are right-to-left: `z`, `y` `x`.
+ match (LogDrop(o, 3), Ok(LogDrop(o, 2)), LogDrop(o, 1)) { (x, Ok(y) | Err(y), z) => {} }
});
assert_drop_order(1..=2, |o| {
- // The last or-pattern alternative determines the bindings' drop order: `x`, `y`.
- match (true, LogDrop(o, 1), LogDrop(o, 2)) { (true, x, y) | (false, y, x) => {} }
+ // The first or-pattern alternative determines the bindings' drop order: `y`, `x`.
+ match (true, LogDrop(o, 2), LogDrop(o, 1)) { (true, x, y) | (false, y, x) => {} }
});
assert_drop_order(1..=2, |o| {
- // That drop order is used regardless of which or-pattern alternative matches: `x`, `y`.
- match (false, LogDrop(o, 2), LogDrop(o, 1)) { (true, x, y) | (false, y, x) => {} }
+ // That drop order is used regardless of which or-pattern alternative matches: `y`, `x`.
+ match (false, LogDrop(o, 1), LogDrop(o, 2)) { (true, x, y) | (false, y, x) => {} }
});
// Function params are visited one-by-one, and the order of bindings within a param's pattern is
- // the same as `let pat = expr`;
+ // the same as `let pat = expr;`
assert_drop_order(1..=3, |o| {
// Among separate params, the drop order is right-to-left: `z`, `y`, `x`.
(|x, (Ok(y) | Err(y)), z| {})(LogDrop(o, 3), Ok(LogDrop(o, 2)), LogDrop(o, 1));
});
assert_drop_order(1..=3, |o| {
- // Within a param's pattern, or-patterns are treated as rightmost: `y`, `z`, `x`.
- (|(x, Ok(y) | Err(y), z)| {})((LogDrop(o, 3), Ok(LogDrop(o, 1)), LogDrop(o, 2)));
+ // Within a param's pattern, likewise: `z`, `y`, `x`.
+ (|(x, Ok(y) | Err(y), z)| {})((LogDrop(o, 3), Ok(LogDrop(o, 2)), LogDrop(o, 1)));
});
assert_drop_order(1..=2, |o| {
// The first or-pattern alternative determines the bindings' drop order: `y`, `x`.
@@ -89,12 +88,11 @@ fn main() {
});
// `if let` and `let`-`else` see bindings in the same order as `let pat = expr;`.
- // Vars in or-patterns are seen last (dropped first), and the first alternative's order is used.
assert_drop_order(1..=3, |o| {
- if let (x, Ok(y) | Err(y), z) = (LogDrop(o, 3), Ok(LogDrop(o, 1)), LogDrop(o, 2)) {}
+ if let (x, Ok(y) | Err(y), z) = (LogDrop(o, 3), Ok(LogDrop(o, 2)), LogDrop(o, 1)) {}
});
assert_drop_order(1..=3, |o| {
- let (x, Ok(y) | Err(y), z) = (LogDrop(o, 3), Ok(LogDrop(o, 1)), LogDrop(o, 2)) else {
+ let (x, Ok(y) | Err(y), z) = (LogDrop(o, 3), Ok(LogDrop(o, 2)), LogDrop(o, 1)) else {
unreachable!();
};
});
@@ -106,4 +104,21 @@ fn main() {
unreachable!();
};
});
+
+ // Test nested and adjacent or-patterns, including or-patterns without bindings under a guard.
+ assert_drop_order(1..=6, |o| {
+ // The `LogDrop`s that aren't moved into bindings are dropped last.
+ match [
+ [LogDrop(o, 6), LogDrop(o, 4)],
+ [LogDrop(o, 3), LogDrop(o, 2)],
+ [LogDrop(o, 1), LogDrop(o, 5)],
+ ] {
+ [
+ [_ | _, w | w] | [w | w, _ | _],
+ [x | x, y | y] | [y | y, x | x],
+ [z | z, _ | _] | [_ | _, z | z],
+ ] if true => {}
+ _ => unreachable!(),
+ }
+ });
}
diff --git a/tests/ui/dropck/eager-by-ref-binding-for-guards.rs b/tests/ui/dropck/eager-by-ref-binding-for-guards.rs
index 3f47583..90ff9a7 100644
--- a/tests/ui/dropck/eager-by-ref-binding-for-guards.rs
+++ b/tests/ui/dropck/eager-by-ref-binding-for-guards.rs
@@ -17,15 +17,15 @@ fn main() {
(mut long2, ref short2) if true => long2.0 = &short2,
_ => unreachable!(),
}
- // This depends on the binding modes of the final or-pattern alternatives (see #142163):
+ // This depends on the binding modes of the first or-pattern alternatives:
let res: &Result<u8, &u8> = &Ok(1);
match (Struct(&&0), res) {
(mut long3, Ok(short3) | &Err(short3)) if true => long3.0 = &short3,
- //~^ ERROR `short3` does not live long enough
_ => unreachable!(),
}
match (Struct(&&0), res) {
(mut long4, &Err(short4) | Ok(short4)) if true => long4.0 = &short4,
+ //~^ ERROR `short4` does not live long enough
_ => unreachable!(),
}
}
diff --git a/tests/ui/dropck/eager-by-ref-binding-for-guards.stderr b/tests/ui/dropck/eager-by-ref-binding-for-guards.stderr
index cb1a04c..2648ce6 100644
--- a/tests/ui/dropck/eager-by-ref-binding-for-guards.stderr
+++ b/tests/ui/dropck/eager-by-ref-binding-for-guards.stderr
@@ -11,15 +11,15 @@
|
= note: values in a scope are dropped in the opposite order they are defined
-error[E0597]: `short3` does not live long enough
- --> $DIR/eager-by-ref-binding-for-guards.rs:23:69
+error[E0597]: `short4` does not live long enough
+ --> $DIR/eager-by-ref-binding-for-guards.rs:27:69
|
-LL | (mut long3, Ok(short3) | &Err(short3)) if true => long3.0 = &short3,
- | ------ ^^^^^^-
- | | | |
- | | | `short3` dropped here while still borrowed
- | | | borrow might be used here, when `long3` is dropped and runs the `Drop` code for type `Struct`
- | binding `short3` declared here borrowed value does not live long enough
+LL | (mut long4, &Err(short4) | Ok(short4)) if true => long4.0 = &short4,
+ | ------ ^^^^^^-
+ | | | |
+ | | | `short4` dropped here while still borrowed
+ | | | borrow might be used here, when `long4` is dropped and runs the `Drop` code for type `Struct`
+ | binding `short4` declared here borrowed value does not live long enough
|
= note: values in a scope are dropped in the opposite order they are defined
diff --git a/tests/ui/dropck/let-else-more-permissive.rs b/tests/ui/dropck/let-else-more-permissive.rs
index 0020814..6247b0e 100644
--- a/tests/ui/dropck/let-else-more-permissive.rs
+++ b/tests/ui/dropck/let-else-more-permissive.rs
@@ -1,5 +1,5 @@
-//! The drop check is currently more permissive when `let` statements have an `else` block, due to
-//! scheduling drops for bindings' storage before pattern-matching (#142056).
+//! Regression test for #142056. The drop check used to be more permissive for `let` statements with
+//! `else` blocks, due to scheduling drops for bindings' storage before pattern-matching.
struct Struct<T>(T);
impl<T> Drop for Struct<T> {
@@ -14,10 +14,11 @@ fn main() {
//~^ ERROR `short1` does not live long enough
}
{
- // This is OK: `short2`'s storage is live until after `long2`'s drop runs.
+ // This was OK: `short2`'s storage was live until after `long2`'s drop ran.
#[expect(irrefutable_let_patterns)]
let (mut long2, short2) = (Struct(&0), 1) else { unreachable!() };
long2.0 = &short2;
+ //~^ ERROR `short2` does not live long enough
}
{
// Sanity check: `short3`'s drop is significant; it's dropped before `long3`:
diff --git a/tests/ui/dropck/let-else-more-permissive.stderr b/tests/ui/dropck/let-else-more-permissive.stderr
index 7c37e17..4f0c193 100644
--- a/tests/ui/dropck/let-else-more-permissive.stderr
+++ b/tests/ui/dropck/let-else-more-permissive.stderr
@@ -14,8 +14,24 @@
|
= note: values in a scope are dropped in the opposite order they are defined
+error[E0597]: `short2` does not live long enough
+ --> $DIR/let-else-more-permissive.rs:20:19
+ |
+LL | let (mut long2, short2) = (Struct(&0), 1) else { unreachable!() };
+ | ------ binding `short2` declared here
+LL | long2.0 = &short2;
+ | ^^^^^^^ borrowed value does not live long enough
+LL |
+LL | }
+ | -
+ | |
+ | `short2` dropped here while still borrowed
+ | borrow might be used here, when `long2` is dropped and runs the `Drop` code for type `Struct`
+ |
+ = note: values in a scope are dropped in the opposite order they are defined
+
error[E0597]: `short3` does not live long enough
- --> $DIR/let-else-more-permissive.rs:27:19
+ --> $DIR/let-else-more-permissive.rs:28:19
|
LL | let (mut long3, short3) = (Struct(&tmp), Box::new(1)) else { unreachable!() };
| ------ binding `short3` declared here
@@ -30,6 +46,6 @@
|
= note: values in a scope are dropped in the opposite order they are defined
-error: aborting due to 2 previous errors
+error: aborting due to 3 previous errors
For more information about this error, try `rustc --explain E0597`.
diff --git a/tests/ui/explicit-tail-calls/drop-order.rs b/tests/ui/explicit-tail-calls/drop-order.rs
index 242336b..58e1afb 100644
--- a/tests/ui/explicit-tail-calls/drop-order.rs
+++ b/tests/ui/explicit-tail-calls/drop-order.rs
@@ -1,5 +1,3 @@
-// FIXME(explicit_tail_calls): enable this test once rustc_codegen_ssa supports tail calls
-//@ ignore-test: tail calls are not implemented in rustc_codegen_ssa yet, so this causes 🧊
//@ run-pass
#![expect(incomplete_features)]
#![feature(explicit_tail_calls)]
diff --git a/tests/ui/explicit-tail-calls/higher-ranked-arg.rs b/tests/ui/explicit-tail-calls/higher-ranked-arg.rs
new file mode 100644
index 0000000..e60686a
--- /dev/null
+++ b/tests/ui/explicit-tail-calls/higher-ranked-arg.rs
@@ -0,0 +1,13 @@
+// Regression test for <https://github.com/rust-lang/rust/issues/144826>.
+//@ check-pass
+
+#![feature(explicit_tail_calls)]
+#![expect(incomplete_features)]
+
+fn foo(x: fn(&i32)) {
+ become bar(x);
+}
+
+fn bar(_: fn(&i32)) {}
+
+fn main() {}
diff --git a/tests/ui/explicit-tail-calls/indexer.rs b/tests/ui/explicit-tail-calls/indexer.rs
new file mode 100644
index 0000000..5644506
--- /dev/null
+++ b/tests/ui/explicit-tail-calls/indexer.rs
@@ -0,0 +1,22 @@
+//@ run-pass
+// Indexing taken from
+// https://github.com/phi-go/rfcs/blob/guaranteed-tco/text%2F0000-explicit-tail-calls.md#tail-call-elimination
+// no other test has utilized the "function table"
+// described in the RFC aside from this one at this point.
+#![expect(incomplete_features)]
+#![feature(explicit_tail_calls)]
+
+fn f0(_: usize) {}
+fn f1(_: usize) {}
+fn f2(_: usize) {}
+
+fn indexer(idx: usize) {
+ let v: [fn(usize); 3] = [f0, f1, f2];
+ become v[idx](idx)
+}
+
+fn main() {
+ for idx in 0..3 {
+ indexer(idx);
+ }
+}
diff --git a/tests/ui/explicit-tail-calls/ret-ty-borrowck-constraints.rs b/tests/ui/explicit-tail-calls/ret-ty-borrowck-constraints.rs
new file mode 100644
index 0000000..111ae84
--- /dev/null
+++ b/tests/ui/explicit-tail-calls/ret-ty-borrowck-constraints.rs
@@ -0,0 +1,16 @@
+#![feature(explicit_tail_calls)]
+#![expect(incomplete_features)]
+
+fn link(x: &str) -> &'static str {
+ become passthrough(x);
+ //~^ ERROR lifetime may not live long enough
+}
+
+fn passthrough<T>(t: T) -> T { t }
+
+fn main() {
+ let x = String::from("hello, world");
+ let s = link(&x);
+ drop(x);
+ println!("{s}");
+}
diff --git a/tests/ui/explicit-tail-calls/ret-ty-borrowck-constraints.stderr b/tests/ui/explicit-tail-calls/ret-ty-borrowck-constraints.stderr
new file mode 100644
index 0000000..26a8e1f
--- /dev/null
+++ b/tests/ui/explicit-tail-calls/ret-ty-borrowck-constraints.stderr
@@ -0,0 +1,10 @@
+error: lifetime may not live long enough
+ --> $DIR/ret-ty-borrowck-constraints.rs:5:5
+ |
+LL | fn link(x: &str) -> &'static str {
+ | - let's call the lifetime of this reference `'1`
+LL | become passthrough(x);
+ | ^^^^^^^^^^^^^^^^^^^^^ returning this value requires that `'1` must outlive `'static`
+
+error: aborting due to 1 previous error
+
diff --git a/tests/ui/extern/extern-types-field-offset.run.stderr b/tests/ui/extern/extern-types-field-offset.run.stderr
index 07bd4fc..b096e80 100644
--- a/tests/ui/extern/extern-types-field-offset.run.stderr
+++ b/tests/ui/extern/extern-types-field-offset.run.stderr
@@ -1,5 +1,5 @@
-thread 'main' panicked at library/core/src/panicking.rs:$LINE:$COL:
+thread 'main' ($TID) panicked at library/core/src/panicking.rs:$LINE:$COL:
attempted to compute the size or alignment of extern type `Opaque`
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
thread caused non-unwinding panic. aborting.
diff --git a/tests/ui/extern/extern-types-size_of_val.align.run.stderr b/tests/ui/extern/extern-types-size_of_val.align.run.stderr
index 5ba372d..66206f3 100644
--- a/tests/ui/extern/extern-types-size_of_val.align.run.stderr
+++ b/tests/ui/extern/extern-types-size_of_val.align.run.stderr
@@ -1,5 +1,5 @@
-thread 'main' panicked at library/core/src/panicking.rs:$LINE:$COL:
+thread 'main' ($TID) panicked at library/core/src/panicking.rs:$LINE:$COL:
attempted to compute the size or alignment of extern type `A`
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
thread caused non-unwinding panic. aborting.
diff --git a/tests/ui/extern/extern-types-size_of_val.size.run.stderr b/tests/ui/extern/extern-types-size_of_val.size.run.stderr
index 5ba372d..66206f3 100644
--- a/tests/ui/extern/extern-types-size_of_val.size.run.stderr
+++ b/tests/ui/extern/extern-types-size_of_val.size.run.stderr
@@ -1,5 +1,5 @@
-thread 'main' panicked at library/core/src/panicking.rs:$LINE:$COL:
+thread 'main' ($TID) panicked at library/core/src/panicking.rs:$LINE:$COL:
attempted to compute the size or alignment of extern type `A`
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
thread caused non-unwinding panic. aborting.
diff --git a/tests/ui/extern/issue-80074.rs b/tests/ui/extern/issue-80074.rs
index ba7b55a..942b789 100644
--- a/tests/ui/extern/issue-80074.rs
+++ b/tests/ui/extern/issue-80074.rs
@@ -11,7 +11,7 @@
fn main() {
foo!();
- //~^ WARN: macro `foo` is private
+ //~^ ERROR: macro `foo` is private
//~| WARN: it will become a hard error in a future release!
bar!();
//~^ ERROR: cannot find macro `bar` in this scope
diff --git a/tests/ui/extern/issue-80074.stderr b/tests/ui/extern/issue-80074.stderr
index b30b761..510ca1b 100644
--- a/tests/ui/extern/issue-80074.stderr
+++ b/tests/ui/extern/issue-80074.stderr
@@ -16,7 +16,7 @@
LL | m!();
| ^
-warning: macro `foo` is private
+error: macro `foo` is private
--> $DIR/issue-80074.rs:13:5
|
LL | foo!();
@@ -24,8 +24,19 @@
|
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
= note: for more information, see issue #120192 <https://github.com/rust-lang/rust/issues/120192>
- = note: `#[warn(private_macro_use)]` on by default
+ = note: `#[deny(private_macro_use)]` on by default
-error: aborting due to 3 previous errors; 1 warning emitted
+error: aborting due to 4 previous errors
For more information about this error, try `rustc --explain E0469`.
+Future incompatibility report: Future breakage diagnostic:
+error: macro `foo` is private
+ --> $DIR/issue-80074.rs:13:5
+ |
+LL | foo!();
+ | ^^^
+ |
+ = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
+ = note: for more information, see issue #120192 <https://github.com/rust-lang/rust/issues/120192>
+ = note: `#[deny(private_macro_use)]` on by default
+
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 8bac1f6..f2ae50b 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
@@ -361,12 +361,6 @@
LL | #[type_length_limit="0100"]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^
-warning: `#[should_panic]` only has an effect on functions
- --> $DIR/issue-43106-gating-of-builtin-attrs.rs:53:1
- |
-LL | #![should_panic]
- | ^^^^^^^^^^^^^^^^
-
warning: attribute should be applied to an `extern` block with non-Rust ABI
--> $DIR/issue-43106-gating-of-builtin-attrs.rs:64:1
|
@@ -409,6 +403,12 @@
LL | #![proc_macro_derive(Test)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+warning: `#[should_panic]` only has an effect on functions
+ --> $DIR/issue-43106-gating-of-builtin-attrs.rs:53:1
+ |
+LL | #![should_panic]
+ | ^^^^^^^^^^^^^^^^
+
warning: attribute should be applied to a function definition
--> $DIR/issue-43106-gating-of-builtin-attrs.rs:62:1
|
diff --git a/tests/ui/generic-associated-types/type-param-defaults.rs b/tests/ui/generic-associated-types/type-param-defaults.rs
index eea54c4..6e9a62b 100644
--- a/tests/ui/generic-associated-types/type-param-defaults.rs
+++ b/tests/ui/generic-associated-types/type-param-defaults.rs
@@ -4,17 +4,17 @@
trait Trait {
type Assoc<T = u32>;
- //~^ ERROR defaults for type parameters are only allowed
+ //~^ ERROR defaults for generic parameters are not allowed here
}
impl Trait for () {
type Assoc<T = u32> = u64;
- //~^ ERROR defaults for type parameters are only allowed
+ //~^ ERROR defaults for generic parameters are not allowed here
}
impl Trait for u32 {
type Assoc<T = u32> = T;
- //~^ ERROR defaults for type parameters are only allowed
+ //~^ ERROR defaults for generic parameters are not allowed here
}
trait Other {}
diff --git a/tests/ui/generic-associated-types/type-param-defaults.stderr b/tests/ui/generic-associated-types/type-param-defaults.stderr
index 3c094d4..d9872da 100644
--- a/tests/ui/generic-associated-types/type-param-defaults.stderr
+++ b/tests/ui/generic-associated-types/type-param-defaults.stderr
@@ -1,16 +1,16 @@
-error: defaults for type parameters are only allowed in `struct`, `enum`, `type`, or `trait` definitions
+error: defaults for generic parameters are not allowed here
--> $DIR/type-param-defaults.rs:6:16
|
LL | type Assoc<T = u32>;
| ^^^^^^^
-error: defaults for type parameters are only allowed in `struct`, `enum`, `type`, or `trait` definitions
+error: defaults for generic parameters are not allowed here
--> $DIR/type-param-defaults.rs:11:16
|
LL | type Assoc<T = u32> = u64;
| ^^^^^^^
-error: defaults for type parameters are only allowed in `struct`, `enum`, `type`, or `trait` definitions
+error: defaults for generic parameters are not allowed here
--> $DIR/type-param-defaults.rs:16:16
|
LL | type Assoc<T = u32> = T;
diff --git a/tests/ui/generic-const-items/parameter-defaults.rs b/tests/ui/generic-const-items/parameter-defaults.rs
index c933db1..b52cb0f 100644
--- a/tests/ui/generic-const-items/parameter-defaults.rs
+++ b/tests/ui/generic-const-items/parameter-defaults.rs
@@ -7,9 +7,17 @@
// FIXME(default_type_parameter_fallback): Consider reallowing them once they work properly.
-const NONE<T = ()>: Option<T> = None::<T>; //~ ERROR defaults for type parameters are only allowed
+const NONE<T = ()>: Option<T> = None::<T>;
+//~^ ERROR defaults for generic parameters are not allowed here
-fn main() {
- let _ = NONE;
- //~^ ERROR type annotations needed
+impl Host {
+ const NADA<T = ()>: Option<T> = None::<T>;
+ //~^ ERROR defaults for generic parameters are not allowed here
}
+
+enum Host {}
+
+fn body0() { let _ = NONE; } //~ ERROR type annotations needed
+fn body1() { let _ = Host::NADA; } //~ ERROR type annotations needed
+
+fn main() {}
diff --git a/tests/ui/generic-const-items/parameter-defaults.stderr b/tests/ui/generic-const-items/parameter-defaults.stderr
index 13562c9..9bf1f64 100644
--- a/tests/ui/generic-const-items/parameter-defaults.stderr
+++ b/tests/ui/generic-const-items/parameter-defaults.stderr
@@ -1,20 +1,37 @@
-error: defaults for type parameters are only allowed in `struct`, `enum`, `type`, or `trait` definitions
+error: defaults for generic parameters are not allowed here
--> $DIR/parameter-defaults.rs:10:12
|
LL | const NONE<T = ()>: Option<T> = None::<T>;
| ^^^^^^
-error[E0282]: type annotations needed for `Option<_>`
- --> $DIR/parameter-defaults.rs:13:9
+error: defaults for generic parameters are not allowed here
+ --> $DIR/parameter-defaults.rs:14:16
|
-LL | let _ = NONE;
- | ^ ---- type must be known at this point
+LL | const NADA<T = ()>: Option<T> = None::<T>;
+ | ^^^^^^
+
+error[E0282]: type annotations needed for `Option<_>`
+ --> $DIR/parameter-defaults.rs:20:18
+ |
+LL | fn body0() { let _ = NONE; }
+ | ^ ---- type must be known at this point
|
help: consider giving this pattern a type, where the type for type parameter `T` is specified
|
-LL | let _: Option<T> = NONE;
- | +++++++++++
+LL | fn body0() { let _: Option<T> = NONE; }
+ | +++++++++++
-error: aborting due to 2 previous errors
+error[E0282]: type annotations needed for `Option<_>`
+ --> $DIR/parameter-defaults.rs:21:18
+ |
+LL | fn body1() { let _ = Host::NADA; }
+ | ^ ---------- type must be known at this point
+ |
+help: consider giving this pattern a type, where the type for type parameter `T` is specified
+ |
+LL | fn body1() { let _: Option<T> = Host::NADA; }
+ | +++++++++++
+
+error: aborting due to 4 previous errors
For more information about this error, try `rustc --explain E0282`.
diff --git a/tests/ui/generics/generic-extern.rs b/tests/ui/generics/generic-extern.rs
index 36fa5ea..b4f00fc1 100644
--- a/tests/ui/generics/generic-extern.rs
+++ b/tests/ui/generics/generic-extern.rs
@@ -1,7 +1,15 @@
+// Ensure that we reject generic parameters on foreign items.
+
extern "C" {
fn foo<T>(); //~ ERROR foreign items may not have type parameters
+
+ // Furthermore, check that type parameter defaults lead to a *hard* error,
+ // not just a lint error, for maximum forward compatibility.
+ #[allow(invalid_type_param_default)] // Should have no effect here.
+ fn bar<T = ()>(); //~ ERROR foreign items may not have type parameters
+ //~^ ERROR defaults for generic parameters are not allowed here
}
fn main() {
- foo::<i32>(); //~ ERROR requires unsafe
+ unsafe { foo::<i32>() };
}
diff --git a/tests/ui/generics/generic-extern.stderr b/tests/ui/generics/generic-extern.stderr
index a3f2882..6e83715 100644
--- a/tests/ui/generics/generic-extern.stderr
+++ b/tests/ui/generics/generic-extern.stderr
@@ -1,20 +1,25 @@
error[E0044]: foreign items may not have type parameters
- --> $DIR/generic-extern.rs:2:5
+ --> $DIR/generic-extern.rs:4:5
|
LL | fn foo<T>();
| ^^^^^^^^^^^^ can't have type parameters
|
= help: replace the type parameters with concrete types like `u32`
-error[E0133]: call to unsafe function `foo` is unsafe and requires unsafe function or block
- --> $DIR/generic-extern.rs:6:5
+error: defaults for generic parameters are not allowed here
+ --> $DIR/generic-extern.rs:9:12
|
-LL | foo::<i32>();
- | ^^^^^^^^^^^^ call to unsafe function
+LL | fn bar<T = ()>();
+ | ^^^^^^
+
+error[E0044]: foreign items may not have type parameters
+ --> $DIR/generic-extern.rs:9:5
|
- = note: consult the function's documentation for information on how to avoid undefined behavior
+LL | fn bar<T = ()>();
+ | ^^^^^^^^^^^^^^^^^ can't have type parameters
+ |
+ = help: replace the type parameters with concrete types like `u32`
-error: aborting due to 2 previous errors
+error: aborting due to 3 previous errors
-Some errors have detailed explanations: E0044, E0133.
-For more information about an error, try `rustc --explain E0044`.
+For more information about this error, try `rustc --explain E0044`.
diff --git a/tests/ui/generics/invalid-type-param-default.rs b/tests/ui/generics/invalid-type-param-default.rs
new file mode 100644
index 0000000..b47e142
--- /dev/null
+++ b/tests/ui/generics/invalid-type-param-default.rs
@@ -0,0 +1,22 @@
+// Ensure that we emit the deny-by-default lint `invalid_type_param_default` in locations where
+// type parameter defaults were accidentally allowed but don't have any effect whatsoever.
+//
+// Tracked in <https://github.com/rust-lang/rust/issues/36887>.
+// FIXME(default_type_parameter_fallback): Consider reallowing them once they work properly.
+
+fn avg<T = i32>(_: T) {}
+//~^ ERROR defaults for generic parameters are not allowed here [invalid_type_param_default]
+//~| WARN this was previously accepted
+
+// issue: <https://github.com/rust-lang/rust/issues/26812>
+fn mdn<T = T::Item>(_: T) {}
+//~^ ERROR generic parameter defaults cannot reference parameters before they are declared
+//~| ERROR defaults for generic parameters are not allowed here [invalid_type_param_default]
+//~| WARN this was previously accepted
+
+struct S<T>(T);
+impl<T = i32> S<T> {}
+//~^ ERROR defaults for generic parameters are not allowed here [invalid_type_param_default]
+//~| WARN this was previously accepted
+
+fn main() {}
diff --git a/tests/ui/generics/invalid-type-param-default.stderr b/tests/ui/generics/invalid-type-param-default.stderr
new file mode 100644
index 0000000..1c8fdd8
--- /dev/null
+++ b/tests/ui/generics/invalid-type-param-default.stderr
@@ -0,0 +1,70 @@
+error[E0128]: generic parameter defaults cannot reference parameters before they are declared
+ --> $DIR/invalid-type-param-default.rs:12:12
+ |
+LL | fn mdn<T = T::Item>(_: T) {}
+ | ^^^^^^^ cannot reference `T` before it is declared
+
+error: defaults for generic parameters are not allowed here
+ --> $DIR/invalid-type-param-default.rs:7:8
+ |
+LL | fn avg<T = i32>(_: T) {}
+ | ^^^^^^^
+ |
+ = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
+ = note: for more information, see issue #36887 <https://github.com/rust-lang/rust/issues/36887>
+ = note: `#[deny(invalid_type_param_default)]` on by default
+
+error: defaults for generic parameters are not allowed here
+ --> $DIR/invalid-type-param-default.rs:12:8
+ |
+LL | fn mdn<T = T::Item>(_: T) {}
+ | ^^^^^^^^^^^
+ |
+ = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
+ = note: for more information, see issue #36887 <https://github.com/rust-lang/rust/issues/36887>
+
+error: defaults for generic parameters are not allowed here
+ --> $DIR/invalid-type-param-default.rs:18:6
+ |
+LL | impl<T = i32> S<T> {}
+ | ^^^^^^^
+ |
+ = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
+ = note: for more information, see issue #36887 <https://github.com/rust-lang/rust/issues/36887>
+
+error: aborting due to 4 previous errors
+
+For more information about this error, try `rustc --explain E0128`.
+Future incompatibility report: Future breakage diagnostic:
+error: defaults for generic parameters are not allowed here
+ --> $DIR/invalid-type-param-default.rs:7:8
+ |
+LL | fn avg<T = i32>(_: T) {}
+ | ^^^^^^^
+ |
+ = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
+ = note: for more information, see issue #36887 <https://github.com/rust-lang/rust/issues/36887>
+ = note: `#[deny(invalid_type_param_default)]` on by default
+
+Future breakage diagnostic:
+error: defaults for generic parameters are not allowed here
+ --> $DIR/invalid-type-param-default.rs:12:8
+ |
+LL | fn mdn<T = T::Item>(_: T) {}
+ | ^^^^^^^^^^^
+ |
+ = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
+ = note: for more information, see issue #36887 <https://github.com/rust-lang/rust/issues/36887>
+ = note: `#[deny(invalid_type_param_default)]` on by default
+
+Future breakage diagnostic:
+error: defaults for generic parameters are not allowed here
+ --> $DIR/invalid-type-param-default.rs:18:6
+ |
+LL | impl<T = i32> S<T> {}
+ | ^^^^^^^
+ |
+ = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
+ = note: for more information, see issue #36887 <https://github.com/rust-lang/rust/issues/36887>
+ = note: `#[deny(invalid_type_param_default)]` on by default
+
diff --git a/tests/ui/generics/overlapping-errors-span-issue-123861.rs b/tests/ui/generics/overlapping-errors-span-issue-123861.rs
index e0a27f6..2549f4b 100644
--- a/tests/ui/generics/overlapping-errors-span-issue-123861.rs
+++ b/tests/ui/generics/overlapping-errors-span-issue-123861.rs
@@ -1,7 +1,7 @@
fn mainIterator<_ = _> {}
//~^ ERROR expected identifier, found reserved identifier `_`
//~| ERROR missing parameters for function definition
-//~| ERROR defaults for type parameters are only allowed in `struct`, `enum`, `type`, or `trait` definitions [invalid_type_param_default]
+//~| ERROR defaults for generic parameters are not allowed here [invalid_type_param_default]
//~| WARNING this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
//~| ERROR the placeholder `_` is not allowed within types on item signatures for functions [E0121]
diff --git a/tests/ui/generics/overlapping-errors-span-issue-123861.stderr b/tests/ui/generics/overlapping-errors-span-issue-123861.stderr
index 7d08d8f..44e8b4a 100644
--- a/tests/ui/generics/overlapping-errors-span-issue-123861.stderr
+++ b/tests/ui/generics/overlapping-errors-span-issue-123861.stderr
@@ -15,7 +15,7 @@
LL | fn mainIterator<_ = _>() {}
| ++
-error: defaults for type parameters are only allowed in `struct`, `enum`, `type`, or `trait` definitions
+error: defaults for generic parameters are not allowed here
--> $DIR/overlapping-errors-span-issue-123861.rs:1:17
|
LL | fn mainIterator<_ = _> {}
@@ -35,7 +35,7 @@
For more information about this error, try `rustc --explain E0121`.
Future incompatibility report: Future breakage diagnostic:
-error: defaults for type parameters are only allowed in `struct`, `enum`, `type`, or `trait` definitions
+error: defaults for generic parameters are not allowed here
--> $DIR/overlapping-errors-span-issue-123861.rs:1:17
|
LL | fn mainIterator<_ = _> {}
diff --git a/tests/ui/hygiene/panic-location.run.stderr b/tests/ui/hygiene/panic-location.run.stderr
index 5cd07dc..d28ab86 100644
--- a/tests/ui/hygiene/panic-location.run.stderr
+++ b/tests/ui/hygiene/panic-location.run.stderr
@@ -1,4 +1,4 @@
-thread 'main' panicked at $DIR/panic-location.rs:LL:CC:
+thread 'main' ($TID) panicked at $DIR/panic-location.rs:LL:CC:
capacity overflow
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
diff --git a/tests/ui/impl-trait/where-allowed.rs b/tests/ui/impl-trait/where-allowed.rs
index 1c3c66c..04a95f7 100644
--- a/tests/ui/impl-trait/where-allowed.rs
+++ b/tests/ui/impl-trait/where-allowed.rs
@@ -236,17 +236,15 @@ trait InTraitGenericParamDefault<T = impl Debug> {}
//~^ ERROR `impl Trait` is not allowed in generic parameter defaults
// Disallowed
-impl <T = impl Debug> T {}
-//~^ ERROR defaults for type parameters are only allowed in `struct`, `enum`, `type`, or `trait` definitions
-//~| WARNING this was previously accepted by the compiler but is being phased out
-//~| ERROR `impl Trait` is not allowed in generic parameter defaults
+#[expect(invalid_type_param_default)]
+impl<T = impl Debug> T {}
+//~^ ERROR `impl Trait` is not allowed in generic parameter defaults
//~| ERROR no nominal type found
// Disallowed
+#[expect(invalid_type_param_default)]
fn in_method_generic_param_default<T = impl Debug>(_: T) {}
-//~^ ERROR defaults for type parameters are only allowed in `struct`, `enum`, `type`, or `trait` definitions
-//~| WARNING this was previously accepted by the compiler but is being phased out
-//~| ERROR `impl Trait` is not allowed in generic parameter defaults
+//~^ ERROR `impl Trait` is not allowed in generic parameter defaults
fn main() {
let _in_local_variable: impl Fn() = || {};
diff --git a/tests/ui/impl-trait/where-allowed.stderr b/tests/ui/impl-trait/where-allowed.stderr
index 052ae5a..08caff3 100644
--- a/tests/ui/impl-trait/where-allowed.stderr
+++ b/tests/ui/impl-trait/where-allowed.stderr
@@ -311,10 +311,10 @@
= note: `impl Trait` is only allowed in arguments and return types of functions and methods
error[E0562]: `impl Trait` is not allowed in generic parameter defaults
- --> $DIR/where-allowed.rs:239:11
+ --> $DIR/where-allowed.rs:240:10
|
-LL | impl <T = impl Debug> T {}
- | ^^^^^^^^^^
+LL | impl<T = impl Debug> T {}
+ | ^^^^^^^^^^
|
= note: `impl Trait` is only allowed in arguments and return types of functions and methods
@@ -327,7 +327,7 @@
= note: `impl Trait` is only allowed in arguments and return types of functions and methods
error[E0562]: `impl Trait` is not allowed in the type of variable bindings
- --> $DIR/where-allowed.rs:252:29
+ --> $DIR/where-allowed.rs:250:29
|
LL | let _in_local_variable: impl Fn() = || {};
| ^^^^^^^^^
@@ -338,7 +338,7 @@
= note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
error[E0562]: `impl Trait` is not allowed in closure return types
- --> $DIR/where-allowed.rs:254:46
+ --> $DIR/where-allowed.rs:252:46
|
LL | let _in_return_in_local_variable = || -> impl Fn() { || {} };
| ^^^^^^^^^
@@ -368,25 +368,6 @@
LL + fn in_trait_impl_return() -> <() as DummyTrait>::Out { () }
|
-error: defaults for type parameters are only allowed in `struct`, `enum`, `type`, or `trait` definitions
- --> $DIR/where-allowed.rs:246:36
- |
-LL | fn in_method_generic_param_default<T = impl Debug>(_: T) {}
- | ^^^^^^^^^^^^^^
- |
- = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
- = note: for more information, see issue #36887 <https://github.com/rust-lang/rust/issues/36887>
- = note: `#[deny(invalid_type_param_default)]` on by default
-
-error: defaults for type parameters are only allowed in `struct`, `enum`, `type`, or `trait` definitions
- --> $DIR/where-allowed.rs:239:7
- |
-LL | impl <T = impl Debug> T {}
- | ^^^^^^^^^^^^^^
- |
- = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
- = note: for more information, see issue #36887 <https://github.com/rust-lang/rust/issues/36887>
-
error[E0283]: type annotations needed
--> $DIR/where-allowed.rs:46:57
|
@@ -408,10 +389,10 @@
where Args: Tuple, F: Fn<Args>, A: Allocator, F: ?Sized;
error[E0118]: no nominal type found for inherent implementation
- --> $DIR/where-allowed.rs:239:1
+ --> $DIR/where-allowed.rs:240:1
|
-LL | impl <T = impl Debug> T {}
- | ^^^^^^^^^^^^^^^^^^^^^^^ impl requires a nominal type
+LL | impl<T = impl Debug> T {}
+ | ^^^^^^^^^^^^^^^^^^^^^^ impl requires a nominal type
|
= note: either implement a trait on it or create a newtype to wrap it instead
@@ -431,29 +412,21 @@
|
= note: `InTypeAlias` must be used in combination with a concrete type within the same crate
-error: aborting due to 50 previous errors
+error: aborting due to 48 previous errors
Some errors have detailed explanations: E0053, E0118, E0283, E0562, E0658, E0666.
For more information about an error, try `rustc --explain E0053`.
Future incompatibility report: Future breakage diagnostic:
-error: defaults for type parameters are only allowed in `struct`, `enum`, `type`, or `trait` definitions
+warning: defaults for generic parameters are not allowed here
--> $DIR/where-allowed.rs:246:36
|
LL | fn in_method_generic_param_default<T = impl Debug>(_: T) {}
| ^^^^^^^^^^^^^^
- |
- = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
- = note: for more information, see issue #36887 <https://github.com/rust-lang/rust/issues/36887>
- = note: `#[deny(invalid_type_param_default)]` on by default
Future breakage diagnostic:
-error: defaults for type parameters are only allowed in `struct`, `enum`, `type`, or `trait` definitions
- --> $DIR/where-allowed.rs:239:7
+warning: defaults for generic parameters are not allowed here
+ --> $DIR/where-allowed.rs:240:6
|
-LL | impl <T = impl Debug> T {}
- | ^^^^^^^^^^^^^^
- |
- = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
- = note: for more information, see issue #36887 <https://github.com/rust-lang/rust/issues/36887>
- = note: `#[deny(invalid_type_param_default)]` on by default
+LL | impl<T = impl Debug> T {}
+ | ^^^^^^^^^^^^^^
diff --git a/tests/ui/imports/local-modularized-tricky-fail-2.stderr b/tests/ui/imports/local-modularized-tricky-fail-2.stderr
index 49f5c72..ea4056b 100644
--- a/tests/ui/imports/local-modularized-tricky-fail-2.stderr
+++ b/tests/ui/imports/local-modularized-tricky-fail-2.stderr
@@ -41,3 +41,47 @@
error: aborting due to 2 previous errors
+Future incompatibility report: Future breakage diagnostic:
+error: macro-expanded `macro_export` macros from the current crate cannot be referred to by absolute paths
+ --> $DIR/local-modularized-tricky-fail-2.rs:13:9
+ |
+LL | use crate::exported;
+ | ^^^^^^^^^^^^^^^
+ |
+ = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
+ = note: for more information, see issue #52234 <https://github.com/rust-lang/rust/issues/52234>
+note: the macro is defined here
+ --> $DIR/local-modularized-tricky-fail-2.rs:5:5
+ |
+LL | / macro_rules! exported {
+LL | | () => ()
+LL | | }
+ | |_____^
+...
+LL | define_exported!();
+ | ------------------ in this macro invocation
+ = note: `#[deny(macro_expanded_macro_exports_accessed_by_absolute_paths)]` on by default
+ = note: this error originates in the macro `define_exported` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+Future breakage diagnostic:
+error: macro-expanded `macro_export` macros from the current crate cannot be referred to by absolute paths
+ --> $DIR/local-modularized-tricky-fail-2.rs:19:5
+ |
+LL | crate::exported!();
+ | ^^^^^^^^^^^^^^^
+ |
+ = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
+ = note: for more information, see issue #52234 <https://github.com/rust-lang/rust/issues/52234>
+note: the macro is defined here
+ --> $DIR/local-modularized-tricky-fail-2.rs:5:5
+ |
+LL | / macro_rules! exported {
+LL | | () => ()
+LL | | }
+ | |_____^
+...
+LL | define_exported!();
+ | ------------------ in this macro invocation
+ = note: `#[deny(macro_expanded_macro_exports_accessed_by_absolute_paths)]` on by default
+ = note: this error originates in the macro `define_exported` (in Nightly builds, run with -Z macro-backtrace for more info)
+
diff --git a/tests/ui/intrinsics/const-eval-select-backtrace-std.run.stderr b/tests/ui/intrinsics/const-eval-select-backtrace-std.run.stderr
index 71d792b..397eeaf 100644
--- a/tests/ui/intrinsics/const-eval-select-backtrace-std.run.stderr
+++ b/tests/ui/intrinsics/const-eval-select-backtrace-std.run.stderr
@@ -1,4 +1,4 @@
-thread 'main' panicked at $DIR/const-eval-select-backtrace-std.rs:6:8:
+thread 'main' ($TID) panicked at $DIR/const-eval-select-backtrace-std.rs:6:8:
byte index 1 is out of bounds of ``
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
diff --git a/tests/ui/intrinsics/const-eval-select-backtrace.run.stderr b/tests/ui/intrinsics/const-eval-select-backtrace.run.stderr
index 4f11f59..6491740 100644
--- a/tests/ui/intrinsics/const-eval-select-backtrace.run.stderr
+++ b/tests/ui/intrinsics/const-eval-select-backtrace.run.stderr
@@ -1,4 +1,4 @@
-thread 'main' panicked at $DIR/const-eval-select-backtrace.rs:15:5:
+thread 'main' ($TID) panicked at $DIR/const-eval-select-backtrace.rs:15:5:
Aaah!
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
diff --git a/tests/ui/intrinsics/not-overridden.rs b/tests/ui/intrinsics/not-overridden.rs
index 2359eee..ce85548 100644
--- a/tests/ui/intrinsics/not-overridden.rs
+++ b/tests/ui/intrinsics/not-overridden.rs
@@ -4,7 +4,7 @@
//@ build-fail
//@ failure-status:101
//@ normalize-stderr: ".*note: .*\n\n" -> ""
-//@ normalize-stderr: "thread 'rustc' panicked.*:\n.*\n" -> ""
+//@ normalize-stderr: "thread 'rustc'.*panicked.*:\n.*\n" -> ""
//@ normalize-stderr: "internal compiler error:.*: intrinsic const_deallocate " -> ""
//@ rustc-env:RUST_BACKTRACE=0
diff --git a/tests/ui/issues/issue-26812.rs b/tests/ui/issues/issue-26812.rs
deleted file mode 100644
index 8eb030a..0000000
--- a/tests/ui/issues/issue-26812.rs
+++ /dev/null
@@ -1,6 +0,0 @@
-fn avg<T=T::Item>(_: T) {}
-//~^ ERROR generic parameter defaults cannot reference parameters before they are declared
-//~| ERROR defaults for type parameters
-//~| WARN previously accepted
-
-fn main() {}
diff --git a/tests/ui/issues/issue-26812.stderr b/tests/ui/issues/issue-26812.stderr
deleted file mode 100644
index bb60d67..0000000
--- a/tests/ui/issues/issue-26812.stderr
+++ /dev/null
@@ -1,30 +0,0 @@
-error[E0128]: generic parameter defaults cannot reference parameters before they are declared
- --> $DIR/issue-26812.rs:1:10
- |
-LL | fn avg<T=T::Item>(_: T) {}
- | ^^^^^^^ cannot reference `T` before it is declared
-
-error: defaults for type parameters are only allowed in `struct`, `enum`, `type`, or `trait` definitions
- --> $DIR/issue-26812.rs:1:8
- |
-LL | fn avg<T=T::Item>(_: T) {}
- | ^^^^^^^^^
- |
- = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
- = note: for more information, see issue #36887 <https://github.com/rust-lang/rust/issues/36887>
- = note: `#[deny(invalid_type_param_default)]` on by default
-
-error: aborting due to 2 previous errors
-
-For more information about this error, try `rustc --explain E0128`.
-Future incompatibility report: Future breakage diagnostic:
-error: defaults for type parameters are only allowed in `struct`, `enum`, `type`, or `trait` definitions
- --> $DIR/issue-26812.rs:1:8
- |
-LL | fn avg<T=T::Item>(_: T) {}
- | ^^^^^^^^^
- |
- = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
- = note: for more information, see issue #36887 <https://github.com/rust-lang/rust/issues/36887>
- = note: `#[deny(invalid_type_param_default)]` on by default
-
diff --git a/tests/ui/issues/issue-87707.run.stderr b/tests/ui/issues/issue-87707.run.stderr
index eb1d65a..8485c05 100644
--- a/tests/ui/issues/issue-87707.run.stderr
+++ b/tests/ui/issues/issue-87707.run.stderr
@@ -1,7 +1,7 @@
-thread 'main' panicked at $DIR/issue-87707.rs:14:24:
+thread 'main' ($TID) panicked at $DIR/issue-87707.rs:14:24:
Here Once instance is poisoned.
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
-thread 'main' panicked at $DIR/issue-87707.rs:16:7:
+thread 'main' ($TID) panicked at $DIR/issue-87707.rs:16:7:
Once instance has previously been poisoned
diff --git a/tests/ui/layout/valid_range_oob.rs b/tests/ui/layout/valid_range_oob.rs
index df816e7..8ae9f6e 100644
--- a/tests/ui/layout/valid_range_oob.rs
+++ b/tests/ui/layout/valid_range_oob.rs
@@ -1,6 +1,6 @@
//@ failure-status: 101
//@ normalize-stderr: "note: .*\n\n" -> ""
-//@ normalize-stderr: "thread 'rustc' panicked.*\n" -> ""
+//@ normalize-stderr: "thread 'rustc'.*panicked.*\n" -> ""
//@ rustc-env:RUST_BACKTRACE=0
#![feature(rustc_attrs)]
diff --git a/tests/ui/lifetimes/unusual-rib-combinations.rs b/tests/ui/lifetimes/unusual-rib-combinations.rs
index 0e92b41..b3e9642 100644
--- a/tests/ui/lifetimes/unusual-rib-combinations.rs
+++ b/tests/ui/lifetimes/unusual-rib-combinations.rs
@@ -14,7 +14,7 @@ fn b<const C: u8()>() {}
// Paren generic args in AnonymousReportError
fn c<T = u8()>() {}
//~^ ERROR parenthesized type parameters may only be used with a `Fn` trait
-//~| ERROR defaults for type parameters are only allowed in
+//~| ERROR defaults for generic parameters are not allowed here
//~| WARN this was previously accepted
// Elided lifetime in path in ConstGeneric
diff --git a/tests/ui/lifetimes/unusual-rib-combinations.stderr b/tests/ui/lifetimes/unusual-rib-combinations.stderr
index 7373ca8..bd68479 100644
--- a/tests/ui/lifetimes/unusual-rib-combinations.stderr
+++ b/tests/ui/lifetimes/unusual-rib-combinations.stderr
@@ -22,7 +22,7 @@
LL | fn c<T = u8()>() {}
| ^^^^ only `Fn` traits may use parentheses
-error: defaults for type parameters are only allowed in `struct`, `enum`, `type`, or `trait` definitions
+error: defaults for generic parameters are not allowed here
--> $DIR/unusual-rib-combinations.rs:15:6
|
LL | fn c<T = u8()>() {}
@@ -43,7 +43,7 @@
Some errors have detailed explanations: E0106, E0214, E0308, E0770.
For more information about an error, try `rustc --explain E0106`.
Future incompatibility report: Future breakage diagnostic:
-error: defaults for type parameters are only allowed in `struct`, `enum`, `type`, or `trait` definitions
+error: defaults for generic parameters are not allowed here
--> $DIR/unusual-rib-combinations.rs:15:6
|
LL | fn c<T = u8()>() {}
diff --git a/tests/ui/lint/semicolon-in-expressions-from-macros/warn-semicolon-in-expressions-from-macros.rs b/tests/ui/lint/semicolon-in-expressions-from-macros/warn-semicolon-in-expressions-from-macros.rs
index 05fbfec..8ec70a1 100644
--- a/tests/ui/lint/semicolon-in-expressions-from-macros/warn-semicolon-in-expressions-from-macros.rs
+++ b/tests/ui/lint/semicolon-in-expressions-from-macros/warn-semicolon-in-expressions-from-macros.rs
@@ -1,9 +1,8 @@
-//@ check-pass
-// Ensure that trailing semicolons cause warnings by default
+// Ensure that trailing semicolons cause errors by default
macro_rules! foo {
() => {
- true; //~ WARN trailing semicolon in macro
+ true; //~ ERROR trailing semicolon in macro
//~| WARN this was previously
}
}
diff --git a/tests/ui/lint/semicolon-in-expressions-from-macros/warn-semicolon-in-expressions-from-macros.stderr b/tests/ui/lint/semicolon-in-expressions-from-macros/warn-semicolon-in-expressions-from-macros.stderr
index 0fec499..99cdcaf 100644
--- a/tests/ui/lint/semicolon-in-expressions-from-macros/warn-semicolon-in-expressions-from-macros.stderr
+++ b/tests/ui/lint/semicolon-in-expressions-from-macros/warn-semicolon-in-expressions-from-macros.stderr
@@ -1,5 +1,5 @@
-warning: trailing semicolon in macro used in expression position
- --> $DIR/warn-semicolon-in-expressions-from-macros.rs:6:13
+error: trailing semicolon in macro used in expression position
+ --> $DIR/warn-semicolon-in-expressions-from-macros.rs:5:13
|
LL | true;
| ^
@@ -9,14 +9,14 @@
|
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
= note: for more information, see issue #79813 <https://github.com/rust-lang/rust/issues/79813>
- = note: `#[warn(semicolon_in_expressions_from_macros)]` on by default
- = note: this warning originates in the macro `foo` (in Nightly builds, run with -Z macro-backtrace for more info)
+ = note: `#[deny(semicolon_in_expressions_from_macros)]` on by default
+ = note: this error originates in the macro `foo` (in Nightly builds, run with -Z macro-backtrace for more info)
-warning: 1 warning emitted
+error: aborting due to 1 previous error
Future incompatibility report: Future breakage diagnostic:
-warning: trailing semicolon in macro used in expression position
- --> $DIR/warn-semicolon-in-expressions-from-macros.rs:6:13
+error: trailing semicolon in macro used in expression position
+ --> $DIR/warn-semicolon-in-expressions-from-macros.rs:5:13
|
LL | true;
| ^
@@ -26,6 +26,6 @@
|
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
= note: for more information, see issue #79813 <https://github.com/rust-lang/rust/issues/79813>
- = note: `#[warn(semicolon_in_expressions_from_macros)]` on by default
- = note: this warning originates in the macro `foo` (in Nightly builds, run with -Z macro-backtrace for more info)
+ = note: `#[deny(semicolon_in_expressions_from_macros)]` on by default
+ = note: this error originates in the macro `foo` (in Nightly builds, run with -Z macro-backtrace for more info)
diff --git a/tests/ui/lint/unused/unused-attr-duplicate.stderr b/tests/ui/lint/unused/unused-attr-duplicate.stderr
index e277f52..6c44e88 100644
--- a/tests/ui/lint/unused/unused-attr-duplicate.stderr
+++ b/tests/ui/lint/unused/unused-attr-duplicate.stderr
@@ -16,19 +16,6 @@
| ^^^^^^^^^^^^^^^^^
error: unused attribute
- --> $DIR/unused-attr-duplicate.rs:55:1
- |
-LL | #[should_panic(expected = "values don't match")]
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: remove this attribute
- |
-note: attribute also specified here
- --> $DIR/unused-attr-duplicate.rs:54:1
- |
-LL | #[should_panic]
- | ^^^^^^^^^^^^^^^
- = 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"]
@@ -154,6 +141,19 @@
| ^^^^^^^^^
error: unused attribute
+ --> $DIR/unused-attr-duplicate.rs:55:1
+ |
+LL | #[should_panic(expected = "values don't match")]
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: remove this attribute
+ |
+note: attribute also specified here
+ --> $DIR/unused-attr-duplicate.rs:54:1
+ |
+LL | #[should_panic]
+ | ^^^^^^^^^^^^^^^
+ = 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:60:1
|
LL | #[must_use = "some message"]
diff --git a/tests/ui/macros/assert-long-condition.run.stderr b/tests/ui/macros/assert-long-condition.run.stderr
index c2c5fe5..a9fac03 100644
--- a/tests/ui/macros/assert-long-condition.run.stderr
+++ b/tests/ui/macros/assert-long-condition.run.stderr
@@ -1,5 +1,5 @@
-thread 'main' panicked at $DIR/assert-long-condition.rs:7:5:
+thread 'main' ($TID) panicked at $DIR/assert-long-condition.rs:7:5:
assertion failed: 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + 15 + 16 + 17 + 18
+ 19 + 20 + 21 + 22 + 23 + 24 + 25 == 0
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
diff --git a/tests/ui/macros/lint-trailing-macro-call.rs b/tests/ui/macros/lint-trailing-macro-call.rs
index 78b861f..25fa910 100644
--- a/tests/ui/macros/lint-trailing-macro-call.rs
+++ b/tests/ui/macros/lint-trailing-macro-call.rs
@@ -1,12 +1,10 @@
-//@ check-pass
-//
// Ensures that we properly lint
// a removed 'expression' resulting from a macro
// in trailing expression position
macro_rules! expand_it {
() => {
- #[cfg(false)] 25; //~ WARN trailing semicolon in macro
+ #[cfg(false)] 25; //~ ERROR trailing semicolon in macro
//~| WARN this was previously
}
}
diff --git a/tests/ui/macros/lint-trailing-macro-call.stderr b/tests/ui/macros/lint-trailing-macro-call.stderr
index 223b85e..3fd1ea8 100644
--- a/tests/ui/macros/lint-trailing-macro-call.stderr
+++ b/tests/ui/macros/lint-trailing-macro-call.stderr
@@ -1,5 +1,5 @@
-warning: trailing semicolon in macro used in expression position
- --> $DIR/lint-trailing-macro-call.rs:9:25
+error: trailing semicolon in macro used in expression position
+ --> $DIR/lint-trailing-macro-call.rs:7:25
|
LL | #[cfg(false)] 25;
| ^
@@ -11,14 +11,14 @@
= note: for more information, see issue #79813 <https://github.com/rust-lang/rust/issues/79813>
= note: macro invocations at the end of a block are treated as expressions
= note: to ignore the value produced by the macro, add a semicolon after the invocation of `expand_it`
- = note: `#[warn(semicolon_in_expressions_from_macros)]` on by default
- = note: this warning originates in the macro `expand_it` (in Nightly builds, run with -Z macro-backtrace for more info)
+ = note: `#[deny(semicolon_in_expressions_from_macros)]` on by default
+ = note: this error originates in the macro `expand_it` (in Nightly builds, run with -Z macro-backtrace for more info)
-warning: 1 warning emitted
+error: aborting due to 1 previous error
Future incompatibility report: Future breakage diagnostic:
-warning: trailing semicolon in macro used in expression position
- --> $DIR/lint-trailing-macro-call.rs:9:25
+error: trailing semicolon in macro used in expression position
+ --> $DIR/lint-trailing-macro-call.rs:7:25
|
LL | #[cfg(false)] 25;
| ^
@@ -30,6 +30,6 @@
= note: for more information, see issue #79813 <https://github.com/rust-lang/rust/issues/79813>
= note: macro invocations at the end of a block are treated as expressions
= note: to ignore the value produced by the macro, add a semicolon after the invocation of `expand_it`
- = note: `#[warn(semicolon_in_expressions_from_macros)]` on by default
- = note: this warning originates in the macro `expand_it` (in Nightly builds, run with -Z macro-backtrace for more info)
+ = note: `#[deny(semicolon_in_expressions_from_macros)]` on by default
+ = note: this error originates in the macro `expand_it` (in Nightly builds, run with -Z macro-backtrace for more info)
diff --git a/tests/ui/macros/macro-context.rs b/tests/ui/macros/macro-context.rs
index a314702..e1c24ba 100644
--- a/tests/ui/macros/macro-context.rs
+++ b/tests/ui/macros/macro-context.rs
@@ -6,7 +6,7 @@ macro_rules! m {
//~| ERROR macro expansion ignores `;`
//~| ERROR cannot find type `i` in this scope
//~| ERROR cannot find value `i` in this scope
- //~| WARN trailing semicolon in macro
+ //~| ERROR trailing semicolon in macro
//~| WARN this was previously
}
diff --git a/tests/ui/macros/macro-context.stderr b/tests/ui/macros/macro-context.stderr
index 4820a43..6b49c05 100644
--- a/tests/ui/macros/macro-context.stderr
+++ b/tests/ui/macros/macro-context.stderr
@@ -64,7 +64,7 @@
|
= note: this error originates in the macro `m` (in Nightly builds, run with -Z macro-backtrace for more info)
-warning: trailing semicolon in macro used in expression position
+error: trailing semicolon in macro used in expression position
--> $DIR/macro-context.rs:3:15
|
LL | () => ( i ; typeof );
@@ -75,15 +75,15 @@
|
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
= note: for more information, see issue #79813 <https://github.com/rust-lang/rust/issues/79813>
- = note: `#[warn(semicolon_in_expressions_from_macros)]` on by default
- = note: this warning originates in the macro `m` (in Nightly builds, run with -Z macro-backtrace for more info)
+ = note: `#[deny(semicolon_in_expressions_from_macros)]` on by default
+ = note: this error originates in the macro `m` (in Nightly builds, run with -Z macro-backtrace for more info)
-error: aborting due to 6 previous errors; 1 warning emitted
+error: aborting due to 7 previous errors
Some errors have detailed explanations: E0412, E0425.
For more information about an error, try `rustc --explain E0412`.
Future incompatibility report: Future breakage diagnostic:
-warning: trailing semicolon in macro used in expression position
+error: trailing semicolon in macro used in expression position
--> $DIR/macro-context.rs:3:15
|
LL | () => ( i ; typeof );
@@ -94,6 +94,6 @@
|
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
= note: for more information, see issue #79813 <https://github.com/rust-lang/rust/issues/79813>
- = note: `#[warn(semicolon_in_expressions_from_macros)]` on by default
- = note: this warning originates in the macro `m` (in Nightly builds, run with -Z macro-backtrace for more info)
+ = note: `#[deny(semicolon_in_expressions_from_macros)]` on by default
+ = note: this error originates in the macro `m` (in Nightly builds, run with -Z macro-backtrace for more info)
diff --git a/tests/ui/macros/macro-in-expression-context.fixed b/tests/ui/macros/macro-in-expression-context.fixed
index 7c83070..52e1b42 100644
--- a/tests/ui/macros/macro-in-expression-context.fixed
+++ b/tests/ui/macros/macro-in-expression-context.fixed
@@ -3,12 +3,12 @@
macro_rules! foo {
() => {
assert_eq!("A", "A");
- //~^ WARN trailing semicolon in macro
+ //~^ ERROR trailing semicolon in macro
//~| WARN this was previously
//~| NOTE macro invocations at the end of a block
//~| NOTE to ignore the value produced by the macro
//~| NOTE for more information
- //~| NOTE `#[warn(semicolon_in_expressions_from_macros)]` on by default
+ //~| NOTE `#[deny(semicolon_in_expressions_from_macros)]` on by default
assert_eq!("B", "B");
}
//~^^ ERROR macro expansion ignores `assert_eq` and any tokens following
diff --git a/tests/ui/macros/macro-in-expression-context.rs b/tests/ui/macros/macro-in-expression-context.rs
index da95017..5c560e7 100644
--- a/tests/ui/macros/macro-in-expression-context.rs
+++ b/tests/ui/macros/macro-in-expression-context.rs
@@ -3,12 +3,12 @@
macro_rules! foo {
() => {
assert_eq!("A", "A");
- //~^ WARN trailing semicolon in macro
+ //~^ ERROR trailing semicolon in macro
//~| WARN this was previously
//~| NOTE macro invocations at the end of a block
//~| NOTE to ignore the value produced by the macro
//~| NOTE for more information
- //~| NOTE `#[warn(semicolon_in_expressions_from_macros)]` on by default
+ //~| NOTE `#[deny(semicolon_in_expressions_from_macros)]` on by default
assert_eq!("B", "B");
}
//~^^ ERROR macro expansion ignores `assert_eq` and any tokens following
diff --git a/tests/ui/macros/macro-in-expression-context.stderr b/tests/ui/macros/macro-in-expression-context.stderr
index 43419f2..b04348d 100644
--- a/tests/ui/macros/macro-in-expression-context.stderr
+++ b/tests/ui/macros/macro-in-expression-context.stderr
@@ -13,7 +13,7 @@
LL | foo!();
| +
-warning: trailing semicolon in macro used in expression position
+error: trailing semicolon in macro used in expression position
--> $DIR/macro-in-expression-context.rs:5:29
|
LL | assert_eq!("A", "A");
@@ -26,13 +26,13 @@
= note: for more information, see issue #79813 <https://github.com/rust-lang/rust/issues/79813>
= note: macro invocations at the end of a block are treated as expressions
= note: to ignore the value produced by the macro, add a semicolon after the invocation of `foo`
- = note: `#[warn(semicolon_in_expressions_from_macros)]` on by default
- = note: this warning originates in the macro `foo` (in Nightly builds, run with -Z macro-backtrace for more info)
+ = note: `#[deny(semicolon_in_expressions_from_macros)]` on by default
+ = note: this error originates in the macro `foo` (in Nightly builds, run with -Z macro-backtrace for more info)
-error: aborting due to 1 previous error; 1 warning emitted
+error: aborting due to 2 previous errors
Future incompatibility report: Future breakage diagnostic:
-warning: trailing semicolon in macro used in expression position
+error: trailing semicolon in macro used in expression position
--> $DIR/macro-in-expression-context.rs:5:29
|
LL | assert_eq!("A", "A");
@@ -45,6 +45,6 @@
= note: for more information, see issue #79813 <https://github.com/rust-lang/rust/issues/79813>
= note: macro invocations at the end of a block are treated as expressions
= note: to ignore the value produced by the macro, add a semicolon after the invocation of `foo`
- = note: `#[warn(semicolon_in_expressions_from_macros)]` on by default
- = note: this warning originates in the macro `foo` (in Nightly builds, run with -Z macro-backtrace for more info)
+ = note: `#[deny(semicolon_in_expressions_from_macros)]` on by default
+ = note: this error originates in the macro `foo` (in Nightly builds, run with -Z macro-backtrace for more info)
diff --git a/tests/ui/methods/issues/issue-105732.stderr b/tests/ui/methods/issues/issue-105732.stderr
index 6244f98..93ce695 100644
--- a/tests/ui/methods/issues/issue-105732.stderr
+++ b/tests/ui/methods/issues/issue-105732.stderr
@@ -4,7 +4,7 @@
LL | auto trait Foo {
| --- auto traits cannot have associated items
LL | fn g(&self);
- | ---^-------- help: remove these associated items
+ | ^
error[E0599]: no method named `g` found for reference `&Self` in the current scope
--> $DIR/issue-105732.rs:10:14
diff --git a/tests/ui/mir/lint/storage-live.rs b/tests/ui/mir/lint/storage-live.rs
index 252e3b8..32bd327 100644
--- a/tests/ui/mir/lint/storage-live.rs
+++ b/tests/ui/mir/lint/storage-live.rs
@@ -1,7 +1,7 @@
//@ compile-flags: -Zlint-mir -Ztreat-err-as-bug
//@ failure-status: 101
//@ normalize-stderr: "note: .*\n\n" -> ""
-//@ normalize-stderr: "thread 'rustc' panicked.*\n" -> ""
+//@ normalize-stderr: "thread 'rustc'.*panicked.*\n" -> ""
//@ normalize-stderr: "storage_live\[....\]" -> "storage_live[HASH]"
//@ normalize-stderr: "(delayed at [^:]+):\d+:\d+ - " -> "$1:LL:CC - "
//@ rustc-env:RUST_BACKTRACE=0
diff --git a/tests/ui/missing/missing-items/missing-type-parameter2.rs b/tests/ui/missing/missing-items/missing-type-parameter2.rs
index e9b32fb..772e60b 100644
--- a/tests/ui/missing/missing-items/missing-type-parameter2.rs
+++ b/tests/ui/missing/missing-items/missing-type-parameter2.rs
@@ -5,7 +5,7 @@ impl X<N> {}
//~| ERROR unresolved item provided when a constant was expected
impl<T, const A: u8 = 2> X<N> {}
//~^ ERROR cannot find type `N` in this scope
-//~| ERROR defaults for const parameters are only allowed in `struct`, `enum`, `type`, or `trait` definitions
+//~| ERROR defaults for generic parameters are not allowed here
//~| ERROR unresolved item provided when a constant was expected
fn foo(_: T) where T: Send {}
diff --git a/tests/ui/missing/missing-items/missing-type-parameter2.stderr b/tests/ui/missing/missing-items/missing-type-parameter2.stderr
index f6418de..3c132e7 100644
--- a/tests/ui/missing/missing-items/missing-type-parameter2.stderr
+++ b/tests/ui/missing/missing-items/missing-type-parameter2.stderr
@@ -103,7 +103,7 @@
LL | impl X<{ N }> {}
| + +
-error: defaults for const parameters are only allowed in `struct`, `enum`, `type`, or `trait` definitions
+error: defaults for generic parameters are not allowed here
--> $DIR/missing-type-parameter2.rs:6:9
|
LL | impl<T, const A: u8 = 2> X<N> {}
diff --git a/tests/ui/nll/issue-51345-2.rs b/tests/ui/nll/issue-51345-2.rs
index 39871d5..6c424d4 100644
--- a/tests/ui/nll/issue-51345-2.rs
+++ b/tests/ui/nll/issue-51345-2.rs
@@ -1,6 +1,6 @@
//@ run-fail
-//@ error-pattern:thread 'main' panicked
-//@ error-pattern:explicit panic
+//@ regex-error-pattern: thread 'main'.*panicked
+//@ error-pattern: explicit panic
//@ needs-subprocess
fn main() {
diff --git a/tests/ui/numbers-arithmetic/overflowing-add.rs b/tests/ui/numbers-arithmetic/overflowing-add.rs
index c1f498c..a63fc3b 100644
--- a/tests/ui/numbers-arithmetic/overflowing-add.rs
+++ b/tests/ui/numbers-arithmetic/overflowing-add.rs
@@ -1,6 +1,6 @@
//@ run-fail
-//@ error-pattern:thread 'main' panicked
-//@ error-pattern:attempt to add with overflow
+//@ regex-error-pattern: thread 'main'.*panicked
+//@ error-pattern: attempt to add with overflow
//@ compile-flags: -C debug-assertions
//@ needs-subprocess
diff --git a/tests/ui/numbers-arithmetic/overflowing-mul.rs b/tests/ui/numbers-arithmetic/overflowing-mul.rs
index 0eece53..2645a32 100644
--- a/tests/ui/numbers-arithmetic/overflowing-mul.rs
+++ b/tests/ui/numbers-arithmetic/overflowing-mul.rs
@@ -1,6 +1,6 @@
//@ run-fail
-//@ error-pattern:thread 'main' panicked
-//@ error-pattern:attempt to multiply with overflow
+//@ regex-error-pattern: thread 'main'.*panicked
+//@ error-pattern: attempt to multiply with overflow
//@ needs-subprocess
//@ compile-flags: -C debug-assertions
diff --git a/tests/ui/numbers-arithmetic/overflowing-pow-signed.rs b/tests/ui/numbers-arithmetic/overflowing-pow-signed.rs
index 28deb7c..6db6682 100644
--- a/tests/ui/numbers-arithmetic/overflowing-pow-signed.rs
+++ b/tests/ui/numbers-arithmetic/overflowing-pow-signed.rs
@@ -1,6 +1,6 @@
//@ run-fail
-//@ error-pattern:thread 'main' panicked
-//@ error-pattern:attempt to multiply with overflow
+//@ regex-error-pattern: thread 'main'.*panicked
+//@ error-pattern: attempt to multiply with overflow
//@ needs-subprocess
//@ compile-flags: -C debug-assertions
diff --git a/tests/ui/numbers-arithmetic/overflowing-pow-unsigned.rs b/tests/ui/numbers-arithmetic/overflowing-pow-unsigned.rs
index dea9a4d..bde0de6 100644
--- a/tests/ui/numbers-arithmetic/overflowing-pow-unsigned.rs
+++ b/tests/ui/numbers-arithmetic/overflowing-pow-unsigned.rs
@@ -1,6 +1,6 @@
//@ run-fail
-//@ error-pattern:thread 'main' panicked
-//@ error-pattern:attempt to multiply with overflow
+//@ regex-error-pattern: thread 'main'.*panicked
+//@ error-pattern: attempt to multiply with overflow
//@ needs-subprocess
//@ compile-flags: -C debug-assertions
diff --git a/tests/ui/numbers-arithmetic/overflowing-sub.rs b/tests/ui/numbers-arithmetic/overflowing-sub.rs
index 88b1b69..1718fcc 100644
--- a/tests/ui/numbers-arithmetic/overflowing-sub.rs
+++ b/tests/ui/numbers-arithmetic/overflowing-sub.rs
@@ -1,6 +1,6 @@
//@ run-fail
-//@ error-pattern:thread 'main' panicked
-//@ error-pattern:attempt to subtract with overflow
+//@ regex-error-pattern: thread 'main'.*panicked
+//@ error-pattern: attempt to subtract with overflow
//@ needs-subprocess
//@ compile-flags: -C debug-assertions
diff --git a/tests/ui/panics/fmt-only-once.run.stderr b/tests/ui/panics/fmt-only-once.run.stderr
index faa3cc9..f0124e4 100644
--- a/tests/ui/panics/fmt-only-once.run.stderr
+++ b/tests/ui/panics/fmt-only-once.run.stderr
@@ -1,5 +1,5 @@
fmt
-thread 'main' panicked at $DIR/fmt-only-once.rs:20:5:
+thread 'main' ($TID) panicked at $DIR/fmt-only-once.rs:20:5:
PrintOnFmt
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
diff --git a/tests/ui/panics/issue-47429-short-backtraces.run.stderr b/tests/ui/panics/issue-47429-short-backtraces.run.stderr
index 32dc659..13b59a7 100644
--- a/tests/ui/panics/issue-47429-short-backtraces.run.stderr
+++ b/tests/ui/panics/issue-47429-short-backtraces.run.stderr
@@ -1,5 +1,5 @@
-thread 'main' panicked at $DIR/issue-47429-short-backtraces.rs:24:5:
+thread 'main' ($TID) panicked at $DIR/issue-47429-short-backtraces.rs:24:5:
explicit panic
stack backtrace:
0: std::panicking::begin_panic
diff --git a/tests/ui/panics/location-detail-panic-no-column.run.stderr b/tests/ui/panics/location-detail-panic-no-column.run.stderr
index f63c096..8f43936 100644
--- a/tests/ui/panics/location-detail-panic-no-column.run.stderr
+++ b/tests/ui/panics/location-detail-panic-no-column.run.stderr
@@ -1,4 +1,4 @@
-thread 'main' panicked at $DIR/location-detail-panic-no-column.rs:7:0:
+thread 'main' ($TID) panicked at $DIR/location-detail-panic-no-column.rs:7:0:
column-redacted
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
diff --git a/tests/ui/panics/location-detail-panic-no-file.run.stderr b/tests/ui/panics/location-detail-panic-no-file.run.stderr
index 3d1c6de..8d0ee14 100644
--- a/tests/ui/panics/location-detail-panic-no-file.run.stderr
+++ b/tests/ui/panics/location-detail-panic-no-file.run.stderr
@@ -1,4 +1,4 @@
-thread 'main' panicked at <redacted>:7:5:
+thread 'main' ($TID) panicked at <redacted>:7:5:
file-redacted
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
diff --git a/tests/ui/panics/location-detail-panic-no-line.run.stderr b/tests/ui/panics/location-detail-panic-no-line.run.stderr
index 9809ab5..79f5c01 100644
--- a/tests/ui/panics/location-detail-panic-no-line.run.stderr
+++ b/tests/ui/panics/location-detail-panic-no-line.run.stderr
@@ -1,4 +1,4 @@
-thread 'main' panicked at $DIR/location-detail-panic-no-line.rs:0:5:
+thread 'main' ($TID) panicked at $DIR/location-detail-panic-no-line.rs:0:5:
line-redacted
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
diff --git a/tests/ui/panics/location-detail-panic-no-location-info.run.stderr b/tests/ui/panics/location-detail-panic-no-location-info.run.stderr
index f68a0d6..12b3e1b 100644
--- a/tests/ui/panics/location-detail-panic-no-location-info.run.stderr
+++ b/tests/ui/panics/location-detail-panic-no-location-info.run.stderr
@@ -1,4 +1,4 @@
-thread 'main' panicked at <redacted>:0:0:
+thread 'main' ($TID) panicked at <redacted>:0:0:
no location info
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
diff --git a/tests/ui/panics/location-detail-unwrap-no-file.run.stderr b/tests/ui/panics/location-detail-unwrap-no-file.run.stderr
index af4a499..a4a8742 100644
--- a/tests/ui/panics/location-detail-unwrap-no-file.run.stderr
+++ b/tests/ui/panics/location-detail-unwrap-no-file.run.stderr
@@ -1,4 +1,4 @@
-thread 'main' panicked at <redacted>:8:9:
+thread 'main' ($TID) panicked at <redacted>:8:9:
called `Option::unwrap()` on a `None` value
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
diff --git a/tests/ui/panics/main-panic.rs b/tests/ui/panics/main-panic.rs
index 0b3d5c3..9f2a92d 100644
--- a/tests/ui/panics/main-panic.rs
+++ b/tests/ui/panics/main-panic.rs
@@ -1,5 +1,5 @@
//@ run-fail
-//@ error-pattern:thread 'main' panicked at
+//@ regex-error-pattern: thread 'main' \(\d+\) panicked at
//@ needs-subprocess
fn main() {
diff --git a/tests/ui/panics/panic-in-cleanup.run.stderr b/tests/ui/panics/panic-in-cleanup.run.stderr
index 3438356..bfe3dc8 100644
--- a/tests/ui/panics/panic-in-cleanup.run.stderr
+++ b/tests/ui/panics/panic-in-cleanup.run.stderr
@@ -1,12 +1,12 @@
-thread 'main' panicked at $DIR/panic-in-cleanup.rs:22:5:
+thread 'main' ($TID) panicked at $DIR/panic-in-cleanup.rs:22:5:
explicit panic
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
-thread 'main' panicked at $DIR/panic-in-cleanup.rs:16:9:
+thread 'main' ($TID) panicked at $DIR/panic-in-cleanup.rs:16:9:
BOOM
stack backtrace:
-thread 'main' panicked at library/core/src/panicking.rs:$LINE:$COL:
+thread 'main' ($TID) panicked at library/core/src/panicking.rs:$LINE:$COL:
panic in a destructor during cleanup
thread caused non-unwinding panic. aborting.
diff --git a/tests/ui/panics/panic-in-ffi.run.stderr b/tests/ui/panics/panic-in-ffi.run.stderr
index a6f3ebe..ce907d6 100644
--- a/tests/ui/panics/panic-in-ffi.run.stderr
+++ b/tests/ui/panics/panic-in-ffi.run.stderr
@@ -1,10 +1,10 @@
-thread 'main' panicked at $DIR/panic-in-ffi.rs:21:5:
+thread 'main' ($TID) panicked at $DIR/panic-in-ffi.rs:21:5:
Test
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
Noisy Drop
-thread 'main' panicked at library/core/src/panicking.rs:$LINE:$COL:
+thread 'main' ($TID) panicked at library/core/src/panicking.rs:$LINE:$COL:
panic in a function that cannot unwind
stack backtrace:
thread caused non-unwinding panic. aborting.
diff --git a/tests/ui/panics/panic-set-unset-handler.rs b/tests/ui/panics/panic-set-unset-handler.rs
index 66d5003..4f64602 100644
--- a/tests/ui/panics/panic-set-unset-handler.rs
+++ b/tests/ui/panics/panic-set-unset-handler.rs
@@ -1,6 +1,6 @@
//@ run-fail
-//@ error-pattern:thread 'main' panicked
-//@ error-pattern:foobar
+//@ regex-error-pattern: thread 'main' \(\d+\) panicked
+//@ error-pattern: foobar
//@ needs-subprocess
use std::panic;
diff --git a/tests/ui/panics/panic-short-backtrace-windows-x86_64.run.stderr b/tests/ui/panics/panic-short-backtrace-windows-x86_64.run.stderr
index 799a8b3..c3c1ce1 100644
--- a/tests/ui/panics/panic-short-backtrace-windows-x86_64.run.stderr
+++ b/tests/ui/panics/panic-short-backtrace-windows-x86_64.run.stderr
@@ -1,4 +1,4 @@
-thread 'main' panicked at 'd was called', $DIR/panic-short-backtrace-windows-x86_64.rs:48:5
+thread 'main' ($TID) panicked at 'd was called', $DIR/panic-short-backtrace-windows-x86_64.rs:48:5
stack backtrace:
0: std::panicking::begin_panic
1: d
diff --git a/tests/ui/panics/panic-take-handler-nop.rs b/tests/ui/panics/panic-take-handler-nop.rs
index f105828..ebea3ef 100644
--- a/tests/ui/panics/panic-take-handler-nop.rs
+++ b/tests/ui/panics/panic-take-handler-nop.rs
@@ -1,6 +1,6 @@
//@ run-fail
-//@ error-pattern:thread 'main' panicked
-//@ error-pattern:foobar
+//@ regex-error-pattern: thread 'main' \(\d+\) panicked
+//@ error-pattern: foobar
//@ needs-subprocess
use std::panic;
diff --git a/tests/ui/panics/panic-task-name-none.rs b/tests/ui/panics/panic-task-name-none.rs
index 8695771..4471cd6 100644
--- a/tests/ui/panics/panic-task-name-none.rs
+++ b/tests/ui/panics/panic-task-name-none.rs
@@ -1,14 +1,14 @@
//@ run-fail
-//@ error-pattern:thread '<unnamed>' panicked
-//@ error-pattern:test
+//@ regex-error-pattern: thread '<unnamed>' \(\d+\) panicked
+//@ error-pattern: test
//@ needs-threads
use std::thread;
fn main() {
let r: Result<(), _> = thread::spawn(move || {
- panic!("test");
- })
- .join();
+ panic!("test");
+ })
+ .join();
assert!(r.is_ok());
}
diff --git a/tests/ui/panics/panic-task-name-owned.rs b/tests/ui/panics/panic-task-name-owned.rs
index 42ae33b..084ac90 100644
--- a/tests/ui/panics/panic-task-name-owned.rs
+++ b/tests/ui/panics/panic-task-name-owned.rs
@@ -1,19 +1,19 @@
//@ run-fail
-//@ error-pattern:thread 'owned name' panicked
-//@ error-pattern:test
+//@ regex-error-pattern: thread 'owned name' \(\d+\) panicked
+//@ error-pattern: test
//@ needs-threads
use std::thread::Builder;
fn main() {
let r: () = Builder::new()
- .name("owned name".to_string())
- .spawn(move || {
- panic!("test");
- ()
- })
- .unwrap()
- .join()
- .unwrap();
+ .name("owned name".to_string())
+ .spawn(move || {
+ panic!("test");
+ ()
+ })
+ .unwrap()
+ .join()
+ .unwrap();
panic!();
}
diff --git a/tests/ui/panics/runtime-switch.run.stderr b/tests/ui/panics/runtime-switch.run.stderr
index 70ed127..f3f6044 100644
--- a/tests/ui/panics/runtime-switch.run.stderr
+++ b/tests/ui/panics/runtime-switch.run.stderr
@@ -1,5 +1,5 @@
-thread 'main' panicked at $DIR/runtime-switch.rs:28:5:
+thread 'main' ($TID) panicked at $DIR/runtime-switch.rs:28:5:
explicit panic
stack backtrace:
0: std::panicking::begin_panic
diff --git a/tests/ui/panics/short-ice-remove-middle-frames-2.run.stderr b/tests/ui/panics/short-ice-remove-middle-frames-2.run.stderr
index 664d51e..584b477 100644
--- a/tests/ui/panics/short-ice-remove-middle-frames-2.run.stderr
+++ b/tests/ui/panics/short-ice-remove-middle-frames-2.run.stderr
@@ -1,5 +1,5 @@
-thread 'main' panicked at $DIR/short-ice-remove-middle-frames-2.rs:62:5:
+thread 'main' ($TID) panicked at $DIR/short-ice-remove-middle-frames-2.rs:62:5:
debug!!!
stack backtrace:
0: std::panicking::begin_panic
diff --git a/tests/ui/panics/short-ice-remove-middle-frames.run.stderr b/tests/ui/panics/short-ice-remove-middle-frames.run.stderr
index e966462..1efcb7d 100644
--- a/tests/ui/panics/short-ice-remove-middle-frames.run.stderr
+++ b/tests/ui/panics/short-ice-remove-middle-frames.run.stderr
@@ -1,5 +1,5 @@
-thread 'main' panicked at $DIR/short-ice-remove-middle-frames.rs:58:5:
+thread 'main' ($TID) panicked at $DIR/short-ice-remove-middle-frames.rs:58:5:
debug!!!
stack backtrace:
0: std::panicking::begin_panic
diff --git a/tests/ui/parser/attribute-on-empty.rs b/tests/ui/parser/attribute-on-empty.rs
new file mode 100644
index 0000000..5932377
--- /dev/null
+++ b/tests/ui/parser/attribute-on-empty.rs
@@ -0,0 +1,29 @@
+//! Regression test for: <https://github.com/rust-lang/rust/issues/144132>
+//! <https://github.com/rust-lang/rust/issues/135017>
+
+struct Baz<const N: usize>(i32);
+
+fn main() {
+ let _: Baz<#[cfg(any())]> = todo!();
+ //~^ ERROR attributes cannot be applied here
+}
+
+fn f(_param: #[attr]) {}
+//~^ ERROR attributes cannot be applied to a function parameter's type
+//~| ERROR expected type, found `)`
+
+fn g() -> #[attr] { 0 }
+//~^ ERROR attributes cannot be applied here
+
+struct S {
+ field: #[attr],
+ //~^ ERROR attributes cannot be applied here
+ field1: (#[attr], i32),
+ //~^ ERROR attributes cannot be applied here
+}
+
+type Tuple = (#[attr], String);
+//~^ ERROR attributes cannot be applied here
+
+impl #[attr] {}
+//~^ ERROR attributes cannot be applied here
diff --git a/tests/ui/parser/attribute-on-empty.stderr b/tests/ui/parser/attribute-on-empty.stderr
new file mode 100644
index 0000000..7c4806c
--- /dev/null
+++ b/tests/ui/parser/attribute-on-empty.stderr
@@ -0,0 +1,52 @@
+error: attributes cannot be applied here
+ --> $DIR/attribute-on-empty.rs:7:16
+ |
+LL | let _: Baz<#[cfg(any())]> = todo!();
+ | - ^^^^^^^^^^^^^ attributes are not allowed here
+ | |
+ | while parsing the type for `_`
+
+error: attributes cannot be applied to a function parameter's type
+ --> $DIR/attribute-on-empty.rs:11:14
+ |
+LL | fn f(_param: #[attr]) {}
+ | ^^^^^^^ attributes are not allowed here
+
+error: expected type, found `)`
+ --> $DIR/attribute-on-empty.rs:11:21
+ |
+LL | fn f(_param: #[attr]) {}
+ | ^ expected type
+
+error: attributes cannot be applied here
+ --> $DIR/attribute-on-empty.rs:15:11
+ |
+LL | fn g() -> #[attr] { 0 }
+ | ^^^^^^^ attributes are not allowed here
+
+error: attributes cannot be applied here
+ --> $DIR/attribute-on-empty.rs:19:12
+ |
+LL | field: #[attr],
+ | ^^^^^^^ attributes are not allowed here
+
+error: attributes cannot be applied here
+ --> $DIR/attribute-on-empty.rs:21:14
+ |
+LL | field1: (#[attr], i32),
+ | ^^^^^^^ attributes are not allowed here
+
+error: attributes cannot be applied here
+ --> $DIR/attribute-on-empty.rs:25:15
+ |
+LL | type Tuple = (#[attr], String);
+ | ^^^^^^^ attributes are not allowed here
+
+error: attributes cannot be applied here
+ --> $DIR/attribute-on-empty.rs:28:6
+ |
+LL | impl #[attr] {}
+ | ^^^^^^^ attributes are not allowed here
+
+error: aborting due to 8 previous errors
+
diff --git a/tests/ui/parser/attribute-on-type.fixed b/tests/ui/parser/attribute-on-type.fixed
new file mode 100644
index 0000000..5024bfd
--- /dev/null
+++ b/tests/ui/parser/attribute-on-type.fixed
@@ -0,0 +1,58 @@
+//! Regression test for: <https://github.com/rust-lang/rust/issues/144132>
+//! <https://github.com/rust-lang/rust/issues/135017>
+
+//@ run-rustfix
+
+#![allow(dead_code, unused_variables)]
+
+struct Foo<T>(T);
+struct Bar<'a>(&'a i32);
+struct Baz<const N: usize>(i32);
+
+fn main() {
+ let foo: Foo<i32> = Foo(2i32);
+ //~^ ERROR attributes cannot be applied to generic arguments
+
+ let _: &'static str = "123";
+ //~^ ERROR attributes cannot be applied to types
+
+ let _: Bar<'static> = Bar(&123);
+ //~^ ERROR attributes cannot be applied to generic arguments
+
+ let _: Baz<42> = Baz(42);
+ //~^ ERROR attributes cannot be applied to generic arguments
+
+ let _: Foo<String> = Foo(String::new());
+ //~^ ERROR attributes cannot be applied to generic arguments
+
+ let _: Bar<'static> = Bar(&456);
+ //~^ ERROR attributes cannot be applied to generic arguments
+
+ let _generic: Box<i32> = Box::new(1);
+ //~^ ERROR attributes cannot be applied to generic arguments
+
+ let _assignment: i32 = *Box::new(1);
+ //~^ ERROR attributes cannot be applied to types
+
+ let _complex: Vec<String> = vec![];
+ //~^ ERROR attributes cannot be applied to generic arguments
+
+ let _nested: Box<Vec<u64>> = Box::new(vec![]);
+ //~^ ERROR attributes cannot be applied to generic arguments
+}
+
+fn g() -> i32 { 0 }
+//~^ ERROR attributes cannot be applied to types
+
+struct S {
+ field: i32,
+ //~^ ERROR attributes cannot be applied to types
+ field1: (i32, i32),
+ //~^ ERROR attributes cannot be applied to types
+}
+
+type Tuple = (i32, String);
+//~^ ERROR attributes cannot be applied to types
+
+impl S {}
+//~^ ERROR attributes cannot be applied to types
diff --git a/tests/ui/parser/attribute-on-type.rs b/tests/ui/parser/attribute-on-type.rs
new file mode 100644
index 0000000..196d322
--- /dev/null
+++ b/tests/ui/parser/attribute-on-type.rs
@@ -0,0 +1,58 @@
+//! Regression test for: <https://github.com/rust-lang/rust/issues/144132>
+//! <https://github.com/rust-lang/rust/issues/135017>
+
+//@ run-rustfix
+
+#![allow(dead_code, unused_variables)]
+
+struct Foo<T>(T);
+struct Bar<'a>(&'a i32);
+struct Baz<const N: usize>(i32);
+
+fn main() {
+ let foo: Foo<#[cfg(not(wrong))] i32> = Foo(2i32);
+ //~^ ERROR attributes cannot be applied to generic arguments
+
+ let _: #[attr] &'static str = "123";
+ //~^ ERROR attributes cannot be applied to types
+
+ let _: Bar<#[cfg(any())] 'static> = Bar(&123);
+ //~^ ERROR attributes cannot be applied to generic arguments
+
+ let _: Baz<#[cfg(any())] 42> = Baz(42);
+ //~^ ERROR attributes cannot be applied to generic arguments
+
+ let _: Foo<#[cfg(not(wrong))]String> = Foo(String::new());
+ //~^ ERROR attributes cannot be applied to generic arguments
+
+ let _: Bar<#[cfg(any())] 'static> = Bar(&456);
+ //~^ ERROR attributes cannot be applied to generic arguments
+
+ let _generic: Box<#[attr] i32> = Box::new(1);
+ //~^ ERROR attributes cannot be applied to generic arguments
+
+ let _assignment: #[attr] i32 = *Box::new(1);
+ //~^ ERROR attributes cannot be applied to types
+
+ let _complex: Vec<#[derive(Debug)] String> = vec![];
+ //~^ ERROR attributes cannot be applied to generic arguments
+
+ let _nested: Box<Vec<#[cfg(feature = "test")] u64>> = Box::new(vec![]);
+ //~^ ERROR attributes cannot be applied to generic arguments
+}
+
+fn g() -> #[attr] i32 { 0 }
+//~^ ERROR attributes cannot be applied to types
+
+struct S {
+ field: #[attr] i32,
+ //~^ ERROR attributes cannot be applied to types
+ field1: (#[attr] i32, i32),
+ //~^ ERROR attributes cannot be applied to types
+}
+
+type Tuple = (#[attr] i32, String);
+//~^ ERROR attributes cannot be applied to types
+
+impl #[attr] S {}
+//~^ ERROR attributes cannot be applied to types
diff --git a/tests/ui/parser/attribute-on-type.stderr b/tests/ui/parser/attribute-on-type.stderr
new file mode 100644
index 0000000..603c7e2
--- /dev/null
+++ b/tests/ui/parser/attribute-on-type.stderr
@@ -0,0 +1,92 @@
+error: attributes cannot be applied to generic arguments
+ --> $DIR/attribute-on-type.rs:13:18
+ |
+LL | let foo: Foo<#[cfg(not(wrong))] i32> = Foo(2i32);
+ | ^^^^^^^^^^^^^^^^^^ attributes are not allowed here
+
+error: attributes cannot be applied to types
+ --> $DIR/attribute-on-type.rs:16:12
+ |
+LL | let _: #[attr] &'static str = "123";
+ | ^^^^^^^ attributes are not allowed here
+
+error: attributes cannot be applied to generic arguments
+ --> $DIR/attribute-on-type.rs:19:16
+ |
+LL | let _: Bar<#[cfg(any())] 'static> = Bar(&123);
+ | ^^^^^^^^^^^^^ attributes are not allowed here
+
+error: attributes cannot be applied to generic arguments
+ --> $DIR/attribute-on-type.rs:22:16
+ |
+LL | let _: Baz<#[cfg(any())] 42> = Baz(42);
+ | ^^^^^^^^^^^^^ attributes are not allowed here
+
+error: attributes cannot be applied to generic arguments
+ --> $DIR/attribute-on-type.rs:25:16
+ |
+LL | let _: Foo<#[cfg(not(wrong))]String> = Foo(String::new());
+ | ^^^^^^^^^^^^^^^^^^ attributes are not allowed here
+
+error: attributes cannot be applied to generic arguments
+ --> $DIR/attribute-on-type.rs:28:16
+ |
+LL | let _: Bar<#[cfg(any())] 'static> = Bar(&456);
+ | ^^^^^^^^^^^^^ attributes are not allowed here
+
+error: attributes cannot be applied to generic arguments
+ --> $DIR/attribute-on-type.rs:31:23
+ |
+LL | let _generic: Box<#[attr] i32> = Box::new(1);
+ | ^^^^^^^ attributes are not allowed here
+
+error: attributes cannot be applied to types
+ --> $DIR/attribute-on-type.rs:34:22
+ |
+LL | let _assignment: #[attr] i32 = *Box::new(1);
+ | ^^^^^^^ attributes are not allowed here
+
+error: attributes cannot be applied to generic arguments
+ --> $DIR/attribute-on-type.rs:37:23
+ |
+LL | let _complex: Vec<#[derive(Debug)] String> = vec![];
+ | ^^^^^^^^^^^^^^^^ attributes are not allowed here
+
+error: attributes cannot be applied to generic arguments
+ --> $DIR/attribute-on-type.rs:40:26
+ |
+LL | let _nested: Box<Vec<#[cfg(feature = "test")] u64>> = Box::new(vec![]);
+ | ^^^^^^^^^^^^^^^^^^^^^^^^ attributes are not allowed here
+
+error: attributes cannot be applied to types
+ --> $DIR/attribute-on-type.rs:44:11
+ |
+LL | fn g() -> #[attr] i32 { 0 }
+ | ^^^^^^^ attributes are not allowed here
+
+error: attributes cannot be applied to types
+ --> $DIR/attribute-on-type.rs:48:12
+ |
+LL | field: #[attr] i32,
+ | ^^^^^^^ attributes are not allowed here
+
+error: attributes cannot be applied to types
+ --> $DIR/attribute-on-type.rs:50:14
+ |
+LL | field1: (#[attr] i32, i32),
+ | ^^^^^^^ attributes are not allowed here
+
+error: attributes cannot be applied to types
+ --> $DIR/attribute-on-type.rs:54:15
+ |
+LL | type Tuple = (#[attr] i32, String);
+ | ^^^^^^^ attributes are not allowed here
+
+error: attributes cannot be applied to types
+ --> $DIR/attribute-on-type.rs:57:6
+ |
+LL | impl #[attr] S {}
+ | ^^^^^^^ attributes are not allowed here
+
+error: aborting due to 15 previous errors
+
diff --git a/tests/ui/parser/issues/issue-103143.rs b/tests/ui/parser/issues/issue-103143.rs
index a584274..90f10fc 100644
--- a/tests/ui/parser/issues/issue-103143.rs
+++ b/tests/ui/parser/issues/issue-103143.rs
@@ -1,5 +1,5 @@
fn main() {
x::<#[a]y::<z>>
- //~^ ERROR invalid const generic expression
+ //~^ ERROR attributes cannot be applied to generic arguments
//~| ERROR cannot find value `x` in this scope
}
diff --git a/tests/ui/parser/issues/issue-103143.stderr b/tests/ui/parser/issues/issue-103143.stderr
index 4035c69..168a207 100644
--- a/tests/ui/parser/issues/issue-103143.stderr
+++ b/tests/ui/parser/issues/issue-103143.stderr
@@ -1,13 +1,8 @@
-error: invalid const generic expression
- --> $DIR/issue-103143.rs:2:13
+error: attributes cannot be applied to generic arguments
+ --> $DIR/issue-103143.rs:2:9
|
LL | x::<#[a]y::<z>>
- | ^^^^^^
- |
-help: expressions must be enclosed in braces to be used as const generic arguments
- |
-LL | x::<#[a]{ y::<z> }>
- | + +
+ | ^^^^ attributes are not allowed here
error[E0425]: cannot find value `x` in this scope
--> $DIR/issue-103143.rs:2:5
diff --git a/tests/ui/parser/recover/recover-where-clause-before-tuple-struct-body-0.fixed b/tests/ui/parser/recover/recover-where-clause-before-tuple-struct-body-0.fixed
index a851300..4002830 100644
--- a/tests/ui/parser/recover/recover-where-clause-before-tuple-struct-body-0.fixed
+++ b/tests/ui/parser/recover/recover-where-clause-before-tuple-struct-body-0.fixed
@@ -1,7 +1,9 @@
// Regression test for issues #100790 and #106439.
//@ run-rustfix
-pub struct Example(#[allow(dead_code)] usize)
+#![allow(dead_code)]
+
+pub struct Example(usize)
where
(): Sized;
//~^^^ ERROR where clauses are not allowed before tuple struct bodies
diff --git a/tests/ui/parser/recover/recover-where-clause-before-tuple-struct-body-0.rs b/tests/ui/parser/recover/recover-where-clause-before-tuple-struct-body-0.rs
index 10f4358..d8dbb42 100644
--- a/tests/ui/parser/recover/recover-where-clause-before-tuple-struct-body-0.rs
+++ b/tests/ui/parser/recover/recover-where-clause-before-tuple-struct-body-0.rs
@@ -1,10 +1,12 @@
// Regression test for issues #100790 and #106439.
//@ run-rustfix
+#![allow(dead_code)]
+
pub struct Example
where
(): Sized,
-(#[allow(dead_code)] usize);
+(usize);
//~^^^ ERROR where clauses are not allowed before tuple struct bodies
struct _Demo
diff --git a/tests/ui/parser/recover/recover-where-clause-before-tuple-struct-body-0.stderr b/tests/ui/parser/recover/recover-where-clause-before-tuple-struct-body-0.stderr
index ddbf237..66dadd9 100644
--- a/tests/ui/parser/recover/recover-where-clause-before-tuple-struct-body-0.stderr
+++ b/tests/ui/parser/recover/recover-where-clause-before-tuple-struct-body-0.stderr
@@ -1,23 +1,23 @@
error: where clauses are not allowed before tuple struct bodies
- --> $DIR/recover-where-clause-before-tuple-struct-body-0.rs:5:1
+ --> $DIR/recover-where-clause-before-tuple-struct-body-0.rs:7:1
|
LL | pub struct Example
| ------- while parsing this tuple struct
LL | / where
LL | | (): Sized,
| |______________^ unexpected where clause
-LL | (#[allow(dead_code)] usize);
- | --------------------------- the struct body
+LL | (usize);
+ | ------- the struct body
|
help: move the body before the where clause
|
-LL ~ pub struct Example(#[allow(dead_code)] usize)
+LL ~ pub struct Example(usize)
LL | where
LL ~ (): Sized;
|
error: where clauses are not allowed before tuple struct bodies
- --> $DIR/recover-where-clause-before-tuple-struct-body-0.rs:11:1
+ --> $DIR/recover-where-clause-before-tuple-struct-body-0.rs:13:1
|
LL | struct _Demo
| ----- while parsing this tuple struct
diff --git a/tests/ui/pattern/bindings-after-at/bind-by-copy-or-pat.rs b/tests/ui/pattern/bindings-after-at/bind-by-copy-or-pat.rs
index 1555da2..dd23acf 100644
--- a/tests/ui/pattern/bindings-after-at/bind-by-copy-or-pat.rs
+++ b/tests/ui/pattern/bindings-after-at/bind-by-copy-or-pat.rs
@@ -1,16 +1,15 @@
-//@ known-bug: unknown
+//@ run-pass
#![allow(unused)]
struct A(u32);
pub fn main() {
- // The or-pattern bindings are lowered after `x`, which triggers the error.
+ // Bindings are lowered in the order they appear syntactically, so this works.
let x @ (A(a) | A(a)) = A(10);
- // ERROR: use of moved value
assert!(x.0 == 10);
assert!(a == 10);
- // This works.
+ // This also works.
let (x @ A(a) | x @ A(a)) = A(10);
assert!(x.0 == 10);
assert!(a == 10);
diff --git a/tests/ui/pattern/bindings-after-at/bind-by-copy-or-pat.stderr b/tests/ui/pattern/bindings-after-at/bind-by-copy-or-pat.stderr
deleted file mode 100644
index 7980818..0000000
--- a/tests/ui/pattern/bindings-after-at/bind-by-copy-or-pat.stderr
+++ /dev/null
@@ -1,31 +0,0 @@
-error[E0382]: use of moved value
- --> $DIR/bind-by-copy-or-pat.rs:8:16
- |
-LL | let x @ (A(a) | A(a)) = A(10);
- | - ^ ----- move occurs because value has type `A`, which does not implement the `Copy` trait
- | | |
- | | value used here after move
- | value moved here
- |
-help: borrow this binding in the pattern to avoid moving the value
- |
-LL | let ref x @ (A(a) | A(a)) = A(10);
- | +++
-
-error[E0382]: use of moved value
- --> $DIR/bind-by-copy-or-pat.rs:8:23
- |
-LL | let x @ (A(a) | A(a)) = A(10);
- | - ^ ----- move occurs because value has type `A`, which does not implement the `Copy` trait
- | | |
- | | value used here after move
- | value moved here
- |
-help: borrow this binding in the pattern to avoid moving the value
- |
-LL | let ref x @ (A(a) | A(a)) = A(10);
- | +++
-
-error: aborting due to 2 previous errors
-
-For more information about this error, try `rustc --explain E0382`.
diff --git a/tests/ui/proc-macro/derive-helper-shadowing.rs b/tests/ui/proc-macro/derive-helper-shadowing.rs
index e774e46..ee883be 100644
--- a/tests/ui/proc-macro/derive-helper-shadowing.rs
+++ b/tests/ui/proc-macro/derive-helper-shadowing.rs
@@ -17,7 +17,7 @@ macro_rules! gen_helper_use {
}
#[empty_helper] //~ ERROR `empty_helper` is ambiguous
- //~| WARN derive helper attribute is used before it is introduced
+ //~| ERROR derive helper attribute is used before it is introduced
//~| WARN this was previously accepted
#[derive(Empty)]
struct S {
diff --git a/tests/ui/proc-macro/derive-helper-shadowing.stderr b/tests/ui/proc-macro/derive-helper-shadowing.stderr
index 1206778..6598937 100644
--- a/tests/ui/proc-macro/derive-helper-shadowing.stderr
+++ b/tests/ui/proc-macro/derive-helper-shadowing.stderr
@@ -58,7 +58,7 @@
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
= help: use `crate::empty_helper` to refer to this attribute macro unambiguously
-warning: derive helper attribute is used before it is introduced
+error: derive helper attribute is used before it is introduced
--> $DIR/derive-helper-shadowing.rs:19:3
|
LL | #[empty_helper]
@@ -69,8 +69,22 @@
|
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
= note: for more information, see issue #79202 <https://github.com/rust-lang/rust/issues/79202>
- = note: `#[warn(legacy_derive_helpers)]` on by default
+ = note: `#[deny(legacy_derive_helpers)]` on by default
-error: aborting due to 4 previous errors; 1 warning emitted
+error: aborting due to 5 previous errors
For more information about this error, try `rustc --explain E0659`.
+Future incompatibility report: Future breakage diagnostic:
+error: derive helper attribute is used before it is introduced
+ --> $DIR/derive-helper-shadowing.rs:19:3
+ |
+LL | #[empty_helper]
+ | ^^^^^^^^^^^^
+...
+LL | #[derive(Empty)]
+ | ----- the attribute is introduced here
+ |
+ = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
+ = note: for more information, see issue #79202 <https://github.com/rust-lang/rust/issues/79202>
+ = note: `#[deny(legacy_derive_helpers)]` on by default
+
diff --git a/tests/ui/proc-macro/helper-attr-blocked-by-import-ambig.rs b/tests/ui/proc-macro/helper-attr-blocked-by-import-ambig.rs
index 1197dd7..97c81e9 100644
--- a/tests/ui/proc-macro/helper-attr-blocked-by-import-ambig.rs
+++ b/tests/ui/proc-macro/helper-attr-blocked-by-import-ambig.rs
@@ -5,7 +5,7 @@
use test_macros::empty_attr as empty_helper;
#[empty_helper] //~ ERROR `empty_helper` is ambiguous
- //~| WARN derive helper attribute is used before it is introduced
+ //~| ERROR derive helper attribute is used before it is introduced
//~| WARN this was previously accepted
#[derive(Empty)]
struct S;
diff --git a/tests/ui/proc-macro/helper-attr-blocked-by-import-ambig.stderr b/tests/ui/proc-macro/helper-attr-blocked-by-import-ambig.stderr
index 1c12a28..df79514 100644
--- a/tests/ui/proc-macro/helper-attr-blocked-by-import-ambig.stderr
+++ b/tests/ui/proc-macro/helper-attr-blocked-by-import-ambig.stderr
@@ -17,7 +17,7 @@
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
= help: use `crate::empty_helper` to refer to this attribute macro unambiguously
-warning: derive helper attribute is used before it is introduced
+error: derive helper attribute is used before it is introduced
--> $DIR/helper-attr-blocked-by-import-ambig.rs:7:3
|
LL | #[empty_helper]
@@ -28,8 +28,22 @@
|
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
= note: for more information, see issue #79202 <https://github.com/rust-lang/rust/issues/79202>
- = note: `#[warn(legacy_derive_helpers)]` on by default
+ = note: `#[deny(legacy_derive_helpers)]` on by default
-error: aborting due to 1 previous error; 1 warning emitted
+error: aborting due to 2 previous errors
For more information about this error, try `rustc --explain E0659`.
+Future incompatibility report: Future breakage diagnostic:
+error: derive helper attribute is used before it is introduced
+ --> $DIR/helper-attr-blocked-by-import-ambig.rs:7:3
+ |
+LL | #[empty_helper]
+ | ^^^^^^^^^^^^
+...
+LL | #[derive(Empty)]
+ | ----- the attribute is introduced here
+ |
+ = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
+ = note: for more information, see issue #79202 <https://github.com/rust-lang/rust/issues/79202>
+ = note: `#[deny(legacy_derive_helpers)]` on by default
+
diff --git a/tests/ui/proc-macro/issue-75930-derive-cfg.rs b/tests/ui/proc-macro/issue-75930-derive-cfg.rs
index f0851b3..e8df1a6 100644
--- a/tests/ui/proc-macro/issue-75930-derive-cfg.rs
+++ b/tests/ui/proc-macro/issue-75930-derive-cfg.rs
@@ -6,7 +6,7 @@
// Tests that we cfg-strip all targets before invoking
// a derive macro
// FIXME: We currently lose spans here (see issue #43081)
-
+#![warn(legacy_derive_helpers)]
#![no_std] // Don't load unnecessary hygiene information from std
extern crate std;
diff --git a/tests/ui/proc-macro/issue-75930-derive-cfg.stderr b/tests/ui/proc-macro/issue-75930-derive-cfg.stderr
index df1e36d..906e9c6 100644
--- a/tests/ui/proc-macro/issue-75930-derive-cfg.stderr
+++ b/tests/ui/proc-macro/issue-75930-derive-cfg.stderr
@@ -9,7 +9,11 @@
|
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
= note: for more information, see issue #79202 <https://github.com/rust-lang/rust/issues/79202>
- = note: `#[warn(legacy_derive_helpers)]` on by default
+note: the lint level is defined here
+ --> $DIR/issue-75930-derive-cfg.rs:9:9
+ |
+LL | #![warn(legacy_derive_helpers)]
+ | ^^^^^^^^^^^^^^^^^^^^^
warning: derive helper attribute is used before it is introduced
--> $DIR/issue-75930-derive-cfg.rs:46:3
@@ -26,3 +30,39 @@
warning: 2 warnings emitted
+Future incompatibility report: Future breakage diagnostic:
+warning: derive helper attribute is used before it is introduced
+ --> $DIR/issue-75930-derive-cfg.rs:46:3
+ |
+LL | #[print_helper(a)]
+ | ^^^^^^^^^^^^
+...
+LL | #[derive(Print)]
+ | ----- the attribute is introduced here
+ |
+ = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
+ = note: for more information, see issue #79202 <https://github.com/rust-lang/rust/issues/79202>
+note: the lint level is defined here
+ --> $DIR/issue-75930-derive-cfg.rs:9:9
+ |
+LL | #![warn(legacy_derive_helpers)]
+ | ^^^^^^^^^^^^^^^^^^^^^
+
+Future breakage diagnostic:
+warning: derive helper attribute is used before it is introduced
+ --> $DIR/issue-75930-derive-cfg.rs:46:3
+ |
+LL | #[print_helper(a)]
+ | ^^^^^^^^^^^^
+...
+LL | #[derive(Print)]
+ | ----- the attribute is introduced here
+ |
+ = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
+ = note: for more information, see issue #79202 <https://github.com/rust-lang/rust/issues/79202>
+note: the lint level is defined here
+ --> $DIR/issue-75930-derive-cfg.rs:9:9
+ |
+LL | #![warn(legacy_derive_helpers)]
+ | ^^^^^^^^^^^^^^^^^^^^^
+
diff --git a/tests/ui/proc-macro/load-panic-backtrace.rs b/tests/ui/proc-macro/load-panic-backtrace.rs
index 848bdaf..82645eb 100644
--- a/tests/ui/proc-macro/load-panic-backtrace.rs
+++ b/tests/ui/proc-macro/load-panic-backtrace.rs
@@ -1,7 +1,7 @@
//@ proc-macro: test-macros.rs
//@ compile-flags: -Z proc-macro-backtrace
//@ rustc-env:RUST_BACKTRACE=0
-//@ normalize-stderr: "thread '.*' panicked " -> ""
+//@ normalize-stderr: "thread '.*' \(0x[[:xdigit:]]+\) panicked " -> ""
//@ normalize-stderr: "note:.*RUST_BACKTRACE=1.*\n" -> ""
//@ needs-unwind proc macro panics to report errors
diff --git a/tests/ui/proc-macro/load-panic-backtrace.stderr b/tests/ui/proc-macro/load-panic-backtrace.stderr
index a1049f5..b8872eb 100644
--- a/tests/ui/proc-macro/load-panic-backtrace.stderr
+++ b/tests/ui/proc-macro/load-panic-backtrace.stderr
@@ -1,5 +1,5 @@
-at $DIR/auxiliary/test-macros.rs:38:5:
+thread '<unnamed>' ($TID) panicked at $DIR/auxiliary/test-macros.rs:38:5:
panic-derive
error: proc-macro derive panicked
--> $DIR/load-panic-backtrace.rs:11:10
diff --git a/tests/ui/proc-macro/proc-macro-attributes.rs b/tests/ui/proc-macro/proc-macro-attributes.rs
index 455fcc5..f1270b8 100644
--- a/tests/ui/proc-macro/proc-macro-attributes.rs
+++ b/tests/ui/proc-macro/proc-macro-attributes.rs
@@ -4,17 +4,17 @@
extern crate derive_b;
#[B] //~ ERROR `B` is ambiguous
- //~| WARN derive helper attribute is used before it is introduced
+ //~| ERROR derive helper attribute is used before it is introduced
//~| WARN this was previously accepted
#[C] //~ ERROR cannot find attribute `C` in this scope
#[B(D)] //~ ERROR `B` is ambiguous
- //~| WARN derive helper attribute is used before it is introduced
+ //~| ERROR derive helper attribute is used before it is introduced
//~| WARN this was previously accepted
#[B(E = "foo")] //~ ERROR `B` is ambiguous
- //~| WARN derive helper attribute is used before it is introduced
+ //~| ERROR derive helper attribute is used before it is introduced
//~| WARN this was previously accepted
#[B(arbitrary tokens)] //~ ERROR `B` is ambiguous
- //~| WARN derive helper attribute is used before it is introduced
+ //~| ERROR derive helper attribute is used before it is introduced
//~| WARN this was previously accepted
#[derive(B)]
struct B;
diff --git a/tests/ui/proc-macro/proc-macro-attributes.stderr b/tests/ui/proc-macro/proc-macro-attributes.stderr
index 140d879..2cc5738 100644
--- a/tests/ui/proc-macro/proc-macro-attributes.stderr
+++ b/tests/ui/proc-macro/proc-macro-attributes.stderr
@@ -76,7 +76,7 @@
LL | #[macro_use]
| ^^^^^^^^^^^^
-warning: derive helper attribute is used before it is introduced
+error: derive helper attribute is used before it is introduced
--> $DIR/proc-macro-attributes.rs:6:3
|
LL | #[B]
@@ -87,9 +87,9 @@
|
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
= note: for more information, see issue #79202 <https://github.com/rust-lang/rust/issues/79202>
- = note: `#[warn(legacy_derive_helpers)]` on by default
+ = note: `#[deny(legacy_derive_helpers)]` on by default
-warning: derive helper attribute is used before it is introduced
+error: derive helper attribute is used before it is introduced
--> $DIR/proc-macro-attributes.rs:10:3
|
LL | #[B(D)]
@@ -101,7 +101,7 @@
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
= note: for more information, see issue #79202 <https://github.com/rust-lang/rust/issues/79202>
-warning: derive helper attribute is used before it is introduced
+error: derive helper attribute is used before it is introduced
--> $DIR/proc-macro-attributes.rs:13:3
|
LL | #[B(E = "foo")]
@@ -113,7 +113,7 @@
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
= note: for more information, see issue #79202 <https://github.com/rust-lang/rust/issues/79202>
-warning: derive helper attribute is used before it is introduced
+error: derive helper attribute is used before it is introduced
--> $DIR/proc-macro-attributes.rs:16:3
|
LL | #[B(arbitrary tokens)]
@@ -125,6 +125,62 @@
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
= note: for more information, see issue #79202 <https://github.com/rust-lang/rust/issues/79202>
-error: aborting due to 5 previous errors; 4 warnings emitted
+error: aborting due to 9 previous errors
For more information about this error, try `rustc --explain E0659`.
+Future incompatibility report: Future breakage diagnostic:
+error: derive helper attribute is used before it is introduced
+ --> $DIR/proc-macro-attributes.rs:6:3
+ |
+LL | #[B]
+ | ^
+...
+LL | #[derive(B)]
+ | - the attribute is introduced here
+ |
+ = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
+ = note: for more information, see issue #79202 <https://github.com/rust-lang/rust/issues/79202>
+ = note: `#[deny(legacy_derive_helpers)]` on by default
+
+Future breakage diagnostic:
+error: derive helper attribute is used before it is introduced
+ --> $DIR/proc-macro-attributes.rs:10:3
+ |
+LL | #[B(D)]
+ | ^
+...
+LL | #[derive(B)]
+ | - the attribute is introduced here
+ |
+ = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
+ = note: for more information, see issue #79202 <https://github.com/rust-lang/rust/issues/79202>
+ = note: `#[deny(legacy_derive_helpers)]` on by default
+
+Future breakage diagnostic:
+error: derive helper attribute is used before it is introduced
+ --> $DIR/proc-macro-attributes.rs:13:3
+ |
+LL | #[B(E = "foo")]
+ | ^
+...
+LL | #[derive(B)]
+ | - the attribute is introduced here
+ |
+ = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
+ = note: for more information, see issue #79202 <https://github.com/rust-lang/rust/issues/79202>
+ = note: `#[deny(legacy_derive_helpers)]` on by default
+
+Future breakage diagnostic:
+error: derive helper attribute is used before it is introduced
+ --> $DIR/proc-macro-attributes.rs:16:3
+ |
+LL | #[B(arbitrary tokens)]
+ | ^
+...
+LL | #[derive(B)]
+ | - the attribute is introduced here
+ |
+ = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
+ = note: for more information, see issue #79202 <https://github.com/rust-lang/rust/issues/79202>
+ = note: `#[deny(legacy_derive_helpers)]` on by default
+
diff --git a/tests/ui/process/multi-panic.rs b/tests/ui/process/multi-panic.rs
index 481fe75..1fddffe 100644
--- a/tests/ui/process/multi-panic.rs
+++ b/tests/ui/process/multi-panic.rs
@@ -7,18 +7,27 @@ fn check_for_no_backtrace(test: std::process::Output) {
let err = String::from_utf8_lossy(&test.stderr);
let mut it = err.lines().filter(|l| !l.is_empty());
- assert_eq!(it.next().map(|l| l.starts_with("thread '<unnamed>' panicked")), Some(true));
- assert_eq!(it.next().is_some(), true);
+ assert_eq!(
+ it.next().map(|l| l.starts_with("thread '<unnamed>' (") && l.contains("panicked")),
+ Some(true),
+ "out: ```{err}```",
+ );
+ assert_eq!(it.next().is_some(), true, "out: ```{err}```");
assert_eq!(
it.next(),
Some(
"note: run with `RUST_BACKTRACE=1` \
environment variable to display a backtrace"
- )
+ ),
+ "out: ```{err}```",
);
- assert_eq!(it.next().map(|l| l.starts_with("thread 'main' panicked at")), Some(true));
- assert_eq!(it.next().is_some(), true);
- assert_eq!(it.next(), None);
+ assert_eq!(
+ it.next().map(|l| l.starts_with("thread 'main' (") && l.contains("panicked at")),
+ Some(true),
+ "out: ```{err}```",
+ );
+ assert_eq!(it.next().is_some(), true, "out: ```{err}```");
+ assert_eq!(it.next(), None, "out: ```{err}```");
}
fn main() {
diff --git a/tests/ui/process/println-with-broken-pipe.run.stderr b/tests/ui/process/println-with-broken-pipe.run.stderr
index ab41499..c56793d 100644
--- a/tests/ui/process/println-with-broken-pipe.run.stderr
+++ b/tests/ui/process/println-with-broken-pipe.run.stderr
@@ -1,4 +1,4 @@
-thread 'main' panicked at library/std/src/io/stdio.rs:LL:CC:
+thread 'main' ($TID) panicked at library/std/src/io/stdio.rs:LL:CC:
failed printing to stdout: Broken pipe (os error 32)
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
diff --git a/tests/ui/resolve/multiple_definitions_attribute_merging.rs b/tests/ui/resolve/multiple_definitions_attribute_merging.rs
index 155abaf..519b989 100644
--- a/tests/ui/resolve/multiple_definitions_attribute_merging.rs
+++ b/tests/ui/resolve/multiple_definitions_attribute_merging.rs
@@ -5,7 +5,7 @@
//@known-bug: #120873
//@ failure-status: 101
//@ normalize-stderr: "note: .*\n\n" -> ""
-//@ normalize-stderr: "thread 'rustc' panicked.*\n" -> ""
+//@ normalize-stderr: "thread 'rustc'.*panicked.*\n" -> ""
//@ normalize-stderr: "(error: internal compiler error: [^:]+):\d+:\d+: " -> "$1:LL:CC: "
//@ rustc-env:RUST_BACKTRACE=0
diff --git a/tests/ui/resolve/proc_macro_generated_packed.rs b/tests/ui/resolve/proc_macro_generated_packed.rs
index 0cba3c1..41236c7 100644
--- a/tests/ui/resolve/proc_macro_generated_packed.rs
+++ b/tests/ui/resolve/proc_macro_generated_packed.rs
@@ -5,7 +5,7 @@
//@known-bug: #120873
//@ failure-status: 101
//@ normalize-stderr: "note: .*\n\n" -> ""
-//@ normalize-stderr: "thread 'rustc' panicked.*\n" -> ""
+//@ normalize-stderr: "thread 'rustc'.*panicked.*\n" -> ""
//@ normalize-stderr: "(error: internal compiler error: [^:]+):\d+:\d+: " -> "$1:LL:CC: "
//@ rustc-env:RUST_BACKTRACE=0
diff --git a/tests/ui/target-feature/gate.rs b/tests/ui/target-feature/gate.rs
index 9244a98..81ed8b3 100644
--- a/tests/ui/target-feature/gate.rs
+++ b/tests/ui/target-feature/gate.rs
@@ -6,6 +6,7 @@
// gate-test-arm_target_feature
// gate-test-hexagon_target_feature
// gate-test-mips_target_feature
+// gate-test-nvptx_target_feature
// gate-test-wasm_target_feature
// gate-test-adx_target_feature
// gate-test-cmpxchg16b_target_feature
diff --git a/tests/ui/target-feature/gate.stderr b/tests/ui/target-feature/gate.stderr
index 32d60ce..3e9374b 100644
--- a/tests/ui/target-feature/gate.stderr
+++ b/tests/ui/target-feature/gate.stderr
@@ -1,5 +1,5 @@
error[E0658]: the target feature `x87` is currently unstable
- --> $DIR/gate.rs:29:18
+ --> $DIR/gate.rs:30:18
|
LL | #[target_feature(enable = "x87")]
| ^^^^^^^^^^^^^^
diff --git a/tests/ui/target-feature/implied-features-nvptx.rs b/tests/ui/target-feature/implied-features-nvptx.rs
new file mode 100644
index 0000000..1550c99
--- /dev/null
+++ b/tests/ui/target-feature/implied-features-nvptx.rs
@@ -0,0 +1,28 @@
+//@ assembly-output: ptx-linker
+//@ compile-flags: --crate-type cdylib -C target-cpu=sm_80 -Z unstable-options -Clinker-flavor=llbc
+//@ only-nvptx64
+//@ build-pass
+#![no_std]
+#![allow(dead_code)]
+
+#[panic_handler]
+pub fn panic(_info: &core::panic::PanicInfo) -> ! {
+ loop {}
+}
+
+// -Ctarget-cpu=sm_80 directly enables sm_80 and ptx70
+#[cfg(not(all(target_feature = "sm_80", target_feature = "ptx70")))]
+compile_error!("direct target features not enabled");
+
+// -Ctarget-cpu=sm_80 implies all earlier sm_* and ptx* features.
+#[cfg(not(all(
+ target_feature = "sm_60",
+ target_feature = "sm_70",
+ target_feature = "ptx50",
+ target_feature = "ptx60",
+)))]
+compile_error!("implied target features not enabled");
+
+// -Ctarget-cpu=sm_80 implies all earlier sm_* and ptx* features.
+#[cfg(target_feature = "ptx71")]
+compile_error!("sm_80 requires only ptx70, but ptx71 enabled");
diff --git a/tests/ui/test-attrs/terse.run.stdout b/tests/ui/test-attrs/terse.run.stdout
index ac1ac28..381d3cb 100644
--- a/tests/ui/test-attrs/terse.run.stdout
+++ b/tests/ui/test-attrs/terse.run.stdout
@@ -10,18 +10,18 @@
---- abc stdout ----
-thread 'abc' panicked at $DIR/terse.rs:12:5:
+thread 'abc' ($TID) panicked at $DIR/terse.rs:12:5:
explicit panic
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
---- foo stdout ----
-thread 'foo' panicked at $DIR/terse.rs:17:5:
+thread 'foo' ($TID) panicked at $DIR/terse.rs:17:5:
explicit panic
---- foo2 stdout ----
-thread 'foo2' panicked at $DIR/terse.rs:22:5:
+thread 'foo2' ($TID) panicked at $DIR/terse.rs:22:5:
explicit panic
diff --git a/tests/ui/test-attrs/test-panic-abort-nocapture.run.stderr b/tests/ui/test-attrs/test-panic-abort-nocapture.run.stderr
index b9f2678..8d7c62f 100644
--- a/tests/ui/test-attrs/test-panic-abort-nocapture.run.stderr
+++ b/tests/ui/test-attrs/test-panic-abort-nocapture.run.stderr
@@ -1,11 +1,11 @@
-thread 'main' panicked at $DIR/test-panic-abort-nocapture.rs:32:5:
+thread 'main' ($TID) panicked at $DIR/test-panic-abort-nocapture.rs:32:5:
assertion `left == right` failed
left: 2
right: 4
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
-thread 'main' panicked at $DIR/test-panic-abort-nocapture.rs:26:5:
+thread 'main' ($TID) panicked at $DIR/test-panic-abort-nocapture.rs:26:5:
assertion `left == right` failed
left: 2
right: 4
diff --git a/tests/ui/test-attrs/test-panic-abort.run.stdout b/tests/ui/test-attrs/test-panic-abort.run.stdout
index 0faa7f0..4d65c05 100644
--- a/tests/ui/test-attrs/test-panic-abort.run.stdout
+++ b/tests/ui/test-attrs/test-panic-abort.run.stdout
@@ -18,7 +18,7 @@
---- it_fails stderr ----
testing321
-thread 'main' panicked at $DIR/test-panic-abort.rs:37:5:
+thread 'main' ($TID) panicked at $DIR/test-panic-abort.rs:37:5:
assertion `left == right` failed
left: 2
right: 5
diff --git a/tests/ui/test-attrs/test-should-panic-attr.rs b/tests/ui/test-attrs/test-should-panic-attr.rs
index df2893b..af54689 100644
--- a/tests/ui/test-attrs/test-should-panic-attr.rs
+++ b/tests/ui/test-attrs/test-should-panic-attr.rs
@@ -1,4 +1,3 @@
-//@ check-pass
//@ compile-flags: --test
#[test]
@@ -9,28 +8,32 @@ fn test1() {
#[test]
#[should_panic(expected)]
-//~^ WARN: argument must be of the form:
+//~^ ERROR malformed `should_panic` attribute input
+//~| NOTE expected this to be of the form `expected = "..."`
fn test2() {
panic!();
}
#[test]
#[should_panic(expect)]
-//~^ WARN: argument must be of the form:
+//~^ ERROR malformed `should_panic` attribute input
+//~| NOTE the only valid argument here is "expected"
fn test3() {
panic!();
}
#[test]
#[should_panic(expected(foo, bar))]
-//~^ WARN: argument must be of the form:
+//~^ ERROR malformed `should_panic` attribute input
+//~| NOTE expected this to be of the form `expected = "..."`
fn test4() {
panic!();
}
#[test]
#[should_panic(expected = "foo", bar)]
-//~^ WARN: argument must be of the form:
+//~^ ERROR malformed `should_panic` attribute input
+//~| NOTE expected a single argument here
fn test5() {
panic!();
}
diff --git a/tests/ui/test-attrs/test-should-panic-attr.stderr b/tests/ui/test-attrs/test-should-panic-attr.stderr
index 492d1d5..5dfc8e5 100644
--- a/tests/ui/test-attrs/test-should-panic-attr.stderr
+++ b/tests/ui/test-attrs/test-should-panic-attr.stderr
@@ -1,34 +1,82 @@
-warning: argument must be of the form: `expected = "error message"`
- --> $DIR/test-should-panic-attr.rs:11:1
+error[E0539]: malformed `should_panic` attribute input
+ --> $DIR/test-should-panic-attr.rs:10:1
|
LL | #[should_panic(expected)]
- | ^^^^^^^^^^^^^^^^^^^^^^^^^
+ | ^^^^^^^^^^^^^^^--------^^
+ | |
+ | expected this to be of the form `expected = "..."`
|
- = note: errors in this attribute were erroneously allowed and will become a hard error in a future release
+help: try changing it to one of the following valid forms of the attribute
+ |
+LL - #[should_panic(expected)]
+LL + #[should_panic = "reason"]
+ |
+LL | #[should_panic(expected = "reason")]
+ | ++++++++++
+LL - #[should_panic(expected)]
+LL + #[should_panic]
+ |
-warning: argument must be of the form: `expected = "error message"`
+error[E0539]: malformed `should_panic` attribute input
--> $DIR/test-should-panic-attr.rs:18:1
|
LL | #[should_panic(expect)]
- | ^^^^^^^^^^^^^^^^^^^^^^^
+ | ^^^^^^^^^^^^^^--------^
+ | |
+ | the only valid argument here is "expected"
|
- = note: errors in this attribute were erroneously allowed and will become a hard error in a future release
+help: try changing it to one of the following valid forms of the attribute
+ |
+LL - #[should_panic(expect)]
+LL + #[should_panic = "reason"]
+ |
+LL | #[should_panic(expected = "reason")]
+ | +++++++++++++
+LL - #[should_panic(expect)]
+LL + #[should_panic]
+ |
-warning: argument must be of the form: `expected = "error message"`
- --> $DIR/test-should-panic-attr.rs:25:1
+error[E0539]: malformed `should_panic` attribute input
+ --> $DIR/test-should-panic-attr.rs:26:1
|
LL | #[should_panic(expected(foo, bar))]
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+ | ^^^^^^^^^^^^^^^------------------^^
+ | |
+ | expected this to be of the form `expected = "..."`
|
- = note: errors in this attribute were erroneously allowed and will become a hard error in a future release
+help: try changing it to one of the following valid forms of the attribute
+ |
+LL - #[should_panic(expected(foo, bar))]
+LL + #[should_panic = "reason"]
+ |
+LL - #[should_panic(expected(foo, bar))]
+LL + #[should_panic(expected = "reason")]
+ |
+LL - #[should_panic(expected(foo, bar))]
+LL + #[should_panic]
+ |
-warning: argument must be of the form: `expected = "error message"`
- --> $DIR/test-should-panic-attr.rs:32:1
+error[E0805]: malformed `should_panic` attribute input
+ --> $DIR/test-should-panic-attr.rs:34:1
|
LL | #[should_panic(expected = "foo", bar)]
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+ | ^^^^^^^^^^^^^^-----------------------^
+ | |
+ | expected a single argument here
|
- = note: errors in this attribute were erroneously allowed and will become a hard error in a future release
+help: try changing it to one of the following valid forms of the attribute
+ |
+LL - #[should_panic(expected = "foo", bar)]
+LL + #[should_panic = "reason"]
+ |
+LL - #[should_panic(expected = "foo", bar)]
+LL + #[should_panic(expected = "reason")]
+ |
+LL - #[should_panic(expected = "foo", bar)]
+LL + #[should_panic]
+ |
-warning: 4 warnings emitted
+error: aborting due to 4 previous errors
+Some errors have detailed explanations: E0539, E0805.
+For more information about an error, try `rustc --explain E0539`.
diff --git a/tests/ui/test-attrs/test-should-panic-failed-show-span.run.stderr b/tests/ui/test-attrs/test-should-panic-failed-show-span.run.stderr
index db379a1..63bc10e 100644
--- a/tests/ui/test-attrs/test-should-panic-failed-show-span.run.stderr
+++ b/tests/ui/test-attrs/test-should-panic-failed-show-span.run.stderr
@@ -1,13 +1,13 @@
-thread 'should_panic_with_any_message' panicked at $DIR/test-should-panic-failed-show-span.rs:14:5:
+thread 'should_panic_with_any_message' ($TID) panicked at $DIR/test-should-panic-failed-show-span.rs:14:5:
Panic!
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
-thread 'should_panic_with_message' panicked at $DIR/test-should-panic-failed-show-span.rs:20:5:
+thread 'should_panic_with_message' ($TID) panicked at $DIR/test-should-panic-failed-show-span.rs:20:5:
message
-thread 'should_panic_with_substring_panics_with_incorrect_string' panicked at $DIR/test-should-panic-failed-show-span.rs:38:5:
+thread 'should_panic_with_substring_panics_with_incorrect_string' ($TID) panicked at $DIR/test-should-panic-failed-show-span.rs:38:5:
ZOMGWTFBBQ
-thread 'should_panic_with_substring_panics_with_non_string_value' panicked at $DIR/test-should-panic-failed-show-span.rs:45:5:
+thread 'should_panic_with_substring_panics_with_non_string_value' ($TID) panicked at $DIR/test-should-panic-failed-show-span.rs:45:5:
Box<dyn Any>
diff --git a/tests/ui/test-attrs/test-thread-capture.run.stdout b/tests/ui/test-attrs/test-thread-capture.run.stdout
index f9b9757..bea3dcb 100644
--- a/tests/ui/test-attrs/test-thread-capture.run.stdout
+++ b/tests/ui/test-attrs/test-thread-capture.run.stdout
@@ -11,7 +11,7 @@
foe
fum
-thread 'thready_fail' panicked at $DIR/test-thread-capture.rs:32:5:
+thread 'thready_fail' ($TID) panicked at $DIR/test-thread-capture.rs:32:5:
explicit panic
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
diff --git a/tests/ui/test-attrs/test-thread-nocapture.run.stderr b/tests/ui/test-attrs/test-thread-nocapture.run.stderr
index 5956001..b9905b0 100644
--- a/tests/ui/test-attrs/test-thread-nocapture.run.stderr
+++ b/tests/ui/test-attrs/test-thread-nocapture.run.stderr
@@ -1,4 +1,4 @@
-thread 'thready_fail' panicked at $DIR/test-thread-nocapture.rs:32:5:
+thread 'thready_fail' ($TID) panicked at $DIR/test-thread-nocapture.rs:32:5:
explicit panic
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
diff --git a/tests/ui/track-diagnostics/track.rs b/tests/ui/track-diagnostics/track.rs
index 1b2558c..9ce0a4a 100644
--- a/tests/ui/track-diagnostics/track.rs
+++ b/tests/ui/track-diagnostics/track.rs
@@ -13,6 +13,11 @@
// top of this file are present, then assume all args are present.
//@ normalize-stderr: "note: compiler flags: .*-Z ui-testing.*-Z track-diagnostics" -> "note: compiler flags: ... -Z ui-testing ... -Z track-diagnostics"
+// FIXME: this tests a crash in rustc. For stage1, rustc is built with the downloaded standard
+// library which doesn't yet print the thread ID. Normalization can be removed at the stage bump.
+// For the grep: cfg(bootstrap)
+//@normalize-stderr: "thread 'rustc' panicked" -> "thread 'rustc' ($$TID) panicked"
+
fn main() {
break rust
//~^ ERROR cannot find value `rust` in this scope
diff --git a/tests/ui/track-diagnostics/track.stderr b/tests/ui/track-diagnostics/track.stderr
index f827649..bc04ded 100644
--- a/tests/ui/track-diagnostics/track.stderr
+++ b/tests/ui/track-diagnostics/track.stderr
@@ -27,7 +27,7 @@
= note: compiler flags: ... -Z ui-testing ... -Z track-diagnostics
-thread 'rustc' panicked at compiler/rustc_hir_typeck/src/lib.rs:LL:CC:
+thread 'rustc' ($TID) panicked at compiler/rustc_hir_typeck/src/lib.rs:LL:CC:
Box<dyn Any>
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
diff --git a/tests/ui/traits/const-traits/feature-gate.rs b/tests/ui/traits/const-traits/feature-gate.rs
index 5ad56dd..c2918f0 100644
--- a/tests/ui/traits/const-traits/feature-gate.rs
+++ b/tests/ui/traits/const-traits/feature-gate.rs
@@ -13,6 +13,9 @@ impl const T for S {}
const fn f<A: [const] T>() {} //[stock]~ ERROR const trait impls are experimental
fn g<A: const T>() {} //[stock]~ ERROR const trait impls are experimental
+const trait Trait {} //[stock]~ ERROR const trait impls are experimental
+#[cfg(false)] const trait Trait {} //[stock]~ ERROR const trait impls are experimental
+
macro_rules! discard { ($ty:ty) => {} }
discard! { impl [const] T } //[stock]~ ERROR const trait impls are experimental
diff --git a/tests/ui/traits/const-traits/feature-gate.stock.stderr b/tests/ui/traits/const-traits/feature-gate.stock.stderr
index f3ba303..551c7ce 100644
--- a/tests/ui/traits/const-traits/feature-gate.stock.stderr
+++ b/tests/ui/traits/const-traits/feature-gate.stock.stderr
@@ -29,7 +29,27 @@
= 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:17
+ --> $DIR/feature-gate.rs:16:1
+ |
+LL | const trait Trait {}
+ | ^^^^^
+ |
+ = note: see issue #143874 <https://github.com/rust-lang/rust/issues/143874> 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/feature-gate.rs:17:15
+ |
+LL | #[cfg(false)] const trait Trait {}
+ | ^^^^^
+ |
+ = note: see issue #143874 <https://github.com/rust-lang/rust/issues/143874> 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/feature-gate.rs:21:17
|
LL | discard! { impl [const] T }
| ^^^^^^^
@@ -39,7 +59,7 @@
= 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:19:17
+ --> $DIR/feature-gate.rs:22:17
|
LL | discard! { impl const T }
| ^^^^^
@@ -58,6 +78,6 @@
= 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: aborting due to 6 previous errors
+error: aborting due to 8 previous errors
For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/traits/inductive-overflow/supertrait-auto-trait.stderr b/tests/ui/traits/inductive-overflow/supertrait-auto-trait.stderr
index 3a3b99f..45602d6 100644
--- a/tests/ui/traits/inductive-overflow/supertrait-auto-trait.stderr
+++ b/tests/ui/traits/inductive-overflow/supertrait-auto-trait.stderr
@@ -1,8 +1,8 @@
error[E0568]: auto traits cannot have super traits or lifetime bounds
- --> $DIR/supertrait-auto-trait.rs:8:17
+ --> $DIR/supertrait-auto-trait.rs:8:19
|
LL | auto trait Magic: Copy {}
- | -----^^^^^^ help: remove the super traits or lifetime bounds
+ | ----- ^^^^
| |
| auto traits cannot have super traits or lifetime bounds
diff --git a/tests/ui/treat-err-as-bug/err.rs b/tests/ui/treat-err-as-bug/err.rs
index 6f0e3c5..f297a57 100644
--- a/tests/ui/treat-err-as-bug/err.rs
+++ b/tests/ui/treat-err-as-bug/err.rs
@@ -1,7 +1,7 @@
//@ compile-flags: -Ztreat-err-as-bug
//@ failure-status: 101
//@ normalize-stderr: "note: .*\n\n" -> ""
-//@ normalize-stderr: "thread 'rustc' panicked.*:\n.*\n" -> ""
+//@ normalize-stderr: "thread 'rustc'.*panicked.*:\n.*\n" -> ""
//@ rustc-env:RUST_BACKTRACE=0
#![crate_type = "rlib"]
diff --git a/tests/ui/treat-err-as-bug/span_delayed_bug.rs b/tests/ui/treat-err-as-bug/span_delayed_bug.rs
index 4681a8f..ff5a595 100644
--- a/tests/ui/treat-err-as-bug/span_delayed_bug.rs
+++ b/tests/ui/treat-err-as-bug/span_delayed_bug.rs
@@ -1,7 +1,7 @@
//@ compile-flags: -Ztreat-err-as-bug -Zeagerly-emit-delayed-bugs
//@ failure-status: 101
//@ normalize-stderr: "note: .*\n\n" -> ""
-//@ normalize-stderr: "thread 'rustc' panicked.*:\n.*\n" -> ""
+//@ normalize-stderr: "thread 'rustc'.*panicked.*:\n.*\n" -> ""
//@ rustc-env:RUST_BACKTRACE=0
#![feature(rustc_attrs)]
diff --git a/tests/ui/type-inference/unbounded-type-param-in-fn-with-assoc-type.stderr b/tests/ui/type-inference/unbounded-type-param-in-fn-with-assoc-type.stderr
index bf8829c..e8bbdaa 100644
--- a/tests/ui/type-inference/unbounded-type-param-in-fn-with-assoc-type.stderr
+++ b/tests/ui/type-inference/unbounded-type-param-in-fn-with-assoc-type.stderr
@@ -13,7 +13,7 @@
For more information about this error, try `rustc --explain E0282`.
Future incompatibility report: Future breakage diagnostic:
-warning: defaults for type parameters are only allowed in `struct`, `enum`, `type`, or `trait` definitions
+warning: defaults for generic parameters are not allowed here
--> $DIR/unbounded-type-param-in-fn-with-assoc-type.rs:3:11
|
LL | fn foo<T, U = u64>() -> (T, U) {
diff --git a/tests/ui/type/default_type_parameter_in_fn_or_impl.rs b/tests/ui/type/default_type_parameter_in_fn_or_impl.rs
deleted file mode 100644
index 33038e2..0000000
--- a/tests/ui/type/default_type_parameter_in_fn_or_impl.rs
+++ /dev/null
@@ -1,12 +0,0 @@
-#![allow(unused)]
-
-fn avg<T=i32>(_: T) {}
-//~^ ERROR defaults for type parameters are only allowed
-//~| WARN this was previously accepted
-
-struct S<T>(T);
-impl<T=i32> S<T> {}
-//~^ ERROR defaults for type parameters are only allowed
-//~| WARN this was previously accepted
-
-fn main() {}
diff --git a/tests/ui/type/default_type_parameter_in_fn_or_impl.stderr b/tests/ui/type/default_type_parameter_in_fn_or_impl.stderr
deleted file mode 100644
index a3205cd..0000000
--- a/tests/ui/type/default_type_parameter_in_fn_or_impl.stderr
+++ /dev/null
@@ -1,43 +0,0 @@
-error: defaults for type parameters are only allowed in `struct`, `enum`, `type`, or `trait` definitions
- --> $DIR/default_type_parameter_in_fn_or_impl.rs:3:8
- |
-LL | fn avg<T=i32>(_: T) {}
- | ^^^^^
- |
- = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
- = note: for more information, see issue #36887 <https://github.com/rust-lang/rust/issues/36887>
- = note: `#[deny(invalid_type_param_default)]` on by default
-
-error: defaults for type parameters are only allowed in `struct`, `enum`, `type`, or `trait` definitions
- --> $DIR/default_type_parameter_in_fn_or_impl.rs:8:6
- |
-LL | impl<T=i32> S<T> {}
- | ^^^^^
- |
- = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
- = note: for more information, see issue #36887 <https://github.com/rust-lang/rust/issues/36887>
-
-error: aborting due to 2 previous errors
-
-Future incompatibility report: Future breakage diagnostic:
-error: defaults for type parameters are only allowed in `struct`, `enum`, `type`, or `trait` definitions
- --> $DIR/default_type_parameter_in_fn_or_impl.rs:3:8
- |
-LL | fn avg<T=i32>(_: T) {}
- | ^^^^^
- |
- = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
- = note: for more information, see issue #36887 <https://github.com/rust-lang/rust/issues/36887>
- = note: `#[deny(invalid_type_param_default)]` on by default
-
-Future breakage diagnostic:
-error: defaults for type parameters are only allowed in `struct`, `enum`, `type`, or `trait` definitions
- --> $DIR/default_type_parameter_in_fn_or_impl.rs:8:6
- |
-LL | impl<T=i32> S<T> {}
- | ^^^^^
- |
- = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
- = note: for more information, see issue #36887 <https://github.com/rust-lang/rust/issues/36887>
- = note: `#[deny(invalid_type_param_default)]` on by default
-
diff --git a/tests/ui/type/pattern_types/bad_const_generics_args_on_const_param.rs b/tests/ui/type/pattern_types/bad_const_generics_args_on_const_param.rs
index c28fda6..ff99ac9 100644
--- a/tests/ui/type/pattern_types/bad_const_generics_args_on_const_param.rs
+++ b/tests/ui/type/pattern_types/bad_const_generics_args_on_const_param.rs
@@ -1,7 +1,7 @@
//@known-bug: #127972
//@ failure-status: 101
//@ normalize-stderr: "note: .*\n\n" -> ""
-//@ normalize-stderr: "thread 'rustc' panicked.*\n" -> ""
+//@ normalize-stderr: "thread 'rustc'.*panicked.*\n" -> ""
//@ normalize-stderr: "(error: internal compiler error: [^:]+):\d+:\d+: " -> "$1:LL:CC: "
//@ rustc-env:RUST_BACKTRACE=0
diff --git a/tests/ui/wf/ice-hir-wf-check-anon-const-issue-122199.rs b/tests/ui/wf/ice-hir-wf-check-anon-const-issue-122199.rs
index ad7d972..072a699 100644
--- a/tests/ui/wf/ice-hir-wf-check-anon-const-issue-122199.rs
+++ b/tests/ui/wf/ice-hir-wf-check-anon-const-issue-122199.rs
@@ -4,7 +4,7 @@
fn fnc<const N: dyn Trait = u32>(&self) -> dyn Trait {
//~^ ERROR the name `N` is already used for a generic parameter in this item's generic parameters
//~| ERROR expected value, found builtin type `u32`
- //~| ERROR defaults for const parameters are only allowed in `struct`, `enum`, `type`, or `trait` definitions
+ //~| ERROR defaults for generic parameters are not allowed here
bar
//~^ ERROR cannot find value `bar` in this scope
}
diff --git a/tests/ui/wf/ice-hir-wf-check-anon-const-issue-122199.stderr b/tests/ui/wf/ice-hir-wf-check-anon-const-issue-122199.stderr
index dc5a1cf..47f3e83 100644
--- a/tests/ui/wf/ice-hir-wf-check-anon-const-issue-122199.stderr
+++ b/tests/ui/wf/ice-hir-wf-check-anon-const-issue-122199.stderr
@@ -39,7 +39,7 @@
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
= note: see https://rustc-dev-guide.rust-lang.org/overview.html#queries and https://rustc-dev-guide.rust-lang.org/query.html for more information
-error: defaults for const parameters are only allowed in `struct`, `enum`, `type`, or `trait` definitions
+error: defaults for generic parameters are not allowed here
--> $DIR/ice-hir-wf-check-anon-const-issue-122199.rs:4:12
|
LL | fn fnc<const N: dyn Trait = u32>(&self) -> dyn Trait {
