diff --git a/RELEASES.md b/RELEASES.md
index 2da6ed3f100..e0175db7ec8 100644
--- a/RELEASES.md
+++ b/RELEASES.md
@@ -1,3 +1,18 @@
+Version 1.84.1 (2025-01-30)
+==========================
+
+
+
+- [Fix ICE 132920 in duplicate-crate diagnostics.](https://github.com/rust-lang/rust/pull/133304/)
+- [Fix errors for overlapping impls in incremental rebuilds.](https://github.com/rust-lang/rust/pull/133828/)
+- [Fix slow compilation related to the next-generation trait solver.](https://github.com/rust-lang/rust/pull/135618/)
+- [Fix debuginfo when LLVM's location discriminator value limit is exceeded.](https://github.com/rust-lang/rust/pull/135643/)
+- Fixes for building Rust from source:
+ - [Only try to distribute `llvm-objcopy` if llvm tools are enabled.](https://github.com/rust-lang/rust/pull/134240/)
+ - [Add Profile Override for Non-Git Sources.](https://github.com/rust-lang/rust/pull/135433/)
+ - [Resolve symlinks of LLVM tool binaries before copying them.](https://github.com/rust-lang/rust/pull/135585/)
+ - [Make it possible to use ci-rustc on tarball sources.](https://github.com/rust-lang/rust/pull/135722/)
+
Version 1.84.0 (2025-01-09)
==========================
diff --git a/REUSE.toml b/REUSE.toml
index 6b16d97ed80..9e873e94eff 100644
--- a/REUSE.toml
+++ b/REUSE.toml
@@ -92,7 +92,7 @@ SPDX-FileCopyrightText = "2015 Anders Kaseorg "
SPDX-License-Identifier = "MIT"
[[annotations]]
-path = "src/librustdoc/html/static/fonts/FiraSans**"
+path = "src/librustdoc/html/static/fonts/Fira**"
precedence = "override"
SPDX-FileCopyrightText = ["2014, Mozilla Foundation", "2014, Telefonica S.A."]
SPDX-License-Identifier = "OFL-1.1"
diff --git a/compiler/rustc_ast/src/token.rs b/compiler/rustc_ast/src/token.rs
index 3b7367d1ee2..100f664a89f 100644
--- a/compiler/rustc_ast/src/token.rs
+++ b/compiler/rustc_ast/src/token.rs
@@ -527,13 +527,13 @@ impl TokenKind {
/// Returns tokens that are likely to be typed accidentally instead of the current token.
/// Enables better error recovery when the wrong token is found.
- pub fn similar_tokens(&self) -> Option> {
- match *self {
- Comma => Some(vec![Dot, Lt, Semi]),
- Semi => Some(vec![Colon, Comma]),
- Colon => Some(vec![Semi]),
- FatArrow => Some(vec![Eq, RArrow, Ge, Gt]),
- _ => None,
+ pub fn similar_tokens(&self) -> &[TokenKind] {
+ match self {
+ Comma => &[Dot, Lt, Semi],
+ Semi => &[Colon, Comma],
+ Colon => &[Semi],
+ FatArrow => &[Eq, RArrow, Ge, Gt],
+ _ => &[],
}
}
diff --git a/compiler/rustc_borrowck/src/region_infer/opaque_types.rs b/compiler/rustc_borrowck/src/region_infer/opaque_types.rs
index 7c484327e31..5440d451ec8 100644
--- a/compiler/rustc_borrowck/src/region_infer/opaque_types.rs
+++ b/compiler/rustc_borrowck/src/region_infer/opaque_types.rs
@@ -1,6 +1,8 @@
use rustc_data_structures::fx::FxIndexMap;
use rustc_errors::ErrorGuaranteed;
+use rustc_hir::OpaqueTyOrigin;
use rustc_hir::def_id::LocalDefId;
+use rustc_infer::infer::outlives::env::OutlivesEnvironment;
use rustc_infer::infer::{InferCtxt, NllRegionVariableOrigin, TyCtxtInferExt as _};
use rustc_macros::extension;
use rustc_middle::ty::fold::fold_regions;
@@ -10,6 +12,7 @@ use rustc_middle::ty::{
TypingMode,
};
use rustc_span::Span;
+use rustc_trait_selection::regions::OutlivesEnvironmentBuildExt;
use rustc_trait_selection::traits::ObligationCtxt;
use tracing::{debug, instrument};
@@ -406,10 +409,6 @@ impl<'tcx> LazyOpaqueTyEnv<'tcx> {
}
fn get_canonical_args(&self) -> ty::GenericArgsRef<'tcx> {
- use rustc_hir as hir;
- use rustc_infer::infer::outlives::env::OutlivesEnvironment;
- use rustc_trait_selection::traits::outlives_bounds::InferCtxtExt as _;
-
if let Some(&canonical_args) = self.canonical_args.get() {
return canonical_args;
}
@@ -417,9 +416,9 @@ impl<'tcx> LazyOpaqueTyEnv<'tcx> {
let &Self { tcx, def_id, .. } = self;
let origin = tcx.local_opaque_ty_origin(def_id);
let parent = match origin {
- hir::OpaqueTyOrigin::FnReturn { parent, .. }
- | hir::OpaqueTyOrigin::AsyncFn { parent, .. }
- | hir::OpaqueTyOrigin::TyAlias { parent, .. } => parent,
+ OpaqueTyOrigin::FnReturn { parent, .. }
+ | OpaqueTyOrigin::AsyncFn { parent, .. }
+ | OpaqueTyOrigin::TyAlias { parent, .. } => parent,
};
let param_env = tcx.param_env(parent);
let args = GenericArgs::identity_for_item(tcx, parent).extend_to(
@@ -439,8 +438,7 @@ impl<'tcx> LazyOpaqueTyEnv<'tcx> {
tcx.dcx().span_delayed_bug(tcx.def_span(def_id), "error getting implied bounds");
Default::default()
});
- let implied_bounds = infcx.implied_bounds_tys(param_env, parent, &wf_tys);
- let outlives_env = OutlivesEnvironment::with_bounds(param_env, implied_bounds);
+ let outlives_env = OutlivesEnvironment::new(&infcx, parent, param_env, wf_tys);
let mut seen = vec![tcx.lifetimes.re_static];
let canonical_args = fold_regions(tcx, args, |r1, _| {
diff --git a/compiler/rustc_builtin_macros/src/format.rs b/compiler/rustc_builtin_macros/src/format.rs
index a0ab6375a66..7c746bd719f 100644
--- a/compiler/rustc_builtin_macros/src/format.rs
+++ b/compiler/rustc_builtin_macros/src/format.rs
@@ -101,15 +101,14 @@ fn parse_args<'a>(ecx: &ExtCtxt<'a>, sp: Span, tts: TokenStream) -> PResult<'a,
match p.expect(exp!(Comma)) {
Err(err) => {
- match token::TokenKind::Comma.similar_tokens() {
- Some(tks) if tks.contains(&p.token.kind) => {
- // If a similar token is found, then it may be a typo. We
- // consider it as a comma, and continue parsing.
- err.emit();
- p.bump();
- }
+ if token::TokenKind::Comma.similar_tokens().contains(&p.token.kind) {
+ // If a similar token is found, then it may be a typo. We
+ // consider it as a comma, and continue parsing.
+ err.emit();
+ p.bump();
+ } else {
// Otherwise stop the parsing and return the error.
- _ => return Err(err),
+ return Err(err);
}
}
Ok(Recovered::Yes(_)) => (),
diff --git a/compiler/rustc_codegen_cranelift/src/intrinsics/simd.rs b/compiler/rustc_codegen_cranelift/src/intrinsics/simd.rs
index 6d71b8e8aba..d682efd19aa 100644
--- a/compiler/rustc_codegen_cranelift/src/intrinsics/simd.rs
+++ b/compiler/rustc_codegen_cranelift/src/intrinsics/simd.rs
@@ -129,12 +129,7 @@ pub(super) fn codegen_simd_intrinsic_call<'tcx>(
return;
}
- let idx = generic_args[2]
- .expect_const()
- .try_to_valtree()
- .expect("expected monomorphic const in codegen")
- .0
- .unwrap_branch();
+ let idx = generic_args[2].expect_const().to_value().valtree.unwrap_branch();
assert_eq!(x.layout(), y.layout());
let layout = x.layout();
diff --git a/compiler/rustc_codegen_llvm/src/builder.rs b/compiler/rustc_codegen_llvm/src/builder.rs
index d2de62b17f0..2d007416263 100644
--- a/compiler/rustc_codegen_llvm/src/builder.rs
+++ b/compiler/rustc_codegen_llvm/src/builder.rs
@@ -1325,7 +1325,9 @@ impl<'a, 'll, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> {
impl<'ll> StaticBuilderMethods for Builder<'_, 'll, '_> {
fn get_static(&mut self, def_id: DefId) -> &'ll Value {
// Forward to the `get_static` method of `CodegenCx`
- self.cx().get_static(def_id)
+ let s = self.cx().get_static(def_id);
+ // Cast to default address space if globals are in a different addrspace
+ self.cx().const_pointercast(s, self.type_ptr())
}
}
diff --git a/compiler/rustc_codegen_llvm/src/common.rs b/compiler/rustc_codegen_llvm/src/common.rs
index b4e9b9f44f4..f8b30cb507a 100644
--- a/compiler/rustc_codegen_llvm/src/common.rs
+++ b/compiler/rustc_codegen_llvm/src/common.rs
@@ -225,6 +225,8 @@ impl<'ll, 'tcx> ConstCodegenMethods<'tcx> for CodegenCx<'ll, 'tcx> {
llvm::LLVMSetUnnamedAddress(g, llvm::UnnamedAddr::Global);
}
llvm::set_linkage(g, llvm::Linkage::InternalLinkage);
+ // Cast to default address space if globals are in a different addrspace
+ let g = self.const_pointercast(g, self.type_ptr());
(s.to_owned(), g)
})
.1;
@@ -289,7 +291,7 @@ impl<'ll, 'tcx> ConstCodegenMethods<'tcx> for CodegenCx<'ll, 'tcx> {
let alloc = alloc.inner();
let value = match alloc.mutability {
Mutability::Mut => self.static_addr_of_mut(init, alloc.align, None),
- _ => self.static_addr_of(init, alloc.align, None),
+ _ => self.static_addr_of_impl(init, alloc.align, None),
};
if !self.sess().fewer_names() && llvm::get_value_name(value).is_empty()
{
@@ -315,7 +317,7 @@ impl<'ll, 'tcx> ConstCodegenMethods<'tcx> for CodegenCx<'ll, 'tcx> {
.global_alloc(self.tcx.vtable_allocation((ty, dyn_ty.principal())))
.unwrap_memory();
let init = const_alloc_to_llvm(self, alloc, /*static*/ false);
- let value = self.static_addr_of(init, alloc.inner().align, None);
+ let value = self.static_addr_of_impl(init, alloc.inner().align, None);
(value, AddressSpace::DATA)
}
GlobalAlloc::Static(def_id) => {
@@ -327,7 +329,8 @@ impl<'ll, 'tcx> ConstCodegenMethods<'tcx> for CodegenCx<'ll, 'tcx> {
let llval = unsafe {
llvm::LLVMConstInBoundsGEP2(
self.type_i8(),
- self.const_bitcast(base_addr, self.type_ptr_ext(base_addr_space)),
+ // Cast to the required address space if necessary
+ self.const_pointercast(base_addr, self.type_ptr_ext(base_addr_space)),
&self.const_usize(offset.bytes()),
1,
)
diff --git a/compiler/rustc_codegen_llvm/src/consts.rs b/compiler/rustc_codegen_llvm/src/consts.rs
index c7114480d8b..771ebf2057f 100644
--- a/compiler/rustc_codegen_llvm/src/consts.rs
+++ b/compiler/rustc_codegen_llvm/src/consts.rs
@@ -210,6 +210,14 @@ impl<'ll> CodegenCx<'ll, '_> {
unsafe { llvm::LLVMConstBitCast(val, ty) }
}
+ pub(crate) fn const_pointercast(&self, val: &'ll Value, ty: &'ll Type) -> &'ll Value {
+ unsafe { llvm::LLVMConstPointerCast(val, ty) }
+ }
+
+ /// Create a global variable.
+ ///
+ /// The returned global variable is a pointer in the default address space for globals.
+ /// Fails if a symbol with the given name already exists.
pub(crate) fn static_addr_of_mut(
&self,
cv: &'ll Value,
@@ -233,6 +241,34 @@ impl<'ll> CodegenCx<'ll, '_> {
gv
}
+ /// Create a global constant.
+ ///
+ /// The returned global variable is a pointer in the default address space for globals.
+ pub(crate) fn static_addr_of_impl(
+ &self,
+ cv: &'ll Value,
+ align: Align,
+ kind: Option<&str>,
+ ) -> &'ll Value {
+ if let Some(&gv) = self.const_globals.borrow().get(&cv) {
+ unsafe {
+ // Upgrade the alignment in cases where the same constant is used with different
+ // alignment requirements
+ let llalign = align.bytes() as u32;
+ if llalign > llvm::LLVMGetAlignment(gv) {
+ llvm::LLVMSetAlignment(gv, llalign);
+ }
+ }
+ return gv;
+ }
+ let gv = self.static_addr_of_mut(cv, align, kind);
+ unsafe {
+ llvm::LLVMSetGlobalConstant(gv, True);
+ }
+ self.const_globals.borrow_mut().insert(cv, gv);
+ gv
+ }
+
#[instrument(level = "debug", skip(self))]
pub(crate) fn get_static(&self, def_id: DefId) -> &'ll Value {
let instance = Instance::mono(self.tcx, def_id);
@@ -505,24 +541,15 @@ impl<'ll> CodegenCx<'ll, '_> {
}
impl<'ll> StaticCodegenMethods for CodegenCx<'ll, '_> {
+ /// Get a pointer to a global variable.
+ ///
+ /// The pointer will always be in the default address space. If global variables default to a
+ /// different address space, an addrspacecast is inserted.
fn static_addr_of(&self, cv: &'ll Value, align: Align, kind: Option<&str>) -> &'ll Value {
- if let Some(&gv) = self.const_globals.borrow().get(&cv) {
- unsafe {
- // Upgrade the alignment in cases where the same constant is used with different
- // alignment requirements
- let llalign = align.bytes() as u32;
- if llalign > llvm::LLVMGetAlignment(gv) {
- llvm::LLVMSetAlignment(gv, llalign);
- }
- }
- return gv;
- }
- let gv = self.static_addr_of_mut(cv, align, kind);
- unsafe {
- llvm::LLVMSetGlobalConstant(gv, True);
- }
- self.const_globals.borrow_mut().insert(cv, gv);
- gv
+ let gv = self.static_addr_of_impl(cv, align, kind);
+ // static_addr_of_impl returns the bare global variable, which might not be in the default
+ // address space. Cast to the default address space if necessary.
+ self.const_pointercast(gv, self.type_ptr())
}
fn codegen_static(&self, def_id: DefId) {
diff --git a/compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs b/compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs
index 8d782a618fc..6eae16d8be6 100644
--- a/compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs
+++ b/compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs
@@ -919,8 +919,7 @@ pub(crate) fn build_compile_unit_di_node<'ll, 'tcx>(
.unwrap_or_default();
let kind = DebugEmissionKind::from_generic(tcx.sess.opts.debuginfo);
- let dwarf_version =
- tcx.sess.opts.unstable_opts.dwarf_version.unwrap_or(tcx.sess.target.default_dwarf_version);
+ let dwarf_version = tcx.sess.dwarf_version();
let is_dwarf_kind =
matches!(tcx.sess.target.debuginfo_kind, DebuginfoKind::Dwarf | DebuginfoKind::DwarfDsym);
// Don't emit `.debug_pubnames` and `.debug_pubtypes` on DWARFv4 or lower.
@@ -1488,6 +1487,26 @@ fn build_vtable_type_di_node<'ll, 'tcx>(
.di_node
}
+/// Get the global variable for the vtable.
+///
+/// When using global variables, we may have created an addrspacecast to get a pointer to the
+/// default address space if global variables are created in a different address space.
+/// For modifying the vtable, we need the real global variable. This function accepts either a
+/// global variable (which is simply returned), or an addrspacecast constant expression.
+/// If the given value is an addrspacecast, the cast is removed and the global variable behind
+/// the cast is returned.
+fn find_vtable_behind_cast<'ll>(vtable: &'ll Value) -> &'ll Value {
+ // The vtable is a global variable, which may be behind an addrspacecast.
+ unsafe {
+ if let Some(c) = llvm::LLVMIsAConstantExpr(vtable) {
+ if llvm::LLVMGetConstOpcode(c) == llvm::Opcode::AddrSpaceCast {
+ return llvm::LLVMGetOperand(c, 0).unwrap();
+ }
+ }
+ }
+ vtable
+}
+
pub(crate) fn apply_vcall_visibility_metadata<'ll, 'tcx>(
cx: &CodegenCx<'ll, 'tcx>,
ty: Ty<'tcx>,
@@ -1508,6 +1527,8 @@ pub(crate) fn apply_vcall_visibility_metadata<'ll, 'tcx>(
let Some(trait_ref) = trait_ref else { return };
+ // Unwrap potential addrspacecast
+ let vtable = find_vtable_behind_cast(vtable);
let trait_ref_self = trait_ref.with_self_ty(cx.tcx, ty);
let trait_ref_self = cx.tcx.erase_regions(trait_ref_self);
let trait_def_id = trait_ref_self.def_id();
@@ -1581,6 +1602,9 @@ pub(crate) fn create_vtable_di_node<'ll, 'tcx>(
return;
}
+ // Unwrap potential addrspacecast
+ let vtable = find_vtable_behind_cast(vtable);
+
// When full debuginfo is enabled, we want to try and prevent vtables from being
// merged. Otherwise debuggers will have a hard time mapping from dyn pointer
// to concrete type.
diff --git a/compiler/rustc_codegen_llvm/src/debuginfo/mod.rs b/compiler/rustc_codegen_llvm/src/debuginfo/mod.rs
index e6778411365..5089560784a 100644
--- a/compiler/rustc_codegen_llvm/src/debuginfo/mod.rs
+++ b/compiler/rustc_codegen_llvm/src/debuginfo/mod.rs
@@ -22,6 +22,7 @@ use rustc_session::config::{self, DebugInfo};
use rustc_span::{
BytePos, Pos, SourceFile, SourceFileAndLine, SourceFileHash, Span, StableSourceFileId, Symbol,
};
+use rustc_target::spec::DebuginfoKind;
use smallvec::SmallVec;
use tracing::debug;
@@ -93,29 +94,31 @@ impl<'ll, 'tcx> CodegenUnitDebugContext<'ll, 'tcx> {
pub(crate) fn finalize(&self, sess: &Session) {
unsafe { llvm::LLVMRustDIBuilderFinalize(self.builder) };
- if !sess.target.is_like_msvc {
- // Debuginfo generation in LLVM by default uses a higher
- // version of dwarf than macOS currently understands. We can
- // instruct LLVM to emit an older version of dwarf, however,
- // for macOS to understand. For more info see #11352
- // This can be overridden using --llvm-opts -dwarf-version,N.
- // Android has the same issue (#22398)
- let dwarf_version =
- sess.opts.unstable_opts.dwarf_version.unwrap_or(sess.target.default_dwarf_version);
- llvm::add_module_flag_u32(
- self.llmod,
- llvm::ModuleFlagMergeBehavior::Warning,
- "Dwarf Version",
- dwarf_version,
- );
- } else {
- // Indicate that we want CodeView debug information on MSVC
- llvm::add_module_flag_u32(
- self.llmod,
- llvm::ModuleFlagMergeBehavior::Warning,
- "CodeView",
- 1,
- );
+
+ match sess.target.debuginfo_kind {
+ DebuginfoKind::Dwarf | DebuginfoKind::DwarfDsym => {
+ // Debuginfo generation in LLVM by default uses a higher
+ // version of dwarf than macOS currently understands. We can
+ // instruct LLVM to emit an older version of dwarf, however,
+ // for macOS to understand. For more info see #11352
+ // This can be overridden using --llvm-opts -dwarf-version,N.
+ // Android has the same issue (#22398)
+ llvm::add_module_flag_u32(
+ self.llmod,
+ llvm::ModuleFlagMergeBehavior::Warning,
+ "Dwarf Version",
+ sess.dwarf_version(),
+ );
+ }
+ DebuginfoKind::Pdb => {
+ // Indicate that we want CodeView debug information
+ llvm::add_module_flag_u32(
+ self.llmod,
+ llvm::ModuleFlagMergeBehavior::Warning,
+ "CodeView",
+ 1,
+ );
+ }
}
// Prevent bitcode readers from deleting the debug info.
diff --git a/compiler/rustc_codegen_llvm/src/intrinsic.rs b/compiler/rustc_codegen_llvm/src/intrinsic.rs
index eab4a9f30c9..43d6ccfcb4a 100644
--- a/compiler/rustc_codegen_llvm/src/intrinsic.rs
+++ b/compiler/rustc_codegen_llvm/src/intrinsic.rs
@@ -1329,7 +1329,7 @@ fn generic_simd_intrinsic<'ll, 'tcx>(
}
if name == sym::simd_shuffle_generic {
- let idx = fn_args[2].expect_const().try_to_valtree().unwrap().0.unwrap_branch();
+ let idx = fn_args[2].expect_const().to_value().valtree.unwrap_branch();
let n = idx.len() as u64;
let (out_len, out_ty) = require_simd!(ret_ty, SimdReturn);
diff --git a/compiler/rustc_codegen_llvm/src/llvm/ffi.rs b/compiler/rustc_codegen_llvm/src/llvm/ffi.rs
index 009d15a932f..cc7c5231aca 100644
--- a/compiler/rustc_codegen_llvm/src/llvm/ffi.rs
+++ b/compiler/rustc_codegen_llvm/src/llvm/ffi.rs
@@ -661,6 +661,79 @@ pub enum MemoryEffects {
InaccessibleMemOnly,
}
+/// LLVMOpcode
+#[derive(Copy, Clone, PartialEq, Eq)]
+#[repr(C)]
+pub enum Opcode {
+ Ret = 1,
+ Br = 2,
+ Switch = 3,
+ IndirectBr = 4,
+ Invoke = 5,
+ Unreachable = 7,
+ CallBr = 67,
+ FNeg = 66,
+ Add = 8,
+ FAdd = 9,
+ Sub = 10,
+ FSub = 11,
+ Mul = 12,
+ FMul = 13,
+ UDiv = 14,
+ SDiv = 15,
+ FDiv = 16,
+ URem = 17,
+ SRem = 18,
+ FRem = 19,
+ Shl = 20,
+ LShr = 21,
+ AShr = 22,
+ And = 23,
+ Or = 24,
+ Xor = 25,
+ Alloca = 26,
+ Load = 27,
+ Store = 28,
+ GetElementPtr = 29,
+ Trunc = 30,
+ ZExt = 31,
+ SExt = 32,
+ FPToUI = 33,
+ FPToSI = 34,
+ UIToFP = 35,
+ SIToFP = 36,
+ FPTrunc = 37,
+ FPExt = 38,
+ PtrToInt = 39,
+ IntToPtr = 40,
+ BitCast = 41,
+ AddrSpaceCast = 60,
+ ICmp = 42,
+ FCmp = 43,
+ PHI = 44,
+ Call = 45,
+ Select = 46,
+ UserOp1 = 47,
+ UserOp2 = 48,
+ VAArg = 49,
+ ExtractElement = 50,
+ InsertElement = 51,
+ ShuffleVector = 52,
+ ExtractValue = 53,
+ InsertValue = 54,
+ Freeze = 68,
+ Fence = 55,
+ AtomicCmpXchg = 56,
+ AtomicRMW = 57,
+ Resume = 58,
+ LandingPad = 59,
+ CleanupRet = 61,
+ CatchRet = 62,
+ CatchPad = 63,
+ CleanupPad = 64,
+ CatchSwitch = 65,
+}
+
unsafe extern "C" {
type Opaque;
}
@@ -991,7 +1064,10 @@ unsafe extern "C" {
pub fn LLVMConstPtrToInt<'a>(ConstantVal: &'a Value, ToType: &'a Type) -> &'a Value;
pub fn LLVMConstIntToPtr<'a>(ConstantVal: &'a Value, ToType: &'a Type) -> &'a Value;
pub fn LLVMConstBitCast<'a>(ConstantVal: &'a Value, ToType: &'a Type) -> &'a Value;
+ pub fn LLVMConstPointerCast<'a>(ConstantVal: &'a Value, ToType: &'a Type) -> &'a Value;
pub fn LLVMGetAggregateElement(ConstantVal: &Value, Idx: c_uint) -> Option<&Value>;
+ pub fn LLVMGetConstOpcode(ConstantVal: &Value) -> Opcode;
+ pub fn LLVMIsAConstantExpr(Val: &Value) -> Option<&Value>;
// Operations on global variables, functions, and aliases (globals)
pub fn LLVMIsDeclaration(Global: &Value) -> Bool;
@@ -1048,6 +1124,7 @@ unsafe extern "C" {
// Operations on instructions
pub fn LLVMIsAInstruction(Val: &Value) -> Option<&Value>;
pub fn LLVMGetFirstBasicBlock(Fn: &Value) -> &BasicBlock;
+ pub fn LLVMGetOperand(Val: &Value, Index: c_uint) -> Option<&Value>;
// Operations on call sites
pub fn LLVMSetInstructionCallConv(Instr: &Value, CC: c_uint);
diff --git a/compiler/rustc_codegen_ssa/messages.ftl b/compiler/rustc_codegen_ssa/messages.ftl
index de37de09f5a..186b8171dd8 100644
--- a/compiler/rustc_codegen_ssa/messages.ftl
+++ b/compiler/rustc_codegen_ssa/messages.ftl
@@ -30,6 +30,8 @@ codegen_ssa_copy_path = could not copy {$from} to {$to}: {$error}
codegen_ssa_copy_path_buf = unable to copy {$source_file} to {$output_path}: {$error}
+codegen_ssa_cpu_required = target requires explicitly specifying a cpu with `-C target-cpu`
+
codegen_ssa_create_temp_dir = couldn't create a temp dir: {$error}
codegen_ssa_dlltool_fail_import_library =
diff --git a/compiler/rustc_codegen_ssa/src/base.rs b/compiler/rustc_codegen_ssa/src/base.rs
index e438bd70c51..83a9e6e2309 100644
--- a/compiler/rustc_codegen_ssa/src/base.rs
+++ b/compiler/rustc_codegen_ssa/src/base.rs
@@ -615,6 +615,11 @@ pub fn codegen_crate(
return ongoing_codegen;
}
+ if tcx.sess.target.need_explicit_cpu && tcx.sess.opts.cg.target_cpu.is_none() {
+ // The target has no default cpu, but none is set explicitly
+ tcx.dcx().emit_fatal(errors::CpuRequired);
+ }
+
let cgu_name_builder = &mut CodegenUnitNameBuilder::new(tcx);
// Run the monomorphization collector and partition the collected items into
diff --git a/compiler/rustc_codegen_ssa/src/debuginfo/type_names.rs b/compiler/rustc_codegen_ssa/src/debuginfo/type_names.rs
index 869798d8be1..d766ae37e5b 100644
--- a/compiler/rustc_codegen_ssa/src/debuginfo/type_names.rs
+++ b/compiler/rustc_codegen_ssa/src/debuginfo/type_names.rs
@@ -673,25 +673,23 @@ fn push_const_param<'tcx>(tcx: TyCtxt<'tcx>, ct: ty::Const<'tcx>, output: &mut S
ty::ConstKind::Param(param) => {
write!(output, "{}", param.name)
}
- ty::ConstKind::Value(ty, valtree) => {
- match ty.kind() {
+ ty::ConstKind::Value(cv) => {
+ match cv.ty.kind() {
ty::Int(ity) => {
- // FIXME: directly extract the bits from a valtree instead of evaluating an
- // already evaluated `Const` in order to get the bits.
- let bits = ct
+ let bits = cv
.try_to_bits(tcx, ty::TypingEnv::fully_monomorphized())
.expect("expected monomorphic const in codegen");
let val = Integer::from_int_ty(&tcx, *ity).size().sign_extend(bits) as i128;
write!(output, "{val}")
}
ty::Uint(_) => {
- let val = ct
+ let val = cv
.try_to_bits(tcx, ty::TypingEnv::fully_monomorphized())
.expect("expected monomorphic const in codegen");
write!(output, "{val}")
}
ty::Bool => {
- let val = ct.try_to_bool().expect("expected monomorphic const in codegen");
+ let val = cv.try_to_bool().expect("expected monomorphic const in codegen");
write!(output, "{val}")
}
_ => {
@@ -703,9 +701,7 @@ fn push_const_param<'tcx>(tcx: TyCtxt<'tcx>, ct: ty::Const<'tcx>, output: &mut S
// avoiding collisions and will make the emitted type names shorter.
let hash_short = tcx.with_stable_hashing_context(|mut hcx| {
let mut hasher = StableHasher::new();
- hcx.while_hashing_spans(false, |hcx| {
- (ty, valtree).hash_stable(hcx, &mut hasher)
- });
+ hcx.while_hashing_spans(false, |hcx| cv.hash_stable(hcx, &mut hasher));
hasher.finish::()
});
diff --git a/compiler/rustc_codegen_ssa/src/errors.rs b/compiler/rustc_codegen_ssa/src/errors.rs
index 5e684632fb2..f3afb37a9ef 100644
--- a/compiler/rustc_codegen_ssa/src/errors.rs
+++ b/compiler/rustc_codegen_ssa/src/errors.rs
@@ -523,6 +523,10 @@ pub(crate) struct CheckInstalledVisualStudio;
#[diag(codegen_ssa_insufficient_vs_code_product)]
pub(crate) struct InsufficientVSCodeProduct;
+#[derive(Diagnostic)]
+#[diag(codegen_ssa_cpu_required)]
+pub(crate) struct CpuRequired;
+
#[derive(Diagnostic)]
#[diag(codegen_ssa_processing_dymutil_failed)]
#[note]
diff --git a/compiler/rustc_codegen_ssa/src/mir/constant.rs b/compiler/rustc_codegen_ssa/src/mir/constant.rs
index 7676e1e171a..eafc551501c 100644
--- a/compiler/rustc_codegen_ssa/src/mir/constant.rs
+++ b/compiler/rustc_codegen_ssa/src/mir/constant.rs
@@ -43,7 +43,7 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
mir::Const::Ty(_, c) => match c.kind() {
// A constant that came from a const generic but was then used as an argument to
// old-style simd_shuffle (passing as argument instead of as a generic param).
- rustc_type_ir::ConstKind::Value(_, valtree) => return Ok(Ok(valtree)),
+ rustc_type_ir::ConstKind::Value(cv) => return Ok(Ok(cv.valtree)),
other => span_bug!(constant.span, "{other:#?}"),
},
// We should never encounter `Const::Val` unless MIR opts (like const prop) evaluate
diff --git a/compiler/rustc_const_eval/src/check_consts/qualifs.rs b/compiler/rustc_const_eval/src/check_consts/qualifs.rs
index e244b50a4b5..5d368b600a0 100644
--- a/compiler/rustc_const_eval/src/check_consts/qualifs.rs
+++ b/compiler/rustc_const_eval/src/check_consts/qualifs.rs
@@ -345,7 +345,7 @@ where
Const::Ty(_, ct)
if matches!(
ct.kind(),
- ty::ConstKind::Param(_) | ty::ConstKind::Error(_) | ty::ConstKind::Value(_, _)
+ ty::ConstKind::Param(_) | ty::ConstKind::Error(_) | ty::ConstKind::Value(_)
) =>
{
None
diff --git a/compiler/rustc_const_eval/src/const_eval/valtrees.rs b/compiler/rustc_const_eval/src/const_eval/valtrees.rs
index 4ff8aa9a3b4..4d625f76aba 100644
--- a/compiler/rustc_const_eval/src/const_eval/valtrees.rs
+++ b/compiler/rustc_const_eval/src/const_eval/valtrees.rs
@@ -272,7 +272,8 @@ pub(crate) fn eval_to_valtree<'tcx>(
/// Converts a `ValTree` to a `ConstValue`, which is needed after mir
/// construction has finished.
-// FIXME Merge `valtree_to_const_value` and `valtree_into_mplace` into one function
+// FIXME(valtrees): Merge `valtree_to_const_value` and `valtree_into_mplace` into one function
+// FIXME(valtrees): Accept `ty::Value` instead of `Ty` and `ty::ValTree` separately.
#[instrument(skip(tcx), level = "debug", ret)]
pub fn valtree_to_const_value<'tcx>(
tcx: TyCtxt<'tcx>,
diff --git a/compiler/rustc_const_eval/src/lib.rs b/compiler/rustc_const_eval/src/lib.rs
index b5adf06b300..ecf9745b779 100644
--- a/compiler/rustc_const_eval/src/lib.rs
+++ b/compiler/rustc_const_eval/src/lib.rs
@@ -46,8 +46,13 @@ pub fn provide(providers: &mut Providers) {
};
providers.hooks.try_destructure_mir_constant_for_user_output =
const_eval::try_destructure_mir_constant_for_user_output;
- providers.valtree_to_const_val = |tcx, (ty, valtree)| {
- const_eval::valtree_to_const_value(tcx, ty::TypingEnv::fully_monomorphized(), ty, valtree)
+ providers.valtree_to_const_val = |tcx, cv| {
+ const_eval::valtree_to_const_value(
+ tcx,
+ ty::TypingEnv::fully_monomorphized(),
+ cv.ty,
+ cv.valtree,
+ )
};
providers.check_validity_requirement = |tcx, (init_kind, param_env_and_ty)| {
util::check_validity_requirement(tcx, init_kind, param_env_and_ty)
diff --git a/compiler/rustc_hir_analysis/src/check/check.rs b/compiler/rustc_hir_analysis/src/check/check.rs
index b0a6922ff72..40049f96de4 100644
--- a/compiler/rustc_hir_analysis/src/check/check.rs
+++ b/compiler/rustc_hir_analysis/src/check/check.rs
@@ -27,7 +27,6 @@ use rustc_session::lint::builtin::UNINHABITED_STATIC;
use rustc_trait_selection::error_reporting::InferCtxtErrorExt;
use rustc_trait_selection::error_reporting::traits::on_unimplemented::OnUnimplementedDirective;
use rustc_trait_selection::traits;
-use rustc_trait_selection::traits::outlives_bounds::InferCtxtExt as _;
use rustc_type_ir::fold::TypeFoldable;
use tracing::{debug, instrument};
use ty::TypingMode;
@@ -417,9 +416,7 @@ fn check_opaque_meets_bounds<'tcx>(
}
let wf_tys = ocx.assumed_wf_types_and_report_errors(param_env, defining_use_anchor)?;
- let implied_bounds = infcx.implied_bounds_tys(param_env, def_id, &wf_tys);
- let outlives_env = OutlivesEnvironment::with_bounds(param_env, implied_bounds);
- ocx.resolve_regions_and_report_errors(defining_use_anchor, &outlives_env)?;
+ ocx.resolve_regions_and_report_errors(defining_use_anchor, param_env, wf_tys)?;
if infcx.next_trait_solver() {
Ok(())
diff --git a/compiler/rustc_hir_analysis/src/check/compare_impl_item.rs b/compiler/rustc_hir_analysis/src/check/compare_impl_item.rs
index d2ab98bae89..7332888c5f9 100644
--- a/compiler/rustc_hir_analysis/src/check/compare_impl_item.rs
+++ b/compiler/rustc_hir_analysis/src/check/compare_impl_item.rs
@@ -9,7 +9,6 @@ use rustc_errors::{Applicability, ErrorGuaranteed, pluralize, struct_span_code_e
use rustc_hir::def::{DefKind, Res};
use rustc_hir::intravisit::VisitorExt;
use rustc_hir::{self as hir, AmbigArg, GenericParamKind, ImplItemKind, intravisit};
-use rustc_infer::infer::outlives::env::OutlivesEnvironment;
use rustc_infer::infer::{self, InferCtxt, TyCtxtInferExt};
use rustc_infer::traits::util;
use rustc_middle::ty::error::{ExpectedFound, TypeError};
@@ -24,7 +23,6 @@ use rustc_span::Span;
use rustc_trait_selection::error_reporting::InferCtxtErrorExt;
use rustc_trait_selection::infer::InferCtxtExt;
use rustc_trait_selection::regions::InferCtxtRegionExt;
-use rustc_trait_selection::traits::outlives_bounds::InferCtxtExt as _;
use rustc_trait_selection::traits::{
self, FulfillmentError, ObligationCause, ObligationCauseCode, ObligationCtxt,
};
@@ -416,11 +414,7 @@ fn compare_method_predicate_entailment<'tcx>(
// Finally, resolve all regions. This catches wily misuses of
// lifetime parameters.
- let outlives_env = OutlivesEnvironment::with_bounds(
- param_env,
- infcx.implied_bounds_tys(param_env, impl_m_def_id, &wf_tys),
- );
- let errors = infcx.resolve_regions(&outlives_env);
+ let errors = infcx.resolve_regions(impl_m_def_id, param_env, wf_tys);
if !errors.is_empty() {
return Err(infcx
.tainted_by_errors()
@@ -725,11 +719,7 @@ pub(super) fn collect_return_position_impl_trait_in_trait_tys<'tcx>(
// Finally, resolve all regions. This catches wily misuses of
// lifetime parameters.
- let outlives_env = OutlivesEnvironment::with_bounds(
- param_env,
- infcx.implied_bounds_tys(param_env, impl_m_def_id, &wf_tys),
- );
- ocx.resolve_regions_and_report_errors(impl_m_def_id, &outlives_env)?;
+ ocx.resolve_regions_and_report_errors(impl_m_def_id, param_env, wf_tys)?;
let mut remapped_types = DefIdMap::default();
for (def_id, (ty, args)) in collected_types {
@@ -1883,8 +1873,7 @@ fn compare_const_predicate_entailment<'tcx>(
return Err(infcx.err_ctxt().report_fulfillment_errors(errors));
}
- let outlives_env = OutlivesEnvironment::new(param_env);
- ocx.resolve_regions_and_report_errors(impl_ct_def_id, &outlives_env)
+ ocx.resolve_regions_and_report_errors(impl_ct_def_id, param_env, [])
}
#[instrument(level = "debug", skip(tcx))]
@@ -2017,8 +2006,7 @@ fn compare_type_predicate_entailment<'tcx>(
// Finally, resolve all regions. This catches wily misuses of
// lifetime parameters.
- let outlives_env = OutlivesEnvironment::new(param_env);
- ocx.resolve_regions_and_report_errors(impl_ty_def_id, &outlives_env)
+ ocx.resolve_regions_and_report_errors(impl_ty_def_id, param_env, [])
}
/// Validate that `ProjectionCandidate`s created for this associated type will
@@ -2147,9 +2135,7 @@ pub(super) fn check_type_bounds<'tcx>(
// Finally, resolve all regions. This catches wily misuses of
// lifetime parameters.
- let implied_bounds = infcx.implied_bounds_tys(param_env, impl_ty_def_id, &assumed_wf_types);
- let outlives_env = OutlivesEnvironment::with_bounds(param_env, implied_bounds);
- ocx.resolve_regions_and_report_errors(impl_ty_def_id, &outlives_env)
+ ocx.resolve_regions_and_report_errors(impl_ty_def_id, param_env, assumed_wf_types)
}
struct ReplaceTy<'tcx> {
diff --git a/compiler/rustc_hir_analysis/src/check/compare_impl_item/refine.rs b/compiler/rustc_hir_analysis/src/check/compare_impl_item/refine.rs
index 2b14594ea1b..494e9560c81 100644
--- a/compiler/rustc_hir_analysis/src/check/compare_impl_item/refine.rs
+++ b/compiler/rustc_hir_analysis/src/check/compare_impl_item/refine.rs
@@ -3,7 +3,6 @@ use rustc_data_structures::fx::FxIndexSet;
use rustc_hir as hir;
use rustc_hir::def_id::{DefId, LocalDefId};
use rustc_infer::infer::TyCtxtInferExt;
-use rustc_infer::infer::outlives::env::OutlivesEnvironment;
use rustc_lint_defs::builtin::{REFINING_IMPL_TRAIT_INTERNAL, REFINING_IMPL_TRAIT_REACHABLE};
use rustc_middle::span_bug;
use rustc_middle::traits::ObligationCause;
@@ -13,7 +12,6 @@ use rustc_middle::ty::{
};
use rustc_span::Span;
use rustc_trait_selection::regions::InferCtxtRegionExt;
-use rustc_trait_selection::traits::outlives_bounds::InferCtxtExt;
use rustc_trait_selection::traits::{ObligationCtxt, elaborate, normalize_param_env_or_error};
/// Check that an implementation does not refine an RPITIT from a trait method signature.
@@ -170,11 +168,7 @@ pub(crate) fn check_refining_return_position_impl_trait_in_trait<'tcx>(
tcx.dcx().delayed_bug("encountered errors when checking RPITIT refinement (selection)");
return;
}
- let outlives_env = OutlivesEnvironment::with_bounds(
- param_env,
- infcx.implied_bounds_tys(param_env, impl_m.def_id.expect_local(), &implied_wf_types),
- );
- let errors = infcx.resolve_regions(&outlives_env);
+ let errors = infcx.resolve_regions(impl_m.def_id.expect_local(), param_env, implied_wf_types);
if !errors.is_empty() {
tcx.dcx().delayed_bug("encountered errors when checking RPITIT refinement (regions)");
return;
diff --git a/compiler/rustc_hir_analysis/src/check/dropck.rs b/compiler/rustc_hir_analysis/src/check/dropck.rs
index 1c9bbe627fb..0876bb82848 100644
--- a/compiler/rustc_hir_analysis/src/check/dropck.rs
+++ b/compiler/rustc_hir_analysis/src/check/dropck.rs
@@ -5,7 +5,6 @@
use rustc_data_structures::fx::FxHashSet;
use rustc_errors::codes::*;
use rustc_errors::{ErrorGuaranteed, struct_span_code_err};
-use rustc_infer::infer::outlives::env::OutlivesEnvironment;
use rustc_infer::infer::{RegionResolutionError, TyCtxtInferExt};
use rustc_infer::traits::{ObligationCause, ObligationCauseCode};
use rustc_middle::ty::util::CheckRegions;
@@ -192,7 +191,7 @@ fn ensure_drop_predicates_are_implied_by_item_defn<'tcx>(
return Err(guar.unwrap());
}
- let errors = ocx.infcx.resolve_regions(&OutlivesEnvironment::new(adt_env));
+ let errors = ocx.infcx.resolve_regions(adt_def_id, adt_env, []);
if !errors.is_empty() {
let mut guar = None;
for error in errors {
diff --git a/compiler/rustc_hir_analysis/src/check/mod.rs b/compiler/rustc_hir_analysis/src/check/mod.rs
index cc0b7fdd8dd..814c784710a 100644
--- a/compiler/rustc_hir_analysis/src/check/mod.rs
+++ b/compiler/rustc_hir_analysis/src/check/mod.rs
@@ -80,7 +80,6 @@ use rustc_errors::{Diag, ErrorGuaranteed, pluralize, struct_span_code_err};
use rustc_hir::def_id::{DefId, LocalDefId};
use rustc_hir::intravisit::Visitor;
use rustc_index::bit_set::DenseBitSet;
-use rustc_infer::infer::outlives::env::OutlivesEnvironment;
use rustc_infer::infer::{self, TyCtxtInferExt as _};
use rustc_infer::traits::ObligationCause;
use rustc_middle::query::Providers;
@@ -655,8 +654,7 @@ pub fn check_function_signature<'tcx>(
}
}
- let outlives_env = OutlivesEnvironment::new(param_env);
- if let Err(e) = ocx.resolve_regions_and_report_errors(local_id, &outlives_env) {
+ if let Err(e) = ocx.resolve_regions_and_report_errors(local_id, param_env, []) {
return Err(e);
}
diff --git a/compiler/rustc_hir_analysis/src/check/wfcheck.rs b/compiler/rustc_hir_analysis/src/check/wfcheck.rs
index cd19993f937..83bb8c0dfaf 100644
--- a/compiler/rustc_hir_analysis/src/check/wfcheck.rs
+++ b/compiler/rustc_hir_analysis/src/check/wfcheck.rs
@@ -25,11 +25,10 @@ use rustc_middle::{bug, span_bug};
use rustc_session::parse::feature_err;
use rustc_span::{DUMMY_SP, Ident, Span, sym};
use rustc_trait_selection::error_reporting::InferCtxtErrorExt;
-use rustc_trait_selection::regions::InferCtxtRegionExt;
+use rustc_trait_selection::regions::{InferCtxtRegionExt, OutlivesEnvironmentBuildExt};
use rustc_trait_selection::traits::misc::{
ConstParamTyImplementationError, type_allowed_to_implement_const_param_ty,
};
-use rustc_trait_selection::traits::outlives_bounds::InferCtxtExt as _;
use rustc_trait_selection::traits::query::evaluate_obligation::InferCtxtExt as _;
use rustc_trait_selection::traits::{
self, FulfillmentError, Obligation, ObligationCause, ObligationCauseCode, ObligationCtxt,
@@ -128,13 +127,17 @@ where
let infcx_compat = infcx.fork();
// We specifically want to call the non-compat version of `implied_bounds_tys`; we do this always.
- let implied_bounds =
- infcx.implied_bounds_tys_compat(param_env, body_def_id, &assumed_wf_types, false);
- let outlives_env = OutlivesEnvironment::with_bounds(param_env, implied_bounds);
+ let outlives_env = OutlivesEnvironment::new_with_implied_bounds_compat(
+ &infcx,
+ body_def_id,
+ param_env,
+ assumed_wf_types.iter().copied(),
+ false,
+ );
lint_redundant_lifetimes(tcx, body_def_id, &outlives_env);
- let errors = infcx.resolve_regions(&outlives_env);
+ let errors = infcx.resolve_regions_with_outlives_env(&outlives_env);
if errors.is_empty() {
return Ok(());
}
@@ -172,10 +175,14 @@ where
// but that does result in slightly more work when this option is set and
// just obscures what we mean here anyways. Let's just be explicit.
if is_bevy && !infcx.tcx.sess.opts.unstable_opts.no_implied_bounds_compat {
- let implied_bounds =
- infcx_compat.implied_bounds_tys_compat(param_env, body_def_id, &assumed_wf_types, true);
- let outlives_env = OutlivesEnvironment::with_bounds(param_env, implied_bounds);
- let errors_compat = infcx_compat.resolve_regions(&outlives_env);
+ let outlives_env = OutlivesEnvironment::new_with_implied_bounds_compat(
+ &infcx,
+ body_def_id,
+ param_env,
+ assumed_wf_types,
+ true,
+ );
+ let errors_compat = infcx_compat.resolve_regions_with_outlives_env(&outlives_env);
if errors_compat.is_empty() {
Ok(())
} else {
@@ -769,12 +776,7 @@ fn test_region_obligations<'tcx>(
add_constraints(&infcx);
- let outlives_environment = OutlivesEnvironment::with_bounds(
- param_env,
- infcx.implied_bounds_tys(param_env, id, wf_tys),
- );
-
- let errors = infcx.resolve_regions(&outlives_environment);
+ let errors = infcx.resolve_regions(id, param_env, wf_tys.iter().copied());
debug!(?errors, "errors");
// If we were able to prove that the type outlives the region without
diff --git a/compiler/rustc_hir_analysis/src/coherence/builtin.rs b/compiler/rustc_hir_analysis/src/coherence/builtin.rs
index 27a7c2ea530..6bbd76633da 100644
--- a/compiler/rustc_hir_analysis/src/coherence/builtin.rs
+++ b/compiler/rustc_hir_analysis/src/coherence/builtin.rs
@@ -10,7 +10,6 @@ use rustc_hir as hir;
use rustc_hir::ItemKind;
use rustc_hir::def_id::{DefId, LocalDefId};
use rustc_hir::lang_items::LangItem;
-use rustc_infer::infer::outlives::env::OutlivesEnvironment;
use rustc_infer::infer::{self, RegionResolutionError, TyCtxtInferExt};
use rustc_infer::traits::Obligation;
use rustc_middle::ty::adjustment::CoerceUnsizedInfo;
@@ -346,8 +345,7 @@ fn visit_implementation_of_dispatch_from_dyn(checker: &Checker<'_>) -> Result<()
}
// Finally, resolve all regions.
- let outlives_env = OutlivesEnvironment::new(param_env);
- res = res.and(ocx.resolve_regions_and_report_errors(impl_did, &outlives_env));
+ res = res.and(ocx.resolve_regions_and_report_errors(impl_did, param_env, []));
}
res
}
@@ -564,8 +562,7 @@ pub(crate) fn coerce_unsized_info<'tcx>(
}
// Finally, resolve all regions.
- let outlives_env = OutlivesEnvironment::new(param_env);
- let _ = ocx.resolve_regions_and_report_errors(impl_did, &outlives_env);
+ let _ = ocx.resolve_regions_and_report_errors(impl_did, param_env, []);
Ok(CoerceUnsizedInfo { custom_kind: kind })
}
diff --git a/compiler/rustc_hir_analysis/src/impl_wf_check/min_specialization.rs b/compiler/rustc_hir_analysis/src/impl_wf_check/min_specialization.rs
index ee55e1bc21a..32694d5f4bc 100644
--- a/compiler/rustc_hir_analysis/src/impl_wf_check/min_specialization.rs
+++ b/compiler/rustc_hir_analysis/src/impl_wf_check/min_specialization.rs
@@ -68,7 +68,6 @@
use rustc_data_structures::fx::FxHashSet;
use rustc_hir::def_id::{DefId, LocalDefId};
use rustc_infer::infer::TyCtxtInferExt;
-use rustc_infer::infer::outlives::env::OutlivesEnvironment;
use rustc_infer::traits::ObligationCause;
use rustc_infer::traits::specialization_graph::Node;
use rustc_middle::ty::trait_def::TraitSpecializationKind;
@@ -77,7 +76,6 @@ use rustc_middle::ty::{
};
use rustc_span::{ErrorGuaranteed, Span};
use rustc_trait_selection::error_reporting::InferCtxtErrorExt;
-use rustc_trait_selection::traits::outlives_bounds::InferCtxtExt as _;
use rustc_trait_selection::traits::{self, ObligationCtxt, translate_args_with_cause, wf};
use tracing::{debug, instrument};
@@ -176,7 +174,6 @@ fn get_impl_args(
let ocx = ObligationCtxt::new_with_diagnostics(infcx);
let param_env = tcx.param_env(impl1_def_id);
let impl1_span = tcx.def_span(impl1_def_id);
- let assumed_wf_types = ocx.assumed_wf_types_and_report_errors(param_env, impl1_def_id)?;
let impl1_args = GenericArgs::identity_for_item(tcx, impl1_def_id);
let impl2_args = translate_args_with_cause(
@@ -194,9 +191,8 @@ fn get_impl_args(
return Err(guar);
}
- let implied_bounds = infcx.implied_bounds_tys(param_env, impl1_def_id, &assumed_wf_types);
- let outlives_env = OutlivesEnvironment::with_bounds(param_env, implied_bounds);
- let _ = ocx.resolve_regions_and_report_errors(impl1_def_id, &outlives_env);
+ let assumed_wf_types = ocx.assumed_wf_types_and_report_errors(param_env, impl1_def_id)?;
+ let _ = ocx.resolve_regions_and_report_errors(impl1_def_id, param_env, assumed_wf_types);
let Ok(impl2_args) = infcx.fully_resolve(impl2_args) else {
let span = tcx.def_span(impl1_def_id);
let guar = tcx.dcx().emit_err(GenericArgsOnOverriddenImpl { span });
diff --git a/compiler/rustc_hir_typeck/src/pat.rs b/compiler/rustc_hir_typeck/src/pat.rs
index 0aa2f1110fb..c947ecde656 100644
--- a/compiler/rustc_hir_typeck/src/pat.rs
+++ b/compiler/rustc_hir_typeck/src/pat.rs
@@ -243,8 +243,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
fn downgrade_mut_inside_shared(&self) -> bool {
// NB: RFC 3627 proposes stabilizing Rule 3 in all editions. If we adopt the same behavior
// across all editions, this may be removed.
- self.tcx.features().ref_pat_eat_one_layer_2024()
- || self.tcx.features().ref_pat_eat_one_layer_2024_structural()
+ self.tcx.features().ref_pat_eat_one_layer_2024_structural()
}
/// Experimental pattern feature: when do reference patterns match against inherited references?
@@ -435,7 +434,10 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
max_ref_mutbl: MutblCap,
) -> (Ty<'tcx>, ByRef, MutblCap) {
#[cfg(debug_assertions)]
- if def_br == ByRef::Yes(Mutability::Mut) && max_ref_mutbl != MutblCap::Mut {
+ if def_br == ByRef::Yes(Mutability::Mut)
+ && max_ref_mutbl != MutblCap::Mut
+ && self.downgrade_mut_inside_shared()
+ {
span_bug!(pat.span, "Pattern mutability cap violated!");
}
match adjust_mode {
@@ -2328,22 +2330,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
// (RFC 3627, Rule 5). If we implement a pattern typing ruleset with Rule 4E
// but not Rule 5, we'll need to check that here.
debug_assert!(ref_pat_matches_mut_ref);
- let err_msg = "mismatched types";
- let err = if let Some(span) = pat_prefix_span {
- let mut err = self.dcx().struct_span_err(span, err_msg);
- err.code(E0308);
- err.note("cannot match inherited `&` with `&mut` pattern");
- err.span_suggestion_verbose(
- span,
- "replace this `&mut` pattern with `&`",
- "&",
- Applicability::MachineApplicable,
- );
- err
- } else {
- self.dcx().struct_span_err(pat.span, err_msg)
- };
- err.emit();
+ self.error_inherited_ref_mutability_mismatch(pat, pat_prefix_span);
}
pat_info.binding_mode = ByRef::No;
@@ -2352,28 +2339,38 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
return expected;
}
InheritedRefMatchRule::EatInner => {
- if let ty::Ref(_, _, r_mutbl) = *expected.kind() {
+ if let ty::Ref(_, _, r_mutbl) = *expected.kind()
+ && pat_mutbl <= r_mutbl
+ {
// Match against the reference type; don't consume the inherited ref.
- pat_info.binding_mode = pat_info.binding_mode.cap_ref_mutability(r_mutbl);
+ // NB: The check for compatible pattern and ref type mutability assumes that
+ // `&` patterns can match against mutable references (RFC 3627, Rule 5). If
+ // we implement a pattern typing ruleset with Rule 4 (including the fallback
+ // to matching the inherited ref when the inner ref can't match) but not
+ // Rule 5, we'll need to check that here.
+ debug_assert!(ref_pat_matches_mut_ref);
+ // NB: For RFC 3627's Rule 3, we limit the default binding mode's ref
+ // mutability to `pat_info.max_ref_mutbl`. If we implement a pattern typing
+ // ruleset with Rule 4 but not Rule 3, we'll need to check that here.
+ debug_assert!(self.downgrade_mut_inside_shared());
+ let mutbl_cap = cmp::min(r_mutbl, pat_info.max_ref_mutbl.as_mutbl());
+ pat_info.binding_mode = pat_info.binding_mode.cap_ref_mutability(mutbl_cap);
} else {
- // The expected type isn't a reference, so match against the inherited ref.
+ // The reference pattern can't match against the expected type, so try
+ // matching against the inherited ref instead.
if pat_mutbl > inh_mut {
- // We can't match an inherited shared reference with `&mut`. This will
- // be a type error later, since we're matching a reference pattern
- // against a non-reference type.
+ // We can't match an inherited shared reference with `&mut`.
// NB: This assumes that `&` patterns can match against mutable
// references (RFC 3627, Rule 5). If we implement a pattern typing
// ruleset with Rule 4 but not Rule 5, we'll need to check that here.
debug_assert!(ref_pat_matches_mut_ref);
- } else {
- pat_info.binding_mode = ByRef::No;
- self.typeck_results
- .borrow_mut()
- .skipped_ref_pats_mut()
- .insert(pat.hir_id);
- self.check_pat(inner, expected, pat_info);
- return expected;
+ self.error_inherited_ref_mutability_mismatch(pat, pat_prefix_span);
}
+
+ pat_info.binding_mode = ByRef::No;
+ self.typeck_results.borrow_mut().skipped_ref_pats_mut().insert(pat.hir_id);
+ self.check_pat(inner, expected, pat_info);
+ return expected;
}
}
InheritedRefMatchRule::EatBoth => {
@@ -2447,6 +2444,29 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
Ty::new_ref(self.tcx, region, ty, mutbl)
}
+ fn error_inherited_ref_mutability_mismatch(
+ &self,
+ pat: &'tcx Pat<'tcx>,
+ pat_prefix_span: Option,
+ ) -> ErrorGuaranteed {
+ let err_msg = "mismatched types";
+ let err = if let Some(span) = pat_prefix_span {
+ let mut err = self.dcx().struct_span_err(span, err_msg);
+ err.code(E0308);
+ err.note("cannot match inherited `&` with `&mut` pattern");
+ err.span_suggestion_verbose(
+ span,
+ "replace this `&mut` pattern with `&`",
+ "&",
+ Applicability::MachineApplicable,
+ );
+ err
+ } else {
+ self.dcx().struct_span_err(pat.span, err_msg)
+ };
+ err.emit()
+ }
+
fn try_resolve_slice_ty_to_array_ty(
&self,
before: &'tcx [Pat<'tcx>],
diff --git a/compiler/rustc_infer/src/infer/freshen.rs b/compiler/rustc_infer/src/infer/freshen.rs
index 28eac5b7496..74c8b463fc8 100644
--- a/compiler/rustc_infer/src/infer/freshen.rs
+++ b/compiler/rustc_infer/src/infer/freshen.rs
@@ -170,7 +170,7 @@ impl<'a, 'tcx> TypeFolder> for TypeFreshener<'a, 'tcx> {
}
ty::ConstKind::Param(_)
- | ty::ConstKind::Value(_, _)
+ | ty::ConstKind::Value(_)
| ty::ConstKind::Unevaluated(..)
| ty::ConstKind::Expr(..)
| ty::ConstKind::Error(_) => ct.super_fold_with(self),
diff --git a/compiler/rustc_infer/src/infer/mod.rs b/compiler/rustc_infer/src/infer/mod.rs
index 283ebdfa236..515c9c34098 100644
--- a/compiler/rustc_infer/src/infer/mod.rs
+++ b/compiler/rustc_infer/src/infer/mod.rs
@@ -1055,7 +1055,7 @@ impl<'tcx> InferCtxt<'tcx> {
| ty::ConstKind::Bound(_, _)
| ty::ConstKind::Placeholder(_)
| ty::ConstKind::Unevaluated(_)
- | ty::ConstKind::Value(_, _)
+ | ty::ConstKind::Value(_)
| ty::ConstKind::Error(_)
| ty::ConstKind::Expr(_) => ct,
}
diff --git a/compiler/rustc_infer/src/infer/outlives/env.rs b/compiler/rustc_infer/src/infer/outlives/env.rs
index 9300fc574dc..e924c974a02 100644
--- a/compiler/rustc_infer/src/infer/outlives/env.rs
+++ b/compiler/rustc_infer/src/infer/outlives/env.rs
@@ -31,26 +31,14 @@ use crate::traits::query::OutlivesBound;
pub struct OutlivesEnvironment<'tcx> {
pub param_env: ty::ParamEnv<'tcx>,
free_region_map: FreeRegionMap<'tcx>,
-
- // Contains the implied region bounds in scope for our current body.
- //
- // Example:
- //
- // ```
- // fn foo<'a, 'b, T>(x: &'a T, y: &'b ()) {
- // bar(x, y, |y: &'b T| { .. } // body B1)
- // } // body B0
- // ```
- //
- // Here, when checking the body B0, the list would be `[T: 'a]`, because we
- // infer that `T` must outlive `'a` from the implied bounds on the
- // fn declaration.
- //
- // For the body B1 however, the list would be `[T: 'a, T: 'b]`, because we
- // also can see that -- within the closure body! -- `T` must
- // outlive `'b`. This is not necessarily true outside the closure
- // body, since the closure may never be called.
+ /// FIXME: Your first reaction may be that this is a bit strange. `RegionBoundPairs`
+ /// does not contain lifetimes, which are instead in the `FreeRegionMap`, and other
+ /// known type outlives are stored in the `known_type_outlives` set. So why do we
+ /// have these at all? It turns out that removing these and using `known_type_outlives`
+ /// everywhere is just enough of a perf regression to matter. This can/should be
+ /// optimized in the future, though.
region_bound_pairs: RegionBoundPairs<'tcx>,
+ known_type_outlives: Vec>,
}
/// "Region-bound pairs" tracks outlives relations that are known to
@@ -59,15 +47,10 @@ pub struct OutlivesEnvironment<'tcx> {
pub type RegionBoundPairs<'tcx> = FxIndexSet>>;
impl<'tcx> OutlivesEnvironment<'tcx> {
- /// Create a new `OutlivesEnvironment` without extra outlives bounds.
- #[inline]
- pub fn new(param_env: ty::ParamEnv<'tcx>) -> Self {
- Self::with_bounds(param_env, vec![])
- }
-
- /// Create a new `OutlivesEnvironment` with extra outlives bounds.
- pub fn with_bounds(
+ /// Create a new `OutlivesEnvironment` from normalized outlives bounds.
+ pub fn from_normalized_bounds(
param_env: ty::ParamEnv<'tcx>,
+ known_type_outlives: Vec>,
extra_bounds: impl IntoIterator>,
) -> Self {
let mut region_relation = TransitiveRelationBuilder::default();
@@ -102,18 +85,21 @@ impl<'tcx> OutlivesEnvironment<'tcx> {
OutlivesEnvironment {
param_env,
+ known_type_outlives,
free_region_map: FreeRegionMap { relation: region_relation.freeze() },
region_bound_pairs,
}
}
- /// Borrows current value of the `free_region_map`.
pub fn free_region_map(&self) -> &FreeRegionMap<'tcx> {
&self.free_region_map
}
- /// Borrows current `region_bound_pairs`.
pub fn region_bound_pairs(&self) -> &RegionBoundPairs<'tcx> {
&self.region_bound_pairs
}
+
+ pub fn known_type_outlives(&self) -> &[ty::PolyTypeOutlivesPredicate<'tcx>] {
+ &self.known_type_outlives
+ }
}
diff --git a/compiler/rustc_infer/src/infer/outlives/obligations.rs b/compiler/rustc_infer/src/infer/outlives/obligations.rs
index 0383c81f2af..84e51b18dc5 100644
--- a/compiler/rustc_infer/src/infer/outlives/obligations.rs
+++ b/compiler/rustc_infer/src/infer/outlives/obligations.rs
@@ -67,7 +67,6 @@ use rustc_middle::ty::{
self, GenericArgKind, GenericArgsRef, PolyTypeOutlivesPredicate, Region, Ty, TyCtxt,
TypeFoldable as _, TypeVisitableExt,
};
-use rustc_span::DUMMY_SP;
use rustc_type_ir::outlives::{Component, push_outlives_components};
use smallvec::smallvec;
use tracing::{debug, instrument};
@@ -142,25 +141,6 @@ impl<'tcx> InferCtxt<'tcx> {
) -> Result<(), (PolyTypeOutlivesPredicate<'tcx>, SubregionOrigin<'tcx>)> {
assert!(!self.in_snapshot(), "cannot process registered region obligations in a snapshot");
- let normalized_caller_bounds: Vec<_> = outlives_env
- .param_env
- .caller_bounds()
- .iter()
- .filter_map(|clause| {
- let outlives = clause.as_type_outlives_clause()?;
- Some(
- deeply_normalize_ty(
- outlives,
- SubregionOrigin::AscribeUserTypeProvePredicate(DUMMY_SP),
- )
- // FIXME(-Znext-solver): How do we accurately report an error span here :(
- .map_err(|NoSolution| {
- (outlives, SubregionOrigin::AscribeUserTypeProvePredicate(DUMMY_SP))
- }),
- )
- })
- .try_collect()?;
-
// Must loop since the process of normalizing may itself register region obligations.
for iteration in 0.. {
let my_region_obligations = self.take_registered_region_obligations();
@@ -194,7 +174,7 @@ impl<'tcx> InferCtxt<'tcx> {
self.tcx,
outlives_env.region_bound_pairs(),
None,
- &normalized_caller_bounds,
+ outlives_env.known_type_outlives(),
);
let category = origin.to_constraint_category();
outlives.type_must_outlive(origin, sup_type, sub_region, category);
diff --git a/compiler/rustc_lint/src/impl_trait_overcaptures.rs b/compiler/rustc_lint/src/impl_trait_overcaptures.rs
index 44f86535527..d251b4b7459 100644
--- a/compiler/rustc_lint/src/impl_trait_overcaptures.rs
+++ b/compiler/rustc_lint/src/impl_trait_overcaptures.rs
@@ -25,8 +25,8 @@ use rustc_span::{Span, Symbol};
use rustc_trait_selection::errors::{
AddPreciseCapturingForOvercapture, impl_trait_overcapture_suggestion,
};
+use rustc_trait_selection::regions::OutlivesEnvironmentBuildExt;
use rustc_trait_selection::traits::ObligationCtxt;
-use rustc_trait_selection::traits::outlives_bounds::InferCtxtExt;
use crate::{LateContext, LateLintPass, fluent_generated as fluent};
@@ -190,9 +190,7 @@ fn check_fn(tcx: TyCtxt<'_>, parent_def_id: LocalDefId) {
let (infcx, param_env) = tcx.infer_ctxt().build_with_typing_env(typing_env);
let ocx = ObligationCtxt::new(&infcx);
let assumed_wf_tys = ocx.assumed_wf_types(param_env, parent_def_id).unwrap_or_default();
- let implied_bounds =
- infcx.implied_bounds_tys_compat(param_env, parent_def_id, &assumed_wf_tys, false);
- OutlivesEnvironment::with_bounds(param_env, implied_bounds)
+ OutlivesEnvironment::new(&infcx, parent_def_id, param_env, assumed_wf_tys)
}),
});
}
diff --git a/compiler/rustc_middle/src/mir/consts.rs b/compiler/rustc_middle/src/mir/consts.rs
index 66d97fda433..923160cc0cc 100644
--- a/compiler/rustc_middle/src/mir/consts.rs
+++ b/compiler/rustc_middle/src/mir/consts.rs
@@ -250,7 +250,7 @@ impl<'tcx> Const<'tcx> {
// Dont use the outer ty as on invalid code we can wind up with them not being the same.
// this then results in allowing const eval to add `1_i64 + 1_usize` in cases where the mir
// was originally `({N: usize} + 1_usize)` under `generic_const_exprs`.
- ty::ConstKind::Value(ty, _) => ty,
+ ty::ConstKind::Value(cv) => cv.ty,
_ => *ty,
}
}
@@ -264,7 +264,7 @@ impl<'tcx> Const<'tcx> {
pub fn is_required_const(&self) -> bool {
match self {
Const::Ty(_, c) => match c.kind() {
- ty::ConstKind::Value(_, _) => false, // already a value, cannot error
+ ty::ConstKind::Value(_) => false, // already a value, cannot error
_ => true,
},
Const::Val(..) => false, // already a value, cannot error
@@ -276,11 +276,11 @@ impl<'tcx> Const<'tcx> {
pub fn try_to_scalar(self) -> Option {
match self {
Const::Ty(_, c) => match c.kind() {
- ty::ConstKind::Value(ty, valtree) if ty.is_primitive() => {
+ ty::ConstKind::Value(cv) if cv.ty.is_primitive() => {
// A valtree of a type where leaves directly represent the scalar const value.
// Just checking whether it is a leaf is insufficient as e.g. references are leafs
// but the leaf value is the value they point to, not the reference itself!
- Some(valtree.unwrap_leaf().into())
+ Some(cv.valtree.unwrap_leaf().into())
}
_ => None,
},
@@ -295,9 +295,7 @@ impl<'tcx> Const<'tcx> {
match self {
Const::Val(ConstValue::Scalar(Scalar::Int(x)), _) => Some(x),
Const::Ty(_, c) => match c.kind() {
- ty::ConstKind::Value(ty, valtree) if ty.is_primitive() => {
- Some(valtree.unwrap_leaf())
- }
+ ty::ConstKind::Value(cv) if cv.ty.is_primitive() => Some(cv.valtree.unwrap_leaf()),
_ => None,
},
_ => None,
@@ -328,7 +326,7 @@ impl<'tcx> Const<'tcx> {
}
match c.kind() {
- ConstKind::Value(ty, val) => Ok(tcx.valtree_to_const_val((ty, val))),
+ ConstKind::Value(cv) => Ok(tcx.valtree_to_const_val(cv)),
ConstKind::Expr(_) => {
bug!("Normalization of `ty::ConstKind::Expr` is unimplemented")
}
@@ -353,13 +351,13 @@ impl<'tcx> Const<'tcx> {
typing_env: ty::TypingEnv<'tcx>,
) -> Option {
if let Const::Ty(_, c) = self
- && let ty::ConstKind::Value(ty, val) = c.kind()
- && ty.is_primitive()
+ && let ty::ConstKind::Value(cv) = c.kind()
+ && cv.ty.is_primitive()
{
// Avoid the `valtree_to_const_val` query. Can only be done on primitive types that
// are valtree leaves, and *not* on references. (References should return the
// pointer here, which valtrees don't represent.)
- Some(val.unwrap_leaf().into())
+ Some(cv.valtree.unwrap_leaf().into())
} else {
self.eval(tcx, typing_env, DUMMY_SP).ok()?.try_to_scalar()
}
@@ -473,7 +471,7 @@ impl<'tcx> Const<'tcx> {
// A valtree may be a reference. Valtree references correspond to a
// different allocation each time they are evaluated. Valtrees for primitive
// types are fine though.
- ty::ConstKind::Value(ty, _) => ty.is_primitive(),
+ ty::ConstKind::Value(cv) => cv.ty.is_primitive(),
ty::ConstKind::Unevaluated(..) | ty::ConstKind::Expr(..) => false,
// This can happen if evaluation of a constant failed. The result does not matter
// much since compilation is doomed.
diff --git a/compiler/rustc_middle/src/mir/pretty.rs b/compiler/rustc_middle/src/mir/pretty.rs
index 3b4fba97e60..a318bacb866 100644
--- a/compiler/rustc_middle/src/mir/pretty.rs
+++ b/compiler/rustc_middle/src/mir/pretty.rs
@@ -1441,7 +1441,9 @@ impl<'tcx> Visitor<'tcx> for ExtraComments<'tcx> {
ty::ConstKind::Unevaluated(uv) => {
format!("ty::Unevaluated({}, {:?})", self.tcx.def_path_str(uv.def), uv.args,)
}
- ty::ConstKind::Value(_, val) => format!("ty::Valtree({})", fmt_valtree(&val)),
+ ty::ConstKind::Value(cv) => {
+ format!("ty::Valtree({})", fmt_valtree(&cv.valtree))
+ }
// No `ty::` prefix since we also use this to represent errors from `mir::Unevaluated`.
ty::ConstKind::Error(_) => "Error".to_string(),
// These variants shouldn't exist in the MIR.
diff --git a/compiler/rustc_middle/src/query/keys.rs b/compiler/rustc_middle/src/query/keys.rs
index e243425c0b7..f7090fa69e2 100644
--- a/compiler/rustc_middle/src/query/keys.rs
+++ b/compiler/rustc_middle/src/query/keys.rs
@@ -550,7 +550,7 @@ impl<'tcx> Key for (ty::Instance<'tcx>, &'tcx ty::List>) {
}
}
-impl<'tcx> Key for (Ty<'tcx>, ty::ValTree<'tcx>) {
+impl<'tcx> Key for ty::Value<'tcx> {
type Cache = DefaultCache;
fn default_span(&self, _: TyCtxt<'_>) -> Span {
diff --git a/compiler/rustc_middle/src/query/mod.rs b/compiler/rustc_middle/src/query/mod.rs
index d83bc19a6a2..560e3bf3ade 100644
--- a/compiler/rustc_middle/src/query/mod.rs
+++ b/compiler/rustc_middle/src/query/mod.rs
@@ -1256,9 +1256,9 @@ rustc_queries! {
desc { "evaluating type-level constant" }
}
- /// Converts a type level constant value into `ConstValue`
- query valtree_to_const_val(key: (Ty<'tcx>, ty::ValTree<'tcx>)) -> mir::ConstValue<'tcx> {
- desc { "converting type-level constant value to mir constant value"}
+ /// Converts a type-level constant value into a MIR constant value.
+ query valtree_to_const_val(key: ty::Value<'tcx>) -> mir::ConstValue<'tcx> {
+ desc { "converting type-level constant value to MIR constant value"}
}
/// Destructures array, ADT or tuple constants into the constants
diff --git a/compiler/rustc_middle/src/ty/consts.rs b/compiler/rustc_middle/src/ty/consts.rs
index 31055276422..d77fb1cc91e 100644
--- a/compiler/rustc_middle/src/ty/consts.rs
+++ b/compiler/rustc_middle/src/ty/consts.rs
@@ -5,7 +5,6 @@ use rustc_error_messages::MultiSpan;
use rustc_macros::HashStable;
use rustc_type_ir::{self as ir, TypeFlags, WithCachedTypeInfo};
-use crate::mir::interpret::Scalar;
use crate::ty::{self, Ty, TyCtxt};
mod int;
@@ -110,8 +109,8 @@ impl<'tcx> Const<'tcx> {
}
#[inline]
- pub fn new_value(tcx: TyCtxt<'tcx>, val: ty::ValTree<'tcx>, ty: Ty<'tcx>) -> Const<'tcx> {
- Const::new(tcx, ty::ConstKind::Value(ty, val))
+ pub fn new_value(tcx: TyCtxt<'tcx>, valtree: ty::ValTree<'tcx>, ty: Ty<'tcx>) -> Const<'tcx> {
+ Const::new(tcx, ty::ConstKind::Value(ty::Value { ty, valtree }))
}
#[inline]
@@ -214,47 +213,31 @@ impl<'tcx> Const<'tcx> {
Self::from_bits(tcx, n as u128, ty::TypingEnv::fully_monomorphized(), tcx.types.usize)
}
- /// Panics if self.kind != ty::ConstKind::Value
- pub fn to_valtree(self) -> (ty::ValTree<'tcx>, Ty<'tcx>) {
+ /// Panics if `self.kind != ty::ConstKind::Value`.
+ pub fn to_value(self) -> ty::Value<'tcx> {
match self.kind() {
- ty::ConstKind::Value(ty, valtree) => (valtree, ty),
+ ty::ConstKind::Value(cv) => cv,
_ => bug!("expected ConstKind::Value, got {:?}", self.kind()),
}
}
- /// Attempts to convert to a `ValTree`
- pub fn try_to_valtree(self) -> Option<(ty::ValTree<'tcx>, Ty<'tcx>)> {
+ /// Attempts to convert to a value.
+ ///
+ /// Note that this does not evaluate the constant.
+ pub fn try_to_value(self) -> Option> {
match self.kind() {
- ty::ConstKind::Value(ty, valtree) => Some((valtree, ty)),
+ ty::ConstKind::Value(cv) => Some(cv),
_ => None,
}
}
- #[inline]
- pub fn try_to_scalar(self) -> Option<(Scalar, Ty<'tcx>)> {
- let (valtree, ty) = self.try_to_valtree()?;
- Some((valtree.try_to_scalar()?, ty))
- }
-
- pub fn try_to_bool(self) -> Option {
- self.try_to_valtree()?.0.try_to_scalar_int()?.try_to_bool().ok()
- }
-
+ /// Convenience method to extract the value of a usize constant,
+ /// useful to get the length of an array type.
+ ///
+ /// Note that this does not evaluate the constant.
#[inline]
pub fn try_to_target_usize(self, tcx: TyCtxt<'tcx>) -> Option {
- self.try_to_valtree()?.0.try_to_target_usize(tcx)
- }
-
- /// Attempts to evaluate the given constant to bits. Can fail to evaluate in the presence of
- /// generics (or erroneous code) or if the value can't be represented as bits (e.g. because it
- /// contains const generic parameters or pointers).
- #[inline]
- pub fn try_to_bits(self, tcx: TyCtxt<'tcx>, typing_env: ty::TypingEnv<'tcx>) -> Option {
- let (scalar, ty) = self.try_to_scalar()?;
- let scalar = scalar.try_to_scalar_int().ok()?;
- let input = typing_env.with_post_analysis_normalized(tcx).as_query_input(ty);
- let size = tcx.layout_of(input).ok()?.size;
- Some(scalar.to_bits(size))
+ self.try_to_value()?.try_to_target_usize(tcx)
}
pub fn is_ct_infer(self) -> bool {
diff --git a/compiler/rustc_middle/src/ty/consts/valtree.rs b/compiler/rustc_middle/src/ty/consts/valtree.rs
index 9f9bf41c335..d914b7576dc 100644
--- a/compiler/rustc_middle/src/ty/consts/valtree.rs
+++ b/compiler/rustc_middle/src/ty/consts/valtree.rs
@@ -1,11 +1,9 @@
-use rustc_macros::{HashStable, TyDecodable, TyEncodable};
+use rustc_macros::{HashStable, TyDecodable, TyEncodable, TypeFoldable, TypeVisitable};
use super::ScalarInt;
use crate::mir::interpret::Scalar;
use crate::ty::{self, Ty, TyCtxt};
-#[derive(Copy, Clone, Debug, Hash, TyEncodable, TyDecodable, Eq, PartialEq)]
-#[derive(HashStable)]
/// This datastructure is used to represent the value of constants used in the type system.
///
/// We explicitly choose a different datastructure from the way values are processed within
@@ -18,6 +16,8 @@ use crate::ty::{self, Ty, TyCtxt};
///
/// `ValTree` does not have this problem with representation, as it only contains integers or
/// lists of (nested) `ValTree`.
+#[derive(Copy, Clone, Debug, Hash, Eq, PartialEq)]
+#[derive(HashStable, TyEncodable, TyDecodable)]
pub enum ValTree<'tcx> {
/// integers, `bool`, `char` are represented as scalars.
/// See the `ScalarInt` documentation for how `ScalarInt` guarantees that equal values
@@ -79,10 +79,6 @@ impl<'tcx> ValTree<'tcx> {
}
}
- pub fn try_to_target_usize(self, tcx: TyCtxt<'tcx>) -> Option {
- self.try_to_scalar_int().map(|s| s.to_target_usize(tcx))
- }
-
/// Get the values inside the ValTree as a slice of bytes. This only works for
/// constants with types &str, &[u8], or [u8; _].
pub fn try_to_raw_bytes(self, tcx: TyCtxt<'tcx>, ty: Ty<'tcx>) -> Option<&'tcx [u8]> {
@@ -107,3 +103,54 @@ impl<'tcx> ValTree<'tcx> {
)
}
}
+
+/// A type-level constant value.
+///
+/// Represents a typed, fully evaluated constant.
+#[derive(Copy, Clone, Debug, Hash, Eq, PartialEq)]
+#[derive(HashStable, TyEncodable, TyDecodable, TypeFoldable, TypeVisitable)]
+pub struct Value<'tcx> {
+ pub ty: Ty<'tcx>,
+ pub valtree: ValTree<'tcx>,
+}
+
+impl<'tcx> Value<'tcx> {
+ /// Attempts to extract the raw bits from the constant.
+ ///
+ /// Fails if the value can't be represented as bits (e.g. because it is a reference
+ /// or an aggregate).
+ #[inline]
+ pub fn try_to_bits(self, tcx: TyCtxt<'tcx>, typing_env: ty::TypingEnv<'tcx>) -> Option {
+ let (ty::Bool | ty::Char | ty::Uint(_) | ty::Int(_) | ty::Float(_)) = self.ty.kind() else {
+ return None;
+ };
+ let scalar = self.valtree.try_to_scalar_int()?;
+ let input = typing_env.with_post_analysis_normalized(tcx).as_query_input(self.ty);
+ let size = tcx.layout_of(input).ok()?.size;
+ Some(scalar.to_bits(size))
+ }
+
+ pub fn try_to_bool(self) -> Option {
+ if !self.ty.is_bool() {
+ return None;
+ }
+ self.valtree.try_to_scalar_int()?.try_to_bool().ok()
+ }
+
+ pub fn try_to_target_usize(self, tcx: TyCtxt<'tcx>) -> Option {
+ if !self.ty.is_usize() {
+ return None;
+ }
+ self.valtree.try_to_scalar_int().map(|s| s.to_target_usize(tcx))
+ }
+}
+
+impl<'tcx> rustc_type_ir::inherent::ValueConst> for Value<'tcx> {
+ fn ty(self) -> Ty<'tcx> {
+ self.ty
+ }
+
+ fn valtree(self) -> ValTree<'tcx> {
+ self.valtree
+ }
+}
diff --git a/compiler/rustc_middle/src/ty/context.rs b/compiler/rustc_middle/src/ty/context.rs
index 0c22c056dab..69f6fc0ad8a 100644
--- a/compiler/rustc_middle/src/ty/context.rs
+++ b/compiler/rustc_middle/src/ty/context.rs
@@ -142,10 +142,11 @@ impl<'tcx> Interner for TyCtxt<'tcx> {
type ParamConst = ty::ParamConst;
type BoundConst = ty::BoundVar;
- type ValueConst = ty::ValTree<'tcx>;
+ type ValueConst = ty::Value<'tcx>;
type ExprConst = ty::Expr<'tcx>;
- type Region = Region<'tcx>;
+ type ValTree = ty::ValTree<'tcx>;
+ type Region = Region<'tcx>;
type EarlyParamRegion = ty::EarlyParamRegion;
type LateParamRegion = ty::LateParamRegion;
type BoundRegion = ty::BoundRegion;
@@ -1118,15 +1119,18 @@ impl<'tcx> CommonConsts<'tcx> {
};
CommonConsts {
- unit: mk_const(ty::ConstKind::Value(types.unit, ty::ValTree::zst())),
- true_: mk_const(ty::ConstKind::Value(
- types.bool,
- ty::ValTree::Leaf(ty::ScalarInt::TRUE),
- )),
- false_: mk_const(ty::ConstKind::Value(
- types.bool,
- ty::ValTree::Leaf(ty::ScalarInt::FALSE),
- )),
+ unit: mk_const(ty::ConstKind::Value(ty::Value {
+ ty: types.unit,
+ valtree: ty::ValTree::zst(),
+ })),
+ true_: mk_const(ty::ConstKind::Value(ty::Value {
+ ty: types.bool,
+ valtree: ty::ValTree::Leaf(ty::ScalarInt::TRUE),
+ })),
+ false_: mk_const(ty::ConstKind::Value(ty::Value {
+ ty: types.bool,
+ valtree: ty::ValTree::Leaf(ty::ScalarInt::FALSE),
+ })),
}
}
}
diff --git a/compiler/rustc_middle/src/ty/flags.rs b/compiler/rustc_middle/src/ty/flags.rs
index 0af57f636aa..ec0498b168c 100644
--- a/compiler/rustc_middle/src/ty/flags.rs
+++ b/compiler/rustc_middle/src/ty/flags.rs
@@ -381,7 +381,7 @@ impl FlagComputation {
self.add_flags(TypeFlags::HAS_CT_PLACEHOLDER);
self.add_flags(TypeFlags::STILL_FURTHER_SPECIALIZABLE);
}
- ty::ConstKind::Value(ty, _) => self.add_ty(ty),
+ ty::ConstKind::Value(cv) => self.add_ty(cv.ty),
ty::ConstKind::Expr(e) => self.add_args(e.args()),
ty::ConstKind::Error(_) => self.add_flags(TypeFlags::HAS_ERROR),
}
diff --git a/compiler/rustc_middle/src/ty/layout.rs b/compiler/rustc_middle/src/ty/layout.rs
index 0d41a1d7dbf..b212992bd2d 100644
--- a/compiler/rustc_middle/src/ty/layout.rs
+++ b/compiler/rustc_middle/src/ty/layout.rs
@@ -504,6 +504,9 @@ impl<'tcx> SizeSkeleton<'tcx> {
}
}
+ // Pattern types are always the same size as their base.
+ ty::Pat(base, _) => SizeSkeleton::compute(base, tcx, typing_env),
+
_ => Err(err),
}
}
diff --git a/compiler/rustc_middle/src/ty/mod.rs b/compiler/rustc_middle/src/ty/mod.rs
index 8cd632790a8..88eea6101b5 100644
--- a/compiler/rustc_middle/src/ty/mod.rs
+++ b/compiler/rustc_middle/src/ty/mod.rs
@@ -60,7 +60,7 @@ pub use self::closure::{
place_to_string_for_capture,
};
pub use self::consts::{
- Const, ConstInt, ConstKind, Expr, ExprKind, ScalarInt, UnevaluatedConst, ValTree,
+ Const, ConstInt, ConstKind, Expr, ExprKind, ScalarInt, UnevaluatedConst, ValTree, Value,
};
pub use self::context::{
CtxtInterners, CurrentGcx, DeducedParamAttrs, Feed, FreeRegionInfo, GlobalCtxt, Lift, TyCtxt,
diff --git a/compiler/rustc_middle/src/ty/print/pretty.rs b/compiler/rustc_middle/src/ty/print/pretty.rs
index 027a4315b4b..018fcc66aee 100644
--- a/compiler/rustc_middle/src/ty/print/pretty.rs
+++ b/compiler/rustc_middle/src/ty/print/pretty.rs
@@ -1484,8 +1484,8 @@ pub trait PrettyPrinter<'tcx>: Printer<'tcx> + fmt::Write {
_ => write!(self, "_")?,
},
ty::ConstKind::Param(ParamConst { name, .. }) => p!(write("{}", name)),
- ty::ConstKind::Value(ty, value) => {
- return self.pretty_print_const_valtree(value, ty, print_ty);
+ ty::ConstKind::Value(cv) => {
+ return self.pretty_print_const_valtree(cv.valtree, cv.ty, print_ty);
}
ty::ConstKind::Bound(debruijn, bound_var) => {
@@ -1637,33 +1637,32 @@ pub trait PrettyPrinter<'tcx>: Printer<'tcx> + fmt::Write {
match ty.kind() {
// Byte strings (&[u8; N])
ty::Ref(_, inner, _) => {
- if let ty::Array(elem, len) = inner.kind() {
- if let ty::Uint(ty::UintTy::U8) = elem.kind() {
- if let ty::ConstKind::Value(_, ty::ValTree::Leaf(int)) = len.kind() {
- match self.tcx().try_get_global_alloc(prov.alloc_id()) {
- Some(GlobalAlloc::Memory(alloc)) => {
- let len = int.to_bits(self.tcx().data_layout.pointer_size);
- let range =
- AllocRange { start: offset, size: Size::from_bytes(len) };
- if let Ok(byte_str) =
- alloc.inner().get_bytes_strip_provenance(&self.tcx(), range)
- {
- p!(pretty_print_byte_str(byte_str))
- } else {
- p!("")
- }
- }
- // FIXME: for statics, vtables, and functions, we could in principle print more detail.
- Some(GlobalAlloc::Static(def_id)) => {
- p!(write("", def_id))
- }
- Some(GlobalAlloc::Function { .. }) => p!(""),
- Some(GlobalAlloc::VTable(..)) => p!(""),
- None => p!(""),
+ if let ty::Array(elem, len) = inner.kind()
+ && let ty::Uint(ty::UintTy::U8) = elem.kind()
+ && let ty::ConstKind::Value(cv) = len.kind()
+ && let ty::ValTree::Leaf(int) = cv.valtree
+ {
+ match self.tcx().try_get_global_alloc(prov.alloc_id()) {
+ Some(GlobalAlloc::Memory(alloc)) => {
+ let len = int.to_bits(self.tcx().data_layout.pointer_size);
+ let range = AllocRange { start: offset, size: Size::from_bytes(len) };
+ if let Ok(byte_str) =
+ alloc.inner().get_bytes_strip_provenance(&self.tcx(), range)
+ {
+ p!(pretty_print_byte_str(byte_str))
+ } else {
+ p!("")
}
- return Ok(());
}
+ // FIXME: for statics, vtables, and functions, we could in principle print more detail.
+ Some(GlobalAlloc::Static(def_id)) => {
+ p!(write("", def_id))
+ }
+ Some(GlobalAlloc::Function { .. }) => p!(""),
+ Some(GlobalAlloc::VTable(..)) => p!(""),
+ None => p!(""),
}
+ return Ok(());
}
}
ty::FnPtr(..) => {
@@ -1786,6 +1785,7 @@ pub trait PrettyPrinter<'tcx>: Printer<'tcx> + fmt::Write {
Ok(())
}
+ // FIXME(valtrees): Accept `ty::Value` instead of `Ty` and `ty::ValTree` separately.
fn pretty_print_const_valtree(
&mut self,
valtree: ty::ValTree<'tcx>,
diff --git a/compiler/rustc_middle/src/ty/structural_impls.rs b/compiler/rustc_middle/src/ty/structural_impls.rs
index 68cb56f3583..9e9de4fb064 100644
--- a/compiler/rustc_middle/src/ty/structural_impls.rs
+++ b/compiler/rustc_middle/src/ty/structural_impls.rs
@@ -162,16 +162,15 @@ impl<'tcx> fmt::Debug for ty::consts::Expr<'tcx> {
impl<'tcx> fmt::Debug for ty::Const<'tcx> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
// If this is a value, we spend some effort to make it look nice.
- if let ConstKind::Value(_, _) = self.kind() {
+ if let ConstKind::Value(_) = self.kind() {
return ty::tls::with(move |tcx| {
- // Somehow trying to lift the valtree results in lifetime errors, so we lift the
- // entire constant.
+ // ValTrees aren't interned, so we lift the entire constant.
let lifted = tcx.lift(*self).unwrap();
- let ConstKind::Value(ty, valtree) = lifted.kind() else {
+ let ConstKind::Value(cv) = lifted.kind() else {
bug!("we checked that this is a valtree")
};
let mut cx = FmtPrinter::new(tcx, Namespace::ValueNS);
- cx.pretty_print_const_valtree(valtree, ty, /*print_ty*/ true)?;
+ cx.pretty_print_const_valtree(cv.valtree, cv.ty, /*print_ty*/ true)?;
f.write_str(&cx.into_buffer())
});
}
@@ -589,9 +588,7 @@ impl<'tcx> TypeSuperFoldable> for ty::Const<'tcx> {
}
ConstKind::Placeholder(p) => ConstKind::Placeholder(p.try_fold_with(folder)?),
ConstKind::Unevaluated(uv) => ConstKind::Unevaluated(uv.try_fold_with(folder)?),
- ConstKind::Value(t, v) => {
- ConstKind::Value(t.try_fold_with(folder)?, v.try_fold_with(folder)?)
- }
+ ConstKind::Value(v) => ConstKind::Value(v.try_fold_with(folder)?),
ConstKind::Error(e) => ConstKind::Error(e.try_fold_with(folder)?),
ConstKind::Expr(e) => ConstKind::Expr(e.try_fold_with(folder)?),
};
@@ -610,10 +607,7 @@ impl<'tcx> TypeSuperVisitable> for ty::Const<'tcx> {
}
ConstKind::Placeholder(p) => p.visit_with(visitor),
ConstKind::Unevaluated(uv) => uv.visit_with(visitor),
- ConstKind::Value(t, v) => {
- try_visit!(t.visit_with(visitor));
- v.visit_with(visitor)
- }
+ ConstKind::Value(v) => v.visit_with(visitor),
ConstKind::Error(e) => e.visit_with(visitor),
ConstKind::Expr(e) => e.visit_with(visitor),
}
diff --git a/compiler/rustc_middle/src/ty/walk.rs b/compiler/rustc_middle/src/ty/walk.rs
index 2dcba8c2f82..3e8a3d1a289 100644
--- a/compiler/rustc_middle/src/ty/walk.rs
+++ b/compiler/rustc_middle/src/ty/walk.rs
@@ -206,7 +206,7 @@ fn push_inner<'tcx>(stack: &mut TypeWalkerStack<'tcx>, parent: GenericArg<'tcx>)
| ty::ConstKind::Bound(..)
| ty::ConstKind::Error(_) => {}
- ty::ConstKind::Value(ty, _) => stack.push(ty.into()),
+ ty::ConstKind::Value(cv) => stack.push(cv.ty.into()),
ty::ConstKind::Expr(expr) => stack.extend(expr.args().iter().rev()),
ty::ConstKind::Unevaluated(ct) => {
diff --git a/compiler/rustc_mir_build/src/thir/pattern/const_to_pat.rs b/compiler/rustc_mir_build/src/thir/pattern/const_to_pat.rs
index 3853b95f78b..cc6d69710e4 100644
--- a/compiler/rustc_mir_build/src/thir/pattern/const_to_pat.rs
+++ b/compiler/rustc_mir_build/src/thir/pattern/const_to_pat.rs
@@ -46,7 +46,7 @@ impl<'a, 'tcx> PatCtxt<'a, 'tcx> {
match c.kind() {
ty::ConstKind::Unevaluated(uv) => convert.unevaluated_to_pat(uv, ty),
- ty::ConstKind::Value(_, val) => convert.valtree_to_pat(val, ty),
+ ty::ConstKind::Value(cv) => convert.valtree_to_pat(cv.valtree, cv.ty),
_ => span_bug!(span, "Invalid `ConstKind` for `const_to_pat`: {:?}", c),
}
}
@@ -214,6 +214,7 @@ impl<'tcx> ConstToPat<'tcx> {
}
// Recursive helper for `to_pat`; invoke that (instead of calling this directly).
+ // FIXME(valtrees): Accept `ty::Value` instead of `Ty` and `ty::ValTree` separately.
#[instrument(skip(self), level = "debug")]
fn valtree_to_pat(&self, cv: ValTree<'tcx>, ty: Ty<'tcx>) -> Box> {
let span = self.span;
diff --git a/compiler/rustc_next_trait_solver/src/canonicalizer.rs b/compiler/rustc_next_trait_solver/src/canonicalizer.rs
index 62a7c84bc28..7eeed721d5a 100644
--- a/compiler/rustc_next_trait_solver/src/canonicalizer.rs
+++ b/compiler/rustc_next_trait_solver/src/canonicalizer.rs
@@ -522,7 +522,7 @@ impl, I: Interner> TypeFolder for Canonicaliz
// FIXME: See comment above -- we could fold the region separately or something.
ty::ConstKind::Bound(_, _)
| ty::ConstKind::Unevaluated(_)
- | ty::ConstKind::Value(_, _)
+ | ty::ConstKind::Value(_)
| ty::ConstKind::Error(_)
| ty::ConstKind::Expr(_) => return c.super_fold_with(self),
};
diff --git a/compiler/rustc_next_trait_solver/src/solve/mod.rs b/compiler/rustc_next_trait_solver/src/solve/mod.rs
index 8d1194ee539..1fa35b60304 100644
--- a/compiler/rustc_next_trait_solver/src/solve/mod.rs
+++ b/compiler/rustc_next_trait_solver/src/solve/mod.rs
@@ -160,9 +160,7 @@ where
ty::ConstKind::Infer(_) => {
self.evaluate_added_goals_and_make_canonical_response(Certainty::AMBIGUOUS)
}
- ty::ConstKind::Placeholder(_)
- | ty::ConstKind::Value(_, _)
- | ty::ConstKind::Error(_) => {
+ ty::ConstKind::Placeholder(_) | ty::ConstKind::Value(_) | ty::ConstKind::Error(_) => {
self.evaluate_added_goals_and_make_canonical_response(Certainty::Yes)
}
// We can freely ICE here as:
@@ -199,7 +197,7 @@ where
unreachable!("`ConstKind::Param` should have been canonicalized to `Placeholder`")
}
ty::ConstKind::Bound(_, _) => panic!("escaping bound vars in {:?}", ct),
- ty::ConstKind::Value(ty, _) => ty,
+ ty::ConstKind::Value(cv) => cv.ty(),
ty::ConstKind::Placeholder(placeholder) => {
self.cx().find_const_ty_from_env(goal.param_env, placeholder)
}
diff --git a/compiler/rustc_parse/src/parser/expr.rs b/compiler/rustc_parse/src/parser/expr.rs
index a5b73ce4098..ffd46f20767 100644
--- a/compiler/rustc_parse/src/parser/expr.rs
+++ b/compiler/rustc_parse/src/parser/expr.rs
@@ -3114,9 +3114,8 @@ impl<'a> Parser<'a> {
let span_before_body = this.prev_token.span;
let arm_body;
let is_fat_arrow = this.check(exp!(FatArrow));
- let is_almost_fat_arrow = TokenKind::FatArrow
- .similar_tokens()
- .is_some_and(|similar_tokens| similar_tokens.contains(&this.token.kind));
+ let is_almost_fat_arrow =
+ TokenKind::FatArrow.similar_tokens().contains(&this.token.kind);
// this avoids the compiler saying that a `,` or `}` was expected even though
// the pattern isn't a never pattern (and thus an arm body is required)
diff --git a/compiler/rustc_parse/src/parser/mod.rs b/compiler/rustc_parse/src/parser/mod.rs
index 714a60cb179..faebb5a40bb 100644
--- a/compiler/rustc_parse/src/parser/mod.rs
+++ b/compiler/rustc_parse/src/parser/mod.rs
@@ -924,10 +924,8 @@ impl<'a> Parser<'a> {
_ => {
// Attempt to keep parsing if it was a similar separator.
- if let Some(tokens) = exp.tok.similar_tokens() {
- if tokens.contains(&self.token.kind) {
- self.bump();
- }
+ if exp.tok.similar_tokens().contains(&self.token.kind) {
+ self.bump();
}
}
}
diff --git a/compiler/rustc_parse_format/src/lib.rs b/compiler/rustc_parse_format/src/lib.rs
index 09c88e7f83b..d021ea107ed 100644
--- a/compiler/rustc_parse_format/src/lib.rs
+++ b/compiler/rustc_parse_format/src/lib.rs
@@ -363,12 +363,7 @@ impl<'a> Parser<'a> {
/// Notifies of an error. The message doesn't actually need to be of type
/// String, but I think it does when this eventually uses conditions so it
/// might as well start using it now.
- fn err, S2: Into>(
- &mut self,
- description: S1,
- label: S2,
- span: InnerSpan,
- ) {
+ fn err(&mut self, description: impl Into, label: impl Into, span: InnerSpan) {
self.errors.push(ParseError {
description: description.into(),
note: None,
@@ -382,11 +377,11 @@ impl<'a> Parser<'a> {
/// Notifies of an error. The message doesn't actually need to be of type
/// String, but I think it does when this eventually uses conditions so it
/// might as well start using it now.
- fn err_with_note, S2: Into, S3: Into>(
+ fn err_with_note(
&mut self,
- description: S1,
- label: S2,
- note: S3,
+ description: impl Into,
+ label: impl Into,
+ note: impl Into,
span: InnerSpan,
) {
self.errors.push(ParseError {
diff --git a/compiler/rustc_sanitizers/src/cfi/typeid/itanium_cxx_abi/encode.rs b/compiler/rustc_sanitizers/src/cfi/typeid/itanium_cxx_abi/encode.rs
index 09648e28df4..5f0c1afdf64 100644
--- a/compiler/rustc_sanitizers/src/cfi/typeid/itanium_cxx_abi/encode.rs
+++ b/compiler/rustc_sanitizers/src/cfi/typeid/itanium_cxx_abi/encode.rs
@@ -103,7 +103,7 @@ fn encode_args<'tcx>(
/// ).
fn encode_const<'tcx>(
tcx: TyCtxt<'tcx>,
- c: Const<'tcx>,
+ ct: Const<'tcx>,
ct_ty: Ty<'tcx>,
dict: &mut FxHashMap, usize>,
options: EncodeTyOptions,
@@ -111,7 +111,7 @@ fn encode_const<'tcx>(
// L[n][]E as literal argument
let mut s = String::from('L');
- match c.kind() {
+ match ct.kind() {
// Const parameters
ty::ConstKind::Param(..) => {
// LE as literal argument
@@ -121,18 +121,18 @@ fn encode_const<'tcx>(
}
// Literal arguments
- ty::ConstKind::Value(ct_ty, ..) => {
+ ty::ConstKind::Value(cv) => {
// L[n]E as literal argument
// Element type
- s.push_str(&encode_ty(tcx, ct_ty, dict, options));
+ s.push_str(&encode_ty(tcx, cv.ty, dict, options));
// The only allowed types of const values are bool, u8, u16, u32,
// u64, u128, usize i8, i16, i32, i64, i128, isize, and char. The
// bool value false is encoded as 0 and true as 1.
- match ct_ty.kind() {
+ match cv.ty.kind() {
ty::Int(ity) => {
- let bits = c
+ let bits = cv
.try_to_bits(tcx, ty::TypingEnv::fully_monomorphized())
.expect("expected monomorphic const in cfi");
let val = Integer::from_int_ty(&tcx, *ity).size().sign_extend(bits) as i128;
@@ -142,30 +142,30 @@ fn encode_const<'tcx>(
let _ = write!(s, "{val}");
}
ty::Uint(_) => {
- let val = c
+ let val = cv
.try_to_bits(tcx, ty::TypingEnv::fully_monomorphized())
.expect("expected monomorphic const in cfi");
let _ = write!(s, "{val}");
}
ty::Bool => {
- let val = c.try_to_bool().expect("expected monomorphic const in cfi");
+ let val = cv.try_to_bool().expect("expected monomorphic const in cfi");
let _ = write!(s, "{val}");
}
_ => {
- bug!("encode_const: unexpected type `{:?}`", ct_ty);
+ bug!("encode_const: unexpected type `{:?}`", cv.ty);
}
}
}
_ => {
- bug!("encode_const: unexpected kind `{:?}`", c.kind());
+ bug!("encode_const: unexpected kind `{:?}`", ct.kind());
}
}
// Close the "L..E" pair
s.push('E');
- compress(dict, DictKey::Const(c), &mut s);
+ compress(dict, DictKey::Const(ct), &mut s);
s
}
diff --git a/compiler/rustc_sanitizers/src/cfi/typeid/itanium_cxx_abi/transform.rs b/compiler/rustc_sanitizers/src/cfi/typeid/itanium_cxx_abi/transform.rs
index 9c6186d6882..b711c238d59 100644
--- a/compiler/rustc_sanitizers/src/cfi/typeid/itanium_cxx_abi/transform.rs
+++ b/compiler/rustc_sanitizers/src/cfi/typeid/itanium_cxx_abi/transform.rs
@@ -51,8 +51,7 @@ impl<'tcx> TypeFolder> for TransformTy<'tcx> {
// Transforms a ty:Ty for being encoded and used in the substitution dictionary.
fn fold_ty(&mut self, t: Ty<'tcx>) -> Ty<'tcx> {
match t.kind() {
- ty::Array(..)
- | ty::Closure(..)
+ ty::Closure(..)
| ty::Coroutine(..)
| ty::CoroutineClosure(..)
| ty::CoroutineWitness(..)
@@ -67,6 +66,13 @@ impl<'tcx> TypeFolder> for TransformTy<'tcx> {
| ty::Tuple(..)
| ty::UnsafeBinder(_) => t.super_fold_with(self),
+ // Don't transform the type of the array length and keep it as `usize`.
+ // This is required for `try_to_target_usize` to work correctly.
+ &ty::Array(inner, len) => {
+ let inner = self.fold_ty(inner);
+ Ty::new_array_with_const_len(self.tcx, inner, len)
+ }
+
ty::Bool => {
if self.options.contains(EncodeTyOptions::NORMALIZE_INTEGERS) {
// Note: on all platforms that Rust's currently supports, its size and alignment
diff --git a/compiler/rustc_session/src/options.rs b/compiler/rustc_session/src/options.rs
index 4ce63825129..c7af40a8ad4 100644
--- a/compiler/rustc_session/src/options.rs
+++ b/compiler/rustc_session/src/options.rs
@@ -1803,6 +1803,7 @@ options! {
"output statistics about monomorphization collection"),
dump_mono_stats_format: DumpMonoStatsFormat = (DumpMonoStatsFormat::Markdown, parse_dump_mono_stats, [UNTRACKED],
"the format to use for -Z dump-mono-stats (`markdown` (default) or `json`)"),
+ #[rustc_lint_opt_deny_field_access("use `Session::dwarf_version` instead of this field")]
dwarf_version: Option = (None, parse_opt_number, [TRACKED],
"version of DWARF debug information to emit (default: 2 or 4, depending on platform)"),
dylib_lto: bool = (false, parse_bool, [UNTRACKED],
diff --git a/compiler/rustc_session/src/session.rs b/compiler/rustc_session/src/session.rs
index 1f03de3f53d..c0f5f0d4a9e 100644
--- a/compiler/rustc_session/src/session.rs
+++ b/compiler/rustc_session/src/session.rs
@@ -732,6 +732,11 @@ impl Session {
self.opts.cg.split_debuginfo.unwrap_or(self.target.split_debuginfo)
}
+ /// Returns the DWARF version passed on the CLI or the default for the target.
+ pub fn dwarf_version(&self) -> u32 {
+ self.opts.unstable_opts.dwarf_version.unwrap_or(self.target.default_dwarf_version)
+ }
+
pub fn stack_protector(&self) -> StackProtector {
if self.target.options.supports_stack_protector {
self.opts.unstable_opts.stack_protector
@@ -1263,8 +1268,7 @@ fn validate_commandline_args_with_session_available(sess: &Session) {
}
if sess.opts.unstable_opts.embed_source {
- let dwarf_version =
- sess.opts.unstable_opts.dwarf_version.unwrap_or(sess.target.default_dwarf_version);
+ let dwarf_version = sess.dwarf_version();
if dwarf_version < 5 {
sess.dcx().emit_warn(errors::EmbedSourceInsufficientDwarfVersion { dwarf_version });
diff --git a/compiler/rustc_smir/src/rustc_smir/context.rs b/compiler/rustc_smir/src/rustc_smir/context.rs
index 31c7e6c3eb4..8d4e55dc036 100644
--- a/compiler/rustc_smir/src/rustc_smir/context.rs
+++ b/compiler/rustc_smir/src/rustc_smir/context.rs
@@ -450,8 +450,9 @@ impl<'tcx> Context for TablesWrapper<'tcx> {
let tcx = tables.tcx;
let ty = ty::Ty::new_static_str(tcx);
let bytes = value.as_bytes();
- let val_tree = ty::ValTree::from_raw_bytes(tcx, bytes);
- let val = tcx.valtree_to_const_val((ty, val_tree));
+ let valtree = ty::ValTree::from_raw_bytes(tcx, bytes);
+ let cv = ty::Value { ty, valtree };
+ let val = tcx.valtree_to_const_val(cv);
mir::Const::from_value(val, ty).stable(&mut tables)
}
diff --git a/compiler/rustc_smir/src/rustc_smir/convert/ty.rs b/compiler/rustc_smir/src/rustc_smir/convert/ty.rs
index ff452eea23d..a2d95f0f693 100644
--- a/compiler/rustc_smir/src/rustc_smir/convert/ty.rs
+++ b/compiler/rustc_smir/src/rustc_smir/convert/ty.rs
@@ -418,23 +418,16 @@ impl<'tcx> Stable<'tcx> for ty::Const<'tcx> {
type T = stable_mir::ty::TyConst;
fn stable(&self, tables: &mut Tables<'_>) -> Self::T {
- let kind = match self.kind() {
- ty::ConstKind::Value(ty, val) => {
- let val = match val {
- ty::ValTree::Leaf(scalar) => ty::ValTree::Leaf(scalar),
- ty::ValTree::Branch(branch) => {
- ty::ValTree::Branch(tables.tcx.lift(branch).unwrap())
- }
- };
-
- let ty = tables.tcx.lift(ty).unwrap();
- let const_val = tables.tcx.valtree_to_const_val((ty, val));
+ let ct = tables.tcx.lift(*self).unwrap();
+ let kind = match ct.kind() {
+ ty::ConstKind::Value(cv) => {
+ let const_val = tables.tcx.valtree_to_const_val(cv);
if matches!(const_val, mir::ConstValue::ZeroSized) {
- stable_mir::ty::TyConstKind::ZSTValue(ty.stable(tables))
+ stable_mir::ty::TyConstKind::ZSTValue(cv.ty.stable(tables))
} else {
stable_mir::ty::TyConstKind::Value(
- ty.stable(tables),
- alloc::new_allocation(ty, const_val, tables),
+ cv.ty.stable(tables),
+ alloc::new_allocation(cv.ty, const_val, tables),
)
}
}
@@ -449,7 +442,7 @@ impl<'tcx> Stable<'tcx> for ty::Const<'tcx> {
ty::ConstKind::Placeholder(_) => unimplemented!(),
ty::ConstKind::Expr(_) => unimplemented!(),
};
- let id = tables.intern_ty_const(tables.tcx.lift(*self).unwrap());
+ let id = tables.intern_ty_const(ct);
stable_mir::ty::TyConst::new(kind, id)
}
}
diff --git a/compiler/rustc_symbol_mangling/src/legacy.rs b/compiler/rustc_symbol_mangling/src/legacy.rs
index 879f3fac21f..8ae35572d01 100644
--- a/compiler/rustc_symbol_mangling/src/legacy.rs
+++ b/compiler/rustc_symbol_mangling/src/legacy.rs
@@ -274,14 +274,15 @@ impl<'tcx> Printer<'tcx> for SymbolPrinter<'tcx> {
fn print_const(&mut self, ct: ty::Const<'tcx>) -> Result<(), PrintError> {
// only print integers
match ct.kind() {
- ty::ConstKind::Value(ty, ty::ValTree::Leaf(scalar)) if ty.is_integral() => {
+ ty::ConstKind::Value(cv) if cv.ty.is_integral() => {
// The `pretty_print_const` formatting depends on -Zverbose-internals
// flag, so we cannot reuse it here.
- let signed = matches!(ty.kind(), ty::Int(_));
+ let scalar = cv.valtree.unwrap_leaf();
+ let signed = matches!(cv.ty.kind(), ty::Int(_));
write!(
self,
"{:#?}",
- ty::ConstInt::new(scalar, signed, ty.is_ptr_sized_integral())
+ ty::ConstInt::new(scalar, signed, cv.ty.is_ptr_sized_integral())
)?;
}
_ => self.write_str("_")?,
diff --git a/compiler/rustc_symbol_mangling/src/v0.rs b/compiler/rustc_symbol_mangling/src/v0.rs
index 4ddf530a00d..5b3272feecd 100644
--- a/compiler/rustc_symbol_mangling/src/v0.rs
+++ b/compiler/rustc_symbol_mangling/src/v0.rs
@@ -590,8 +590,8 @@ impl<'tcx> Printer<'tcx> for SymbolMangler<'tcx> {
fn print_const(&mut self, ct: ty::Const<'tcx>) -> Result<(), PrintError> {
// We only mangle a typed value if the const can be evaluated.
- let (ct_ty, valtree) = match ct.kind() {
- ty::ConstKind::Value(ty, val) => (ty, val),
+ let cv = match ct.kind() {
+ ty::ConstKind::Value(cv) => cv,
// Should only be encountered within the identity-substituted
// impl header of an item nested within an impl item.
@@ -619,13 +619,14 @@ impl<'tcx> Printer<'tcx> for SymbolMangler<'tcx> {
return Ok(());
}
+ let ty::Value { ty: ct_ty, valtree } = cv;
let start = self.out.len();
match ct_ty.kind() {
ty::Uint(_) | ty::Int(_) | ty::Bool | ty::Char => {
ct_ty.print(self)?;
- let mut bits = ct
+ let mut bits = cv
.try_to_bits(self.tcx, ty::TypingEnv::fully_monomorphized())
.expect("expected const to be monomorphic");
diff --git a/compiler/rustc_target/src/spec/json.rs b/compiler/rustc_target/src/spec/json.rs
index 9cdc0801b1f..015ea97f2ac 100644
--- a/compiler/rustc_target/src/spec/json.rs
+++ b/compiler/rustc_target/src/spec/json.rs
@@ -546,6 +546,7 @@ impl Target {
key!(link_env_remove, list);
key!(asm_args, list);
key!(cpu);
+ key!(need_explicit_cpu, bool);
key!(features);
key!(dynamic_linking, bool);
key!(direct_access_external_data, Option);
@@ -720,6 +721,7 @@ impl ToJson for Target {
target_option_val!(link_env_remove);
target_option_val!(asm_args);
target_option_val!(cpu);
+ target_option_val!(need_explicit_cpu);
target_option_val!(features);
target_option_val!(dynamic_linking);
target_option_val!(direct_access_external_data);
diff --git a/compiler/rustc_target/src/spec/mod.rs b/compiler/rustc_target/src/spec/mod.rs
index bcd2aff54bb..3fc7a07fb91 100644
--- a/compiler/rustc_target/src/spec/mod.rs
+++ b/compiler/rustc_target/src/spec/mod.rs
@@ -2254,6 +2254,9 @@ pub struct TargetOptions {
/// Default CPU to pass to LLVM. Corresponds to `llc -mcpu=$cpu`. Defaults
/// to "generic".
pub cpu: StaticCow,
+ /// Whether a cpu needs to be explicitly set.
+ /// Set to true if there is no default cpu. Defaults to false.
+ pub need_explicit_cpu: bool,
/// Default target features to pass to LLVM. These features overwrite
/// `-Ctarget-cpu` but can be overwritten with `-Ctarget-features`.
/// Corresponds to `llc -mattr=$features`.
@@ -2686,6 +2689,7 @@ impl Default for TargetOptions {
link_script: None,
asm_args: cvs![],
cpu: "generic".into(),
+ need_explicit_cpu: false,
features: "".into(),
direct_access_external_data: None,
dynamic_linking: false,
diff --git a/compiler/rustc_trait_selection/src/error_reporting/infer/mod.rs b/compiler/rustc_trait_selection/src/error_reporting/infer/mod.rs
index 9eacd377361..117b6a76425 100644
--- a/compiler/rustc_trait_selection/src/error_reporting/infer/mod.rs
+++ b/compiler/rustc_trait_selection/src/error_reporting/infer/mod.rs
@@ -2023,14 +2023,12 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
_ => None,
};
if let Some(tykind) = tykind
- && let hir::TyKind::Array(_, length) = tykind
- && let Some((scalar, ty)) = sz.found.try_to_scalar()
- && ty == self.tcx.types.usize
+ && let hir::TyKind::Array(_, length_arg) = tykind
+ && let Some(length_val) = sz.found.try_to_target_usize(self.tcx)
{
- let span = length.span();
Some(TypeErrorAdditionalDiags::ConsiderSpecifyingLength {
- span,
- length: scalar.to_target_usize(&self.tcx).unwrap(),
+ span: length_arg.span(),
+ length: length_val,
})
} else {
None
diff --git a/compiler/rustc_trait_selection/src/regions.rs b/compiler/rustc_trait_selection/src/regions.rs
index 863b6e293ff..55171754618 100644
--- a/compiler/rustc_trait_selection/src/regions.rs
+++ b/compiler/rustc_trait_selection/src/regions.rs
@@ -1,10 +1,73 @@
+use rustc_hir::def_id::LocalDefId;
use rustc_infer::infer::outlives::env::OutlivesEnvironment;
use rustc_infer::infer::{InferCtxt, RegionResolutionError};
use rustc_macros::extension;
use rustc_middle::traits::ObligationCause;
use rustc_middle::traits::query::NoSolution;
+use rustc_middle::ty::{self, Ty};
use crate::traits::ScrubbedTraitError;
+use crate::traits::outlives_bounds::InferCtxtExt;
+
+#[extension(pub trait OutlivesEnvironmentBuildExt<'tcx>)]
+impl<'tcx> OutlivesEnvironment<'tcx> {
+ fn new(
+ infcx: &InferCtxt<'tcx>,
+ body_id: LocalDefId,
+ param_env: ty::ParamEnv<'tcx>,
+ assumed_wf_tys: impl IntoIterator>,
+ ) -> Self {
+ Self::new_with_implied_bounds_compat(
+ infcx,
+ body_id,
+ param_env,
+ assumed_wf_tys,
+ !infcx.tcx.sess.opts.unstable_opts.no_implied_bounds_compat,
+ )
+ }
+
+ fn new_with_implied_bounds_compat(
+ infcx: &InferCtxt<'tcx>,
+ body_id: LocalDefId,
+ param_env: ty::ParamEnv<'tcx>,
+ assumed_wf_tys: impl IntoIterator>,
+ implied_bounds_compat: bool,
+ ) -> Self {
+ let mut bounds = vec![];
+
+ for bound in param_env.caller_bounds() {
+ if let Some(mut type_outlives) = bound.as_type_outlives_clause() {
+ if infcx.next_trait_solver() {
+ match crate::solve::deeply_normalize::<_, ScrubbedTraitError<'tcx>>(
+ infcx.at(&ObligationCause::dummy(), param_env),
+ type_outlives,
+ ) {
+ Ok(new) => type_outlives = new,
+ Err(_) => {
+ infcx.dcx().delayed_bug(format!("could not normalize `{bound}`"));
+ }
+ }
+ }
+ bounds.push(type_outlives);
+ }
+ }
+
+ // FIXME: This needs to be modified so that we normalize the known type
+ // outlives obligations then elaborate them into their region/type components.
+ // Otherwise, ` as Mirror>::Assoc: 'b` will not imply `'a: 'b` even
+ // if we can normalize `'a`.
+ OutlivesEnvironment::from_normalized_bounds(
+ param_env,
+ bounds,
+ infcx.implied_bounds_tys_with_compat(
+ body_id,
+ param_env,
+ assumed_wf_tys,
+ implied_bounds_compat,
+ ),
+ )
+ }
+}
#[extension(pub trait InferCtxtRegionExt<'tcx>)]
impl<'tcx> InferCtxt<'tcx> {
@@ -15,10 +78,25 @@ impl<'tcx> InferCtxt<'tcx> {
/// Prefer this method over `resolve_regions_with_normalize`, unless you are
/// doing something specific for normalization.
fn resolve_regions(
+ &self,
+ body_id: LocalDefId,
+ param_env: ty::ParamEnv<'tcx>,
+ assumed_wf_tys: impl IntoIterator>,
+ ) -> Vec> {
+ self.resolve_regions_with_outlives_env(&OutlivesEnvironment::new(
+ self,
+ body_id,
+ param_env,
+ assumed_wf_tys,
+ ))
+ }
+
+ /// Don't call this directly unless you know what you're doing.
+ fn resolve_regions_with_outlives_env(
&self,
outlives_env: &OutlivesEnvironment<'tcx>,
) -> Vec> {
- self.resolve_regions_with_normalize(outlives_env, |ty, origin| {
+ self.resolve_regions_with_normalize(&outlives_env, |ty, origin| {
let ty = self.resolve_vars_if_possible(ty);
if self.next_trait_solver() {
diff --git a/compiler/rustc_trait_selection/src/solve/fulfill.rs b/compiler/rustc_trait_selection/src/solve/fulfill.rs
index 2b7da4bc5ff..c8ae977b5ad 100644
--- a/compiler/rustc_trait_selection/src/solve/fulfill.rs
+++ b/compiler/rustc_trait_selection/src/solve/fulfill.rs
@@ -264,7 +264,7 @@ fn fulfillment_error_for_no_solution<'tcx>(
infcx.tcx.type_of(uv.def).instantiate(infcx.tcx, uv.args)
}
ty::ConstKind::Param(param_ct) => param_ct.find_ty_from_env(obligation.param_env),
- ty::ConstKind::Value(ty, _) => ty,
+ ty::ConstKind::Value(cv) => cv.ty,
kind => span_bug!(
obligation.cause.span,
"ConstArgHasWrongType failed but we don't know how to compute type for {kind:?}"
diff --git a/compiler/rustc_trait_selection/src/traits/auto_trait.rs b/compiler/rustc_trait_selection/src/traits/auto_trait.rs
index 9a53e8a5d51..1fca2f4da7e 100644
--- a/compiler/rustc_trait_selection/src/traits/auto_trait.rs
+++ b/compiler/rustc_trait_selection/src/traits/auto_trait.rs
@@ -6,6 +6,7 @@ use std::iter;
use rustc_data_structures::fx::{FxIndexMap, FxIndexSet, IndexEntry};
use rustc_data_structures::unord::UnordSet;
+use rustc_hir::def_id::CRATE_DEF_ID;
use rustc_infer::infer::DefineOpaqueTypes;
use rustc_middle::ty::{Region, RegionVid};
use tracing::debug;
@@ -13,6 +14,7 @@ use tracing::debug;
use super::*;
use crate::errors::UnableToConstructConstantValue;
use crate::infer::region_constraints::{Constraint, RegionConstraintData};
+use crate::regions::OutlivesEnvironmentBuildExt;
use crate::traits::project::ProjectAndUnifyResult;
// FIXME(twk): this is obviously not nice to duplicate like that
@@ -158,7 +160,7 @@ impl<'tcx> AutoTraitFinder<'tcx> {
panic!("Unable to fulfill trait {trait_did:?} for '{ty:?}': {errors:?}");
}
- let outlives_env = OutlivesEnvironment::new(full_env);
+ let outlives_env = OutlivesEnvironment::new(&infcx, CRATE_DEF_ID, full_env, []);
let _ = infcx.process_registered_region_obligations(&outlives_env, |ty, _| Ok(ty));
let region_data = infcx.inner.borrow_mut().unwrap_region_constraints().data().clone();
diff --git a/compiler/rustc_trait_selection/src/traits/coherence.rs b/compiler/rustc_trait_selection/src/traits/coherence.rs
index 50d47d20e1a..7ee9eb45309 100644
--- a/compiler/rustc_trait_selection/src/traits/coherence.rs
+++ b/compiler/rustc_trait_selection/src/traits/coherence.rs
@@ -9,7 +9,7 @@ use std::fmt::Debug;
use rustc_data_structures::fx::{FxHashSet, FxIndexSet};
use rustc_errors::{Diag, EmissionGuarantee};
use rustc_hir::def::DefKind;
-use rustc_hir::def_id::DefId;
+use rustc_hir::def_id::{CRATE_DEF_ID, DefId};
use rustc_infer::infer::{DefineOpaqueTypes, InferCtxt, TyCtxtInferExt};
use rustc_infer::traits::PredicateObligations;
use rustc_middle::bug;
@@ -27,7 +27,6 @@ use tracing::{debug, instrument, warn};
use super::ObligationCtxt;
use crate::error_reporting::traits::suggest_new_overflow_limit;
use crate::infer::InferOk;
-use crate::infer::outlives::env::OutlivesEnvironment;
use crate::solve::inspect::{InspectGoal, ProofTreeInferCtxtExt, ProofTreeVisitor};
use crate::solve::{SolverDelegate, deeply_normalize_for_diagnostics, inspect};
use crate::traits::query::evaluate_obligation::InferCtxtExt;
@@ -596,8 +595,7 @@ fn try_prove_negated_where_clause<'tcx>(
// FIXME: We could use the assumed_wf_types from both impls, I think,
// if that wasn't implemented just for LocalDefId, and we'd need to do
// the normalization ourselves since this is totally fallible...
- let outlives_env = OutlivesEnvironment::new(param_env);
- let errors = ocx.resolve_regions(&outlives_env);
+ let errors = ocx.resolve_regions(CRATE_DEF_ID, param_env, []);
if !errors.is_empty() {
return false;
}
diff --git a/compiler/rustc_trait_selection/src/traits/const_evaluatable.rs b/compiler/rustc_trait_selection/src/traits/const_evaluatable.rs
index 446f9eaa348..bdee6ca2afe 100644
--- a/compiler/rustc_trait_selection/src/traits/const_evaluatable.rs
+++ b/compiler/rustc_trait_selection/src/traits/const_evaluatable.rs
@@ -35,7 +35,7 @@ pub fn is_const_evaluatable<'tcx>(
ty::ConstKind::Param(_)
| ty::ConstKind::Bound(_, _)
| ty::ConstKind::Placeholder(_)
- | ty::ConstKind::Value(_, _)
+ | ty::ConstKind::Value(_)
| ty::ConstKind::Error(_) => return Ok(()),
ty::ConstKind::Infer(_) => return Err(NotConstEvaluatable::MentionsInfer),
};
diff --git a/compiler/rustc_trait_selection/src/traits/engine.rs b/compiler/rustc_trait_selection/src/traits/engine.rs
index 4a3983fca31..9f3178f8879 100644
--- a/compiler/rustc_trait_selection/src/traits/engine.rs
+++ b/compiler/rustc_trait_selection/src/traits/engine.rs
@@ -8,7 +8,6 @@ use rustc_infer::infer::at::ToTrace;
use rustc_infer::infer::canonical::{
Canonical, CanonicalQueryResponse, CanonicalVarValues, QueryResponse,
};
-use rustc_infer::infer::outlives::env::OutlivesEnvironment;
use rustc_infer::infer::{DefineOpaqueTypes, InferCtxt, InferOk, RegionResolutionError, TypeTrace};
use rustc_infer::traits::PredicateObligations;
use rustc_macros::extension;
@@ -217,14 +216,15 @@ where
/// will result in region constraints getting ignored.
pub fn resolve_regions_and_report_errors(
self,
- generic_param_scope: LocalDefId,
- outlives_env: &OutlivesEnvironment<'tcx>,
+ body_id: LocalDefId,
+ param_env: ty::ParamEnv<'tcx>,
+ assumed_wf_tys: impl IntoIterator>,
) -> Result<(), ErrorGuaranteed> {
- let errors = self.infcx.resolve_regions(outlives_env);
+ let errors = self.infcx.resolve_regions(body_id, param_env, assumed_wf_tys);
if errors.is_empty() {
Ok(())
} else {
- Err(self.infcx.err_ctxt().report_region_errors(generic_param_scope, &errors))
+ Err(self.infcx.err_ctxt().report_region_errors(body_id, &errors))
}
}
@@ -235,9 +235,11 @@ where
#[must_use]
pub fn resolve_regions(
self,
- outlives_env: &OutlivesEnvironment<'tcx>,
+ body_id: LocalDefId,
+ param_env: ty::ParamEnv<'tcx>,
+ assumed_wf_tys: impl IntoIterator>,
) -> Vec> {
- self.infcx.resolve_regions(outlives_env)
+ self.infcx.resolve_regions(body_id, param_env, assumed_wf_tys)
}
}
diff --git a/compiler/rustc_trait_selection/src/traits/fulfill.rs b/compiler/rustc_trait_selection/src/traits/fulfill.rs
index 7529ee128f5..f2d2dd2f3ce 100644
--- a/compiler/rustc_trait_selection/src/traits/fulfill.rs
+++ b/compiler/rustc_trait_selection/src/traits/fulfill.rs
@@ -479,7 +479,7 @@ impl<'a, 'tcx> ObligationProcessor for FulfillProcessor<'a, 'tcx> {
ty::ConstKind::Error(_) => {
return ProcessResult::Changed(PendingPredicateObligations::new());
}
- ty::ConstKind::Value(ty, _) => ty,
+ ty::ConstKind::Value(cv) => cv.ty,
ty::ConstKind::Unevaluated(uv) => {
infcx.tcx.type_of(uv.def).instantiate(infcx.tcx, uv.args)
}
diff --git a/compiler/rustc_trait_selection/src/traits/misc.rs b/compiler/rustc_trait_selection/src/traits/misc.rs
index 7a67b943e94..79e178150de 100644
--- a/compiler/rustc_trait_selection/src/traits/misc.rs
+++ b/compiler/rustc_trait_selection/src/traits/misc.rs
@@ -4,13 +4,10 @@ use std::assert_matches::assert_matches;
use hir::LangItem;
use rustc_ast::Mutability;
-use rustc_data_structures::fx::FxIndexSet;
use rustc_hir as hir;
-use rustc_infer::infer::outlives::env::OutlivesEnvironment;
use rustc_infer::infer::{RegionResolutionError, TyCtxtInferExt};
use rustc_middle::ty::{self, AdtDef, Ty, TyCtxt, TypeVisitableExt, TypingMode};
-use super::outlives_bounds::InferCtxtExt;
use crate::regions::InferCtxtRegionExt;
use crate::traits::{self, FulfillmentError, ObligationCause};
@@ -170,15 +167,7 @@ pub fn type_allowed_to_implement_const_param_ty<'tcx>(
}
// Check regions assuming the self type of the impl is WF
- let outlives_env = OutlivesEnvironment::with_bounds(
- param_env,
- infcx.implied_bounds_tys(
- param_env,
- parent_cause.body_id,
- &FxIndexSet::from_iter([self_type]),
- ),
- );
- let errors = infcx.resolve_regions(&outlives_env);
+ let errors = infcx.resolve_regions(parent_cause.body_id, param_env, [self_type]);
if !errors.is_empty() {
infringing_inner_tys.push((inner_ty, InfringingFieldsReason::Regions(errors)));
continue;
@@ -261,15 +250,7 @@ pub fn all_fields_implement_trait<'tcx>(
}
// Check regions assuming the self type of the impl is WF
- let outlives_env = OutlivesEnvironment::with_bounds(
- param_env,
- infcx.implied_bounds_tys(
- param_env,
- parent_cause.body_id,
- &FxIndexSet::from_iter([self_type]),
- ),
- );
- let errors = infcx.resolve_regions(&outlives_env);
+ let errors = infcx.resolve_regions(parent_cause.body_id, param_env, [self_type]);
if !errors.is_empty() {
infringing.push((field, ty, InfringingFieldsReason::Regions(errors)));
}
diff --git a/compiler/rustc_trait_selection/src/traits/mod.rs b/compiler/rustc_trait_selection/src/traits/mod.rs
index fe5ad003a7e..6b5ebade6ae 100644
--- a/compiler/rustc_trait_selection/src/traits/mod.rs
+++ b/compiler/rustc_trait_selection/src/traits/mod.rs
@@ -290,12 +290,10 @@ fn do_normalize_predicates<'tcx>(
// We can use the `elaborated_env` here; the region code only
// cares about declarations like `'a: 'b`.
- let outlives_env = OutlivesEnvironment::new(elaborated_env);
-
// FIXME: It's very weird that we ignore region obligations but apparently
// still need to use `resolve_regions` as we need the resolved regions in
// the normalized predicates.
- let errors = infcx.resolve_regions(&outlives_env);
+ let errors = infcx.resolve_regions(cause.body_id, elaborated_env, []);
if !errors.is_empty() {
tcx.dcx().span_delayed_bug(
span,
diff --git a/compiler/rustc_trait_selection/src/traits/outlives_bounds.rs b/compiler/rustc_trait_selection/src/traits/outlives_bounds.rs
index 23dabe32ff2..18932695807 100644
--- a/compiler/rustc_trait_selection/src/traits/outlives_bounds.rs
+++ b/compiler/rustc_trait_selection/src/traits/outlives_bounds.rs
@@ -1,4 +1,3 @@
-use rustc_data_structures::fx::FxIndexSet;
use rustc_infer::infer::InferOk;
use rustc_infer::infer::resolve::OpportunisticRegionResolver;
use rustc_infer::traits::query::type_op::ImpliedOutlivesBounds;
@@ -12,9 +11,6 @@ use tracing::instrument;
use crate::infer::InferCtxt;
use crate::traits::{ObligationCause, ObligationCtxt};
-pub type BoundsCompat<'a, 'tcx: 'a> = impl Iterator> + 'a;
-pub type Bounds<'a, 'tcx: 'a> = impl Iterator> + 'a;
-
/// Implied bounds are region relationships that we deduce
/// automatically. The idea is that (e.g.) a caller must check that a
/// function's argument types are well-formed immediately before
@@ -110,36 +106,18 @@ fn implied_outlives_bounds<'a, 'tcx>(
bounds
}
-#[extension(pub trait InferCtxtExt<'a, 'tcx>)]
-impl<'a, 'tcx: 'a> InferCtxt<'tcx> {
- /// Do *NOT* call this directly.
- fn implied_bounds_tys_compat(
- &'a self,
- param_env: ParamEnv<'tcx>,
+#[extension(pub trait InferCtxtExt<'tcx>)]
+impl<'tcx> InferCtxt<'tcx> {
+ /// Do *NOT* call this directly. You probably want to construct a `OutlivesEnvironment`
+ /// instead if you're interested in the implied bounds for a given signature.
+ fn implied_bounds_tys_with_compat>>(
+ &self,
body_id: LocalDefId,
- tys: &'a FxIndexSet>,
+ param_env: ParamEnv<'tcx>,
+ tys: Tys,
compat: bool,
- ) -> BoundsCompat<'a, 'tcx> {
- tys.iter()
- .flat_map(move |ty| implied_outlives_bounds(self, param_env, body_id, *ty, compat))
- }
-
- /// If `-Z no-implied-bounds-compat` is set, calls `implied_bounds_tys_compat`
- /// with `compat` set to `true`, otherwise `false`.
- fn implied_bounds_tys(
- &'a self,
- param_env: ParamEnv<'tcx>,
- body_id: LocalDefId,
- tys: &'a FxIndexSet>,
- ) -> Bounds<'a, 'tcx> {
- tys.iter().flat_map(move |ty| {
- implied_outlives_bounds(
- self,
- param_env,
- body_id,
- *ty,
- !self.tcx.sess.opts.unstable_opts.no_implied_bounds_compat,
- )
- })
+ ) -> impl Iterator> {
+ tys.into_iter()
+ .flat_map(move |ty| implied_outlives_bounds(self, param_env, body_id, ty, compat))
}
}
diff --git a/compiler/rustc_trait_selection/src/traits/select/mod.rs b/compiler/rustc_trait_selection/src/traits/select/mod.rs
index 6b6e0b32385..99ce1fd9fb4 100644
--- a/compiler/rustc_trait_selection/src/traits/select/mod.rs
+++ b/compiler/rustc_trait_selection/src/traits/select/mod.rs
@@ -962,7 +962,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
return Ok(EvaluatedToAmbig);
}
ty::ConstKind::Error(_) => return Ok(EvaluatedToOk),
- ty::ConstKind::Value(ty, _) => ty,
+ ty::ConstKind::Value(cv) => cv.ty,
ty::ConstKind::Unevaluated(uv) => {
self.tcx().type_of(uv.def).instantiate(self.tcx(), uv.args)
}
diff --git a/compiler/rustc_transmute/src/lib.rs b/compiler/rustc_transmute/src/lib.rs
index ad86813c87e..a50cc8f5932 100644
--- a/compiler/rustc_transmute/src/lib.rs
+++ b/compiler/rustc_transmute/src/lib.rs
@@ -128,16 +128,16 @@ mod rustc {
pub fn from_const<'tcx>(
tcx: TyCtxt<'tcx>,
param_env: ParamEnv<'tcx>,
- c: Const<'tcx>,
+ ct: Const<'tcx>,
) -> Option {
use rustc_middle::ty::ScalarInt;
use rustc_span::sym;
- let Some((cv, ty)) = c.try_to_valtree() else {
+ let Some(cv) = ct.try_to_value() else {
return None;
};
- let adt_def = ty.ty_adt_def()?;
+ let adt_def = cv.ty.ty_adt_def()?;
assert_eq!(
tcx.require_lang_item(LangItem::TransmuteOpts, None),
@@ -147,7 +147,7 @@ mod rustc {
);
let variant = adt_def.non_enum_variant();
- let fields = match cv {
+ let fields = match cv.valtree {
ValTree::Branch(branch) => branch,
_ => {
return Some(Self {
diff --git a/compiler/rustc_ty_utils/src/consts.rs b/compiler/rustc_ty_utils/src/consts.rs
index 51a7c976f60..931c36137ee 100644
--- a/compiler/rustc_ty_utils/src/consts.rs
+++ b/compiler/rustc_ty_utils/src/consts.rs
@@ -22,16 +22,16 @@ fn destructure_const<'tcx>(
tcx: TyCtxt<'tcx>,
const_: ty::Const<'tcx>,
) -> ty::DestructuredConst<'tcx> {
- let ty::ConstKind::Value(ct_ty, valtree) = const_.kind() else {
+ let ty::ConstKind::Value(cv) = const_.kind() else {
bug!("cannot destructure constant {:?}", const_)
};
- let branches = match valtree {
+ let branches = match cv.valtree {
ty::ValTree::Branch(b) => b,
_ => bug!("cannot destructure constant {:?}", const_),
};
- let (fields, variant) = match ct_ty.kind() {
+ let (fields, variant) = match cv.ty.kind() {
ty::Array(inner_ty, _) | ty::Slice(inner_ty) => {
// construct the consts for the elements of the array/slice
let field_consts = branches
diff --git a/compiler/rustc_ty_utils/src/layout.rs b/compiler/rustc_ty_utils/src/layout.rs
index a04c7536118..2f258b23f2d 100644
--- a/compiler/rustc_ty_utils/src/layout.rs
+++ b/compiler/rustc_ty_utils/src/layout.rs
@@ -144,13 +144,13 @@ fn univariant_uninterned<'tcx>(
cx.calc.univariant(fields, repr, kind).map_err(|err| map_error(cx, ty, err))
}
-fn validate_const_with_value<'tcx>(
+fn extract_const_value<'tcx>(
const_: ty::Const<'tcx>,
ty: Ty<'tcx>,
cx: &LayoutCx<'tcx>,
-) -> Result, &'tcx LayoutError<'tcx>> {
+) -> Result, &'tcx LayoutError<'tcx>> {
match const_.kind() {
- ty::ConstKind::Value(..) => Ok(const_),
+ ty::ConstKind::Value(cv) => Ok(cv),
ty::ConstKind::Error(guar) => {
return Err(error(cx, LayoutError::ReferencesError(guar)));
}
@@ -209,13 +209,12 @@ fn layout_of_uncached<'tcx>(
&mut layout.backend_repr
{
if let Some(start) = start {
- scalar.valid_range_mut().start =
- validate_const_with_value(start, ty, cx)?
- .try_to_bits(tcx, cx.typing_env)
- .ok_or_else(|| error(cx, LayoutError::Unknown(ty)))?;
+ scalar.valid_range_mut().start = extract_const_value(start, ty, cx)?
+ .try_to_bits(tcx, cx.typing_env)
+ .ok_or_else(|| error(cx, LayoutError::Unknown(ty)))?;
}
if let Some(end) = end {
- let mut end = validate_const_with_value(end, ty, cx)?
+ let mut end = extract_const_value(end, ty, cx)?
.try_to_bits(tcx, cx.typing_env)
.ok_or_else(|| error(cx, LayoutError::Unknown(ty)))?;
if !include_end {
@@ -348,9 +347,7 @@ fn layout_of_uncached<'tcx>(
// Arrays and slices.
ty::Array(element, count) => {
- let count = validate_const_with_value(count, ty, cx)?
- .to_valtree()
- .0
+ let count = extract_const_value(count, ty, cx)?
.try_to_target_usize(tcx)
.ok_or_else(|| error(cx, LayoutError::Unknown(ty)))?;
diff --git a/compiler/rustc_type_ir/src/const_kind.rs b/compiler/rustc_type_ir/src/const_kind.rs
index 03dfe547ced..aafc0907ae1 100644
--- a/compiler/rustc_type_ir/src/const_kind.rs
+++ b/compiler/rustc_type_ir/src/const_kind.rs
@@ -31,7 +31,7 @@ pub enum ConstKind {
Unevaluated(ty::UnevaluatedConst),
/// Used to hold computed value.
- Value(I::Ty, I::ValueConst),
+ Value(I::ValueConst),
/// A placeholder for a const which could not be computed; this is
/// propagated to avoid useless error messages.
@@ -52,7 +52,7 @@ impl fmt::Debug for ConstKind {
Bound(debruijn, var) => crate::debug_bound_var(f, *debruijn, var),
Placeholder(placeholder) => write!(f, "{placeholder:?}"),
Unevaluated(uv) => write!(f, "{uv:?}"),
- Value(ty, valtree) => write!(f, "({valtree:?}: {ty:?})"),
+ Value(val) => write!(f, "{val:?}"),
Error(_) => write!(f, "{{const error}}"),
Expr(expr) => write!(f, "{expr:?}"),
}
diff --git a/compiler/rustc_type_ir/src/fast_reject.rs b/compiler/rustc_type_ir/src/fast_reject.rs
index 9b3ff14d507..9955e92b55a 100644
--- a/compiler/rustc_type_ir/src/fast_reject.rs
+++ b/compiler/rustc_type_ir/src/fast_reject.rs
@@ -483,8 +483,8 @@ impl match rhs.kind() {
- ty::ConstKind::Value(_, rhs_val) => lhs_val == rhs_val,
+ ty::ConstKind::Value(lhs_val) => match rhs.kind() {
+ ty::ConstKind::Value(rhs_val) => lhs_val.valtree() == rhs_val.valtree(),
_ => false,
},
diff --git a/compiler/rustc_type_ir/src/inherent.rs b/compiler/rustc_type_ir/src/inherent.rs
index 872cf668018..4e6d645e6fa 100644
--- a/compiler/rustc_type_ir/src/inherent.rs
+++ b/compiler/rustc_type_ir/src/inherent.rs
@@ -286,6 +286,11 @@ pub trait Const>:
}
}
+pub trait ValueConst>: Copy + Debug + Hash + Eq {
+ fn ty(self) -> I::Ty;
+ fn valtree(self) -> I::ValTree;
+}
+
pub trait ExprConst>: Copy + Debug + Hash + Eq + Relate {
fn args(self) -> I::GenericArgs;
}
diff --git a/compiler/rustc_type_ir/src/interner.rs b/compiler/rustc_type_ir/src/interner.rs
index 0c3b0758f0f..a6c72da0c56 100644
--- a/compiler/rustc_type_ir/src/interner.rs
+++ b/compiler/rustc_type_ir/src/interner.rs
@@ -112,8 +112,9 @@ pub trait Interner:
type PlaceholderConst: PlaceholderLike;
type ParamConst: Copy + Debug + Hash + Eq + ParamLike;
type BoundConst: Copy + Debug + Hash + Eq + BoundVarLike;
- type ValueConst: Copy + Debug + Hash + Eq;
+ type ValueConst: ValueConst;
type ExprConst: ExprConst;
+ type ValTree: Copy + Debug + Hash + Eq;
// Kinds of regions
type Region: Region;
diff --git a/compiler/rustc_type_ir/src/relate.rs b/compiler/rustc_type_ir/src/relate.rs
index e628b66d2f0..5b696ee5ed4 100644
--- a/compiler/rustc_type_ir/src/relate.rs
+++ b/compiler/rustc_type_ir/src/relate.rs
@@ -606,7 +606,9 @@ pub fn structurally_relate_consts>(
true
}
(ty::ConstKind::Placeholder(p1), ty::ConstKind::Placeholder(p2)) => p1 == p2,
- (ty::ConstKind::Value(_, a_val), ty::ConstKind::Value(_, b_val)) => a_val == b_val,
+ (ty::ConstKind::Value(a_val), ty::ConstKind::Value(b_val)) => {
+ a_val.valtree() == b_val.valtree()
+ }
// While this is slightly incorrect, it shouldn't matter for `min_const_generics`
// and is the better alternative to waiting until `generic_const_exprs` can
diff --git a/library/alloc/src/collections/btree/node.rs b/library/alloc/src/collections/btree/node.rs
index 6815ac1c193..37f784a322c 100644
--- a/library/alloc/src/collections/btree/node.rs
+++ b/library/alloc/src/collections/btree/node.rs
@@ -600,8 +600,8 @@ impl NodeRef {
/// no cleanup is done on any of the keys, values and other children.
/// This decreases the height by 1 and is the opposite of `push_internal_level`.
///
- /// Requires exclusive access to the `NodeRef` object but not to the root node;
- /// it will not invalidate other handles or references to the root node.
+ /// Does not invalidate any handles or references pointing into the subtree
+ /// rooted at the first child of `self`.
///
/// Panics if there is no internal level, i.e., if the root node is a leaf.
pub(super) fn pop_internal_level(&mut self, alloc: A) {
diff --git a/library/core/src/alloc/mod.rs b/library/core/src/alloc/mod.rs
index aa841db045c..dcab6136ae8 100644
--- a/library/core/src/alloc/mod.rs
+++ b/library/core/src/alloc/mod.rs
@@ -49,26 +49,26 @@ impl fmt::Display for AllocError {
/// An implementation of `Allocator` can allocate, grow, shrink, and deallocate arbitrary blocks of
/// data described via [`Layout`][].
///
-/// `Allocator` is designed to be implemented on ZSTs, references, or smart pointers because having
-/// an allocator like `MyAlloc([u8; N])` cannot be moved, without updating the pointers to the
+/// `Allocator` is designed to be implemented on ZSTs, references, or smart pointers.
+/// An allocator for `MyAlloc([u8; N])` cannot be moved, without updating the pointers to the
/// allocated memory.
///
-/// Unlike [`GlobalAlloc`][], zero-sized allocations are allowed in `Allocator`. If an underlying
-/// allocator does not support this (like jemalloc) or return a null pointer (such as
-/// `libc::malloc`), this must be caught by the implementation.
+/// In contrast to [`GlobalAlloc`][], `Allocator` allows zero-sized allocations. If an underlying
+/// allocator does not support this (like jemalloc) or responds by returning a null pointer
+/// (such as `libc::malloc`), this must be caught by the implementation.
///
/// ### Currently allocated memory
///
-/// Some of the methods require that a memory block be *currently allocated* via an allocator. This
-/// means that:
+/// Some of the methods require that a memory block is *currently allocated* by an allocator.
+/// This means that:
+/// * the starting address for that memory block was previously
+/// returned by [`allocate`], [`grow`], or [`shrink`], and
+/// * the memory block has not subsequently been deallocated.
///
-/// * the starting address for that memory block was previously returned by [`allocate`], [`grow`], or
-/// [`shrink`], and
-///
-/// * the memory block has not been subsequently deallocated, where blocks are either deallocated
-/// directly by being passed to [`deallocate`] or were changed by being passed to [`grow`] or
-/// [`shrink`] that returns `Ok`. If `grow` or `shrink` have returned `Err`, the passed pointer
-/// remains valid.
+/// A memory block is deallocated by a call to [`deallocate`],
+/// or by a call to [`grow`] or [`shrink`] that returns `Ok`.
+/// A call to `grow` or `shrink` that returns `Err`,
+/// does not deallocate the memory block passed to it.
///
/// [`allocate`]: Allocator::allocate
/// [`grow`]: Allocator::grow
@@ -77,32 +77,28 @@ impl fmt::Display for AllocError {
///
/// ### Memory fitting
///
-/// Some of the methods require that a layout *fit* a memory block. What it means for a layout to
-/// "fit" a memory block means (or equivalently, for a memory block to "fit" a layout) is that the
+/// Some of the methods require that a `layout` *fit* a memory block or vice versa. This means that the
/// following conditions must hold:
-///
-/// * The block must be allocated with the same alignment as [`layout.align()`], and
-///
-/// * The provided [`layout.size()`] must fall in the range `min ..= max`, where:
-/// - `min` is the size of the layout most recently used to allocate the block, and
-/// - `max` is the latest actual size returned from [`allocate`], [`grow`], or [`shrink`].
+/// * the memory block must be *currently allocated* with alignment of [`layout.align()`], and
+/// * [`layout.size()`] must fall in the range `min ..= max`, where:
+/// - `min` is the size of the layout used to allocate the block, and
+/// - `max` is the actual size returned from [`allocate`], [`grow`], or [`shrink`].
///
/// [`layout.align()`]: Layout::align
/// [`layout.size()`]: Layout::size
///
/// # Safety
///
-/// * Memory blocks returned from an allocator that are [*currently allocated*] must point to
-/// valid memory and retain their validity while they are [*currently allocated*] and the shorter
-/// of:
-/// - the borrow-checker lifetime of the allocator type itself.
-/// - as long as at least one of the instance and all of its clones has not been dropped.
+/// Memory blocks that are [*currently allocated*] by an allocator,
+/// must point to valid memory, and retain their validity while until either:
+/// - the memory block is deallocated, or
+/// - the allocator is dropped.
///
-/// * copying, cloning, or moving the allocator must not invalidate memory blocks returned from this
-/// allocator. A copied or cloned allocator must behave like the same allocator, and
+/// Copying, cloning, or moving the allocator must not invalidate memory blocks returned from it
+/// A copied or cloned allocator must behave like the original allocator.
///
-/// * any pointer to a memory block which is [*currently allocated*] may be passed to any other
-/// method of the allocator.
+/// A memory block which is [*currently allocated*] may be passed to
+/// any method of the allocator that accepts such an argument.
///
/// [*currently allocated*]: #currently-allocated-memory
#[unstable(feature = "allocator_api", issue = "32838")]
diff --git a/library/core/src/mem/maybe_uninit.rs b/library/core/src/mem/maybe_uninit.rs
index ac5307a671d..0d8c3ef906b 100644
--- a/library/core/src/mem/maybe_uninit.rs
+++ b/library/core/src/mem/maybe_uninit.rs
@@ -276,10 +276,9 @@ impl Clone for MaybeUninit {
impl fmt::Debug for MaybeUninit {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
// NB: there is no `.pad_fmt` so we can't use a simpler `format_args!("MaybeUninit<{..}>").
- // This needs to be adjusted if `MaybeUninit` moves modules.
let full_name = type_name::();
- let short_name = full_name.split_once("mem::maybe_uninit::").unwrap().1;
- f.pad(short_name)
+ let prefix_len = full_name.find("MaybeUninit").unwrap();
+ f.pad(&full_name[prefix_len..])
}
}
diff --git a/library/core/src/num/mod.rs b/library/core/src/num/mod.rs
index 6c1b568e231..55f4ccd958e 100644
--- a/library/core/src/num/mod.rs
+++ b/library/core/src/num/mod.rs
@@ -1322,20 +1322,6 @@ pub enum FpCategory {
Normal,
}
-macro_rules! from_str_radix_int_impl {
- ($($t:ty)*) => {$(
- #[stable(feature = "rust1", since = "1.0.0")]
- impl FromStr for $t {
- type Err = ParseIntError;
- #[inline]
- fn from_str(src: &str) -> Result {
- <$t>::from_str_radix(src, 10)
- }
- }
- )*}
-}
-from_str_radix_int_impl! { isize i8 i16 i32 i64 i128 usize u8 u16 u32 u64 u128 }
-
/// Determines if a string of text of that length of that radix could be guaranteed to be
/// stored in the given type T.
/// Note that if the radix is known to the compiler, it is just the check of digits.len that
@@ -1351,18 +1337,58 @@ pub const fn can_not_overflow(radix: u32, is_signed_ty: bool, digits: &[u8])
#[cfg_attr(feature = "panic_immediate_abort", inline)]
#[cold]
#[track_caller]
-const fn from_str_radix_panic(radix: u32) -> ! {
+const fn from_ascii_radix_panic(radix: u32) -> ! {
const_panic!(
- "from_str_radix_int: must lie in the range `[2, 36]`",
- "from_str_radix_int: must lie in the range `[2, 36]` - found {radix}",
+ "from_ascii_radix: radix must lie in the range `[2, 36]`",
+ "from_ascii_radix: radix must lie in the range `[2, 36]` - found {radix}",
radix: u32 = radix,
)
}
-macro_rules! from_str_radix {
+macro_rules! from_str_int_impl {
($signedness:ident $($int_ty:ty)+) => {$(
+ #[stable(feature = "rust1", since = "1.0.0")]
+ impl FromStr for $int_ty {
+ type Err = ParseIntError;
+
+ /// Parses an integer from a string slice with decimal digits.
+ ///
+ /// The characters are expected to be an optional
+ #[doc = sign_dependent_expr!{
+ $signedness ?
+ if signed {
+ " `+` or `-` "
+ }
+ if unsigned {
+ " `+` "
+ }
+ }]
+ /// sign followed by only digits. Leading and trailing non-digit characters (including
+ /// whitespace) represent an error. Underscores (which are accepted in Rust literals)
+ /// also represent an error.
+ ///
+ /// # Examples
+ ///
+ /// Basic usage:
+ /// ```
+ /// use std::str::FromStr;
+ ///
+ #[doc = concat!("assert_eq!(", stringify!($int_ty), "::from_str(\"+10\"), Ok(10));")]
+ /// ```
+ /// Trailing space returns error:
+ /// ```
+ /// # use std::str::FromStr;
+ /// #
+ #[doc = concat!("assert!(", stringify!($int_ty), "::from_str(\"1 \").is_err());")]
+ /// ```
+ #[inline]
+ fn from_str(src: &str) -> Result<$int_ty, ParseIntError> {
+ <$int_ty>::from_str_radix(src, 10)
+ }
+ }
+
impl $int_ty {
- /// Converts a string slice in a given base to an integer.
+ /// Parses an integer from a string slice with digits in a given base.
///
/// The string is expected to be an optional
#[doc = sign_dependent_expr!{
@@ -1375,7 +1401,7 @@ macro_rules! from_str_radix {
}
}]
/// sign followed by only digits. Leading and trailing non-digit characters (including
- /// whitespace) represent an error. Underscores (which are accepted in rust literals)
+ /// whitespace) represent an error. Underscores (which are accepted in Rust literals)
/// also represent an error.
///
/// Digits are a subset of these characters, depending on `radix`:
@@ -1401,11 +1427,92 @@ macro_rules! from_str_radix {
#[rustc_const_stable(feature = "const_int_from_str", since = "1.82.0")]
#[inline]
pub const fn from_str_radix(src: &str, radix: u32) -> Result<$int_ty, ParseIntError> {
+ <$int_ty>::from_ascii_radix(src.as_bytes(), radix)
+ }
+
+ /// Parses an integer from an ASCII-byte slice with decimal digits.
+ ///
+ /// The characters are expected to be an optional
+ #[doc = sign_dependent_expr!{
+ $signedness ?
+ if signed {
+ " `+` or `-` "
+ }
+ if unsigned {
+ " `+` "
+ }
+ }]
+ /// sign followed by only digits. Leading and trailing non-digit characters (including
+ /// whitespace) represent an error. Underscores (which are accepted in Rust literals)
+ /// also represent an error.
+ ///
+ /// # Examples
+ ///
+ /// Basic usage:
+ /// ```
+ /// #![feature(int_from_ascii)]
+ ///
+ #[doc = concat!("assert_eq!(", stringify!($int_ty), "::from_ascii(b\"+10\"), Ok(10));")]
+ /// ```
+ /// Trailing space returns error:
+ /// ```
+ /// # #![feature(int_from_ascii)]
+ /// #
+ #[doc = concat!("assert!(", stringify!($int_ty), "::from_ascii(b\"1 \").is_err());")]
+ /// ```
+ #[unstable(feature = "int_from_ascii", issue = "134821")]
+ #[inline]
+ pub const fn from_ascii(src: &[u8]) -> Result<$int_ty, ParseIntError> {
+ <$int_ty>::from_ascii_radix(src, 10)
+ }
+
+ /// Parses an integer from an ASCII-byte slice with digits in a given base.
+ ///
+ /// The characters are expected to be an optional
+ #[doc = sign_dependent_expr!{
+ $signedness ?
+ if signed {
+ " `+` or `-` "
+ }
+ if unsigned {
+ " `+` "
+ }
+ }]
+ /// sign followed by only digits. Leading and trailing non-digit characters (including
+ /// whitespace) represent an error. Underscores (which are accepted in Rust literals)
+ /// also represent an error.
+ ///
+ /// Digits are a subset of these characters, depending on `radix`:
+ /// * `0-9`
+ /// * `a-z`
+ /// * `A-Z`
+ ///
+ /// # Panics
+ ///
+ /// This function panics if `radix` is not in the range from 2 to 36.
+ ///
+ /// # Examples
+ ///
+ /// Basic usage:
+ /// ```
+ /// #![feature(int_from_ascii)]
+ ///
+ #[doc = concat!("assert_eq!(", stringify!($int_ty), "::from_ascii_radix(b\"A\", 16), Ok(10));")]
+ /// ```
+ /// Trailing space returns error:
+ /// ```
+ /// # #![feature(int_from_ascii)]
+ /// #
+ #[doc = concat!("assert!(", stringify!($int_ty), "::from_ascii_radix(b\"1 \", 10).is_err());")]
+ /// ```
+ #[unstable(feature = "int_from_ascii", issue = "134821")]
+ #[inline]
+ pub const fn from_ascii_radix(src: &[u8], radix: u32) -> Result<$int_ty, ParseIntError> {
use self::IntErrorKind::*;
use self::ParseIntError as PIE;
if 2 > radix || radix > 36 {
- from_str_radix_panic(radix);
+ from_ascii_radix_panic(radix);
}
if src.is_empty() {
@@ -1415,12 +1522,6 @@ macro_rules! from_str_radix {
#[allow(unused_comparisons)]
let is_signed_ty = 0 > <$int_ty>::MIN;
- // all valid digits are ascii, so we will just iterate over the utf8 bytes
- // and cast them to chars. .to_digit() will safely return None for anything
- // other than a valid ascii digit for the given radix, including the first-byte
- // of multi-byte sequences
- let src = src.as_bytes();
-
let (is_positive, mut digits) = match src {
[b'+' | b'-'] => {
return Err(PIE { kind: InvalidDigit });
@@ -1496,67 +1597,8 @@ macro_rules! from_str_radix {
Ok(result)
}
}
- )+}
+ )*}
}
-from_str_radix! { unsigned u8 u16 u32 u64 u128 }
-from_str_radix! { signed i8 i16 i32 i64 i128 }
-
-// Re-use the relevant implementation of from_str_radix for isize and usize to avoid outputting two
-// identical functions.
-macro_rules! from_str_radix_size_impl {
- ($($signedness:ident $t:ident $size:ty),*) => {$(
- impl $size {
- /// Converts a string slice in a given base to an integer.
- ///
- /// The string is expected to be an optional
- #[doc = sign_dependent_expr!{
- $signedness ?
- if signed {
- " `+` or `-` "
- }
- if unsigned {
- " `+` "
- }
- }]
- /// sign followed by only digits. Leading and trailing non-digit characters (including
- /// whitespace) represent an error. Underscores (which are accepted in rust literals)
- /// also represent an error.
- ///
- /// Digits are a subset of these characters, depending on `radix`:
- /// * `0-9`
- /// * `a-z`
- /// * `A-Z`
- ///
- /// # Panics
- ///
- /// This function panics if `radix` is not in the range from 2 to 36.
- ///
- /// # Examples
- ///
- /// Basic usage:
- /// ```
- #[doc = concat!("assert_eq!(", stringify!($size), "::from_str_radix(\"A\", 16), Ok(10));")]
- /// ```
- /// Trailing space returns error:
- /// ```
- #[doc = concat!("assert!(", stringify!($size), "::from_str_radix(\"1 \", 10).is_err());")]
- /// ```
- #[stable(feature = "rust1", since = "1.0.0")]
- #[rustc_const_stable(feature = "const_int_from_str", since = "1.82.0")]
- #[inline]
- pub const fn from_str_radix(src: &str, radix: u32) -> Result<$size, ParseIntError> {
- match <$t>::from_str_radix(src, radix) {
- Ok(x) => Ok(x as $size),
- Err(e) => Err(e),
- }
- }
- })*}
-}
-
-#[cfg(target_pointer_width = "16")]
-from_str_radix_size_impl! { signed i16 isize, unsigned u16 usize }
-#[cfg(target_pointer_width = "32")]
-from_str_radix_size_impl! { signed i32 isize, unsigned u32 usize }
-#[cfg(target_pointer_width = "64")]
-from_str_radix_size_impl! { signed i64 isize, unsigned u64 usize }
+from_str_int_impl! { signed isize i8 i16 i32 i64 i128 }
+from_str_int_impl! { unsigned usize u8 u16 u32 u64 u128 }
diff --git a/library/core/src/prelude/common.rs b/library/core/src/prelude/common.rs
index e38ef1e147c..8b116cecb52 100644
--- a/library/core/src/prelude/common.rs
+++ b/library/core/src/prelude/common.rs
@@ -12,6 +12,9 @@ pub use crate::marker::{Copy, Send, Sized, Sync, Unpin};
#[stable(feature = "core_prelude", since = "1.4.0")]
#[doc(no_inline)]
pub use crate::ops::{Drop, Fn, FnMut, FnOnce};
+#[stable(feature = "async_closure", since = "1.85.0")]
+#[doc(no_inline)]
+pub use crate::ops::{AsyncFn, AsyncFnMut, AsyncFnOnce};
// Re-exported functions
#[stable(feature = "core_prelude", since = "1.4.0")]
diff --git a/library/core/src/slice/rotate.rs b/library/core/src/slice/rotate.rs
index d8e0acb565c..5d5ee4c7b62 100644
--- a/library/core/src/slice/rotate.rs
+++ b/library/core/src/slice/rotate.rs
@@ -1,6 +1,8 @@
use crate::mem::{self, MaybeUninit, SizedTypeProperties};
use crate::{cmp, ptr};
+type BufType = [usize; 32];
+
/// Rotates the range `[mid-left, mid+right)` such that the element at `mid` becomes the first
/// element. Equivalently, rotates the range `left` elements to the left or `right` elements to the
/// right.
@@ -8,14 +10,82 @@ use crate::{cmp, ptr};
/// # Safety
///
/// The specified range must be valid for reading and writing.
+#[inline]
+pub(super) unsafe fn ptr_rotate(left: usize, mid: *mut T, right: usize) {
+ if T::IS_ZST {
+ return;
+ }
+ // abort early if the rotate is a no-op
+ if (left == 0) || (right == 0) {
+ return;
+ }
+ // `T` is not a zero-sized type, so it's okay to divide by its size.
+ if !cfg!(feature = "optimize_for_size")
+ && cmp::min(left, right) <= mem::size_of::() / mem::size_of::()
+ {
+ // SAFETY: guaranteed by the caller
+ unsafe { ptr_rotate_memmove(left, mid, right) };
+ } else if !cfg!(feature = "optimize_for_size")
+ && ((left + right < 24) || (mem::size_of::() > mem::size_of::<[usize; 4]>()))
+ {
+ // SAFETY: guaranteed by the caller
+ unsafe { ptr_rotate_gcd(left, mid, right) }
+ } else {
+ // SAFETY: guaranteed by the caller
+ unsafe { ptr_rotate_swap(left, mid, right) }
+ }
+}
+
+/// Algorithm 1 is used if `min(left, right)` is small enough to fit onto a stack buffer. The
+/// `min(left, right)` elements are copied onto the buffer, `memmove` is applied to the others, and
+/// the ones on the buffer are moved back into the hole on the opposite side of where they
+/// originated.
///
-/// # Algorithm
+/// # Safety
///
-/// Algorithm 1 is used for small values of `left + right` or for large `T`. The elements are moved
-/// into their final positions one at a time starting at `mid - left` and advancing by `right` steps
-/// modulo `left + right`, such that only one temporary is needed. Eventually, we arrive back at
-/// `mid - left`. However, if `gcd(left + right, right)` is not 1, the above steps skipped over
-/// elements. For example:
+/// The specified range must be valid for reading and writing.
+#[inline]
+unsafe fn ptr_rotate_memmove(left: usize, mid: *mut T, right: usize) {
+ // The `[T; 0]` here is to ensure this is appropriately aligned for T
+ let mut rawarray = MaybeUninit::<(BufType, [T; 0])>::uninit();
+ let buf = rawarray.as_mut_ptr() as *mut T;
+ // SAFETY: `mid-left <= mid-left+right < mid+right`
+ let dim = unsafe { mid.sub(left).add(right) };
+ if left <= right {
+ // SAFETY:
+ //
+ // 1) The `if` condition about the sizes ensures `[mid-left; left]` will fit in
+ // `buf` without overflow and `buf` was created just above and so cannot be
+ // overlapped with any value of `[mid-left; left]`
+ // 2) [mid-left, mid+right) are all valid for reading and writing and we don't care
+ // about overlaps here.
+ // 3) The `if` condition about `left <= right` ensures writing `left` elements to
+ // `dim = mid-left+right` is valid because:
+ // - `buf` is valid and `left` elements were written in it in 1)
+ // - `dim+left = mid-left+right+left = mid+right` and we write `[dim, dim+left)`
+ unsafe {
+ // 1)
+ ptr::copy_nonoverlapping(mid.sub(left), buf, left);
+ // 2)
+ ptr::copy(mid, mid.sub(left), right);
+ // 3)
+ ptr::copy_nonoverlapping(buf, dim, left);
+ }
+ } else {
+ // SAFETY: same reasoning as above but with `left` and `right` reversed
+ unsafe {
+ ptr::copy_nonoverlapping(mid, buf, right);
+ ptr::copy(mid.sub(left), dim, left);
+ ptr::copy_nonoverlapping(buf, mid.sub(left), right);
+ }
+ }
+}
+
+/// Algorithm 2 is used for small values of `left + right` or for large `T`. The elements
+/// are moved into their final positions one at a time starting at `mid - left` and advancing by
+/// `right` steps modulo `left + right`, such that only one temporary is needed. Eventually, we
+/// arrive back at `mid - left`. However, if `gcd(left + right, right)` is not 1, the above steps
+/// skipped over elements. For example:
/// ```text
/// left = 10, right = 6
/// the `^` indicates an element in its final place
@@ -39,17 +109,104 @@ use crate::{cmp, ptr};
/// `gcd(left + right, right)` value). The end result is that all elements are finalized once and
/// only once.
///
-/// Algorithm 2 is used if `left + right` is large but `min(left, right)` is small enough to
-/// fit onto a stack buffer. The `min(left, right)` elements are copied onto the buffer, `memmove`
-/// is applied to the others, and the ones on the buffer are moved back into the hole on the
-/// opposite side of where they originated.
-///
-/// Algorithms that can be vectorized outperform the above once `left + right` becomes large enough.
-/// Algorithm 1 can be vectorized by chunking and performing many rounds at once, but there are too
+/// Algorithm 2 can be vectorized by chunking and performing many rounds at once, but there are too
/// few rounds on average until `left + right` is enormous, and the worst case of a single
-/// round is always there. Instead, algorithm 3 utilizes repeated swapping of
-/// `min(left, right)` elements until a smaller rotate problem is left.
+/// round is always there.
///
+/// # Safety
+///
+/// The specified range must be valid for reading and writing.
+#[inline]
+unsafe fn ptr_rotate_gcd(left: usize, mid: *mut T, right: usize) {
+ // Algorithm 2
+ // Microbenchmarks indicate that the average performance for random shifts is better all
+ // the way until about `left + right == 32`, but the worst case performance breaks even
+ // around 16. 24 was chosen as middle ground. If the size of `T` is larger than 4
+ // `usize`s, this algorithm also outperforms other algorithms.
+ // SAFETY: callers must ensure `mid - left` is valid for reading and writing.
+ let x = unsafe { mid.sub(left) };
+ // beginning of first round
+ // SAFETY: see previous comment.
+ let mut tmp: T = unsafe { x.read() };
+ let mut i = right;
+ // `gcd` can be found before hand by calculating `gcd(left + right, right)`,
+ // but it is faster to do one loop which calculates the gcd as a side effect, then
+ // doing the rest of the chunk
+ let mut gcd = right;
+ // benchmarks reveal that it is faster to swap temporaries all the way through instead
+ // of reading one temporary once, copying backwards, and then writing that temporary at
+ // the very end. This is possibly due to the fact that swapping or replacing temporaries
+ // uses only one memory address in the loop instead of needing to manage two.
+ loop {
+ // [long-safety-expl]
+ // SAFETY: callers must ensure `[left, left+mid+right)` are all valid for reading and
+ // writing.
+ //
+ // - `i` start with `right` so `mid-left <= x+i = x+right = mid-left+right < mid+right`
+ // - `i <= left+right-1` is always true
+ // - if `i < left`, `right` is added so `i < left+right` and on the next
+ // iteration `left` is removed from `i` so it doesn't go further
+ // - if `i >= left`, `left` is removed immediately and so it doesn't go further.
+ // - overflows cannot happen for `i` since the function's safety contract ask for
+ // `mid+right-1 = x+left+right` to be valid for writing
+ // - underflows cannot happen because `i` must be bigger or equal to `left` for
+ // a subtraction of `left` to happen.
+ //
+ // So `x+i` is valid for reading and writing if the caller respected the contract
+ tmp = unsafe { x.add(i).replace(tmp) };
+ // instead of incrementing `i` and then checking if it is outside the bounds, we
+ // check if `i` will go outside the bounds on the next increment. This prevents
+ // any wrapping of pointers or `usize`.
+ if i >= left {
+ i -= left;
+ if i == 0 {
+ // end of first round
+ // SAFETY: tmp has been read from a valid source and x is valid for writing
+ // according to the caller.
+ unsafe { x.write(tmp) };
+ break;
+ }
+ // this conditional must be here if `left + right >= 15`
+ if i < gcd {
+ gcd = i;
+ }
+ } else {
+ i += right;
+ }
+ }
+ // finish the chunk with more rounds
+ for start in 1..gcd {
+ // SAFETY: `gcd` is at most equal to `right` so all values in `1..gcd` are valid for
+ // reading and writing as per the function's safety contract, see [long-safety-expl]
+ // above
+ tmp = unsafe { x.add(start).read() };
+ // [safety-expl-addition]
+ //
+ // Here `start < gcd` so `start < right` so `i < right+right`: `right` being the
+ // greatest common divisor of `(left+right, right)` means that `left = right` so
+ // `i < left+right` so `x+i = mid-left+i` is always valid for reading and writing
+ // according to the function's safety contract.
+ i = start + right;
+ loop {
+ // SAFETY: see [long-safety-expl] and [safety-expl-addition]
+ tmp = unsafe { x.add(i).replace(tmp) };
+ if i >= left {
+ i -= left;
+ if i == start {
+ // SAFETY: see [long-safety-expl] and [safety-expl-addition]
+ unsafe { x.add(start).write(tmp) };
+ break;
+ }
+ } else {
+ i += right;
+ }
+ }
+ }
+}
+
+/// Algorithm 3 utilizes repeated swapping of `min(left, right)` elements.
+///
+/// ///
/// ```text
/// left = 11, right = 4
/// [4 5 6 7 8 9 10 11 12 13 14 . 0 1 2 3]
@@ -60,144 +217,14 @@ use crate::{cmp, ptr};
/// we cannot swap any more, but a smaller rotation problem is left to solve
/// ```
/// when `left < right` the swapping happens from the left instead.
-pub(super) unsafe fn ptr_rotate(mut left: usize, mut mid: *mut T, mut right: usize) {
- type BufType = [usize; 32];
- if T::IS_ZST {
- return;
- }
+///
+/// # Safety
+///
+/// The specified range must be valid for reading and writing.
+#[inline]
+unsafe fn ptr_rotate_swap(mut left: usize, mut mid: *mut T, mut right: usize) {
loop {
- // N.B. the below algorithms can fail if these cases are not checked
- if (right == 0) || (left == 0) {
- return;
- }
- if !cfg!(feature = "optimize_for_size")
- && ((left + right < 24) || (mem::size_of::() > mem::size_of::<[usize; 4]>()))
- {
- // Algorithm 1
- // Microbenchmarks indicate that the average performance for random shifts is better all
- // the way until about `left + right == 32`, but the worst case performance breaks even
- // around 16. 24 was chosen as middle ground. If the size of `T` is larger than 4
- // `usize`s, this algorithm also outperforms other algorithms.
- // SAFETY: callers must ensure `mid - left` is valid for reading and writing.
- let x = unsafe { mid.sub(left) };
- // beginning of first round
- // SAFETY: see previous comment.
- let mut tmp: T = unsafe { x.read() };
- let mut i = right;
- // `gcd` can be found before hand by calculating `gcd(left + right, right)`,
- // but it is faster to do one loop which calculates the gcd as a side effect, then
- // doing the rest of the chunk
- let mut gcd = right;
- // benchmarks reveal that it is faster to swap temporaries all the way through instead
- // of reading one temporary once, copying backwards, and then writing that temporary at
- // the very end. This is possibly due to the fact that swapping or replacing temporaries
- // uses only one memory address in the loop instead of needing to manage two.
- loop {
- // [long-safety-expl]
- // SAFETY: callers must ensure `[left, left+mid+right)` are all valid for reading and
- // writing.
- //
- // - `i` start with `right` so `mid-left <= x+i = x+right = mid-left+right < mid+right`
- // - `i <= left+right-1` is always true
- // - if `i < left`, `right` is added so `i < left+right` and on the next
- // iteration `left` is removed from `i` so it doesn't go further
- // - if `i >= left`, `left` is removed immediately and so it doesn't go further.
- // - overflows cannot happen for `i` since the function's safety contract ask for
- // `mid+right-1 = x+left+right` to be valid for writing
- // - underflows cannot happen because `i` must be bigger or equal to `left` for
- // a subtraction of `left` to happen.
- //
- // So `x+i` is valid for reading and writing if the caller respected the contract
- tmp = unsafe { x.add(i).replace(tmp) };
- // instead of incrementing `i` and then checking if it is outside the bounds, we
- // check if `i` will go outside the bounds on the next increment. This prevents
- // any wrapping of pointers or `usize`.
- if i >= left {
- i -= left;
- if i == 0 {
- // end of first round
- // SAFETY: tmp has been read from a valid source and x is valid for writing
- // according to the caller.
- unsafe { x.write(tmp) };
- break;
- }
- // this conditional must be here if `left + right >= 15`
- if i < gcd {
- gcd = i;
- }
- } else {
- i += right;
- }
- }
- // finish the chunk with more rounds
- for start in 1..gcd {
- // SAFETY: `gcd` is at most equal to `right` so all values in `1..gcd` are valid for
- // reading and writing as per the function's safety contract, see [long-safety-expl]
- // above
- tmp = unsafe { x.add(start).read() };
- // [safety-expl-addition]
- //
- // Here `start < gcd` so `start < right` so `i < right+right`: `right` being the
- // greatest common divisor of `(left+right, right)` means that `left = right` so
- // `i < left+right` so `x+i = mid-left+i` is always valid for reading and writing
- // according to the function's safety contract.
- i = start + right;
- loop {
- // SAFETY: see [long-safety-expl] and [safety-expl-addition]
- tmp = unsafe { x.add(i).replace(tmp) };
- if i >= left {
- i -= left;
- if i == start {
- // SAFETY: see [long-safety-expl] and [safety-expl-addition]
- unsafe { x.add(start).write(tmp) };
- break;
- }
- } else {
- i += right;
- }
- }
- }
- return;
- // `T` is not a zero-sized type, so it's okay to divide by its size.
- } else if !cfg!(feature = "optimize_for_size")
- && cmp::min(left, right) <= mem::size_of::() / mem::size_of::()
- {
- // Algorithm 2
- // The `[T; 0]` here is to ensure this is appropriately aligned for T
- let mut rawarray = MaybeUninit::<(BufType, [T; 0])>::uninit();
- let buf = rawarray.as_mut_ptr() as *mut T;
- // SAFETY: `mid-left <= mid-left+right < mid+right`
- let dim = unsafe { mid.sub(left).add(right) };
- if left <= right {
- // SAFETY:
- //
- // 1) The `else if` condition about the sizes ensures `[mid-left; left]` will fit in
- // `buf` without overflow and `buf` was created just above and so cannot be
- // overlapped with any value of `[mid-left; left]`
- // 2) [mid-left, mid+right) are all valid for reading and writing and we don't care
- // about overlaps here.
- // 3) The `if` condition about `left <= right` ensures writing `left` elements to
- // `dim = mid-left+right` is valid because:
- // - `buf` is valid and `left` elements were written in it in 1)
- // - `dim+left = mid-left+right+left = mid+right` and we write `[dim, dim+left)`
- unsafe {
- // 1)
- ptr::copy_nonoverlapping(mid.sub(left), buf, left);
- // 2)
- ptr::copy(mid, mid.sub(left), right);
- // 3)
- ptr::copy_nonoverlapping(buf, dim, left);
- }
- } else {
- // SAFETY: same reasoning as above but with `left` and `right` reversed
- unsafe {
- ptr::copy_nonoverlapping(mid, buf, right);
- ptr::copy(mid.sub(left), dim, left);
- ptr::copy_nonoverlapping(buf, mid.sub(left), right);
- }
- }
- return;
- } else if left >= right {
+ if left >= right {
// Algorithm 3
// There is an alternate way of swapping that involves finding where the last swap
// of this algorithm would be, and swapping using that last chunk instead of swapping
@@ -233,5 +260,8 @@ pub(super) unsafe fn ptr_rotate(mut left: usize, mut mid: *mut T, mut right:
}
}
}
+ if (right == 0) || (left == 0) {
+ return;
+ }
}
}
diff --git a/library/std/src/fs.rs b/library/std/src/fs.rs
index 1f8aac48a9a..a5b0111adfb 100644
--- a/library/std/src/fs.rs
+++ b/library/std/src/fs.rs
@@ -629,9 +629,9 @@ impl File {
/// This acquires an exclusive advisory lock; no other file handle to this file may acquire
/// another lock.
///
- /// If this file handle, or a clone of it, already holds an advisory lock the exact behavior is
- /// unspecified and platform dependent, including the possibility that it will deadlock.
- /// However, if this method returns, then an exclusive lock is held.
+ /// If this file handle/descriptor, or a clone of it, already holds an advisory lock the exact
+ /// behavior is unspecified and platform dependent, including the possibility that it will
+ /// deadlock. However, if this method returns, then an exclusive lock is held.
///
/// If the file not open for writing, it is unspecified whether this function returns an error.
///
@@ -639,6 +639,9 @@ impl File {
/// [`try_lock_shared`], and [`unlock`]. Its interactions with other methods, such as [`read`]
/// and [`write`] are platform specific, and it may or may not cause non-lockholders to block.
///
+ /// The lock will be released when this file (along with any other file descriptors/handles
+ /// duplicated or inherited from it) is closed, or if the [`unlock`] method is called.
+ ///
/// # Platform-specific behavior
///
/// This function currently corresponds to the `flock` function on Unix with the `LOCK_EX` flag,
@@ -671,19 +674,22 @@ impl File {
self.inner.lock()
}
- /// Acquire a shared advisory lock on the file. Blocks until the lock can be acquired.
+ /// Acquire a shared (non-exclusive) advisory lock on the file. Blocks until the lock can be acquired.
///
/// This acquires a shared advisory lock; more than one file handle may hold a shared lock, but
- /// none may hold an exclusive lock.
+ /// none may hold an exclusive lock at the same time.
///
- /// If this file handle, or a clone of it, already holds an advisory lock, the exact behavior is
- /// unspecified and platform dependent, including the possibility that it will deadlock.
- /// However, if this method returns, then a shared lock is held.
+ /// If this file handle/descriptor, or a clone of it, already holds an advisory lock, the exact
+ /// behavior is unspecified and platform dependent, including the possibility that it will
+ /// deadlock. However, if this method returns, then a shared lock is held.
///
/// Note, this is an advisory lock meant to interact with [`lock`], [`try_lock`],
/// [`try_lock_shared`], and [`unlock`]. Its interactions with other methods, such as [`read`]
/// and [`write`] are platform specific, and it may or may not cause non-lockholders to block.
///
+ /// The lock will be released when this file (along with any other file descriptors/handles
+ /// duplicated or inherited from it) is closed, or if the [`unlock`] method is called.
+ ///
/// # Platform-specific behavior
///
/// This function currently corresponds to the `flock` function on Unix with the `LOCK_SH` flag,
@@ -716,14 +722,18 @@ impl File {
self.inner.lock_shared()
}
- /// Acquire an exclusive advisory lock on the file. Returns `Ok(false)` if the file is locked.
+ /// Try to acquire an exclusive advisory lock on the file.
+ ///
+ /// Returns `Ok(false)` if a different lock is already held on this file (via another
+ /// handle/descriptor).
///
/// This acquires an exclusive advisory lock; no other file handle to this file may acquire
/// another lock.
///
- /// If this file handle, or a clone of it, already holds an advisory lock, the exact behavior is
- /// unspecified and platform dependent, including the possibility that it will deadlock.
- /// However, if this method returns, then an exclusive lock is held.
+ /// If this file handle/descriptor, or a clone of it, already holds an advisory lock, the exact
+ /// behavior is unspecified and platform dependent, including the possibility that it will
+ /// deadlock. However, if this method returns `Ok(true)`, then it has acquired an exclusive
+ /// lock.
///
/// If the file not open for writing, it is unspecified whether this function returns an error.
///
@@ -731,6 +741,9 @@ impl File {
/// [`try_lock_shared`], and [`unlock`]. Its interactions with other methods, such as [`read`]
/// and [`write`] are platform specific, and it may or may not cause non-lockholders to block.
///
+ /// The lock will be released when this file (along with any other file descriptors/handles
+ /// duplicated or inherited from it) is closed, or if the [`unlock`] method is called.
+ ///
/// # Platform-specific behavior
///
/// This function currently corresponds to the `flock` function on Unix with the `LOCK_EX` and
@@ -764,20 +777,25 @@ impl File {
self.inner.try_lock()
}
- /// Acquire a shared advisory lock on the file.
- /// Returns `Ok(false)` if the file is exclusively locked.
+ /// Try to acquire a shared (non-exclusive) advisory lock on the file.
+ ///
+ /// Returns `Ok(false)` if an exclusive lock is already held on this file (via another
+ /// handle/descriptor).
///
/// This acquires a shared advisory lock; more than one file handle may hold a shared lock, but
- /// none may hold an exclusive lock.
+ /// none may hold an exclusive lock at the same time.
///
/// If this file handle, or a clone of it, already holds an advisory lock, the exact behavior is
/// unspecified and platform dependent, including the possibility that it will deadlock.
- /// However, if this method returns, then a shared lock is held.
+ /// However, if this method returns `Ok(true)`, then it has acquired a shared lock.
///
/// Note, this is an advisory lock meant to interact with [`lock`], [`try_lock`],
/// [`try_lock`], and [`unlock`]. Its interactions with other methods, such as [`read`]
/// and [`write`] are platform specific, and it may or may not cause non-lockholders to block.
///
+ /// The lock will be released when this file (along with any other file descriptors/handles
+ /// duplicated or inherited from it) is closed, or if the [`unlock`] method is called.
+ ///
/// # Platform-specific behavior
///
/// This function currently corresponds to the `flock` function on Unix with the `LOCK_SH` and
@@ -813,7 +831,12 @@ impl File {
/// Release all locks on the file.
///
- /// All remaining locks are released when the file handle, and all clones of it, are dropped.
+ /// All locks are released when the file (along with any other file descriptors/handles
+ /// duplicated or inherited from it) is closed. This method allows releasing locks without
+ /// closing the file.
+ ///
+ /// If no lock is currently held via this file descriptor/handle, this method may return an
+ /// error, or may return successfully without taking any action.
///
/// # Platform-specific behavior
///
diff --git a/library/std/src/sys/pal/uefi/helpers.rs b/library/std/src/sys/pal/uefi/helpers.rs
index 7504a0f7ad7..dccc137d6f5 100644
--- a/library/std/src/sys/pal/uefi/helpers.rs
+++ b/library/std/src/sys/pal/uefi/helpers.rs
@@ -14,10 +14,12 @@ use r_efi::protocols::{device_path, device_path_to_text, shell};
use crate::ffi::{OsStr, OsString};
use crate::io::{self, const_error};
+use crate::marker::PhantomData;
use crate::mem::{MaybeUninit, size_of};
use crate::os::uefi::env::boot_services;
use crate::os::uefi::ffi::{OsStrExt, OsStringExt};
use crate::os::uefi::{self};
+use crate::path::Path;
use crate::ptr::NonNull;
use crate::slice;
use crate::sync::atomic::{AtomicPtr, Ordering};
@@ -278,6 +280,10 @@ impl OwnedDevicePath {
pub(crate) const fn as_ptr(&self) -> *mut r_efi::protocols::device_path::Protocol {
self.0.as_ptr()
}
+
+ pub(crate) const fn borrow<'a>(&'a self) -> BorrowedDevicePath<'a> {
+ BorrowedDevicePath::new(self.0)
+ }
}
impl Drop for OwnedDevicePath {
@@ -293,13 +299,37 @@ impl Drop for OwnedDevicePath {
impl crate::fmt::Debug for OwnedDevicePath {
fn fmt(&self, f: &mut crate::fmt::Formatter<'_>) -> crate::fmt::Result {
- match device_path_to_text(self.0) {
+ match self.borrow().to_text() {
Ok(p) => p.fmt(f),
Err(_) => f.debug_struct("OwnedDevicePath").finish_non_exhaustive(),
}
}
}
+pub(crate) struct BorrowedDevicePath<'a> {
+ protocol: NonNull,
+ phantom: PhantomData<&'a r_efi::protocols::device_path::Protocol>,
+}
+
+impl<'a> BorrowedDevicePath<'a> {
+ pub(crate) const fn new(protocol: NonNull) -> Self {
+ Self { protocol, phantom: PhantomData }
+ }
+
+ pub(crate) fn to_text(&self) -> io::Result {
+ device_path_to_text(self.protocol)
+ }
+}
+
+impl<'a> crate::fmt::Debug for BorrowedDevicePath<'a> {
+ fn fmt(&self, f: &mut crate::fmt::Formatter<'_>) -> crate::fmt::Result {
+ match self.to_text() {
+ Ok(p) => p.fmt(f),
+ Err(_) => f.debug_struct("BorrowedDevicePath").finish_non_exhaustive(),
+ }
+ }
+}
+
pub(crate) struct OwnedProtocol {
guid: r_efi::efi::Guid,
handle: NonNull,
@@ -452,3 +482,21 @@ pub(crate) fn open_shell() -> Option> {
None
}
+
+/// Get device path protocol associated with shell mapping.
+///
+/// returns None in case no such mapping is exists
+pub(crate) fn get_device_path_from_map(map: &Path) -> io::Result> {
+ let shell =
+ open_shell().ok_or(io::const_error!(io::ErrorKind::NotFound, "UEFI Shell not found"))?;
+ let mut path = os_string_to_raw(map.as_os_str())
+ .ok_or(io::const_error!(io::ErrorKind::InvalidFilename, "Invalid UEFI shell mapping"))?;
+
+ // The Device Path Protocol pointer returned by UEFI shell is owned by the shell and is not
+ // freed throughout it's lifetime. So it has a 'static lifetime.
+ let protocol = unsafe { ((*shell.as_ptr()).get_device_path_from_map)(path.as_mut_ptr()) };
+ let protocol = NonNull::new(protocol)
+ .ok_or(io::const_error!(io::ErrorKind::NotFound, "UEFI Shell mapping not found"))?;
+
+ Ok(BorrowedDevicePath::new(protocol))
+}
diff --git a/library/std/src/sys/path/mod.rs b/library/std/src/sys/path/mod.rs
index 24a94ec7828..1fa4e80d678 100644
--- a/library/std/src/sys/path/mod.rs
+++ b/library/std/src/sys/path/mod.rs
@@ -5,12 +5,12 @@ cfg_if::cfg_if! {
} else if #[cfg(all(target_vendor = "fortanix", target_env = "sgx"))] {
mod sgx;
pub use sgx::*;
- } else if #[cfg(any(
- target_os = "uefi",
- target_os = "solid_asp3",
- ))] {
+ } else if #[cfg(target_os = "solid_asp3")] {
mod unsupported_backslash;
pub use unsupported_backslash::*;
+ } else if #[cfg(target_os = "uefi")] {
+ mod uefi;
+ pub use uefi::*;
} else {
mod unix;
pub use unix::*;
diff --git a/library/std/src/sys/path/uefi.rs b/library/std/src/sys/path/uefi.rs
new file mode 100644
index 00000000000..a3f4a3bfe1b
--- /dev/null
+++ b/library/std/src/sys/path/uefi.rs
@@ -0,0 +1,105 @@
+#![forbid(unsafe_op_in_unsafe_fn)]
+use crate::ffi::OsStr;
+use crate::io;
+use crate::path::{Path, PathBuf, Prefix};
+use crate::sys::{helpers, unsupported_err};
+
+const FORWARD_SLASH: u8 = b'/';
+const COLON: u8 = b':';
+
+#[inline]
+pub fn is_sep_byte(b: u8) -> bool {
+ b == b'\\'
+}
+
+#[inline]
+pub fn is_verbatim_sep(b: u8) -> bool {
+ b == b'\\'
+}
+
+pub fn parse_prefix(_: &OsStr) -> Option> {
+ None
+}
+
+pub const MAIN_SEP_STR: &str = "\\";
+pub const MAIN_SEP: char = '\\';
+
+/// UEFI paths can be of 4 types:
+///
+/// 1. Absolute Shell Path: Uses shell mappings (eg: `FS0:`). Does not exist if UEFI shell not present.
+/// It can be identified with `:`.
+/// Eg: FS0:\abc\run.efi
+///
+/// 2. Absolute Device Path: this is what we want
+/// It can be identified with `/`.
+/// Eg: PciRoot(0x0)/Pci(0x1,0x1)/Ata(Secondary,Slave,0x0)/\abc\run.efi
+///
+/// 3: Relative root: path relative to the current volume.
+/// It will start with `\`.
+/// Eg: \abc\run.efi
+///
+/// 4: Relative
+/// Eg: run.efi
+///
+/// The algorithm is mostly taken from edk2 UEFI shell implementation and is
+/// somewhat simple. Check for the path type in order.
+///
+/// The volume mapping in Absolute Shell Path (not the rest of the path) can be converted to Device
+/// Path Protocol using `EFI_SHELL->GetDevicePathFromMap`. The rest of the path (Relative root
+/// path), can just be appended to the remaining path.
+///
+/// For Relative root, we get the current volume (either in Shell Mapping, or Device Path Protocol
+/// form) and join it with the relative root path. We then recurse the function to resolve the Shell
+/// Mapping if present.
+///
+/// For Relative paths, we use the current working directory to construct
+/// the new path and recurse the function to resolve the Shell mapping if present.
+///
+/// Finally, at the end, we get the 2nd form, i.e. Absolute Device Path, which can be used in the
+/// normal UEFI APIs such as file, process, etc.
+/// Eg: PciRoot(0x0)/Pci(0x1,0x1)/Ata(Secondary,Slave,0x0)/\abc\run.efi
+pub(crate) fn absolute(path: &Path) -> io::Result {
+ // Absolute Shell Path
+ if path.as_os_str().as_encoded_bytes().contains(&COLON) {
+ let mut path_components = path.components();
+ // Since path is not empty, it has at least one Component
+ let prefix = path_components.next().unwrap();
+
+ let dev_path = helpers::get_device_path_from_map(prefix.as_ref())?;
+ let mut dev_path_text = dev_path.to_text().map_err(|_| unsupported_err())?;
+
+ // UEFI Shell does not seem to end device path with `/`
+ if *dev_path_text.as_encoded_bytes().last().unwrap() != FORWARD_SLASH {
+ dev_path_text.push("/");
+ }
+
+ let mut ans = PathBuf::from(dev_path_text);
+ ans.push(path_components);
+
+ return Ok(ans);
+ }
+
+ // Absolute Device Path
+ if path.as_os_str().as_encoded_bytes().contains(&FORWARD_SLASH) {
+ return Ok(path.to_path_buf());
+ }
+
+ // cur_dir() always returns something
+ let cur_dir = crate::env::current_dir().unwrap();
+ let mut path_components = path.components();
+
+ // Relative Root
+ if path_components.next().unwrap() == crate::path::Component::RootDir {
+ let mut ans = PathBuf::new();
+ ans.push(cur_dir.components().next().unwrap());
+ ans.push(path_components);
+ return absolute(&ans);
+ }
+
+ absolute(&cur_dir.join(path))
+}
+
+pub(crate) fn is_absolute(path: &Path) -> bool {
+ let temp = path.as_os_str().as_encoded_bytes();
+ temp.contains(&COLON) || temp.contains(&FORWARD_SLASH)
+}
diff --git a/license-metadata.json b/license-metadata.json
index 09cc3693565..4cf9bea2861 100644
--- a/license-metadata.json
+++ b/license-metadata.json
@@ -113,8 +113,12 @@
{
"directories": [],
"files": [
+ "FiraMono-Medium.woff2",
+ "FiraMono-Regular.woff2",
+ "FiraSans-Italic.woff2",
"FiraSans-LICENSE.txt",
"FiraSans-Medium.woff2",
+ "FiraSans-MediumItalic.woff2",
"FiraSans-Regular.woff2"
],
"license": {
@@ -266,4 +270,4 @@
],
"type": "root"
}
-}
\ No newline at end of file
+}
diff --git a/src/bootstrap/src/core/build_steps/test.rs b/src/bootstrap/src/core/build_steps/test.rs
index 5e250d18ce6..825e5452f0e 100644
--- a/src/bootstrap/src/core/build_steps/test.rs
+++ b/src/bootstrap/src/core/build_steps/test.rs
@@ -86,6 +86,7 @@ impl Step for CrateBootstrap {
SourceType::InTree,
&[],
);
+
let crate_name = path.rsplit_once('/').unwrap().1;
run_cargo_test(cargo, &[], &[], crate_name, crate_name, bootstrap_host, builder);
}
@@ -3106,6 +3107,8 @@ impl Step for Bootstrap {
&[],
);
+ cargo.release_build(false);
+
cargo
.rustflag("-Cdebuginfo=2")
.env("CARGO_TARGET_DIR", builder.out.join("bootstrap"))
diff --git a/src/bootstrap/src/core/builder/cargo.rs b/src/bootstrap/src/core/builder/cargo.rs
index 1b413dcb07e..f6a03a386d1 100644
--- a/src/bootstrap/src/core/builder/cargo.rs
+++ b/src/bootstrap/src/core/builder/cargo.rs
@@ -88,12 +88,14 @@ impl HostFlags {
#[derive(Debug)]
pub struct Cargo {
command: BootstrapCommand,
+ args: Vec,
compiler: Compiler,
target: TargetSelection,
rustflags: Rustflags,
rustdocflags: Rustflags,
hostflags: HostFlags,
allow_features: String,
+ release_build: bool,
}
impl Cargo {
@@ -121,6 +123,10 @@ impl Cargo {
cargo
}
+ pub fn release_build(&mut self, release_build: bool) {
+ self.release_build = release_build;
+ }
+
pub fn compiler(&self) -> Compiler {
self.compiler
}
@@ -153,7 +159,7 @@ impl Cargo {
}
pub fn arg(&mut self, arg: impl AsRef) -> &mut Cargo {
- self.command.arg(arg.as_ref());
+ self.args.push(arg.as_ref().into());
self
}
@@ -342,6 +348,12 @@ impl Cargo {
impl From for BootstrapCommand {
fn from(mut cargo: Cargo) -> BootstrapCommand {
+ if cargo.release_build {
+ cargo.args.insert(0, "--release".into());
+ }
+
+ cargo.command.args(cargo.args);
+
let rustflags = &cargo.rustflags.0;
if !rustflags.is_empty() {
cargo.command.env("RUSTFLAGS", rustflags);
@@ -360,6 +372,7 @@ impl From for BootstrapCommand {
if !cargo.allow_features.is_empty() {
cargo.command.env("RUSTC_ALLOW_FEATURES", cargo.allow_features);
}
+
cargo.command
}
}
@@ -429,13 +442,6 @@ impl Builder<'_> {
assert_eq!(target, compiler.host);
}
- if self.config.rust_optimize.is_release() &&
- // cargo bench/install do not accept `--release` and miri doesn't want it
- !matches!(cmd_kind, Kind::Bench | Kind::Install | Kind::Miri | Kind::MiriSetup | Kind::MiriTest)
- {
- cargo.arg("--release");
- }
-
// Remove make-related flags to ensure Cargo can correctly set things up
cargo.env_remove("MAKEFLAGS");
cargo.env_remove("MFLAGS");
@@ -1218,14 +1224,20 @@ impl Builder<'_> {
rustflags.arg("-Zmir_strip_debuginfo=locals-in-tiny-functions");
}
+ let release_build = self.config.rust_optimize.is_release() &&
+ // cargo bench/install do not accept `--release` and miri doesn't want it
+ !matches!(cmd_kind, Kind::Bench | Kind::Install | Kind::Miri | Kind::MiriSetup | Kind::MiriTest);
+
Cargo {
command: cargo,
+ args: vec![],
compiler,
target,
rustflags,
rustdocflags,
hostflags,
allow_features,
+ release_build,
}
}
}
diff --git a/src/doc/rustc-dev-guide/.github/workflows/ci.yml b/src/doc/rustc-dev-guide/.github/workflows/ci.yml
index 006bcce44b3..3f810e2fbcc 100644
--- a/src/doc/rustc-dev-guide/.github/workflows/ci.yml
+++ b/src/doc/rustc-dev-guide/.github/workflows/ci.yml
@@ -41,7 +41,9 @@ jobs:
uses: actions/cache/restore@v4
with:
path: book/linkcheck/cache.json
- key: linkcheck--${{ env.MDBOOK_LINKCHECK2_VERSION }}
+ key: linkcheck--${{ env.MDBOOK_LINKCHECK2_VERSION }}--${{ github.run_id }}
+ restore-keys: |
+ linkcheck--${{ env.MDBOOK_LINKCHECK2_VERSION }}--
- name: Install latest nightly Rust toolchain
if: steps.mdbook-cache.outputs.cache-hit != 'true'
@@ -66,7 +68,7 @@ jobs:
uses: actions/cache/save@v4
with:
path: book/linkcheck/cache.json
- key: linkcheck--${{ env.MDBOOK_LINKCHECK2_VERSION }}
+ key: linkcheck--${{ env.MDBOOK_LINKCHECK2_VERSION }}--${{ github.run_id }}
- name: Deploy to gh-pages
if: github.event_name == 'push'
diff --git a/src/doc/rustc-dev-guide/.github/workflows/rustc-pull.yml b/src/doc/rustc-dev-guide/.github/workflows/rustc-pull.yml
index 87a3ee2e78f..615927d55e5 100644
--- a/src/doc/rustc-dev-guide/.github/workflows/rustc-pull.yml
+++ b/src/doc/rustc-dev-guide/.github/workflows/rustc-pull.yml
@@ -50,10 +50,10 @@ jobs:
RESULT=`gh pr list --author github-actions[bot] --state open -q 'map(select(.title=="Rustc pull update")) | length' --json title`
if [[ "$RESULT" -eq 0 ]]; then
echo "Creating new pull request"
- PR_URL=gh pr create -B master --title 'Rustc pull update' --body 'Latest update from rustc.'
+ PR_URL=`gh pr create -B master --title 'Rustc pull update' --body 'Latest update from rustc.'`
echo "pr_url=$PR_URL" >> $GITHUB_OUTPUT
else
- PR_URL=gh pr list --author github-actions[bot] --state open -q 'map(select(.title=="Rustc pull update")) | .[0].url' --json url,title
+ PR_URL=`gh pr list --author github-actions[bot] --state open -q 'map(select(.title=="Rustc pull update")) | .[0].url' --json url,title`
echo "pr_url=$PR_URL" >> $GITHUB_OUTPUT
fi
env:
diff --git a/src/doc/rustc-dev-guide/rust-version b/src/doc/rustc-dev-guide/rust-version
index 9693bfd63e8..183d26b2938 100644
--- a/src/doc/rustc-dev-guide/rust-version
+++ b/src/doc/rustc-dev-guide/rust-version
@@ -1 +1 @@
-ecda83b30f0f68cf5692855dddc0bc38ee8863fc
+66d6064f9eb888018775e08f84747ee6f39ba28e
diff --git a/src/doc/rustc-dev-guide/src/about-this-guide.md b/src/doc/rustc-dev-guide/src/about-this-guide.md
index 793bfa9e66e..781a5c51bf7 100644
--- a/src/doc/rustc-dev-guide/src/about-this-guide.md
+++ b/src/doc/rustc-dev-guide/src/about-this-guide.md
@@ -72,7 +72,6 @@ You might also find the following sites useful:
- The [Rust reference][rr], even though it doesn't specifically talk about
Rust's internals, is a great resource nonetheless
- Although out of date, [Tom Lee's great blog article][tlgba] is very helpful
-- [rustaceans.org][ro] is helpful, but mostly dedicated to IRC
- The [Rust Compiler Testing Docs][rctd]
- For [@bors], [this cheat sheet][cheatsheet] is helpful
- Google is always helpful when programming.
diff --git a/src/doc/rustc-dev-guide/src/backend/libs-and-metadata.md b/src/doc/rustc-dev-guide/src/backend/libs-and-metadata.md
index b0823b9a5ee..556b3fdf8f8 100644
--- a/src/doc/rustc-dev-guide/src/backend/libs-and-metadata.md
+++ b/src/doc/rustc-dev-guide/src/backend/libs-and-metadata.md
@@ -42,7 +42,7 @@ format is specific to `rustc`, and may change over time. This file contains:
### dylib
A `dylib` is a platform-specific shared library. It includes the `rustc`
-[metadata] in a special link section called `.rustc` in a compressed format.
+[metadata] in a special link section called `.rustc`.
### rmeta
diff --git a/src/doc/rustc-dev-guide/src/diagnostics.md b/src/doc/rustc-dev-guide/src/diagnostics.md
index 709e9d4f889..8f389640d27 100644
--- a/src/doc/rustc-dev-guide/src/diagnostics.md
+++ b/src/doc/rustc-dev-guide/src/diagnostics.md
@@ -602,7 +602,7 @@ as the linter walks the AST. You can then choose to emit lints in a
very similar way to compile errors.
You also declare the metadata of a particular lint via the `declare_lint!`
-macro. This includes the name, the default level, a short description, and some
+macro. [This macro](https://doc.rust-lang.org/nightly/nightly-rustc/rustc_lint_defs/macro.declare_lint.html) includes the name, the default level, a short description, and some
more details.
Note that the lint and the lint pass must be registered with the compiler.
diff --git a/src/doc/rustc-dev-guide/src/early_late_parameters.md b/src/doc/rustc-dev-guide/src/early_late_parameters.md
index 6d13655294d..3b2a5e8a155 100644
--- a/src/doc/rustc-dev-guide/src/early_late_parameters.md
+++ b/src/doc/rustc-dev-guide/src/early_late_parameters.md
@@ -126,9 +126,9 @@ In this example we call `foo`'s function item type twice, each time with a borro
If the lifetime parameter on `foo` was late bound this would be able to compile as each caller could provide a different lifetime argument for its borrow. See the following example which demonstrates this using the `bar` function defined above:
```rust
-#fn foo<'a: 'a>(b: &'a String) -> &'a String { b }
-#fn bar<'a>(b: &'a String) -> &'a String { b }
-
+# fn foo<'a: 'a>(b: &'a String) -> &'a String { b }
+# fn bar<'a>(b: &'a String) -> &'a String { b }
+#
// Early bound parameters are instantiated here, however as `'a` is
// late bound it is not provided here.
let b = bar;
@@ -220,24 +220,24 @@ Then, for the first case, we can call each function with a single lifetime argum
```rust
#![deny(late_bound_lifetime_arguments)]
-#fn free_function<'a: 'a, 'b>(_: &'a (), _: &'b ()) {}
+# fn free_function<'a: 'a, 'b>(_: &'a (), _: &'b ()) {}
#
-#struct Foo;
+# struct Foo;
#
-#trait Trait: Sized {
-# fn trait_method<'a: 'a, 'b>(self, _: &'a (), _: &'b ());
-# fn trait_function<'a: 'a, 'b>(_: &'a (), _: &'b ());
-#}
+# trait Trait: Sized {
+# fn trait_method<'a: 'a, 'b>(self, _: &'a (), _: &'b ());
+# fn trait_function<'a: 'a, 'b>(_: &'a (), _: &'b ());
+# }
#
-#impl Trait for Foo {
-# fn trait_method<'a: 'a, 'b>(self, _: &'a (), _: &'b ()) {}
-# fn trait_function<'a: 'a, 'b>(_: &'a (), _: &'b ()) {}
-#}
+# impl Trait for Foo {
+# fn trait_method<'a: 'a, 'b>(self, _: &'a (), _: &'b ()) {}
+# fn trait_function<'a: 'a, 'b>(_: &'a (), _: &'b ()) {}
+# }
#
-#impl Foo {
-# fn inherent_method<'a: 'a, 'b>(self, _: &'a (), _: &'b ()) {}
-# fn inherent_function<'a: 'a, 'b>(_: &'a (), _: &'b ()) {}
-#}
+# impl Foo {
+# fn inherent_method<'a: 'a, 'b>(self, _: &'a (), _: &'b ()) {}
+# fn inherent_function<'a: 'a, 'b>(_: &'a (), _: &'b ()) {}
+# }
#
// Specifying as many arguments as there are early
// bound parameters is always a future compat warning
@@ -251,24 +251,24 @@ free_function::<'static>(&(), &());
For the second case we call each function with more lifetime arguments than there are lifetime parameters (be it early or late bound) and note that method calls result in a FCW as opposed to the free/associated functions which result in a hard error:
```rust
-#fn free_function<'a: 'a, 'b>(_: &'a (), _: &'b ()) {}
+# fn free_function<'a: 'a, 'b>(_: &'a (), _: &'b ()) {}
#
-#struct Foo;
+# struct Foo;
#
-#trait Trait: Sized {
-# fn trait_method<'a: 'a, 'b>(self, _: &'a (), _: &'b ());
-# fn trait_function<'a: 'a, 'b>(_: &'a (), _: &'b ());
-#}
+# trait Trait: Sized {
+# fn trait_method<'a: 'a, 'b>(self, _: &'a (), _: &'b ());
+# fn trait_function<'a: 'a, 'b>(_: &'a (), _: &'b ());
+# }
#
-#impl Trait for Foo {
-# fn trait_method<'a: 'a, 'b>(self, _: &'a (), _: &'b ()) {}
-# fn trait_function<'a: 'a, 'b>(_: &'a (), _: &'b ()) {}
-#}
+# impl Trait for Foo {
+# fn trait_method<'a: 'a, 'b>(self, _: &'a (), _: &'b ()) {}
+# fn trait_function<'a: 'a, 'b>(_: &'a (), _: &'b ()) {}
+# }
#
-#impl Foo {
-# fn inherent_method<'a: 'a, 'b>(self, _: &'a (), _: &'b ()) {}
-# fn inherent_function<'a: 'a, 'b>(_: &'a (), _: &'b ()) {}
-#}
+# impl Foo {
+# fn inherent_method<'a: 'a, 'b>(self, _: &'a (), _: &'b ()) {}
+# fn inherent_function<'a: 'a, 'b>(_: &'a (), _: &'b ()) {}
+# }
#
// Specifying more arguments than there are early
// bound parameters is a future compat warning when
@@ -421,4 +421,4 @@ impl<'a> Fn<()> for FooFnItem<'a> {
type Output = &'a String;
/* fn call(...) -> ... { ... } */
}
-```
\ No newline at end of file
+```
diff --git a/src/doc/rustc-dev-guide/src/getting-started.md b/src/doc/rustc-dev-guide/src/getting-started.md
index 03d2811e8b1..4cb1d0b31eb 100644
--- a/src/doc/rustc-dev-guide/src/getting-started.md
+++ b/src/doc/rustc-dev-guide/src/getting-started.md
@@ -137,6 +137,10 @@ pull request, continuing the work on the feature.
[abandoned-prs]: https://github.com/rust-lang/rust/pulls?q=is%3Apr+label%3AS-inactive+is%3Aclosed
+### Writing tests
+
+Issues that have been resolved but do not have a regression test are marked with the `E-needs-test` label. Writing unit tests is a low-risk, lower-priority task that offers new contributors a great opportunity to familiarize themselves with the testing infrastructure and contribution workflow.
+
### Contributing to std (standard library)
See [std-dev-guide](https://std-dev-guide.rust-lang.org/).
diff --git a/src/doc/rustc-dev-guide/src/rustdoc.md b/src/doc/rustc-dev-guide/src/rustdoc.md
index 3867d248988..2a0e212f98e 100644
--- a/src/doc/rustc-dev-guide/src/rustdoc.md
+++ b/src/doc/rustc-dev-guide/src/rustdoc.md
@@ -58,10 +58,13 @@ does is call the `main()` that's in this crate's `lib.rs`, though.)
* If you want to copy those docs to a webserver, copy all of
`build/host/doc`, since that's where the CSS, JS, fonts, and landing
page are.
+ * For frontend debugging, disable the `rust.docs-minification` option in [`config.toml`].
* Use `./x test tests/rustdoc*` to run the tests using a stage1
rustdoc.
* See [Rustdoc internals] for more information about tests.
+[`config.toml`]: ./building/how-to-build-and-run.md
+
## Code structure
* All paths in this section are relative to `src/librustdoc` in the rust-lang/rust repository.
@@ -77,6 +80,7 @@ does is call the `main()` that's in this crate's `lib.rs`, though.)
* The tests on the structure of rustdoc HTML output are located in `tests/rustdoc`, where
they're handled by the test runner of bootstrap and the supplementary script
`src/etc/htmldocck.py`.
+* Frontend CSS and JavaScript are stored in `html/static/`.
## Tests
@@ -91,6 +95,11 @@ does is call the `main()` that's in this crate's `lib.rs`, though.)
browser-UI-test](https://github.com/GuillaumeGomez/browser-UI-test/) that uses
puppeteer to run tests in a headless browser and check rendering and
interactivity.
+* Additionally, JavaScript type annotations are written using [TypeScript-flavored JSDoc]
+ comments and an external d.ts file. The code itself is plain, valid JavaScript; we only
+ use tsc as a linter.
+
+[TypeScript-flavored JSDoc]: https://www.typescriptlang.org/docs/handbook/jsdoc-supported-types.html
## Constraints
diff --git a/src/doc/rustc-dev-guide/src/solve/significant-changes.md b/src/doc/rustc-dev-guide/src/solve/significant-changes.md
index c5bb8a01b12..c82b5d46896 100644
--- a/src/doc/rustc-dev-guide/src/solve/significant-changes.md
+++ b/src/doc/rustc-dev-guide/src/solve/significant-changes.md
@@ -42,7 +42,7 @@ old implementation structurally relates the aliases instead. This enables the
new solver to stall equality until it is able to normalize the related aliases.
The behavior of the old solver is incomplete and relies on eager normalization
-which replaces ambiguous aliases with inference variables. As this is not
+which replaces ambiguous aliases with inference variables. As this is
not possible for aliases containing bound variables, the old implementation does
not handle aliases inside of binders correctly, e.g. [#102048]. See the chapter on
[normalization] for more details.
diff --git a/src/doc/rustc-dev-guide/src/traits/implied-bounds.md b/src/doc/rustc-dev-guide/src/traits/implied-bounds.md
index 63b09a43f47..05693dcd5a1 100644
--- a/src/doc/rustc-dev-guide/src/traits/implied-bounds.md
+++ b/src/doc/rustc-dev-guide/src/traits/implied-bounds.md
@@ -40,7 +40,7 @@ requirements of impls and functions as explicit predicates.
### using implicit implied bounds as assumptions
These bounds are not added to the `ParamEnv` of the affected item itself. For lexical
-region resolution they are added using [`fn OutlivesEnvironment::with_bounds`].
+region resolution they are added using [`fn OutlivesEnvironment::new`].
Similarly, during MIR borrowck we add them using
[`fn UniversalRegionRelationsBuilder::add_implied_bounds`].
@@ -55,7 +55,7 @@ The assumed outlives constraints for implicit bounds are computed using the
MIR borrowck adds the outlives constraints for both the normalized and unnormalized types,
lexical region resolution [only uses the unnormalized types][notnorm].
-[`fn OutlivesEnvironment::with_bounds`]: https://github.com/rust-lang/rust/blob/5b8bc568d28b2e922290c9a966b3231d0ce9398b/compiler/rustc_infer/src/infer/outlives/env.rs#L90-L97
+[`fn OutlivesEnvironment::new`]: TODO
[`fn UniversalRegionRelationsBuilder::add_implied_bounds`]: https://github.com/rust-lang/rust/blob/5b8bc568d28b2e922290c9a966b3231d0ce9398b/compiler/rustc_borrowck/src/type_check/free_region_relations.rs#L316
[mir]: https://github.com/rust-lang/rust/blob/91cae1dcdcf1a31bd8a92e4a63793d65cfe289bb/compiler/rustc_borrowck/src/type_check/free_region_relations.rs#L258-L332
[`fn assumed_wf_types`]: https://github.com/rust-lang/rust/blob/5b8bc568d28b2e922290c9a966b3231d0ce9398b/compiler/rustc_ty_utils/src/implied_bounds.rs#L21
diff --git a/src/doc/unstable-book/src/compiler-flags/dwarf-version.md b/src/doc/unstable-book/src/compiler-flags/dwarf-version.md
index c5e86f17df7..e88799d2cf0 100644
--- a/src/doc/unstable-book/src/compiler-flags/dwarf-version.md
+++ b/src/doc/unstable-book/src/compiler-flags/dwarf-version.md
@@ -1,5 +1,9 @@
## `dwarf-version`
+The tracking issue for this feature is:
+
+----------------------------
+
This option controls the version of DWARF that the compiler emits, on platforms
that use DWARF to encode debug information. It takes one of the following
values:
diff --git a/src/doc/unstable-book/src/language-features/ref-pat-eat-one-layer-2024-structural.md b/src/doc/unstable-book/src/language-features/ref-pat-eat-one-layer-2024-structural.md
new file mode 100644
index 00000000000..bc587686111
--- /dev/null
+++ b/src/doc/unstable-book/src/language-features/ref-pat-eat-one-layer-2024-structural.md
@@ -0,0 +1,19 @@
+# `ref_pat_eat_one_layer_2024_structural`
+
+The tracking issue for this feature is: [#123076]
+
+[#123076]: https://github.com/rust-lang/rust/issues/123076
+
+---
+
+This feature is incomplete and not yet intended for general use.
+
+This implements experimental, Edition-dependent match ergonomics under consideration for inclusion
+in Rust.
+For more information, see the corresponding typing rules for [Editions 2024 and later].
+On earlier Editions, the current behavior is unspecified.
+
+For alternative experimental match ergonomics, see the feature
+[`ref_pat_eat_one_layer_2024`](./ref-pat-eat-one-layer-2024.md).
+
+[Editions 2024 and later]: https://nadrieril.github.io/typing-rust-patterns/?compare=false&opts1=AQEBAgEBAQEBAgIAAAAAAAAAAAAAAAA%3D&mode=rules&do_cmp=false
diff --git a/src/doc/unstable-book/src/language-features/ref-pat-eat-one-layer-2024.md b/src/doc/unstable-book/src/language-features/ref-pat-eat-one-layer-2024.md
new file mode 100644
index 00000000000..43de1849a5e
--- /dev/null
+++ b/src/doc/unstable-book/src/language-features/ref-pat-eat-one-layer-2024.md
@@ -0,0 +1,19 @@
+# `ref_pat_eat_one_layer_2024`
+
+The tracking issue for this feature is: [#123076]
+
+[#123076]: https://github.com/rust-lang/rust/issues/123076
+
+---
+
+This feature is incomplete and not yet intended for general use.
+
+This implements experimental, Edition-dependent match ergonomics under consideration for inclusion
+in Rust.
+For more information, see the corresponding typing rules for [Editions 2024 and later].
+On earlier Editions, the current behavior is unspecified.
+
+For alternative experimental match ergonomics, see the feature
+[`ref_pat_eat_one_layer_2024_structural`](./ref-pat-eat-one-layer-2024-structural.md).
+
+[Editions 2024 and later]: https://nadrieril.github.io/typing-rust-patterns/?compare=false&opts1=AQEBAAABAQABAgIAAQEBAAEBAAABAAA%3D&mode=rules&do_cmp=false
diff --git a/src/librustdoc/build.rs b/src/librustdoc/build.rs
index 69337fb1d25..b4b0a8d0615 100644
--- a/src/librustdoc/build.rs
+++ b/src/librustdoc/build.rs
@@ -17,10 +17,15 @@ fn main() {
"static/images/rust-logo.svg",
"static/images/favicon.svg",
"static/images/favicon-32x32.png",
+ "static/fonts/FiraSans-Italic.woff2",
"static/fonts/FiraSans-Regular.woff2",
"static/fonts/FiraSans-Medium.woff2",
+ "static/fonts/FiraSans-MediumItalic.woff2",
+ "static/fonts/FiraMono-Regular.woff2",
+ "static/fonts/FiraMono-Medium.woff2",
"static/fonts/FiraSans-LICENSE.txt",
"static/fonts/SourceSerif4-Regular.ttf.woff2",
+ "static/fonts/SourceSerif4-Semibold.ttf.woff2",
"static/fonts/SourceSerif4-Bold.ttf.woff2",
"static/fonts/SourceSerif4-It.ttf.woff2",
"static/fonts/SourceSerif4-LICENSE.md",
diff --git a/src/librustdoc/clean/utils.rs b/src/librustdoc/clean/utils.rs
index 77040aeb94d..0b4fd9c2258 100644
--- a/src/librustdoc/clean/utils.rs
+++ b/src/librustdoc/clean/utils.rs
@@ -344,10 +344,8 @@ pub(crate) fn print_const(cx: &DocContext<'_>, n: ty::Const<'_>) -> String {
s
}
// array lengths are obviously usize
- ty::ConstKind::Value(ty, ty::ValTree::Leaf(scalar))
- if *ty.kind() == ty::Uint(ty::UintTy::Usize) =>
- {
- scalar.to_string()
+ ty::ConstKind::Value(cv) if *cv.ty.kind() == ty::Uint(ty::UintTy::Usize) => {
+ cv.valtree.unwrap_leaf().to_string()
}
_ => n.to_string(),
}
diff --git a/src/librustdoc/html/static/COPYRIGHT.txt b/src/librustdoc/html/static/COPYRIGHT.txt
index 1447df792f6..111340298c5 100644
--- a/src/librustdoc/html/static/COPYRIGHT.txt
+++ b/src/librustdoc/html/static/COPYRIGHT.txt
@@ -36,7 +36,7 @@ included, and carry their own copyright notices and license terms:
See SourceCodePro-LICENSE.txt.
* Source Serif 4 (SourceSerif4-Regular.ttf.woff2, SourceSerif4-Bold.ttf.woff2,
- SourceSerif4-It.ttf.woff2):
+ SourceSerif4-It.ttf.woff2, SourceSerif4-Semibold.ttf.woff2):
Copyright 2014-2021 Adobe (http://www.adobe.com/), with Reserved Font Name
'Source'. All Rights Reserved. Source is a trademark of Adobe in the United
diff --git a/src/librustdoc/html/static/css/rustdoc.css b/src/librustdoc/html/static/css/rustdoc.css
index f487d66edac..d0612e997fd 100644
--- a/src/librustdoc/html/static/css/rustdoc.css
+++ b/src/librustdoc/html/static/css/rustdoc.css
@@ -38,6 +38,13 @@ xmlns="http://www.w3.org/2000/svg" fill="black" height="18px">\
--code-block-border-radius: 6px;
--impl-items-indent: 0.3em;
--docblock-indent: 24px;
+ --font-family: "Source Serif 4", NanumBarunGothic, serif;
+ --font-family-code: "Source Code Pro", monospace;
+}
+
+:root.sans-serif {
+ --font-family: "Fira Sans", sans-serif;
+ --font-family-code: "Fira Mono", monospace;
}
/* See FiraSans-LICENSE.txt for the Fira Sans license. */
@@ -49,6 +56,14 @@ xmlns="http://www.w3.org/2000/svg" fill="black" height="18px">\
url("FiraSans-Regular-0fe48ade.woff2") format("woff2");
font-display: swap;
}
+@font-face {
+ font-family: 'Fira Sans';
+ font-style: italic;
+ font-weight: 400;
+ src: local('Fira Sans Italic'),
+ url("FiraSans-Italic-81dc35de.woff2") format("woff2");
+ font-display: swap;
+}
@font-face {
font-family: 'Fira Sans';
font-style: normal;
@@ -57,6 +72,30 @@ xmlns="http://www.w3.org/2000/svg" fill="black" height="18px">\
url("FiraSans-Medium-e1aa3f0a.woff2") format("woff2");
font-display: swap;
}
+@font-face {
+ font-family: 'Fira Sans';
+ font-style: italic;
+ font-weight: 500;
+ src: local('Fira Sans Medium Italic'),
+ url("FiraSans-MediumItalic-ccf7e434.woff2") format("woff2");
+ font-display: swap;
+}
+@font-face {
+ font-family: 'Fira Mono';
+ font-style: normal;
+ font-weight: 400;
+ src: local('Fira Mono'),
+ url("FiraMono-Regular-87c26294.woff2") format("woff2");
+ font-display: swap;
+}
+@font-face {
+ font-family: 'Fira Mono';
+ font-style: normal;
+ font-weight: 500;
+ src: local('Fira Mono Medium'),
+ url("FiraMono-Medium-86f75c8c.woff2") format("woff2");
+ font-display: swap;
+}
/* See SourceSerif4-LICENSE.md for the Source Serif 4 license. */
@font-face {
@@ -75,6 +114,14 @@ xmlns="http://www.w3.org/2000/svg" fill="black" height="18px">\
url("SourceSerif4-It-ca3b17ed.ttf.woff2") format("woff2");
font-display: swap;
}
+@font-face {
+ font-family: 'Source Serif 4';
+ font-style: normal;
+ font-weight: 500;
+ src: local('Source Serif 4 Semibold'),
+ url("SourceSerif4-Semibold-457a13ac.ttf.woff2") format("woff2");
+ font-display: swap;
+}
@font-face {
font-family: 'Source Serif 4';
font-style: normal;
@@ -126,7 +173,7 @@ xmlns="http://www.w3.org/2000/svg" fill="black" height="18px">\
body {
/* Line spacing at least 1.5 per Web Content Accessibility Guidelines
https://www.w3.org/WAI/WCAG21/Understanding/visual-presentation.html */
- font: 1rem/1.5 "Source Serif 4", NanumBarunGothic, serif;
+ font: 1rem/1.5 var(--font-family);
margin: 0;
position: relative;
/* We use overflow-wrap: break-word for Safari, which doesn't recognize
@@ -380,7 +427,7 @@ details:not(.toggle) summary {
}
code, pre, .code-header, .type-signature {
- font-family: "Source Code Pro", monospace;
+ font-family: var(--font-family-code);
}
.docblock code, .item-table dd code {
border-radius: 3px;
diff --git a/src/librustdoc/html/static/fonts/FiraMono-Medium.woff2 b/src/librustdoc/html/static/fonts/FiraMono-Medium.woff2
new file mode 100755
index 00000000000..610e9b2071e
Binary files /dev/null and b/src/librustdoc/html/static/fonts/FiraMono-Medium.woff2 differ
diff --git a/src/librustdoc/html/static/fonts/FiraMono-Regular.woff2 b/src/librustdoc/html/static/fonts/FiraMono-Regular.woff2
new file mode 100755
index 00000000000..9fa44b7cc2d
Binary files /dev/null and b/src/librustdoc/html/static/fonts/FiraMono-Regular.woff2 differ
diff --git a/src/librustdoc/html/static/fonts/FiraSans-Italic.woff2 b/src/librustdoc/html/static/fonts/FiraSans-Italic.woff2
new file mode 100755
index 00000000000..3f63664fee6
Binary files /dev/null and b/src/librustdoc/html/static/fonts/FiraSans-Italic.woff2 differ
diff --git a/src/librustdoc/html/static/fonts/FiraSans-MediumItalic.woff2 b/src/librustdoc/html/static/fonts/FiraSans-MediumItalic.woff2
new file mode 100755
index 00000000000..2d08f9f7d45
Binary files /dev/null and b/src/librustdoc/html/static/fonts/FiraSans-MediumItalic.woff2 differ
diff --git a/src/librustdoc/html/static/fonts/SourceSerif4-Semibold.ttf.woff2 b/src/librustdoc/html/static/fonts/SourceSerif4-Semibold.ttf.woff2
new file mode 100644
index 00000000000..dd55f4e95ec
Binary files /dev/null and b/src/librustdoc/html/static/fonts/SourceSerif4-Semibold.ttf.woff2 differ
diff --git a/src/librustdoc/html/static/js/settings.js b/src/librustdoc/html/static/js/settings.js
index d7b0e4b4f54..bf33e0f17e5 100644
--- a/src/librustdoc/html/static/js/settings.js
+++ b/src/librustdoc/html/static/js/settings.js
@@ -53,6 +53,12 @@
removeClass(document.documentElement, "hide-modnav");
}
break;
+ case "sans-serif-fonts":
+ if (value === true) {
+ addClass(document.documentElement, "sans-serif");
+ } else {
+ removeClass(document.documentElement, "sans-serif");
+ }
}
}
@@ -235,6 +241,11 @@
"js_name": "disable-shortcuts",
"default": false,
},
+ {
+ "name": "Use sans serif fonts",
+ "js_name": "sans-serif-fonts",
+ "default": false,
+ },
];
// Then we build the DOM.
diff --git a/src/librustdoc/html/static/js/storage.js b/src/librustdoc/html/static/js/storage.js
index 4770ccc1279..10369e77320 100644
--- a/src/librustdoc/html/static/js/storage.js
+++ b/src/librustdoc/html/static/js/storage.js
@@ -279,6 +279,9 @@ if (getSettingValue("hide-toc") === "true") {
if (getSettingValue("hide-modnav") === "true") {
addClass(document.documentElement, "hide-modnav");
}
+if (getSettingValue("sans-serif-fonts") === "true") {
+ addClass(document.documentElement, "sans-serif");
+}
function updateSidebarWidth() {
const desktopSidebarWidth = getSettingValue("desktop-sidebar-width");
if (desktopSidebarWidth && desktopSidebarWidth !== "null") {
diff --git a/src/librustdoc/html/static_files.rs b/src/librustdoc/html/static_files.rs
index 6457ac731cb..0bcaf11da0c 100644
--- a/src/librustdoc/html/static_files.rs
+++ b/src/librustdoc/html/static_files.rs
@@ -98,10 +98,15 @@ static_files! {
rust_logo_svg => "static/images/rust-logo.svg",
rust_favicon_svg => "static/images/favicon.svg",
rust_favicon_png_32 => "static/images/favicon-32x32.png",
+ fira_sans_italic => "static/fonts/FiraSans-Italic.woff2",
fira_sans_regular => "static/fonts/FiraSans-Regular.woff2",
fira_sans_medium => "static/fonts/FiraSans-Medium.woff2",
+ fira_sans_medium_italic => "static/fonts/FiraSans-MediumItalic.woff2",
+ fira_mono_regular => "static/fonts/FiraMono-Regular.woff2",
+ fira_mono_medium => "static/fonts/FiraMono-Medium.woff2",
fira_sans_license => "static/fonts/FiraSans-LICENSE.txt",
source_serif_4_regular => "static/fonts/SourceSerif4-Regular.ttf.woff2",
+ source_serif_4_semibold => "static/fonts/SourceSerif4-Semibold.ttf.woff2",
source_serif_4_bold => "static/fonts/SourceSerif4-Bold.ttf.woff2",
source_serif_4_italic => "static/fonts/SourceSerif4-It.ttf.woff2",
source_serif_4_license => "static/fonts/SourceSerif4-LICENSE.md",
diff --git a/src/librustdoc/html/templates/page.html b/src/librustdoc/html/templates/page.html
index a05d6ca8313..5ef376f4acb 100644
--- a/src/librustdoc/html/templates/page.html
+++ b/src/librustdoc/html/templates/page.html
@@ -7,7 +7,7 @@
{# #}
{{page.title}} {# #}
{# #}
{# #}
diff --git a/src/tools/clippy/clippy_lints/src/large_const_arrays.rs b/src/tools/clippy/clippy_lints/src/large_const_arrays.rs
index 623b6b4fcc1..cabf10b7e0e 100644
--- a/src/tools/clippy/clippy_lints/src/large_const_arrays.rs
+++ b/src/tools/clippy/clippy_lints/src/large_const_arrays.rs
@@ -56,9 +56,8 @@ impl<'tcx> LateLintPass<'tcx> for LargeConstArrays {
&& !item.span.from_expansion()
&& let ty = cx.tcx.type_of(item.owner_id).instantiate_identity()
&& let ty::Array(element_type, cst) = ty.kind()
- && let Some((ty::ValTree::Leaf(element_count), _)) = cx.tcx
- .try_normalize_erasing_regions(cx.typing_env(), *cst).unwrap_or(*cst).try_to_valtree()
- && let element_count = element_count.to_target_usize(cx.tcx)
+ && let Some(element_count) = cx.tcx
+ .try_normalize_erasing_regions(cx.typing_env(), *cst).unwrap_or(*cst).try_to_target_usize(cx.tcx)
&& let Ok(element_size) = cx.layout_of(*element_type).map(|l| l.size.bytes())
&& u128::from(self.maximum_allowed_size) < u128::from(element_count) * u128::from(element_size)
{
diff --git a/src/tools/clippy/clippy_lints/src/large_stack_arrays.rs b/src/tools/clippy/clippy_lints/src/large_stack_arrays.rs
index 46d7df6995a..6f5c5d6b3ea 100644
--- a/src/tools/clippy/clippy_lints/src/large_stack_arrays.rs
+++ b/src/tools/clippy/clippy_lints/src/large_stack_arrays.rs
@@ -8,7 +8,7 @@ use clippy_utils::source::snippet;
use rustc_hir::{Expr, ExprKind, Item, ItemKind, Node};
use rustc_lint::{LateContext, LateLintPass};
use rustc_middle::ty::layout::LayoutOf;
-use rustc_middle::ty::{self, ConstKind};
+use rustc_middle::ty;
use rustc_session::impl_lint_pass;
use rustc_span::{Span, sym};
@@ -81,8 +81,7 @@ impl<'tcx> LateLintPass<'tcx> for LargeStackArrays {
&& let ExprKind::Repeat(_, _) | ExprKind::Array(_) = expr.kind
&& !self.is_from_vec_macro(cx, expr.span)
&& let ty::Array(element_type, cst) = cx.typeck_results().expr_ty(expr).kind()
- && let ConstKind::Value(_, ty::ValTree::Leaf(element_count)) = cst.kind()
- && let element_count = element_count.to_target_usize(cx.tcx)
+ && let Some(element_count) = cst.try_to_target_usize(cx.tcx)
&& let Ok(element_size) = cx.layout_of(*element_type).map(|l| l.size.bytes())
&& !cx.tcx.hir().parent_iter(expr.hir_id).any(|(_, node)| {
matches!(
diff --git a/src/tools/compiletest/src/directive-list.rs b/src/tools/compiletest/src/directive-list.rs
index acdb3cbdd45..71496444660 100644
--- a/src/tools/compiletest/src/directive-list.rs
+++ b/src/tools/compiletest/src/directive-list.rs
@@ -177,6 +177,7 @@ const KNOWN_DIRECTIVE_NAMES: &[&str] = &[
"only-bpf",
"only-cdb",
"only-dist",
+ "only-emscripten",
"only-gnu",
"only-i686-pc-windows-gnu",
"only-i686-pc-windows-msvc",
diff --git a/src/tools/miri/src/intrinsics/simd.rs b/src/tools/miri/src/intrinsics/simd.rs
index 54bdd3f02c2..63a61dcd148 100644
--- a/src/tools/miri/src/intrinsics/simd.rs
+++ b/src/tools/miri/src/intrinsics/simd.rs
@@ -640,7 +640,7 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
let (dest, dest_len) = this.project_to_simd(dest)?;
let index =
- generic_args[2].expect_const().try_to_valtree().unwrap().0.unwrap_branch();
+ generic_args[2].expect_const().to_value().valtree.unwrap_branch();
let index_len = index.len();
assert_eq!(left_len, right_len);
diff --git a/src/tools/opt-dist/src/main.rs b/src/tools/opt-dist/src/main.rs
index 04de3493ea2..565721a9093 100644
--- a/src/tools/opt-dist/src/main.rs
+++ b/src/tools/opt-dist/src/main.rs
@@ -148,16 +148,6 @@ fn create_environment(args: Args) -> anyhow::Result<(Environment, Vec)>
let is_aarch64 = target_triple.starts_with("aarch64");
- let skip_tests = if is_aarch64 {
- vec![
- // Those tests fail only inside of Docker on aarch64, as of December 2024
- "tests/ui/consts/promoted_running_out_of_memory_issue-130687.rs".to_string(),
- "tests/ui/consts/large_const_alloc.rs".to_string(),
- ]
- } else {
- vec![]
- };
-
let checkout_dir = Utf8PathBuf::from("/checkout");
let env = EnvironmentBuilder::default()
.host_tuple(target_triple)
@@ -169,7 +159,7 @@ fn create_environment(args: Args) -> anyhow::Result<(Environment, Vec)>
.shared_llvm(true)
// FIXME: Enable bolt for aarch64 once it's fixed upstream. Broken as of December 2024.
.use_bolt(!is_aarch64)
- .skipped_tests(skip_tests)
+ .skipped_tests(vec![])
.build()?;
(env, shared.build_args)
diff --git a/src/tools/run-make-support/src/external_deps/rustc.rs b/src/tools/run-make-support/src/external_deps/rustc.rs
index b70db7130f6..8d99924a2d1 100644
--- a/src/tools/run-make-support/src/external_deps/rustc.rs
+++ b/src/tools/run-make-support/src/external_deps/rustc.rs
@@ -216,6 +216,18 @@ impl Rustc {
self
}
+ /// Specify option of `-C symbol-mangling-version`.
+ pub fn symbol_mangling_version(&mut self, option: &str) -> &mut Self {
+ self.cmd.arg(format!("-Csymbol-mangling-version={option}"));
+ self
+ }
+
+ /// Specify `-C prefer-dynamic`.
+ pub fn prefer_dynamic(&mut self) -> &mut Self {
+ self.cmd.arg(format!("-Cprefer-dynamic"));
+ self
+ }
+
/// Specify error format to use
pub fn error_format(&mut self, format: &str) -> &mut Self {
self.cmd.arg(format!("--error-format={format}"));
diff --git a/src/tools/run-make-support/src/lib.rs b/src/tools/run-make-support/src/lib.rs
index 7316244b384..a8c9bec57fd 100644
--- a/src/tools/run-make-support/src/lib.rs
+++ b/src/tools/run-make-support/src/lib.rs
@@ -47,7 +47,9 @@ pub use wasmparser;
// tidy-alphabetical-end
// Re-exports of external dependencies.
-pub use external_deps::{c_build, c_cxx_compiler, clang, htmldocck, llvm, python, rustc, rustdoc};
+pub use external_deps::{
+ cargo, c_build, c_cxx_compiler, clang, htmldocck, llvm, python, rustc, rustdoc
+};
// These rely on external dependencies.
pub use c_cxx_compiler::{Cc, Gcc, cc, cxx, extra_c_flags, extra_cxx_flags, gcc};
@@ -79,7 +81,10 @@ pub use env::{env_var, env_var_os, set_current_dir};
pub use run::{cmd, run, run_fail, run_with_args};
/// Helpers for checking target information.
-pub use targets::{is_aix, is_darwin, is_msvc, is_windows, llvm_components_contain, target, uname, apple_os};
+pub use targets::{
+ apple_os, is_aix, is_darwin, is_msvc, is_windows, is_windows_gnu, llvm_components_contain,
+ target, uname,
+};
/// Helpers for building names of output artifacts that are potentially target-specific.
pub use artifact_names::{
@@ -104,4 +109,3 @@ pub use assertion_helpers::{
pub use string::{
count_regex_matches_in_files_with_extension, invalid_utf8_contains, invalid_utf8_not_contains,
};
-use crate::external_deps::cargo;
diff --git a/src/tools/run-make-support/src/symbols.rs b/src/tools/run-make-support/src/symbols.rs
index fd0c866bcc9..e4d244e14a4 100644
--- a/src/tools/run-make-support/src/symbols.rs
+++ b/src/tools/run-make-support/src/symbols.rs
@@ -2,28 +2,44 @@ use std::path::Path;
use object::{self, Object, ObjectSymbol, SymbolIterator};
-/// Iterate through the symbols in an object file.
+/// Given an [`object::File`], find the exported dynamic symbol names via
+/// [`object::Object::exports`]. This does not distinguish between which section the symbols appear
+/// in.
+#[track_caller]
+pub fn exported_dynamic_symbol_names<'file>(file: &'file object::File<'file>) -> Vec<&'file str> {
+ file.exports()
+ .unwrap()
+ .into_iter()
+ .filter_map(|sym| std::str::from_utf8(sym.name()).ok())
+ .collect()
+}
+
+/// Iterate through the symbols in an object file. See [`object::Object::symbols`].
///
-/// Uses a callback because `SymbolIterator` does not own its data.
-///
-/// Panics if `path` is not a valid object file readable by the current user.
+/// Panics if `path` is not a valid object file readable by the current user or if `path` cannot be
+/// parsed as a recognized object file.
+#[track_caller]
pub fn with_symbol_iter(path: P, func: F) -> R
where
P: AsRef,
F: FnOnce(&mut SymbolIterator<'_, '_>) -> R,
{
- let raw_bytes = crate::fs::read(path);
- let f = object::File::parse(raw_bytes.as_slice()).expect("unable to parse file");
+ let path = path.as_ref();
+ let blob = crate::fs::read(path);
+ let f = object::File::parse(&*blob)
+ .unwrap_or_else(|e| panic!("failed to parse `{}`: {e}", path.display()));
let mut iter = f.symbols();
func(&mut iter)
}
/// Check an object file's symbols for substrings.
///
-/// Returns `true` if any of the symbols found in the object file at
-/// `path` contain a substring listed in `substrings`.
+/// Returns `true` if any of the symbols found in the object file at `path` contain a substring
+/// listed in `substrings`.
///
-/// Panics if `path` is not a valid object file readable by the current user.
+/// Panics if `path` is not a valid object file readable by the current user or if `path` cannot be
+/// parsed as a recognized object file.
+#[track_caller]
pub fn any_symbol_contains(path: impl AsRef, substrings: &[&str]) -> bool {
with_symbol_iter(path, |syms| {
for sym in syms {
diff --git a/src/tools/run-make-support/src/targets.rs b/src/tools/run-make-support/src/targets.rs
index ae004fd0cbd..a16fca71d2e 100644
--- a/src/tools/run-make-support/src/targets.rs
+++ b/src/tools/run-make-support/src/targets.rs
@@ -22,6 +22,12 @@ pub fn is_msvc() -> bool {
target().contains("msvc")
}
+/// Check if target is windows-gnu.
+#[must_use]
+pub fn is_windows_gnu() -> bool {
+ target().ends_with("windows-gnu")
+}
+
/// Check if target uses macOS.
#[must_use]
pub fn is_darwin() -> bool {
diff --git a/src/tools/tidy/src/allowed_run_make_makefiles.txt b/src/tools/tidy/src/allowed_run_make_makefiles.txt
index e75d3dc2147..45b40b17ea3 100644
--- a/src/tools/tidy/src/allowed_run_make_makefiles.txt
+++ b/src/tools/tidy/src/allowed_run_make_makefiles.txt
@@ -1,2 +1 @@
run-make/split-debuginfo/Makefile
-run-make/symbol-mangling-hashed/Makefile
diff --git a/src/tools/tidy/src/bins.rs b/src/tools/tidy/src/bins.rs
index d158a8e6324..9b78ba75a05 100644
--- a/src/tools/tidy/src/bins.rs
+++ b/src/tools/tidy/src/bins.rs
@@ -134,7 +134,7 @@ mod os_impl {
&mut |entry| {
let file = entry.path();
let extension = file.extension();
- let scripts = ["py", "sh", "ps1"];
+ let scripts = ["py", "sh", "ps1", "woff2"];
if scripts.into_iter().any(|e| extension == Some(OsStr::new(e))) {
return;
}
diff --git a/tests/codegen/float/f128.rs b/tests/codegen/float/f128.rs
index 514d35433e1..562a8e6c9e9 100644
--- a/tests/codegen/float/f128.rs
+++ b/tests/codegen/float/f128.rs
@@ -1,11 +1,15 @@
// 32-bit x86 returns float types differently to avoid the x87 stack.
// 32-bit systems will return 128bit values using a return area pointer.
-//@ revisions: x86 bit32 bit64
+// Emscripten aligns f128 to 8 bytes, not 16.
+//@ revisions: x86 bit32 bit64 emscripten
//@[x86] only-x86
//@[bit32] ignore-x86
+//@[bit32] ignore-emscripten
//@[bit32] only-32bit
//@[bit64] ignore-x86
+//@[bit64] ignore-emscripten
//@[bit64] only-64bit
+//@[emscripten] only-emscripten
// Verify that our intrinsics generate the correct LLVM calls for f128
@@ -59,6 +63,7 @@ pub fn f128_le(a: f128, b: f128) -> bool {
// x86-LABEL: void @f128_neg({{.*}}sret([16 x i8])
// bit32-LABEL: void @f128_neg({{.*}}sret([16 x i8])
// bit64-LABEL: fp128 @f128_neg(
+// emscripten-LABEL: void @f128_neg({{.*}}sret([16 x i8])
#[no_mangle]
pub fn f128_neg(a: f128) -> f128 {
// CHECK: fneg fp128
@@ -68,6 +73,7 @@ pub fn f128_neg(a: f128) -> f128 {
// x86-LABEL: void @f128_add({{.*}}sret([16 x i8])
// bit32-LABEL: void @f128_add({{.*}}sret([16 x i8])
// bit64-LABEL: fp128 @f128_add(
+// emscripten-LABEL: void @f128_add({{.*}}sret([16 x i8])
#[no_mangle]
pub fn f128_add(a: f128, b: f128) -> f128 {
// CHECK: fadd fp128 %{{.+}}, %{{.+}}
@@ -77,6 +83,7 @@ pub fn f128_add(a: f128, b: f128) -> f128 {
// x86-LABEL: void @f128_sub({{.*}}sret([16 x i8])
// bit32-LABEL: void @f128_sub({{.*}}sret([16 x i8])
// bit64-LABEL: fp128 @f128_sub(
+// emscripten-LABEL: void @f128_sub({{.*}}sret([16 x i8])
#[no_mangle]
pub fn f128_sub(a: f128, b: f128) -> f128 {
// CHECK: fsub fp128 %{{.+}}, %{{.+}}
@@ -86,6 +93,7 @@ pub fn f128_sub(a: f128, b: f128) -> f128 {
// x86-LABEL: void @f128_mul({{.*}}sret([16 x i8])
// bit32-LABEL: void @f128_mul({{.*}}sret([16 x i8])
// bit64-LABEL: fp128 @f128_mul(
+// emscripten-LABEL: void @f128_mul({{.*}}sret([16 x i8])
#[no_mangle]
pub fn f128_mul(a: f128, b: f128) -> f128 {
// CHECK: fmul fp128 %{{.+}}, %{{.+}}
@@ -95,6 +103,7 @@ pub fn f128_mul(a: f128, b: f128) -> f128 {
// x86-LABEL: void @f128_div({{.*}}sret([16 x i8])
// bit32-LABEL: void @f128_div({{.*}}sret([16 x i8])
// bit64-LABEL: fp128 @f128_div(
+// emscripten-LABEL: void @f128_div({{.*}}sret([16 x i8])
#[no_mangle]
pub fn f128_div(a: f128, b: f128) -> f128 {
// CHECK: fdiv fp128 %{{.+}}, %{{.+}}
@@ -104,6 +113,7 @@ pub fn f128_div(a: f128, b: f128) -> f128 {
// x86-LABEL: void @f128_rem({{.*}}sret([16 x i8])
// bit32-LABEL: void @f128_rem({{.*}}sret([16 x i8])
// bit64-LABEL: fp128 @f128_rem(
+// emscripten-LABEL: void @f128_rem({{.*}}sret([16 x i8])
#[no_mangle]
pub fn f128_rem(a: f128, b: f128) -> f128 {
// CHECK: frem fp128 %{{.+}}, %{{.+}}
@@ -164,6 +174,7 @@ pub fn f128_as_f16(a: f128) -> f16 {
// x86-LABEL: i32 @f128_as_f32(
// bit32-LABEL: float @f128_as_f32(
// bit64-LABEL: float @f128_as_f32(
+// emscripten-LABEL: float @f128_as_f32(
#[no_mangle]
pub fn f128_as_f32(a: f128) -> f32 {
// CHECK: fptrunc fp128 %{{.+}} to float
@@ -173,6 +184,7 @@ pub fn f128_as_f32(a: f128) -> f32 {
// x86-LABEL: void @f128_as_f64(
// bit32-LABEL: double @f128_as_f64(
// bit64-LABEL: double @f128_as_f64(
+// emscripten-LABEL: double @f128_as_f64(
#[no_mangle]
pub fn f128_as_f64(a: f128) -> f64 {
// CHECK: fptrunc fp128 %{{.+}} to double
@@ -182,17 +194,20 @@ pub fn f128_as_f64(a: f128) -> f64 {
// x86-LABEL: void @f128_as_self({{.*}}sret([16 x i8])
// bit32-LABEL: void @f128_as_self({{.*}}sret([16 x i8])
// bit64-LABEL: fp128 @f128_as_self(
+// emscripten-LABEL: void @f128_as_self({{.*}}sret([16 x i8])
#[no_mangle]
pub fn f128_as_self(a: f128) -> f128 {
// x86: store fp128 %a, ptr %_0, align 16
// bit32: store fp128 %a, ptr %_0, align 16
// bit64: ret fp128 %{{.+}}
+ // emscripten: store fp128 %a, ptr %_0, align 8
a as f128
}
// x86-LABEL: void @f16_as_f128({{.*}}sret([16 x i8])
// bit32-LABEL: void @f16_as_f128({{.*}}sret([16 x i8])
// bit64-LABEL: fp128 @f16_as_f128(
+// emscripten-LABEL: void @f16_as_f128({{.*}}sret([16 x i8])
#[no_mangle]
pub fn f16_as_f128(a: f16) -> f128 {
// CHECK: fpext half %{{.+}} to fp128
@@ -202,6 +217,7 @@ pub fn f16_as_f128(a: f16) -> f128 {
// x86-LABEL: void @f32_as_f128({{.*}}sret([16 x i8])
// bit32-LABEL: void @f32_as_f128({{.*}}sret([16 x i8])
// bit64-LABEL: fp128 @f32_as_f128(
+// emscripten-LABEL: void @f32_as_f128({{.*}}sret([16 x i8])
#[no_mangle]
pub fn f32_as_f128(a: f32) -> f128 {
// CHECK: fpext float %{{.+}} to fp128
@@ -211,6 +227,7 @@ pub fn f32_as_f128(a: f32) -> f128 {
// x86-LABEL: void @f64_as_f128({{.*}}sret([16 x i8])
// bit32-LABEL: void @f64_as_f128({{.*}}sret([16 x i8])
// bit64-LABEL: fp128 @f64_as_f128(
+// emscripten-LABEL: void @f64_as_f128({{.*}}sret([16 x i8])
#[no_mangle]
pub fn f64_as_f128(a: f64) -> f128 {
// CHECK: fpext double %{{.+}} to fp128
@@ -249,6 +266,7 @@ pub fn f128_as_u64(a: f128) -> u64 {
// x86-LABEL: void @f128_as_u128({{.*}}sret([16 x i8])
// bit32-LABEL: void @f128_as_u128({{.*}}sret([16 x i8])
// bit64-LABEL: i128 @f128_as_u128(
+// emscripten-LABEL: void @f128_as_u128({{.*}}sret([16 x i8])
#[no_mangle]
pub fn f128_as_u128(a: f128) -> u128 {
// CHECK: call i128 @llvm.fptoui.sat.i128.f128(fp128 %{{.+}})
@@ -285,6 +303,7 @@ pub fn f128_as_i64(a: f128) -> i64 {
// x86-LABEL: void @f128_as_i128({{.*}}sret([16 x i8])
// bit32-LABEL: void @f128_as_i128({{.*}}sret([16 x i8])
// bit64-LABEL: i128 @f128_as_i128(
+// emscripten-LABEL: void @f128_as_i128({{.*}}sret([16 x i8])
#[no_mangle]
pub fn f128_as_i128(a: f128) -> i128 {
// CHECK: call i128 @llvm.fptosi.sat.i128.f128(fp128 %{{.+}})
@@ -296,6 +315,7 @@ pub fn f128_as_i128(a: f128) -> i128 {
// x86-LABEL: void @u8_as_f128({{.*}}sret([16 x i8])
// bit32-LABEL: void @u8_as_f128({{.*}}sret([16 x i8])
// bit64-LABEL: fp128 @u8_as_f128(
+// emscripten-LABEL: void @u8_as_f128({{.*}}sret([16 x i8])
#[no_mangle]
pub fn u8_as_f128(a: u8) -> f128 {
// CHECK: uitofp i8 %{{.+}} to fp128
@@ -305,6 +325,7 @@ pub fn u8_as_f128(a: u8) -> f128 {
// x86-LABEL: void @u16_as_f128({{.*}}sret([16 x i8])
// bit32-LABEL: void @u16_as_f128({{.*}}sret([16 x i8])
// bit64-LABEL: fp128 @u16_as_f128(
+// emscripten-LABEL: void @u16_as_f128({{.*}}sret([16 x i8])
#[no_mangle]
pub fn u16_as_f128(a: u16) -> f128 {
// CHECK: uitofp i16 %{{.+}} to fp128
@@ -314,6 +335,7 @@ pub fn u16_as_f128(a: u16) -> f128 {
// x86-LABEL: void @u32_as_f128({{.*}}sret([16 x i8])
// bit32-LABEL: void @u32_as_f128({{.*}}sret([16 x i8])
// bit64-LABEL: fp128 @u32_as_f128(
+// emscripten-LABEL: void @u32_as_f128({{.*}}sret([16 x i8])
#[no_mangle]
pub fn u32_as_f128(a: u32) -> f128 {
// CHECK: uitofp i32 %{{.+}} to fp128
@@ -323,6 +345,7 @@ pub fn u32_as_f128(a: u32) -> f128 {
// x86-LABEL: void @u64_as_f128({{.*}}sret([16 x i8])
// bit32-LABEL: void @u64_as_f128({{.*}}sret([16 x i8])
// bit64-LABEL: fp128 @u64_as_f128(
+// emscripten-LABEL: void @u64_as_f128({{.*}}sret([16 x i8])
#[no_mangle]
pub fn u64_as_f128(a: u64) -> f128 {
// CHECK: uitofp i64 %{{.+}} to fp128
@@ -332,6 +355,7 @@ pub fn u64_as_f128(a: u64) -> f128 {
// x86-LABEL: void @u128_as_f128({{.*}}sret([16 x i8])
// bit32-LABEL: void @u128_as_f128({{.*}}sret([16 x i8])
// bit64-LABEL: fp128 @u128_as_f128(
+// emscripten-LABEL: void @u128_as_f128({{.*}}sret([16 x i8])
#[no_mangle]
pub fn u128_as_f128(a: u128) -> f128 {
// CHECK: uitofp i128 %{{.+}} to fp128
@@ -341,6 +365,7 @@ pub fn u128_as_f128(a: u128) -> f128 {
// x86-LABEL: void @i8_as_f128({{.*}}sret([16 x i8])
// bit32-LABEL: void @i8_as_f128({{.*}}sret([16 x i8])
// bit64-LABEL: fp128 @i8_as_f128(
+// emscripten-LABEL: void @i8_as_f128({{.*}}sret([16 x i8])
#[no_mangle]
pub fn i8_as_f128(a: i8) -> f128 {
// CHECK: sitofp i8 %{{.+}} to fp128
@@ -350,6 +375,7 @@ pub fn i8_as_f128(a: i8) -> f128 {
// x86-LABEL: void @i16_as_f128({{.*}}sret([16 x i8])
// bit32-LABEL: void @i16_as_f128({{.*}}sret([16 x i8])
// bit64-LABEL: fp128 @i16_as_f128(
+// emscripten-LABEL: void @i16_as_f128({{.*}}sret([16 x i8])
#[no_mangle]
pub fn i16_as_f128(a: i16) -> f128 {
// CHECK: sitofp i16 %{{.+}} to fp128
@@ -359,6 +385,7 @@ pub fn i16_as_f128(a: i16) -> f128 {
// x86-LABEL: void @i32_as_f128({{.*}}sret([16 x i8])
// bit32-LABEL: void @i32_as_f128({{.*}}sret([16 x i8])
// bit64-LABEL: fp128 @i32_as_f128(
+// emscripten-LABEL: void @i32_as_f128({{.*}}sret([16 x i8])
#[no_mangle]
pub fn i32_as_f128(a: i32) -> f128 {
// CHECK: sitofp i32 %{{.+}} to fp128
@@ -368,6 +395,7 @@ pub fn i32_as_f128(a: i32) -> f128 {
// x86-LABEL: void @i64_as_f128({{.*}}sret([16 x i8])
// bit32-LABEL: void @i64_as_f128({{.*}}sret([16 x i8])
// bit64-LABEL: fp128 @i64_as_f128(
+// emscripten-LABEL: void @i64_as_f128({{.*}}sret([16 x i8])
#[no_mangle]
pub fn i64_as_f128(a: i64) -> f128 {
// CHECK: sitofp i64 %{{.+}} to fp128
@@ -377,6 +405,7 @@ pub fn i64_as_f128(a: i64) -> f128 {
// x86-LABEL: void @i128_as_f128({{.*}}sret([16 x i8])
// bit32-LABEL: void @i128_as_f128({{.*}}sret([16 x i8])
// bit64-LABEL: fp128 @i128_as_f128(
+// emscripten-LABEL: void @i128_as_f128({{.*}}sret([16 x i8])
#[no_mangle]
pub fn i128_as_f128(a: i128) -> f128 {
// CHECK: sitofp i128 %{{.+}} to fp128
diff --git a/tests/codegen/lib-optimizations/slice_rotate.rs b/tests/codegen/lib-optimizations/slice_rotate.rs
new file mode 100644
index 00000000000..d0a7b328d18
--- /dev/null
+++ b/tests/codegen/lib-optimizations/slice_rotate.rs
@@ -0,0 +1,30 @@
+//@ compile-flags: -O
+
+#![crate_type = "lib"]
+
+// Ensure that the simple case of rotating by a constant 1 optimizes to the obvious thing
+
+// CHECK-LABEL: @rotate_left_by_one
+#[no_mangle]
+pub fn rotate_left_by_one(slice: &mut [i32]) {
+ // CHECK-NOT: phi
+ // CHECK-NOT: call
+ // CHECK-NOT: load
+ // CHECK-NOT: store
+ // CHECK-NOT: getelementptr
+ // CHECK: %[[END:.+]] = getelementptr
+ // CHECK-NEXT: %[[DIM:.+]] = getelementptr
+ // CHECK-NEXT: %[[LAST:.+]] = load
+ // CHECK-NEXT: %[[FIRST:.+]] = shl
+ // CHECK-NEXT: call void @llvm.memmove
+ // CHECK-NEXT: store i32 %[[LAST]], ptr %[[DIM:.+]]
+ // CHECK-NOT: phi
+ // CHECK-NOT: call
+ // CHECK-NOT: load
+ // CHECK-NOT: store
+ // CHECK-NOT: getelementptr
+ // CHECK: ret void
+ if !slice.is_empty() {
+ slice.rotate_left(1);
+ }
+}
diff --git a/tests/codegen/wasm_exceptions.rs b/tests/codegen/wasm_exceptions.rs
index 719499dd8ea..07b8ae6e9d7 100644
--- a/tests/codegen/wasm_exceptions.rs
+++ b/tests/codegen/wasm_exceptions.rs
@@ -1,5 +1,5 @@
//@ only-wasm32
-//@ compile-flags: -C panic=unwind
+//@ compile-flags: -C panic=unwind -Z emscripten-wasm-eh
#![crate_type = "lib"]
#![feature(core_intrinsics)]
diff --git a/tests/crashes/131102.rs b/tests/crashes/131102.rs
deleted file mode 100644
index 12b35f8d1b2..00000000000
--- a/tests/crashes/131102.rs
+++ /dev/null
@@ -1,4 +0,0 @@
-//@ known-bug: #131102
-pub struct Blorb([String; N]);
-pub struct Wrap(Blorb<0>);
-pub const fn i(_: Wrap) {}
diff --git a/tests/run-make/symbol-mangling-hashed/Makefile b/tests/run-make/symbol-mangling-hashed/Makefile
deleted file mode 100644
index c95036ead95..00000000000
--- a/tests/run-make/symbol-mangling-hashed/Makefile
+++ /dev/null
@@ -1,48 +0,0 @@
-include ../tools.mk
-
-# ignore-cross-compile
-# only-linux
-# only-x86_64
-
-NM=nm -D
-RLIB_NAME=liba_rlib.rlib
-DYLIB_NAME=liba_dylib.so
-SO_NAME=libb_dylib.so
-BIN_NAME=b_bin
-
-ifeq ($(UNAME),Darwin)
-NM=nm -gU
-RLIB_NAME=liba_rlib.rlib
-DYLIB_NAME=liba_dylib.dylib
-SO_NAME=libb_dylib.dylib
-BIN_NAME=b_bin
-endif
-
-ifdef IS_WINDOWS
-NM=nm -g
-RLIB_NAME=liba_rlib.dll.a
-DYLIB_NAME=liba_dylib.dll
-SO_NAME=libb_dylib.dll
-BIN_NAME=b_bin.exe
-endif
-
-all:
- $(RUSTC) -C prefer-dynamic -Z unstable-options -C symbol-mangling-version=hashed -C metadata=foo a_dylib.rs
- $(RUSTC) -C prefer-dynamic -Z unstable-options -C symbol-mangling-version=hashed -C metadata=bar a_rlib.rs
- $(RUSTC) -C prefer-dynamic -L $(TMPDIR) b_dylib.rs
- $(RUSTC) -C prefer-dynamic -L $(TMPDIR) b_bin.rs
-
- # Check hashed symbol name
-
- [ "$$($(NM) $(TMPDIR)/$(DYLIB_NAME) | grep -c hello)" -eq "0" ]
- [ "$$($(NM) $(TMPDIR)/$(DYLIB_NAME) | grep _RNxC7a_dylib | grep -c ' T ')" -eq "2" ]
-
- [ "$$($(NM) $(TMPDIR)/$(SO_NAME) | grep b_dylib | grep -c hello)" -eq "1" ]
- [ "$$($(NM) $(TMPDIR)/$(SO_NAME) | grep _RNxC6a_rlib | grep -c ' T ')" -eq "2" ]
- [ "$$($(NM) $(TMPDIR)/$(SO_NAME) | grep _RNxC7a_dylib | grep -c ' U ')" -eq "1" ]
-
- [ "$$($(NM) $(TMPDIR)/$(BIN_NAME) | grep _RNxC6a_rlib | grep -c ' U ')" -eq "1" ]
- [ "$$($(NM) $(TMPDIR)/$(BIN_NAME) | grep _RNxC7a_dylib | grep -c ' U ')" -eq "1" ]
- [ "$$($(NM) $(TMPDIR)/$(BIN_NAME) | grep b_dylib | grep hello | grep -c ' U ')" -eq "1" ]
-
- $(call RUN,$(BIN_NAME))
diff --git a/tests/run-make/symbol-mangling-hashed/b_bin.rs b/tests/run-make/symbol-mangling-hashed/b_bin.rs
deleted file mode 100644
index 8ee7fecda62..00000000000
--- a/tests/run-make/symbol-mangling-hashed/b_bin.rs
+++ /dev/null
@@ -1,9 +0,0 @@
-extern crate a_dylib;
-extern crate a_rlib;
-extern crate b_dylib;
-
-fn main() {
- a_rlib::hello();
- a_dylib::hello();
- b_dylib::hello();
-}
diff --git a/tests/run-make/symbol-mangling-hashed/b_dylib.rs b/tests/run-make/symbol-mangling-hashed/b_dylib.rs
deleted file mode 100644
index 3252c9c75c2..00000000000
--- a/tests/run-make/symbol-mangling-hashed/b_dylib.rs
+++ /dev/null
@@ -1,9 +0,0 @@
-#![crate_type = "dylib"]
-
-extern crate a_dylib;
-extern crate a_rlib;
-
-pub fn hello() {
- a_rlib::hello();
- a_dylib::hello();
-}
diff --git a/tests/run-make/symbol-mangling-hashed/default_bin.rs b/tests/run-make/symbol-mangling-hashed/default_bin.rs
new file mode 100644
index 00000000000..387596705c3
--- /dev/null
+++ b/tests/run-make/symbol-mangling-hashed/default_bin.rs
@@ -0,0 +1,9 @@
+extern crate default_dylib;
+extern crate hashed_dylib;
+extern crate hashed_rlib;
+
+fn main() {
+ hashed_rlib::hrhello();
+ hashed_dylib::hdhello();
+ default_dylib::ddhello();
+}
diff --git a/tests/run-make/symbol-mangling-hashed/default_dylib.rs b/tests/run-make/symbol-mangling-hashed/default_dylib.rs
new file mode 100644
index 00000000000..986d1c7b74d
--- /dev/null
+++ b/tests/run-make/symbol-mangling-hashed/default_dylib.rs
@@ -0,0 +1,9 @@
+#![crate_type = "dylib"]
+
+extern crate hashed_dylib;
+extern crate hashed_rlib;
+
+pub fn ddhello() {
+ hashed_rlib::hrhello();
+ hashed_dylib::hdhello();
+}
diff --git a/tests/run-make/symbol-mangling-hashed/a_dylib.rs b/tests/run-make/symbol-mangling-hashed/hashed_dylib.rs
similarity index 74%
rename from tests/run-make/symbol-mangling-hashed/a_dylib.rs
rename to tests/run-make/symbol-mangling-hashed/hashed_dylib.rs
index 49d65b72cac..fbb7cba43e0 100644
--- a/tests/run-make/symbol-mangling-hashed/a_dylib.rs
+++ b/tests/run-make/symbol-mangling-hashed/hashed_dylib.rs
@@ -1,4 +1,4 @@
#![crate_type = "dylib"]
-pub fn hello() {
+pub fn hdhello() {
println!("hello dylib");
}
diff --git a/tests/run-make/symbol-mangling-hashed/a_rlib.rs b/tests/run-make/symbol-mangling-hashed/hashed_rlib.rs
similarity index 74%
rename from tests/run-make/symbol-mangling-hashed/a_rlib.rs
rename to tests/run-make/symbol-mangling-hashed/hashed_rlib.rs
index 71e44ccc200..048e67784d2 100644
--- a/tests/run-make/symbol-mangling-hashed/a_rlib.rs
+++ b/tests/run-make/symbol-mangling-hashed/hashed_rlib.rs
@@ -1,5 +1,5 @@
#![crate_type = "rlib"]
-pub fn hello() {
+pub fn hrhello() {
println!("hello rlib");
}
diff --git a/tests/run-make/symbol-mangling-hashed/rmake.rs b/tests/run-make/symbol-mangling-hashed/rmake.rs
new file mode 100644
index 00000000000..136e6b9fa3a
--- /dev/null
+++ b/tests/run-make/symbol-mangling-hashed/rmake.rs
@@ -0,0 +1,108 @@
+// ignore-tidy-linelength
+//! Basic smoke test for the unstable option `-C symbol_mangling_version=hashed` which aims to
+//! replace full symbol mangling names based on hash digests to shorten symbol name lengths in
+//! dylibs for space savings.
+//!
+//! # References
+//!
+//! - MCP #705: Provide option to shorten symbol names by replacing them with a digest:
+//! .
+//! - Implementation PR: .
+//! - PE format: .
+
+//@ ignore-cross-compile
+
+#![deny(warnings)]
+
+use run_make_support::symbols::exported_dynamic_symbol_names;
+use run_make_support::{bin_name, cwd, dynamic_lib_name, is_darwin, object, rfs, run, rustc};
+
+macro_rules! adjust_symbol_prefix {
+ ($name:literal) => {
+ if is_darwin() { concat!("_", $name) } else { $name }
+ };
+}
+
+fn main() {
+ rustc()
+ .input("hashed_dylib.rs")
+ .prefer_dynamic()
+ .arg("-Zunstable-options")
+ .symbol_mangling_version("hashed")
+ .metadata("foo")
+ .run();
+
+ rustc()
+ .input("hashed_rlib.rs")
+ .prefer_dynamic()
+ .arg("-Zunstable-options")
+ .symbol_mangling_version("hashed")
+ .metadata("bar")
+ .run();
+
+ rustc().input("default_dylib.rs").library_search_path(cwd()).prefer_dynamic().run();
+ rustc().input("default_bin.rs").library_search_path(cwd()).prefer_dynamic().run();
+
+ {
+ // Check hashed symbol name
+
+ let dylib_filename = dynamic_lib_name("hashed_dylib");
+ println!("checking dylib `{dylib_filename}`");
+
+ let dylib_blob = rfs::read(&dylib_filename);
+ let dylib_file = object::File::parse(&*dylib_blob)
+ .unwrap_or_else(|e| panic!("failed to parse `{dylib_filename}`: {e}"));
+
+ let dynamic_symbols = exported_dynamic_symbol_names(&dylib_file);
+
+ if dynamic_symbols.iter().filter(|sym| sym.contains("hdhello")).count() != 0 {
+ eprintln!("exported dynamic symbols: {:#?}", dynamic_symbols);
+ panic!("expected no occurrence of `hdhello`");
+ }
+
+ let expected_prefix = adjust_symbol_prefix!("_RNxC12hashed_dylib");
+ if dynamic_symbols.iter().filter(|sym| sym.starts_with(expected_prefix)).count() != 2 {
+ eprintln!("exported dynamic symbols: {:#?}", dynamic_symbols);
+ panic!("expected two dynamic symbols starting with `{expected_prefix}`");
+ }
+ }
+
+ {
+ let dylib_filename = dynamic_lib_name("default_dylib");
+ println!("checking so `{dylib_filename}`");
+
+ let dylib_blob = rfs::read(&dylib_filename);
+ let dylib_file = object::File::parse(&*dylib_blob)
+ .unwrap_or_else(|e| panic!("failed to parse `{dylib_filename}`: {e}"));
+
+ let dynamic_symbols = exported_dynamic_symbol_names(&dylib_file);
+
+ if dynamic_symbols
+ .iter()
+ .filter(|sym| sym.contains("default_dylib") && sym.contains("ddhello"))
+ .count()
+ != 1
+ {
+ eprintln!("exported dynamic symbols: {:#?}", dynamic_symbols);
+ panic!("expected one occurrence of mangled `ddhello`");
+ }
+
+ let expected_rlib_prefix = adjust_symbol_prefix!("_RNxC11hashed_rlib");
+ if dynamic_symbols.iter().filter(|sym| sym.starts_with(expected_rlib_prefix)).count() != 2 {
+ eprintln!("exported dynamic symbols: {:#?}", dynamic_symbols);
+ panic!("expected two exported symbols starting with `{expected_rlib_prefix}`");
+ }
+
+ let expected_dylib_prefix = adjust_symbol_prefix!("_RNxC12hashed_dylib");
+ if dynamic_symbols.iter().any(|sym| sym.starts_with("_RNxC12hashed_dylib")) {
+ eprintln!("exported dynamic symbols: {:#?}", dynamic_symbols);
+ panic!("did not expect any symbols starting with `{expected_dylib_prefix}`");
+ }
+ }
+
+ // Check that the final binary can be run.
+ {
+ let bin_filename = bin_name("default_bin");
+ run(&bin_filename);
+ }
+}
diff --git a/tests/run-make/target-specs/require-explicit-cpu.json b/tests/run-make/target-specs/require-explicit-cpu.json
new file mode 100644
index 00000000000..5cbb9573b3f
--- /dev/null
+++ b/tests/run-make/target-specs/require-explicit-cpu.json
@@ -0,0 +1,11 @@
+{
+ "data-layout": "e-m:e-p:32:32-p270:32:32-p271:32:32-p272:64:64-i128:128-f64:32:64-f80:32-n8:16:32-S128",
+ "linker-flavor": "gcc",
+ "llvm-target": "i686-unknown-linux-gnu",
+ "target-endian": "little",
+ "target-pointer-width": "32",
+ "target-c-int-width": "32",
+ "arch": "x86",
+ "os": "linux",
+ "need-explicit-cpu": true
+}
diff --git a/tests/run-make/target-specs/rmake.rs b/tests/run-make/target-specs/rmake.rs
index 79c888ab340..f36a5784c89 100644
--- a/tests/run-make/target-specs/rmake.rs
+++ b/tests/run-make/target-specs/rmake.rs
@@ -63,4 +63,17 @@ fn main() {
.crate_type("lib")
.run_fail()
.assert_stderr_contains("data-layout for target");
+ rustc()
+ .input("foo.rs")
+ .target("require-explicit-cpu")
+ .crate_type("lib")
+ .run_fail()
+ .assert_stderr_contains("target requires explicitly specifying a cpu");
+ rustc()
+ .input("foo.rs")
+ .target("require-explicit-cpu")
+ .crate_type("lib")
+ .arg("-Ctarget-cpu=generic")
+ .run();
+ rustc().target("require-explicit-cpu").arg("--print=target-cpus").run();
}
diff --git a/tests/rustdoc-gui/font-serif-change.goml b/tests/rustdoc-gui/font-serif-change.goml
new file mode 100644
index 00000000000..b14d5ae96f9
--- /dev/null
+++ b/tests/rustdoc-gui/font-serif-change.goml
@@ -0,0 +1,31 @@
+// Ensures that the font serif change is working as expected.
+go-to: "file://" + |DOC_PATH| + "/test_docs/index.html"
+
+// By default, it should be the serif fonts.
+store-value: (serif_font, '"Source Serif 4", NanumBarunGothic, serif')
+store-value: (serif_code_font, '"Source Code Pro", monospace')
+assert-css: ("body", {"font-family": |serif_font|})
+assert-css: ("p code", {"font-family": |serif_code_font|})
+
+// We now switch to the sans serif font
+click: "#settings-menu"
+wait-for: "#sans-serif-fonts"
+click: "#sans-serif-fonts"
+
+store-value: (font, '"Fira Sans", sans-serif')
+store-value: (code_font, '"Fira Mono", monospace')
+assert-css: ("body", {"font-family": |font|})
+assert-css: ("p code", {"font-family": |code_font|})
+
+// Reloading the page to ensure it is loaded correctly.
+reload:
+assert-css: ("body", {"font-family": |font|})
+assert-css: ("p code", {"font-family": |code_font|})
+
+// We switch back to the serif font
+click: "#settings-menu"
+wait-for: "#sans-serif-fonts"
+click: "#sans-serif-fonts"
+
+assert-css: ("body", {"font-family": |serif_font|})
+assert-css: ("p code", {"font-family": |serif_code_font|})
diff --git a/tests/rustdoc-gui/settings.goml b/tests/rustdoc-gui/settings.goml
index 1d93c07f9ec..4ab5b83d7c4 100644
--- a/tests/rustdoc-gui/settings.goml
+++ b/tests/rustdoc-gui/settings.goml
@@ -257,15 +257,15 @@ assert-text: ("#preferred-light-theme .setting-radio-name", "Preferred light the
// We now check that clicking on the toggles' text is like clicking on the checkbox.
// To test it, we use the "Disable keyboard shortcuts".
set-local-storage: {"rustdoc-disable-shortcuts": "false"}
-click: ".setting-line:last-child .setting-check span"
+click: "#disable-shortcuts"
assert-local-storage: {"rustdoc-disable-shortcuts": "true"}
// We now check that focusing a toggle and pressing Space is like clicking on it.
assert-local-storage: {"rustdoc-disable-shortcuts": "true"}
-focus: ".setting-line:last-child .setting-check input"
+focus: "#disable-shortcuts"
press-key: "Space"
assert-local-storage: {"rustdoc-disable-shortcuts": "false"}
-focus: ".setting-line:last-child .setting-check input"
+focus: "#disable-shortcuts"
press-key: "Space"
assert-local-storage: {"rustdoc-disable-shortcuts": "true"}
@@ -276,7 +276,7 @@ assert-false: "#help-button .popover"
wait-for-css: ("#settings-menu .popover", {"display": "block"})
// Now turn keyboard shortcuts back on, and see if they work.
-click: ".setting-line:last-child .setting-check span"
+click: "#disable-shortcuts"
assert-local-storage: {"rustdoc-disable-shortcuts": "false"}
press-key: "Escape"
press-key: "?"
diff --git a/tests/ui/consts/bad-array-size-in-type-err.rs b/tests/ui/consts/bad-array-size-in-type-err.rs
index cb02ad3205d..0490a9d3620 100644
--- a/tests/ui/consts/bad-array-size-in-type-err.rs
+++ b/tests/ui/consts/bad-array-size-in-type-err.rs
@@ -8,3 +8,14 @@ fn main() {
//~^ ERROR mismatched types
//~| ERROR the constant `2` is not of type `usize`
}
+
+fn iter(val: BadArraySize::<2>) {
+ for _ in val.arr {}
+ //~^ ERROR the constant `2` is not of type `usize`
+ //~| ERROR `[i32; 2]` is not an iterator
+}
+
+// issue #131102
+pub struct Blorb([String; N]); //~ ERROR the constant `N` is not of type `usize`
+pub struct Wrap(Blorb<0>);
+pub const fn i(_: Wrap) {} //~ ERROR destructor of `Wrap` cannot be evaluated at compile-time
diff --git a/tests/ui/consts/bad-array-size-in-type-err.stderr b/tests/ui/consts/bad-array-size-in-type-err.stderr
index c3ff216432e..84e16f8d931 100644
--- a/tests/ui/consts/bad-array-size-in-type-err.stderr
+++ b/tests/ui/consts/bad-array-size-in-type-err.stderr
@@ -6,6 +6,14 @@ LL | arr: [i32; N],
|
= note: the length of array `[i32; N]` must be type `usize`
+error: the constant `N` is not of type `usize`
+ --> $DIR/bad-array-size-in-type-err.rs:19:32
+ |
+LL | pub struct Blorb([String; N]);
+ | ^^^^^^^^^^^ expected `usize`, found `u16`
+ |
+ = note: the length of array `[String; N]` must be type `usize`
+
error[E0308]: mismatched types
--> $DIR/bad-array-size-in-type-err.rs:7:38
|
@@ -20,6 +28,37 @@ LL | let _ = BadArraySize::<2> { arr: [0, 0, 0] };
|
= note: the length of array `[i32; 2]` must be type `usize`
-error: aborting due to 3 previous errors
+error: the constant `2` is not of type `usize`
+ --> $DIR/bad-array-size-in-type-err.rs:13:14
+ |
+LL | for _ in val.arr {}
+ | ^^^^^^^ expected `usize`, found `u8`
+ |
+ = note: the length of array `[i32; 2]` must be type `usize`
-For more information about this error, try `rustc --explain E0308`.
+error[E0277]: `[i32; 2]` is not an iterator
+ --> $DIR/bad-array-size-in-type-err.rs:13:14
+ |
+LL | for _ in val.arr {}
+ | ^^^^^^^ `[i32; 2]` is not an iterator; try calling `.into_iter()` or `.iter()`
+ |
+ = help: the trait `IntoIterator` is not implemented for `[i32; 2]`
+ = help: the following other types implement trait `IntoIterator`:
+ &[T; N]
+ &[T]
+ &mut [T; N]
+ &mut [T]
+ [T; N]
+
+error[E0493]: destructor of `Wrap` cannot be evaluated at compile-time
+ --> $DIR/bad-array-size-in-type-err.rs:21:16
+ |
+LL | pub const fn i(_: Wrap) {}
+ | ^ - value is dropped here
+ | |
+ | the destructor for this type cannot be evaluated in constant functions
+
+error: aborting due to 7 previous errors
+
+Some errors have detailed explanations: E0277, E0308, E0493.
+For more information about an error, try `rustc --explain E0277`.
diff --git a/tests/ui/consts/const-eval/parse_ints.stderr b/tests/ui/consts/const-eval/parse_ints.stderr
index ec9249ece8e..189d3c3958b 100644
--- a/tests/ui/consts/const-eval/parse_ints.stderr
+++ b/tests/ui/consts/const-eval/parse_ints.stderr
@@ -1,8 +1,10 @@
error[E0080]: evaluation of constant value failed
--> $SRC_DIR/core/src/num/mod.rs:LL:COL
|
- = note: the evaluated program panicked at 'from_str_radix_int: must lie in the range `[2, 36]`', $SRC_DIR/core/src/num/mod.rs:LL:COL
+ = note: the evaluated program panicked at 'from_ascii_radix: radix must lie in the range `[2, 36]`', $SRC_DIR/core/src/num/mod.rs:LL:COL
|
+note: inside `core::num::::from_ascii_radix`
+ --> $SRC_DIR/core/src/num/mod.rs:LL:COL
note: inside `core::num::::from_str_radix`
--> $SRC_DIR/core/src/num/mod.rs:LL:COL
note: inside `_TOO_LOW`
@@ -10,13 +12,15 @@ note: inside `_TOO_LOW`
|
LL | const _TOO_LOW: () = { u64::from_str_radix("12345ABCD", 1); };
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
- = note: this error originates in the macro `from_str_radix` (in Nightly builds, run with -Z macro-backtrace for more info)
+ = note: this error originates in the macro `from_str_int_impl` (in Nightly builds, run with -Z macro-backtrace for more info)
error[E0080]: evaluation of constant value failed
--> $SRC_DIR/core/src/num/mod.rs:LL:COL
|
- = note: the evaluated program panicked at 'from_str_radix_int: must lie in the range `[2, 36]`', $SRC_DIR/core/src/num/mod.rs:LL:COL
+ = note: the evaluated program panicked at 'from_ascii_radix: radix must lie in the range `[2, 36]`', $SRC_DIR/core/src/num/mod.rs:LL:COL
|
+note: inside `core::num::::from_ascii_radix`
+ --> $SRC_DIR/core/src/num/mod.rs:LL:COL
note: inside `core::num::::from_str_radix`
--> $SRC_DIR/core/src/num/mod.rs:LL:COL
note: inside `_TOO_HIGH`
@@ -24,7 +28,7 @@ note: inside `_TOO_HIGH`
|
LL | const _TOO_HIGH: () = { u64::from_str_radix("12345ABCD", 37); };
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
- = note: this error originates in the macro `from_str_radix` (in Nightly builds, run with -Z macro-backtrace for more info)
+ = note: this error originates in the macro `from_str_int_impl` (in Nightly builds, run with -Z macro-backtrace for more info)
error: aborting due to 2 previous errors
diff --git a/tests/ui/consts/large_const_alloc.rs b/tests/ui/consts/large_const_alloc.rs
index 61a22216ae5..14edc1bb696 100644
--- a/tests/ui/consts/large_const_alloc.rs
+++ b/tests/ui/consts/large_const_alloc.rs
@@ -1,5 +1,7 @@
//@ only-64bit
// on 32bit and 16bit platforms it is plausible that the maximum allocation size will succeed
+// FIXME (#135952) In some cases on AArch64 Linux the diagnostic does not trigger
+//@ ignore-aarch64-unknown-linux-gnu
const FOO: () = {
// 128 TiB, unlikely anyone has that much RAM
diff --git a/tests/ui/consts/large_const_alloc.stderr b/tests/ui/consts/large_const_alloc.stderr
index 25d660f1217..fa7d5977a95 100644
--- a/tests/ui/consts/large_const_alloc.stderr
+++ b/tests/ui/consts/large_const_alloc.stderr
@@ -1,11 +1,11 @@
error[E0080]: evaluation of constant value failed
- --> $DIR/large_const_alloc.rs:6:13
+ --> $DIR/large_const_alloc.rs:8:13
|
LL | let x = [0_u8; (1 << 47) - 1];
| ^^^^^^^^^^^^^^^^^^^^^ tried to allocate more memory than available to compiler
error[E0080]: could not evaluate static initializer
- --> $DIR/large_const_alloc.rs:11:13
+ --> $DIR/large_const_alloc.rs:13:13
|
LL | let x = [0_u8; (1 << 47) - 1];
| ^^^^^^^^^^^^^^^^^^^^^ tried to allocate more memory than available to compiler
diff --git a/tests/ui/consts/promoted_running_out_of_memory_issue-130687.rs b/tests/ui/consts/promoted_running_out_of_memory_issue-130687.rs
index b923a768cbf..53618e2e86a 100644
--- a/tests/ui/consts/promoted_running_out_of_memory_issue-130687.rs
+++ b/tests/ui/consts/promoted_running_out_of_memory_issue-130687.rs
@@ -3,6 +3,8 @@
// Needs the max type size to be much bigger than the RAM people typically have.
//@ only-64bit
+// FIXME (#135952) In some cases on AArch64 Linux the diagnostic does not trigger
+//@ ignore-aarch64-unknown-linux-gnu
pub struct Data([u8; (1 << 47) - 1]);
const _: &'static Data = &Data([0; (1 << 47) - 1]);
diff --git a/tests/ui/consts/promoted_running_out_of_memory_issue-130687.stderr b/tests/ui/consts/promoted_running_out_of_memory_issue-130687.stderr
index f5d767efceb..aac805dbd8c 100644
--- a/tests/ui/consts/promoted_running_out_of_memory_issue-130687.stderr
+++ b/tests/ui/consts/promoted_running_out_of_memory_issue-130687.stderr
@@ -1,5 +1,5 @@
error[E0080]: evaluation of constant value failed
- --> $DIR/promoted_running_out_of_memory_issue-130687.rs:8:32
+ --> $DIR/promoted_running_out_of_memory_issue-130687.rs:10:32
|
LL | const _: &'static Data = &Data([0; (1 << 47) - 1]);
| ^^^^^^^^^^^^^^^^^^ tried to allocate more memory than available to compiler
diff --git a/tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/borrowck-errors.classic2024.stderr b/tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/borrowck-errors.classic2024.stderr
new file mode 100644
index 00000000000..331b86736a0
--- /dev/null
+++ b/tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/borrowck-errors.classic2024.stderr
@@ -0,0 +1,79 @@
+error[E0508]: cannot move out of type `[&mut u32; 1]`, a non-copy array
+ --> $DIR/borrowck-errors.rs:13:16
+ |
+LL | let [&x] = &[&mut 0];
+ | - ^^^^^^^^^ cannot move out of here
+ | |
+ | data moved here
+ | move occurs because `x` has type `&mut u32`, which does not implement the `Copy` trait
+ |
+help: consider borrowing the pattern binding
+ |
+LL | let [&ref x] = &[&mut 0];
+ | +++
+
+error[E0508]: cannot move out of type `[&mut u32; 1]`, a non-copy array
+ --> $DIR/borrowck-errors.rs:19:16
+ |
+LL | let [&x] = &mut [&mut 0];
+ | - ^^^^^^^^^^^^^ cannot move out of here
+ | |
+ | data moved here
+ | move occurs because `x` has type `&mut u32`, which does not implement the `Copy` trait
+ |
+help: consider borrowing the pattern binding
+ |
+LL | let [&ref x] = &mut [&mut 0];
+ | +++
+
+error[E0507]: cannot move out of a shared reference
+ --> $DIR/borrowck-errors.rs:27:29
+ |
+LL | if let Some(&Some(x)) = Some(&Some(&mut 0)) {
+ | - ^^^^^^^^^^^^^^^^^^^
+ | |
+ | data moved here
+ | move occurs because `x` has type `&mut u32`, which does not implement the `Copy` trait
+ |
+help: consider removing the borrow
+ |
+LL - if let Some(&Some(x)) = Some(&Some(&mut 0)) {
+LL + if let Some(Some(x)) = Some(&Some(&mut 0)) {
+ |
+
+error[E0596]: cannot borrow data in a `&` reference as mutable
+ --> $DIR/borrowck-errors.rs:32:10
+ |
+LL | let &ref mut x = &0;
+ | ^^^^^^^^^ cannot borrow as mutable
+
+error[E0596]: cannot borrow data in a `&` reference as mutable
+ --> $DIR/borrowck-errors.rs:35:23
+ |
+LL | if let &Some(Some(x)) = &Some(&mut Some(0)) {
+ | ^ cannot borrow as mutable
+
+error[E0596]: cannot borrow data in a `&` reference as mutable
+ --> $DIR/borrowck-errors.rs:40:11
+ |
+LL | let &[x] = &&mut [0];
+ | ^ cannot borrow as mutable
+
+error[E0508]: cannot move out of type `[&mut i32; 1]`, a non-copy array
+ --> $DIR/borrowck-errors.rs:44:20
+ |
+LL | let [&mut x] = &mut [&mut 0];
+ | - ^^^^^^^^^^^^^ cannot move out of here
+ | |
+ | data moved here
+ | move occurs because `x` has type `&mut i32`, which does not implement the `Copy` trait
+ |
+help: consider borrowing the pattern binding
+ |
+LL | let [&mut ref x] = &mut [&mut 0];
+ | +++
+
+error: aborting due to 7 previous errors
+
+Some errors have detailed explanations: E0507, E0508, E0596.
+For more information about an error, try `rustc --explain E0507`.
diff --git a/tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/borrowck-errors.rs b/tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/borrowck-errors.rs
index a01e9ca2657..3f5d9c8db5d 100644
--- a/tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/borrowck-errors.rs
+++ b/tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/borrowck-errors.rs
@@ -1,9 +1,27 @@
-//@ edition: 2024
-//@ revisions: classic structural
+//@ revisions: stable2021 classic2024 structural2024
+//@[stable2021] edition: 2021
+//@[classic2024] edition: 2024
+//@[structural2024] edition: 2024
//! Tests for pattern errors not handled by the pattern typing rules, but by borrowck.
#![allow(incomplete_features)]
-#![cfg_attr(classic, feature(ref_pat_eat_one_layer_2024))]
-#![cfg_attr(structural, feature(ref_pat_eat_one_layer_2024_structural))]
+#![cfg_attr(classic2024, feature(ref_pat_eat_one_layer_2024))]
+#![cfg_attr(structural2024, feature(ref_pat_eat_one_layer_2024_structural))]
+
+/// These patterns additionally use `&` to match a `&mut` reference type, which causes compilation
+/// to fail in HIR typeck on stable. As such, they need to be separate from the other tests.
+fn errors_caught_in_hir_typeck_on_stable() {
+ let [&x] = &[&mut 0];
+ //[stable2021]~^ mismatched types
+ //[stable2021]~| types differ in mutability
+ //[classic2024]~^^^ ERROR: cannot move out of type
+ let _: &u32 = x;
+
+ let [&x] = &mut [&mut 0];
+ //[stable2021]~^ mismatched types
+ //[stable2021]~| types differ in mutability
+ //[classic2024]~^^^ ERROR: cannot move out of type
+ let _: &u32 = x;
+}
pub fn main() {
if let Some(&Some(x)) = Some(&Some(&mut 0)) {
@@ -13,4 +31,18 @@ pub fn main() {
let &ref mut x = &0;
//~^ cannot borrow data in a `&` reference as mutable [E0596]
+
+ if let &Some(Some(x)) = &Some(&mut Some(0)) {
+ //[stable2021,classic2024]~^ ERROR: cannot borrow data in a `&` reference as mutable
+ let _: &u32 = x;
+ }
+
+ let &[x] = &&mut [0];
+ //[stable2021,classic2024]~^ ERROR: cannot borrow data in a `&` reference as mutable
+ let _: &u32 = x;
+
+ let [&mut x] = &mut [&mut 0];
+ //[classic2024]~^ ERROR: cannot move out of type
+ #[cfg(stable2021)] let _: u32 = x;
+ #[cfg(structural2024)] let _: &mut u32 = x;
}
diff --git a/tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/borrowck-errors.stable2021.stderr b/tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/borrowck-errors.stable2021.stderr
new file mode 100644
index 00000000000..65c98e2da9c
--- /dev/null
+++ b/tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/borrowck-errors.stable2021.stderr
@@ -0,0 +1,69 @@
+error[E0308]: mismatched types
+ --> $DIR/borrowck-errors.rs:13:10
+ |
+LL | let [&x] = &[&mut 0];
+ | ^^ --------- this expression has type `&[&mut {integer}; 1]`
+ | |
+ | types differ in mutability
+ |
+ = note: expected mutable reference `&mut {integer}`
+ found reference `&_`
+help: consider removing `&` from the pattern
+ |
+LL - let [&x] = &[&mut 0];
+LL + let [x] = &[&mut 0];
+ |
+
+error[E0308]: mismatched types
+ --> $DIR/borrowck-errors.rs:19:10
+ |
+LL | let [&x] = &mut [&mut 0];
+ | ^^ ------------- this expression has type `&mut [&mut {integer}; 1]`
+ | |
+ | types differ in mutability
+ |
+ = note: expected mutable reference `&mut {integer}`
+ found reference `&_`
+help: consider removing `&` from the pattern
+ |
+LL - let [&x] = &mut [&mut 0];
+LL + let [x] = &mut [&mut 0];
+ |
+
+error[E0507]: cannot move out of a shared reference
+ --> $DIR/borrowck-errors.rs:27:29
+ |
+LL | if let Some(&Some(x)) = Some(&Some(&mut 0)) {
+ | - ^^^^^^^^^^^^^^^^^^^
+ | |
+ | data moved here
+ | move occurs because `x` has type `&mut u32`, which does not implement the `Copy` trait
+ |
+help: consider removing the borrow
+ |
+LL - if let Some(&Some(x)) = Some(&Some(&mut 0)) {
+LL + if let Some(Some(x)) = Some(&Some(&mut 0)) {
+ |
+
+error[E0596]: cannot borrow data in a `&` reference as mutable
+ --> $DIR/borrowck-errors.rs:32:10
+ |
+LL | let &ref mut x = &0;
+ | ^^^^^^^^^ cannot borrow as mutable
+
+error[E0596]: cannot borrow data in a `&` reference as mutable
+ --> $DIR/borrowck-errors.rs:35:23
+ |
+LL | if let &Some(Some(x)) = &Some(&mut Some(0)) {
+ | ^ cannot borrow as mutable
+
+error[E0596]: cannot borrow data in a `&` reference as mutable
+ --> $DIR/borrowck-errors.rs:40:11
+ |
+LL | let &[x] = &&mut [0];
+ | ^ cannot borrow as mutable
+
+error: aborting due to 6 previous errors
+
+Some errors have detailed explanations: E0308, E0507, E0596.
+For more information about an error, try `rustc --explain E0308`.
diff --git a/tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/borrowck-errors.structural.stderr b/tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/borrowck-errors.structural.stderr
deleted file mode 100644
index c6246114075..00000000000
--- a/tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/borrowck-errors.structural.stderr
+++ /dev/null
@@ -1,25 +0,0 @@
-error[E0507]: cannot move out of a shared reference
- --> $DIR/borrowck-errors.rs:9:29
- |
-LL | if let Some(&Some(x)) = Some(&Some(&mut 0)) {
- | - ^^^^^^^^^^^^^^^^^^^
- | |
- | data moved here
- | move occurs because `x` has type `&mut u32`, which does not implement the `Copy` trait
- |
-help: consider removing the borrow
- |
-LL - if let Some(&Some(x)) = Some(&Some(&mut 0)) {
-LL + if let Some(Some(x)) = Some(&Some(&mut 0)) {
- |
-
-error[E0596]: cannot borrow data in a `&` reference as mutable
- --> $DIR/borrowck-errors.rs:14:10
- |
-LL | let &ref mut x = &0;
- | ^^^^^^^^^ cannot borrow as mutable
-
-error: aborting due to 2 previous errors
-
-Some errors have detailed explanations: E0507, E0596.
-For more information about an error, try `rustc --explain E0507`.
diff --git a/tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/borrowck-errors.classic.stderr b/tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/borrowck-errors.structural2024.stderr
similarity index 91%
rename from tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/borrowck-errors.classic.stderr
rename to tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/borrowck-errors.structural2024.stderr
index c6246114075..30d2f9f3d70 100644
--- a/tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/borrowck-errors.classic.stderr
+++ b/tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/borrowck-errors.structural2024.stderr
@@ -1,5 +1,5 @@
error[E0507]: cannot move out of a shared reference
- --> $DIR/borrowck-errors.rs:9:29
+ --> $DIR/borrowck-errors.rs:27:29
|
LL | if let Some(&Some(x)) = Some(&Some(&mut 0)) {
| - ^^^^^^^^^^^^^^^^^^^
@@ -14,7 +14,7 @@ LL + if let Some(Some(x)) = Some(&Some(&mut 0)) {
|
error[E0596]: cannot borrow data in a `&` reference as mutable
- --> $DIR/borrowck-errors.rs:14:10
+ --> $DIR/borrowck-errors.rs:32:10
|
LL | let &ref mut x = &0;
| ^^^^^^^^^ cannot borrow as mutable
diff --git a/tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/cannot-mutably-deref-shared-ref.classic.stderr b/tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/cannot-mutably-deref-shared-ref.classic2024.stderr
similarity index 100%
rename from tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/cannot-mutably-deref-shared-ref.classic.stderr
rename to tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/cannot-mutably-deref-shared-ref.classic2024.stderr
diff --git a/tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/cannot-mutably-deref-shared-ref.rs b/tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/cannot-mutably-deref-shared-ref.rs
index e22bd1f8f6c..a493b672c92 100644
--- a/tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/cannot-mutably-deref-shared-ref.rs
+++ b/tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/cannot-mutably-deref-shared-ref.rs
@@ -1,9 +1,9 @@
//@ edition: 2024
-//@ revisions: classic structural
+//@ revisions: classic2024 structural2024
//! Test that `&mut` patterns don't match shared reference types under new typing rules in Rust 2024
#![allow(incomplete_features)]
-#![cfg_attr(classic, feature(ref_pat_eat_one_layer_2024))]
-#![cfg_attr(structural, feature(ref_pat_eat_one_layer_2024_structural))]
+#![cfg_attr(classic2024, feature(ref_pat_eat_one_layer_2024))]
+#![cfg_attr(structural2024, feature(ref_pat_eat_one_layer_2024_structural))]
pub fn main() {
let &mut _ = &&0;
diff --git a/tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/cannot-mutably-deref-shared-ref.structural.stderr b/tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/cannot-mutably-deref-shared-ref.structural2024.stderr
similarity index 100%
rename from tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/cannot-mutably-deref-shared-ref.structural.stderr
rename to tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/cannot-mutably-deref-shared-ref.structural2024.stderr
diff --git a/tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/mut-ref-mut.classic.stderr b/tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/mut-ref-mut.classic2024.stderr
similarity index 60%
rename from tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/mut-ref-mut.classic.stderr
rename to tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/mut-ref-mut.classic2024.stderr
index 43560a18030..afaa925a757 100644
--- a/tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/mut-ref-mut.classic.stderr
+++ b/tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/mut-ref-mut.classic2024.stderr
@@ -1,5 +1,5 @@
error[E0658]: binding cannot be both mutable and by-reference
- --> $DIR/mut-ref-mut.rs:11:13
+ --> $DIR/mut-ref-mut.rs:14:13
|
LL | let Foo(mut a) = &Foo(0);
| ^^^^
@@ -9,7 +9,7 @@ LL | let Foo(mut a) = &Foo(0);
= note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
error[E0658]: binding cannot be both mutable and by-reference
- --> $DIR/mut-ref-mut.rs:15:13
+ --> $DIR/mut-ref-mut.rs:19:13
|
LL | let Foo(mut a) = &mut Foo(0);
| ^^^^
@@ -18,6 +18,19 @@ LL | let Foo(mut a) = &mut Foo(0);
= help: add `#![feature(mut_ref)]` 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 2 previous errors
+error[E0308]: mismatched types
+ --> $DIR/mut-ref-mut.rs:24:10
+ |
+LL | let [&mut mut x] = &[&mut 0];
+ | ^^^^^
+ |
+ = note: cannot match inherited `&` with `&mut` pattern
+help: replace this `&mut` pattern with `&`
+ |
+LL | let [&mut x] = &[&mut 0];
+ | ~
-For more information about this error, try `rustc --explain E0658`.
+error: aborting due to 3 previous errors
+
+Some errors have detailed explanations: E0308, E0658.
+For more information about an error, try `rustc --explain E0308`.
diff --git a/tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/mut-ref-mut.rs b/tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/mut-ref-mut.rs
index 786587984ba..fbd6514df73 100644
--- a/tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/mut-ref-mut.rs
+++ b/tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/mut-ref-mut.rs
@@ -1,18 +1,29 @@
-//@ edition: 2024
-//@ revisions: classic structural
+//@ revisions: stable2021 classic2024 structural2024
+//@[stable2021] edition: 2021
+//@[classic2024] edition: 2024
+//@[structural2024] edition: 2024
+//@[stable2021] run-pass
//! Test diagnostics for binding with `mut` when the default binding mode is by-ref.
-#![allow(incomplete_features)]
-#![cfg_attr(classic, feature(ref_pat_eat_one_layer_2024))]
-#![cfg_attr(structural, feature(ref_pat_eat_one_layer_2024_structural))]
+#![allow(incomplete_features, unused_assignments, unused_variables)]
+#![cfg_attr(classic2024, feature(ref_pat_eat_one_layer_2024))]
+#![cfg_attr(structural2024, feature(ref_pat_eat_one_layer_2024_structural))]
pub fn main() {
struct Foo(u8);
let Foo(mut a) = &Foo(0);
- //~^ ERROR: binding cannot be both mutable and by-reference
- a = &42;
+ //[classic2024,structural2024]~^ ERROR: binding cannot be both mutable and by-reference
+ #[cfg(stable2021)] { a = 42 }
+ #[cfg(any(classic2024, structural2024))] { a = &42 }
let Foo(mut a) = &mut Foo(0);
- //~^ ERROR: binding cannot be both mutable and by-reference
- a = &mut 42;
+ //[classic2024,structural2024]~^ ERROR: binding cannot be both mutable and by-reference
+ #[cfg(stable2021)] { a = 42 }
+ #[cfg(any(classic2024, structural2024))] { a = &mut 42 }
+
+ let [&mut mut x] = &[&mut 0];
+ //[classic2024]~^ ERROR: mismatched types
+ //[classic2024]~| cannot match inherited `&` with `&mut` pattern
+ //[structural2024]~^^^ binding cannot be both mutable and by-reference
+ #[cfg(stable2021)] { x = 0 }
}
diff --git a/tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/mut-ref-mut.structural.stderr b/tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/mut-ref-mut.structural2024.stderr
similarity index 61%
rename from tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/mut-ref-mut.structural.stderr
rename to tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/mut-ref-mut.structural2024.stderr
index 43560a18030..fd82da70a18 100644
--- a/tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/mut-ref-mut.structural.stderr
+++ b/tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/mut-ref-mut.structural2024.stderr
@@ -1,5 +1,5 @@
error[E0658]: binding cannot be both mutable and by-reference
- --> $DIR/mut-ref-mut.rs:11:13
+ --> $DIR/mut-ref-mut.rs:14:13
|
LL | let Foo(mut a) = &Foo(0);
| ^^^^
@@ -9,7 +9,7 @@ LL | let Foo(mut a) = &Foo(0);
= note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
error[E0658]: binding cannot be both mutable and by-reference
- --> $DIR/mut-ref-mut.rs:15:13
+ --> $DIR/mut-ref-mut.rs:19:13
|
LL | let Foo(mut a) = &mut Foo(0);
| ^^^^
@@ -18,6 +18,16 @@ LL | let Foo(mut a) = &mut Foo(0);
= help: add `#![feature(mut_ref)]` 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 2 previous errors
+error[E0658]: binding cannot be both mutable and by-reference
+ --> $DIR/mut-ref-mut.rs:24:15
+ |
+LL | let [&mut mut x] = &[&mut 0];
+ | ^^^^
+ |
+ = note: see issue #123076 for more information
+ = help: add `#![feature(mut_ref)]` 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 3 previous errors
For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/pattern-errors.classic.stderr b/tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/pattern-errors.classic2024.stderr
similarity index 70%
rename from tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/pattern-errors.classic.stderr
rename to tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/pattern-errors.classic2024.stderr
index 2bc3ecb7636..3a124dcead5 100644
--- a/tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/pattern-errors.classic.stderr
+++ b/tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/pattern-errors.classic2024.stderr
@@ -1,5 +1,5 @@
error[E0308]: mismatched types
- --> $DIR/pattern-errors.rs:15:17
+ --> $DIR/pattern-errors.rs:12:17
|
LL | if let Some(&mut x) = &Some(&mut 0) {
| ^^^^^
@@ -11,7 +11,7 @@ LL | if let Some(&x) = &Some(&mut 0) {
| ~
error[E0308]: mismatched types
- --> $DIR/pattern-errors.rs:19:17
+ --> $DIR/pattern-errors.rs:18:17
|
LL | if let Some(&mut Some(&x)) = &Some(&mut Some(0)) {
| ^^^^^
@@ -23,7 +23,7 @@ LL | if let Some(&Some(&x)) = &Some(&mut Some(0)) {
| ~
error[E0308]: mismatched types
- --> $DIR/pattern-errors.rs:23:22
+ --> $DIR/pattern-errors.rs:24:22
|
LL | if let Some(Some(&mut x)) = &Some(Some(&mut 0)) {
| ^^^^^
@@ -35,7 +35,7 @@ LL | if let Some(Some(&x)) = &Some(Some(&mut 0)) {
| ~
error[E0308]: mismatched types
- --> $DIR/pattern-errors.rs:28:17
+ --> $DIR/pattern-errors.rs:31:17
|
LL | if let Some(&mut Some(&_)) = &Some(&Some(0)) {
| ^^^^^
@@ -47,19 +47,7 @@ LL | if let Some(&Some(&_)) = &Some(&Some(0)) {
| ~
error[E0308]: mismatched types
- --> $DIR/pattern-errors.rs:31:23
- |
-LL | if let Some(&Some(&mut _)) = &Some(&mut Some(0)) {
- | ^^^^^
- |
- = note: cannot match inherited `&` with `&mut` pattern
-help: replace this `&mut` pattern with `&`
- |
-LL | if let Some(&Some(&_)) = &Some(&mut Some(0)) {
- | ~
-
-error[E0308]: mismatched types
- --> $DIR/pattern-errors.rs:34:23
+ --> $DIR/pattern-errors.rs:41:23
|
LL | if let Some(&Some(&mut _)) = &mut Some(&Some(0)) {
| ^^^^^
@@ -71,19 +59,7 @@ LL | if let Some(&Some(&_)) = &mut Some(&Some(0)) {
| ~
error[E0308]: mismatched types
- --> $DIR/pattern-errors.rs:37:29
- |
-LL | if let Some(&Some(Some((&mut _)))) = &Some(Some(&mut Some(0))) {
- | ^^^^^
- |
- = note: cannot match inherited `&` with `&mut` pattern
-help: replace this `&mut` pattern with `&`
- |
-LL | if let Some(&Some(Some((&_)))) = &Some(Some(&mut Some(0))) {
- | ~
-
-error[E0308]: mismatched types
- --> $DIR/pattern-errors.rs:40:17
+ --> $DIR/pattern-errors.rs:51:17
|
LL | if let Some(&mut Some(x)) = &Some(Some(0)) {
| ^^^^^
@@ -95,17 +71,53 @@ LL | if let Some(&Some(x)) = &Some(Some(0)) {
| ~
error[E0308]: mismatched types
- --> $DIR/pattern-errors.rs:43:17
+ --> $DIR/pattern-errors.rs:147:10
|
-LL | if let Some(&mut Some(x)) = &Some(Some(0)) {
- | ^^^^^
+LL | let [&mut x] = &[&mut 0];
+ | ^^^^^
|
= note: cannot match inherited `&` with `&mut` pattern
help: replace this `&mut` pattern with `&`
|
-LL | if let Some(&Some(x)) = &Some(Some(0)) {
- | ~
+LL | let [&x] = &[&mut 0];
+ | ~
-error: aborting due to 9 previous errors
+error[E0308]: mismatched types
+ --> $DIR/pattern-errors.rs:153:10
+ |
+LL | let [&mut &x] = &[&mut 0];
+ | ^^^^^
+ |
+ = note: cannot match inherited `&` with `&mut` pattern
+help: replace this `&mut` pattern with `&`
+ |
+LL | let [&&x] = &[&mut 0];
+ | ~
+
+error[E0308]: mismatched types
+ --> $DIR/pattern-errors.rs:159:10
+ |
+LL | let [&mut &ref x] = &[&mut 0];
+ | ^^^^^
+ |
+ = note: cannot match inherited `&` with `&mut` pattern
+help: replace this `&mut` pattern with `&`
+ |
+LL | let [&&ref x] = &[&mut 0];
+ | ~
+
+error[E0308]: mismatched types
+ --> $DIR/pattern-errors.rs:165:10
+ |
+LL | let [&mut &(mut x)] = &[&mut 0];
+ | ^^^^^
+ |
+ = note: cannot match inherited `&` with `&mut` pattern
+help: replace this `&mut` pattern with `&`
+ |
+LL | let [&&(mut x)] = &[&mut 0];
+ | ~
+
+error: aborting due to 10 previous errors
For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/pattern-errors.rs b/tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/pattern-errors.rs
index 3535ba9c701..c07c2972cd0 100644
--- a/tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/pattern-errors.rs
+++ b/tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/pattern-errors.rs
@@ -1,46 +1,170 @@
-//@ edition: 2024
-//@ revisions: classic structural
+//@ revisions: stable2021 classic2024 structural2024
+//@[stable2021] edition: 2021
+//@[classic2024] edition: 2024
+//@[structural2024] edition: 2024
//! Test cases for poorly-typed patterns in edition 2024 which are caught by HIR typeck. These must
//! be separate from cases caught by MIR borrowck or the latter errors may not be emitted.
#![allow(incomplete_features)]
-#![cfg_attr(classic, feature(ref_pat_eat_one_layer_2024))]
-#![cfg_attr(structural, feature(ref_pat_eat_one_layer_2024_structural))]
+#![cfg_attr(classic2024, feature(ref_pat_eat_one_layer_2024))]
+#![cfg_attr(structural2024, feature(ref_pat_eat_one_layer_2024_structural))]
pub fn main() {
- if let Some(&mut x) = &mut Some(&0) {
- //[structural]~^ ERROR: mismatched types
- let _: &u32 = x;
- }
-
if let Some(&mut x) = &Some(&mut 0) {
- //[classic]~^ ERROR: mismatched types
- let _: &u32 = x;
+ //[classic2024]~^ ERROR: mismatched types
+ //[classic2024]~| cannot match inherited `&` with `&mut` pattern
+ #[cfg(stable2021)] let _: u32 = x;
+ #[cfg(structural2024)] let _: &u32 = x;
}
if let Some(&mut Some(&x)) = &Some(&mut Some(0)) {
- //[classic]~^ ERROR: mismatched types
+ //[stable2021,classic2024]~^ ERROR: mismatched types
+ //[stable2021]~| expected integer, found `&_`
+ //[classic2024]~| cannot match inherited `&` with `&mut` pattern
let _: u32 = x;
}
if let Some(Some(&mut x)) = &Some(Some(&mut 0)) {
- //[classic]~^ ERROR: mismatched types
- let _: &u32 = x;
+ //[classic2024]~^ ERROR: mismatched types
+ //[classic2024]~| cannot match inherited `&` with `&mut` pattern
+ #[cfg(stable2021)] let _: u32 = x;
+ #[cfg(structural2024)] let _: &u32 = x;
}
if let Some(&mut Some(&_)) = &Some(&Some(0)) {
//~^ ERROR: mismatched types
+ //[stable2021]~| types differ in mutability
+ //[classic2024,structural2024]~| cannot match inherited `&` with `&mut` pattern
}
if let Some(&Some(&mut _)) = &Some(&mut Some(0)) {
- //~^ ERROR: mismatched types
+ //[stable2021,structural2024]~^ ERROR: mismatched types
+ //[stable2021]~| types differ in mutability
+ //[structural2024]~| cannot match inherited `&` with `&mut` pattern
}
if let Some(&Some(&mut _)) = &mut Some(&Some(0)) {
//~^ ERROR: mismatched types
+ //[stable2021]~| expected integer, found `&mut _`
+ //[classic2024,structural2024]~| cannot match inherited `&` with `&mut` pattern
}
- if let Some(&Some(Some((&mut _)))) = &Some(Some(&mut Some(0))) {
- //~^ ERROR: mismatched types
- }
- if let Some(&mut Some(x)) = &Some(Some(0)) {
- //~^ ERROR: mismatched types
+ if let Some(&Some(Some(&mut _))) = &Some(Some(&mut Some(0))) {
+ //[stable2021,structural2024]~^ ERROR: mismatched types
+ //[stable2021]~| expected `Option<&mut Option<{integer}>>`, found `&_`
+ //[structural2024]~| cannot match inherited `&` with `&mut` pattern
}
if let Some(&mut Some(x)) = &Some(Some(0)) {
//~^ ERROR: mismatched types
+ //[stable2021]~| expected `Option<{integer}>`, found `&mut _`
+ //[classic2024,structural2024]~| cannot match inherited `&` with `&mut` pattern
}
}
+
+fn structural_errors_0() {
+ let &[&mut x] = &&mut [0];
+ //[stable2021,structural2024]~^ ERROR: mismatched types
+ //[stable2021]~| expected integer, found `&mut _`
+ //[structural2024]~| cannot match inherited `&` with `&mut` pattern
+ let _: u32 = x;
+
+ let &[&mut x] = &mut &mut [0];
+ //[stable2021,structural2024]~^ ERROR: mismatched types
+ //[stable2021]~| types differ in mutability
+ //[structural2024]~| cannot match inherited `&` with `&mut` pattern
+ let _: u32 = x;
+
+ let &[&mut ref x] = &&mut [0];
+ //[stable2021,structural2024]~^ ERROR: mismatched types
+ //[stable2021]~| expected integer, found `&mut _`
+ //[structural2024]~| cannot match inherited `&` with `&mut` pattern
+ let _: &u32 = x;
+
+ let &[&mut ref x] = &mut &mut [0];
+ //[stable2021,structural2024]~^ ERROR: mismatched types
+ //[stable2021]~| types differ in mutability
+ //[structural2024]~| cannot match inherited `&` with `&mut` pattern
+ let _: &u32 = x;
+
+ let &[&mut mut x] = &&mut [0];
+ //[stable2021,structural2024]~^ ERROR: mismatched types
+ //[stable2021]~| expected integer, found `&mut _`
+ //[structural2024]~| cannot match inherited `&` with `&mut` pattern
+ let _: u32 = x;
+
+ let &[&mut mut x] = &mut &mut [0];
+ //[stable2021,structural2024]~^ ERROR: mismatched types
+ //[stable2021]~| types differ in mutability
+ //[structural2024]~| cannot match inherited `&` with `&mut` pattern
+ let _: u32 = x;
+}
+
+fn structural_errors_1() {
+ let [&(mut x)] = &[&0];
+ //[structural2024]~^ ERROR: binding cannot be both mutable and by-reference
+ #[cfg(stable2021)] let _: u32 = x;
+ #[cfg(classic2024)] let _: &u32 = x;
+
+ let [&(mut x)] = &mut [&0];
+ //[structural2024]~^ ERROR: binding cannot be both mutable and by-reference
+ #[cfg(stable2021)] let _: u32 = x;
+ #[cfg(classic2024)] let _: &u32 = x;
+}
+
+fn structural_errors_2() {
+ let [&&mut x] = &[&mut 0];
+ //[stable2021,structural2024]~^ ERROR: mismatched types
+ //[stable2021]~| types differ in mutability
+ //[structural2024]~| cannot match inherited `&` with `&mut` pattern
+ let _: u32 = x;
+
+ let [&&mut x] = &mut [&mut 0];
+ //[stable2021,structural2024]~^ ERROR: mismatched types
+ //[stable2021]~| types differ in mutability
+ //[structural2024]~| cannot match inherited `&` with `&mut` pattern
+ let _: u32 = x;
+
+ let [&&mut ref x] = &[&mut 0];
+ //[stable2021,structural2024]~^ ERROR: mismatched types
+ //[stable2021]~| types differ in mutability
+ //[structural2024]~| cannot match inherited `&` with `&mut` pattern
+ let _: &u32 = x;
+
+ let [&&mut ref x] = &mut [&mut 0];
+ //[stable2021,structural2024]~^ ERROR: mismatched types
+ //[stable2021]~| types differ in mutability
+ //[structural2024]~| cannot match inherited `&` with `&mut` pattern
+ let _: &u32 = x;
+
+ let [&&mut mut x] = &[&mut 0];
+ //[stable2021,structural2024]~^ ERROR: mismatched types
+ //[stable2021]~| types differ in mutability
+ //[structural2024]~| cannot match inherited `&` with `&mut` pattern
+ let _: u32 = x;
+
+ let [&&mut mut x] = &mut [&mut 0];
+ //[stable2021,structural2024]~^ ERROR: mismatched types
+ //[stable2021]~| types differ in mutability
+ //[structural2024]~| cannot match inherited `&` with `&mut` pattern
+ let _: u32 = x;
+}
+
+fn classic_errors_0() {
+ let [&mut x] = &[&mut 0];
+ //[classic2024]~^ ERROR: mismatched types
+ //[classic2024]~| cannot match inherited `&` with `&mut` pattern
+ #[cfg(stable2021)] let _: u32 = x;
+ #[cfg(structural2024)] let _: &u32 = x;
+
+ let [&mut &x] = &[&mut 0];
+ //[stable2021,classic2024]~^ ERROR: mismatched types
+ //[stable2021]~| expected integer, found `&_`
+ //[classic2024]~| cannot match inherited `&` with `&mut` pattern
+ let _: u32 = x;
+
+ let [&mut &ref x] = &[&mut 0];
+ //[stable2021,classic2024]~^ ERROR: mismatched types
+ //[stable2021]~| expected integer, found `&_`
+ //[classic2024]~| cannot match inherited `&` with `&mut` pattern
+ let _: &u32 = x;
+
+ let [&mut &(mut x)] = &[&mut 0];
+ //[stable2021,classic2024]~^ ERROR: mismatched types
+ //[stable2021]~| expected integer, found `&_`
+ //[classic2024]~| cannot match inherited `&` with `&mut` pattern
+ let _: u32 = x;
+}
diff --git a/tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/pattern-errors.stable2021.stderr b/tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/pattern-errors.stable2021.stderr
new file mode 100644
index 00000000000..e7eb1813846
--- /dev/null
+++ b/tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/pattern-errors.stable2021.stderr
@@ -0,0 +1,283 @@
+error[E0308]: mismatched types
+ --> $DIR/pattern-errors.rs:18:27
+ |
+LL | if let Some(&mut Some(&x)) = &Some(&mut Some(0)) {
+ | ^^ ------------------- this expression has type `&Option<&mut Option<{integer}>>`
+ | |
+ | expected integer, found `&_`
+ |
+ = note: expected type `{integer}`
+ found reference `&_`
+help: consider removing `&` from the pattern
+ |
+LL | if let Some(&mut Some(x)) = &Some(&mut Some(0)) {
+ | ~
+
+error[E0308]: mismatched types
+ --> $DIR/pattern-errors.rs:31:17
+ |
+LL | if let Some(&mut Some(&_)) = &Some(&Some(0)) {
+ | ^^^^^^^^^^^^^ --------------- this expression has type `&Option<&Option<{integer}>>`
+ | |
+ | types differ in mutability
+ |
+ = note: expected reference `&Option<{integer}>`
+ found mutable reference `&mut _`
+
+error[E0308]: mismatched types
+ --> $DIR/pattern-errors.rs:36:17
+ |
+LL | if let Some(&Some(&mut _)) = &Some(&mut Some(0)) {
+ | ^^^^^^^^^^^^^ ------------------- this expression has type `&Option<&mut Option<{integer}>>`
+ | |
+ | types differ in mutability
+ |
+ = note: expected mutable reference `&mut Option<{integer}>`
+ found reference `&_`
+
+error[E0308]: mismatched types
+ --> $DIR/pattern-errors.rs:41:23
+ |
+LL | if let Some(&Some(&mut _)) = &mut Some(&Some(0)) {
+ | ^^^^^^ ------------------- this expression has type `&mut Option<&Option<{integer}>>`
+ | |
+ | expected integer, found `&mut _`
+ |
+ = note: expected type `{integer}`
+ found mutable reference `&mut _`
+
+error[E0308]: mismatched types
+ --> $DIR/pattern-errors.rs:46:17
+ |
+LL | if let Some(&Some(Some(&mut _))) = &Some(Some(&mut Some(0))) {
+ | ^^^^^^^^^^^^^^^^^^^ ------------------------- this expression has type `&Option>>`
+ | |
+ | expected `Option<&mut Option<{integer}>>`, found `&_`
+ |
+ = note: expected enum `Option<&mut Option<{integer}>>`
+ found reference `&_`
+
+error[E0308]: mismatched types
+ --> $DIR/pattern-errors.rs:51:17
+ |
+LL | if let Some(&mut Some(x)) = &Some(Some(0)) {
+ | ^^^^^^^^^^^^ -------------- this expression has type `&Option>`
+ | |
+ | expected `Option<{integer}>`, found `&mut _`
+ |
+ = note: expected enum `Option<{integer}>`
+ found mutable reference `&mut _`
+
+error[E0308]: mismatched types
+ --> $DIR/pattern-errors.rs:59:11
+ |
+LL | let &[&mut x] = &&mut [0];
+ | ^^^^^^ --------- this expression has type `&&mut [{integer}; 1]`
+ | |
+ | expected integer, found `&mut _`
+ |
+ = note: expected type `{integer}`
+ found mutable reference `&mut _`
+note: to declare a mutable binding use: `mut x`
+ --> $DIR/pattern-errors.rs:59:11
+ |
+LL | let &[&mut x] = &&mut [0];
+ | ^^^^^^
+help: consider removing `&mut` from the pattern
+ |
+LL - let &[&mut x] = &&mut [0];
+LL + let &[x] = &&mut [0];
+ |
+
+error[E0308]: mismatched types
+ --> $DIR/pattern-errors.rs:65:9
+ |
+LL | let &[&mut x] = &mut &mut [0];
+ | ^^^^^^^^^ ------------- this expression has type `&mut &mut [{integer}; 1]`
+ | |
+ | types differ in mutability
+ |
+ = note: expected mutable reference `&mut &mut [{integer}; 1]`
+ found reference `&_`
+
+error[E0308]: mismatched types
+ --> $DIR/pattern-errors.rs:71:11
+ |
+LL | let &[&mut ref x] = &&mut [0];
+ | ^^^^^^^^^^ --------- this expression has type `&&mut [{integer}; 1]`
+ | |
+ | expected integer, found `&mut _`
+ |
+ = note: expected type `{integer}`
+ found mutable reference `&mut _`
+note: to declare a mutable binding use: `mut x`
+ --> $DIR/pattern-errors.rs:71:11
+ |
+LL | let &[&mut ref x] = &&mut [0];
+ | ^^^^^^^^^^
+help: consider removing `&mut` from the pattern
+ |
+LL - let &[&mut ref x] = &&mut [0];
+LL + let &[ref x] = &&mut [0];
+ |
+
+error[E0308]: mismatched types
+ --> $DIR/pattern-errors.rs:77:9
+ |
+LL | let &[&mut ref x] = &mut &mut [0];
+ | ^^^^^^^^^^^^^ ------------- this expression has type `&mut &mut [{integer}; 1]`
+ | |
+ | types differ in mutability
+ |
+ = note: expected mutable reference `&mut &mut [{integer}; 1]`
+ found reference `&_`
+
+error[E0308]: mismatched types
+ --> $DIR/pattern-errors.rs:83:11
+ |
+LL | let &[&mut mut x] = &&mut [0];
+ | ^^^^^^^^^^ --------- this expression has type `&&mut [{integer}; 1]`
+ | |
+ | expected integer, found `&mut _`
+ |
+ = note: expected type `{integer}`
+ found mutable reference `&mut _`
+note: to declare a mutable binding use: `mut x`
+ --> $DIR/pattern-errors.rs:83:11
+ |
+LL | let &[&mut mut x] = &&mut [0];
+ | ^^^^^^^^^^
+help: consider removing `&mut` from the pattern
+ |
+LL - let &[&mut mut x] = &&mut [0];
+LL + let &[mut x] = &&mut [0];
+ |
+
+error[E0308]: mismatched types
+ --> $DIR/pattern-errors.rs:89:9
+ |
+LL | let &[&mut mut x] = &mut &mut [0];
+ | ^^^^^^^^^^^^^ ------------- this expression has type `&mut &mut [{integer}; 1]`
+ | |
+ | types differ in mutability
+ |
+ = note: expected mutable reference `&mut &mut [{integer}; 1]`
+ found reference `&_`
+
+error[E0308]: mismatched types
+ --> $DIR/pattern-errors.rs:109:10
+ |
+LL | let [&&mut x] = &[&mut 0];
+ | ^^^^^^^ --------- this expression has type `&[&mut {integer}; 1]`
+ | |
+ | types differ in mutability
+ |
+ = note: expected mutable reference `&mut {integer}`
+ found reference `&_`
+
+error[E0308]: mismatched types
+ --> $DIR/pattern-errors.rs:115:10
+ |
+LL | let [&&mut x] = &mut [&mut 0];
+ | ^^^^^^^ ------------- this expression has type `&mut [&mut {integer}; 1]`
+ | |
+ | types differ in mutability
+ |
+ = note: expected mutable reference `&mut {integer}`
+ found reference `&_`
+
+error[E0308]: mismatched types
+ --> $DIR/pattern-errors.rs:121:10
+ |
+LL | let [&&mut ref x] = &[&mut 0];
+ | ^^^^^^^^^^^ --------- this expression has type `&[&mut {integer}; 1]`
+ | |
+ | types differ in mutability
+ |
+ = note: expected mutable reference `&mut {integer}`
+ found reference `&_`
+
+error[E0308]: mismatched types
+ --> $DIR/pattern-errors.rs:127:10
+ |
+LL | let [&&mut ref x] = &mut [&mut 0];
+ | ^^^^^^^^^^^ ------------- this expression has type `&mut [&mut {integer}; 1]`
+ | |
+ | types differ in mutability
+ |
+ = note: expected mutable reference `&mut {integer}`
+ found reference `&_`
+
+error[E0308]: mismatched types
+ --> $DIR/pattern-errors.rs:133:10
+ |
+LL | let [&&mut mut x] = &[&mut 0];
+ | ^^^^^^^^^^^ --------- this expression has type `&[&mut {integer}; 1]`
+ | |
+ | types differ in mutability
+ |
+ = note: expected mutable reference `&mut {integer}`
+ found reference `&_`
+
+error[E0308]: mismatched types
+ --> $DIR/pattern-errors.rs:139:10
+ |
+LL | let [&&mut mut x] = &mut [&mut 0];
+ | ^^^^^^^^^^^ ------------- this expression has type `&mut [&mut {integer}; 1]`
+ | |
+ | types differ in mutability
+ |
+ = note: expected mutable reference `&mut {integer}`
+ found reference `&_`
+
+error[E0308]: mismatched types
+ --> $DIR/pattern-errors.rs:153:15
+ |
+LL | let [&mut &x] = &[&mut 0];
+ | ^^ --------- this expression has type `&[&mut {integer}; 1]`
+ | |
+ | expected integer, found `&_`
+ |
+ = note: expected type `{integer}`
+ found reference `&_`
+help: consider removing `&` from the pattern
+ |
+LL - let [&mut &x] = &[&mut 0];
+LL + let [&mut x] = &[&mut 0];
+ |
+
+error[E0308]: mismatched types
+ --> $DIR/pattern-errors.rs:159:15
+ |
+LL | let [&mut &ref x] = &[&mut 0];
+ | ^^^^^^ --------- this expression has type `&[&mut {integer}; 1]`
+ | |
+ | expected integer, found `&_`
+ |
+ = note: expected type `{integer}`
+ found reference `&_`
+help: consider removing `&` from the pattern
+ |
+LL - let [&mut &ref x] = &[&mut 0];
+LL + let [&mut ref x] = &[&mut 0];
+ |
+
+error[E0308]: mismatched types
+ --> $DIR/pattern-errors.rs:165:15
+ |
+LL | let [&mut &(mut x)] = &[&mut 0];
+ | ^^^^^^^^ --------- this expression has type `&[&mut {integer}; 1]`
+ | |
+ | expected integer, found `&_`
+ |
+ = note: expected type `{integer}`
+ found reference `&_`
+help: consider removing `&` from the pattern
+ |
+LL - let [&mut &(mut x)] = &[&mut 0];
+LL + let [&mut mut x)] = &[&mut 0];
+ |
+
+error: aborting due to 21 previous errors
+
+For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/pattern-errors.structural.stderr b/tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/pattern-errors.structural.stderr
deleted file mode 100644
index 59d65553fae..00000000000
--- a/tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/pattern-errors.structural.stderr
+++ /dev/null
@@ -1,89 +0,0 @@
-error[E0308]: mismatched types
- --> $DIR/pattern-errors.rs:10:17
- |
-LL | if let Some(&mut x) = &mut Some(&0) {
- | ^^^^^^ ------------- this expression has type `&mut Option<&{integer}>`
- | |
- | types differ in mutability
- |
- = note: expected reference `&{integer}`
- found mutable reference `&mut _`
-note: to declare a mutable binding use: `mut x`
- --> $DIR/pattern-errors.rs:10:17
- |
-LL | if let Some(&mut x) = &mut Some(&0) {
- | ^^^^^^
-help: consider removing `&mut` from the pattern
- |
-LL | if let Some(x) = &mut Some(&0) {
- | ~
-
-error[E0308]: mismatched types
- --> $DIR/pattern-errors.rs:28:17
- |
-LL | if let Some(&mut Some(&_)) = &Some(&Some(0)) {
- | ^^^^^^^^^^^^^ --------------- this expression has type `&Option<&Option<{integer}>>`
- | |
- | types differ in mutability
- |
- = note: expected reference `&Option<{integer}>`
- found mutable reference `&mut _`
-
-error[E0308]: mismatched types
- --> $DIR/pattern-errors.rs:31:23
- |
-LL | if let Some(&Some(&mut _)) = &Some(&mut Some(0)) {
- | ^^^^^^ ------------------- this expression has type `&Option<&mut Option<{integer}>>`
- | |
- | expected integer, found `&mut _`
- |
- = note: expected type `{integer}`
- found mutable reference `&mut _`
-
-error[E0308]: mismatched types
- --> $DIR/pattern-errors.rs:34:23
- |
-LL | if let Some(&Some(&mut _)) = &mut Some(&Some(0)) {
- | ^^^^^^ ------------------- this expression has type `&mut Option<&Option<{integer}>>`
- | |
- | expected integer, found `&mut _`
- |
- = note: expected type `{integer}`
- found mutable reference `&mut _`
-
-error[E0308]: mismatched types
- --> $DIR/pattern-errors.rs:37:29
- |
-LL | if let Some(&Some(Some((&mut _)))) = &Some(Some(&mut Some(0))) {
- | ^^^^^^ ------------------------- this expression has type `&Option>>`
- | |
- | expected integer, found `&mut _`
- |
- = note: expected type `{integer}`
- found mutable reference `&mut _`
-
-error[E0308]: mismatched types
- --> $DIR/pattern-errors.rs:40:17
- |
-LL | if let Some(&mut Some(x)) = &Some(Some(0)) {
- | ^^^^^^^^^^^^ -------------- this expression has type `&Option>`
- | |
- | expected `Option<{integer}>`, found `&mut _`
- |
- = note: expected enum `Option<{integer}>`
- found mutable reference `&mut _`
-
-error[E0308]: mismatched types
- --> $DIR/pattern-errors.rs:43:17
- |
-LL | if let Some(&mut Some(x)) = &Some(Some(0)) {
- | ^^^^^^^^^^^^ -------------- this expression has type `&Option>`
- | |
- | expected `Option<{integer}>`, found `&mut _`
- |
- = note: expected enum `Option<{integer}>`
- found mutable reference `&mut _`
-
-error: aborting due to 7 previous errors
-
-For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/pattern-errors.structural2024.stderr b/tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/pattern-errors.structural2024.stderr
new file mode 100644
index 00000000000..861ed2216cd
--- /dev/null
+++ b/tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/pattern-errors.structural2024.stderr
@@ -0,0 +1,228 @@
+error[E0308]: mismatched types
+ --> $DIR/pattern-errors.rs:31:17
+ |
+LL | if let Some(&mut Some(&_)) = &Some(&Some(0)) {
+ | ^^^^^
+ |
+ = note: cannot match inherited `&` with `&mut` pattern
+help: replace this `&mut` pattern with `&`
+ |
+LL | if let Some(&Some(&_)) = &Some(&Some(0)) {
+ | ~
+
+error[E0308]: mismatched types
+ --> $DIR/pattern-errors.rs:36:23
+ |
+LL | if let Some(&Some(&mut _)) = &Some(&mut Some(0)) {
+ | ^^^^^
+ |
+ = note: cannot match inherited `&` with `&mut` pattern
+help: replace this `&mut` pattern with `&`
+ |
+LL | if let Some(&Some(&_)) = &Some(&mut Some(0)) {
+ | ~
+
+error[E0308]: mismatched types
+ --> $DIR/pattern-errors.rs:41:23
+ |
+LL | if let Some(&Some(&mut _)) = &mut Some(&Some(0)) {
+ | ^^^^^
+ |
+ = note: cannot match inherited `&` with `&mut` pattern
+help: replace this `&mut` pattern with `&`
+ |
+LL | if let Some(&Some(&_)) = &mut Some(&Some(0)) {
+ | ~
+
+error[E0308]: mismatched types
+ --> $DIR/pattern-errors.rs:46:28
+ |
+LL | if let Some(&Some(Some(&mut _))) = &Some(Some(&mut Some(0))) {
+ | ^^^^^
+ |
+ = note: cannot match inherited `&` with `&mut` pattern
+help: replace this `&mut` pattern with `&`
+ |
+LL | if let Some(&Some(Some(&_))) = &Some(Some(&mut Some(0))) {
+ | ~
+
+error[E0308]: mismatched types
+ --> $DIR/pattern-errors.rs:51:17
+ |
+LL | if let Some(&mut Some(x)) = &Some(Some(0)) {
+ | ^^^^^
+ |
+ = note: cannot match inherited `&` with `&mut` pattern
+help: replace this `&mut` pattern with `&`
+ |
+LL | if let Some(&Some(x)) = &Some(Some(0)) {
+ | ~
+
+error[E0308]: mismatched types
+ --> $DIR/pattern-errors.rs:59:11
+ |
+LL | let &[&mut x] = &&mut [0];
+ | ^^^^^
+ |
+ = note: cannot match inherited `&` with `&mut` pattern
+help: replace this `&mut` pattern with `&`
+ |
+LL | let &[&x] = &&mut [0];
+ | ~
+
+error[E0308]: mismatched types
+ --> $DIR/pattern-errors.rs:65:11
+ |
+LL | let &[&mut x] = &mut &mut [0];
+ | ^^^^^
+ |
+ = note: cannot match inherited `&` with `&mut` pattern
+help: replace this `&mut` pattern with `&`
+ |
+LL | let &[&x] = &mut &mut [0];
+ | ~
+
+error[E0308]: mismatched types
+ --> $DIR/pattern-errors.rs:71:11
+ |
+LL | let &[&mut ref x] = &&mut [0];
+ | ^^^^^
+ |
+ = note: cannot match inherited `&` with `&mut` pattern
+help: replace this `&mut` pattern with `&`
+ |
+LL | let &[&ref x] = &&mut [0];
+ | ~
+
+error[E0308]: mismatched types
+ --> $DIR/pattern-errors.rs:77:11
+ |
+LL | let &[&mut ref x] = &mut &mut [0];
+ | ^^^^^
+ |
+ = note: cannot match inherited `&` with `&mut` pattern
+help: replace this `&mut` pattern with `&`
+ |
+LL | let &[&ref x] = &mut &mut [0];
+ | ~
+
+error[E0308]: mismatched types
+ --> $DIR/pattern-errors.rs:83:11
+ |
+LL | let &[&mut mut x] = &&mut [0];
+ | ^^^^^
+ |
+ = note: cannot match inherited `&` with `&mut` pattern
+help: replace this `&mut` pattern with `&`
+ |
+LL | let &[&mut x] = &&mut [0];
+ | ~
+
+error[E0308]: mismatched types
+ --> $DIR/pattern-errors.rs:89:11
+ |
+LL | let &[&mut mut x] = &mut &mut [0];
+ | ^^^^^
+ |
+ = note: cannot match inherited `&` with `&mut` pattern
+help: replace this `&mut` pattern with `&`
+ |
+LL | let &[&mut x] = &mut &mut [0];
+ | ~
+
+error[E0658]: binding cannot be both mutable and by-reference
+ --> $DIR/pattern-errors.rs:97:12
+ |
+LL | let [&(mut x)] = &[&0];
+ | ^^^^
+ |
+ = note: see issue #123076 for more information
+ = help: add `#![feature(mut_ref)]` 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]: binding cannot be both mutable and by-reference
+ --> $DIR/pattern-errors.rs:102:12
+ |
+LL | let [&(mut x)] = &mut [&0];
+ | ^^^^
+ |
+ = note: see issue #123076 for more information
+ = help: add `#![feature(mut_ref)]` 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[E0308]: mismatched types
+ --> $DIR/pattern-errors.rs:109:11
+ |
+LL | let [&&mut x] = &[&mut 0];
+ | ^^^^^
+ |
+ = note: cannot match inherited `&` with `&mut` pattern
+help: replace this `&mut` pattern with `&`
+ |
+LL | let [&&x] = &[&mut 0];
+ | ~
+
+error[E0308]: mismatched types
+ --> $DIR/pattern-errors.rs:115:11
+ |
+LL | let [&&mut x] = &mut [&mut 0];
+ | ^^^^^
+ |
+ = note: cannot match inherited `&` with `&mut` pattern
+help: replace this `&mut` pattern with `&`
+ |
+LL | let [&&x] = &mut [&mut 0];
+ | ~
+
+error[E0308]: mismatched types
+ --> $DIR/pattern-errors.rs:121:11
+ |
+LL | let [&&mut ref x] = &[&mut 0];
+ | ^^^^^
+ |
+ = note: cannot match inherited `&` with `&mut` pattern
+help: replace this `&mut` pattern with `&`
+ |
+LL | let [&&ref x] = &[&mut 0];
+ | ~
+
+error[E0308]: mismatched types
+ --> $DIR/pattern-errors.rs:127:11
+ |
+LL | let [&&mut ref x] = &mut [&mut 0];
+ | ^^^^^
+ |
+ = note: cannot match inherited `&` with `&mut` pattern
+help: replace this `&mut` pattern with `&`
+ |
+LL | let [&&ref x] = &mut [&mut 0];
+ | ~
+
+error[E0308]: mismatched types
+ --> $DIR/pattern-errors.rs:133:11
+ |
+LL | let [&&mut mut x] = &[&mut 0];
+ | ^^^^^
+ |
+ = note: cannot match inherited `&` with `&mut` pattern
+help: replace this `&mut` pattern with `&`
+ |
+LL | let [&&mut x] = &[&mut 0];
+ | ~
+
+error[E0308]: mismatched types
+ --> $DIR/pattern-errors.rs:139:11
+ |
+LL | let [&&mut mut x] = &mut [&mut 0];
+ | ^^^^^
+ |
+ = note: cannot match inherited `&` with `&mut` pattern
+help: replace this `&mut` pattern with `&`
+ |
+LL | let [&&mut x] = &mut [&mut 0];
+ | ~
+
+error: aborting due to 19 previous errors
+
+Some errors have detailed explanations: E0308, E0658.
+For more information about an error, try `rustc --explain E0308`.
diff --git a/tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/ref-binding-on-inh-ref-errors.classic2024.stderr b/tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/ref-binding-on-inh-ref-errors.classic2024.stderr
new file mode 100644
index 00000000000..70cdcbd62eb
--- /dev/null
+++ b/tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/ref-binding-on-inh-ref-errors.classic2024.stderr
@@ -0,0 +1,70 @@
+error[E0308]: mismatched types
+ --> $DIR/ref-binding-on-inh-ref-errors.rs:60:10
+ |
+LL | let [&mut ref x] = &[&mut 0];
+ | ^^^^^
+ |
+ = note: cannot match inherited `&` with `&mut` pattern
+help: replace this `&mut` pattern with `&`
+ |
+LL | let [&ref x] = &[&mut 0];
+ | ~
+
+error: this pattern relies on behavior which may change in edition 2024
+ --> $DIR/ref-binding-on-inh-ref-errors.rs:74:10
+ |
+LL | let [ref mut x] = &[0];
+ | ^^^^^^^ cannot override to bind by-reference when that is the implicit default
+ |
+ = note: for more information, see
+help: make the implied reference pattern explicit
+ |
+LL | let &[ref mut x] = &[0];
+ | +
+
+error[E0596]: cannot borrow data in a `&` reference as mutable
+ --> $DIR/ref-binding-on-inh-ref-errors.rs:74:10
+ |
+LL | let [ref mut x] = &[0];
+ | ^^^^^^^^^ cannot borrow as mutable
+
+error: this pattern relies on behavior which may change in edition 2024
+ --> $DIR/ref-binding-on-inh-ref-errors.rs:83:10
+ |
+LL | let [ref x] = &[0];
+ | ^^^ cannot override to bind by-reference when that is the implicit default
+ |
+ = note: for more information, see
+help: make the implied reference pattern explicit
+ |
+LL | let &[ref x] = &[0];
+ | +
+
+error: this pattern relies on behavior which may change in edition 2024
+ --> $DIR/ref-binding-on-inh-ref-errors.rs:88:10
+ |
+LL | let [ref x] = &mut [0];
+ | ^^^ cannot override to bind by-reference when that is the implicit default
+ |
+ = note: for more information, see
+help: make the implied reference pattern explicit
+ |
+LL | let &mut [ref x] = &mut [0];
+ | ++++
+
+error: this pattern relies on behavior which may change in edition 2024
+ --> $DIR/ref-binding-on-inh-ref-errors.rs:93:10
+ |
+LL | let [ref mut x] = &mut [0];
+ | ^^^^^^^ cannot override to bind by-reference when that is the implicit default
+ |
+ = note: for more information, see
+help: make the implied reference pattern explicit
+ |
+LL | let &mut [ref mut x] = &mut [0];
+ | ++++
+
+error: aborting due to 6 previous errors
+
+Some errors have detailed explanations: E0308, E0596.
+For more information about an error, try `rustc --explain E0308`.
diff --git a/tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/ref-binding-on-inh-ref-errors.rs b/tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/ref-binding-on-inh-ref-errors.rs
new file mode 100644
index 00000000000..4c88c0c63ae
--- /dev/null
+++ b/tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/ref-binding-on-inh-ref-errors.rs
@@ -0,0 +1,97 @@
+//@ revisions: stable2021 classic2024 structural2024
+//@[stable2021] edition: 2021
+//@[classic2024] edition: 2024
+//@[structural2024] edition: 2024
+//! Tests for errors from binding with `ref x` under a by-ref default binding mode in edition 2024.
+//! These can't be in the same body as tests for other errors, since they're emitted during THIR
+//! construction. The errors on stable edition 2021 Rust are unrelated.
+#![allow(incomplete_features)]
+#![cfg_attr(classic2024, feature(ref_pat_eat_one_layer_2024))]
+#![cfg_attr(structural2024, feature(ref_pat_eat_one_layer_2024_structural))]
+
+/// These only fail on the eat-inner variant of the new edition 2024 pattern typing rules.
+/// The eat-outer variant eats the inherited reference, so binding with `ref` isn't a problem.
+fn errors_from_eating_the_real_reference() {
+ let [&ref x] = &[&0];
+ //[structural2024]~^ ERROR: this pattern relies on behavior which may change in edition 2024
+ //[structural2024]~| cannot override to bind by-reference when that is the implicit default
+ #[cfg(stable2021)] let _: &u32 = x;
+ #[cfg(classic2024)] let _: &&u32 = x;
+
+ let [&ref x] = &mut [&0];
+ //[structural2024]~^ ERROR: this pattern relies on behavior which may change in edition 2024
+ //[structural2024]~| cannot override to bind by-reference when that is the implicit default
+ #[cfg(stable2021)] let _: &u32 = x;
+ #[cfg(classic2024)] let _: &&u32 = x;
+
+ let [&mut ref x] = &mut [&mut 0];
+ //[structural2024]~^ ERROR: this pattern relies on behavior which may change in edition 2024
+ //[structural2024]~| cannot override to bind by-reference when that is the implicit default
+ #[cfg(stable2021)] let _: &u32 = x;
+ #[cfg(classic2024)] let _: &&mut u32 = x;
+
+ let [&mut ref mut x] = &mut [&mut 0];
+ //[structural2024]~^ ERROR: this pattern relies on behavior which may change in edition 2024
+ //[structural2024]~| cannot override to bind by-reference when that is the implicit default
+ #[cfg(stable2021)] let _: &mut u32 = x;
+ #[cfg(classic2024)] let _: &mut &mut u32 = x;
+}
+
+/// To make absolutely sure binding with `ref` ignores inherited references on stable, let's
+/// quarantine these typeck errors (from using a `&` pattern to match a `&mut` reference type).
+fn errors_from_eating_the_real_reference_caught_in_hir_typeck_on_stable() {
+ let [&ref x] = &[&mut 0];
+ //[stable2021]~^ ERROR: mismatched types
+ //[stable2021]~| types differ in mutability
+ //[structural2024]~^^^ ERROR: this pattern relies on behavior which may change in edition 2024
+ //[structural2024]~| cannot override to bind by-reference when that is the implicit default
+ #[cfg(classic2024)] let _: &&mut u32 = x;
+
+ let [&ref x] = &mut [&mut 0];
+ //[stable2021]~^ ERROR: mismatched types
+ //[stable2021]~| types differ in mutability
+ //[structural2024]~^^^ ERROR: this pattern relies on behavior which may change in edition 2024
+ //[structural2024]~| cannot override to bind by-reference when that is the implicit default
+ #[cfg(classic2024)] let _: &&mut u32 = x;
+}
+
+/// This one also needs to be quarantined for a typeck error on `classic2024` (eat-outer).
+fn errors_dependent_on_eating_order_caught_in_hir_typeck_when_eating_outer() {
+ let [&mut ref x] = &[&mut 0];
+ //[classic2024]~^ ERROR: mismatched types
+ //[classic2024]~| cannot match inherited `&` with `&mut` pattern
+ //[structural2024]~^^^ ERROR: this pattern relies on behavior which may change in edition 2024
+ //[structural2024]~| cannot override to bind by-reference when that is the implicit default
+ #[cfg(stable2021)] let _: &u32 = x;
+}
+
+/// These should be errors in all editions. In edition 2024, they should be caught by the pattern
+/// typing rules disallowing `ref` when there's an inherited reference. In old editions where that
+/// resets the binding mode, they're borrowck errors due to binding with `ref mut`.
+/// As a quirk of how the edition 2024 error is emitted during THIR construction, it ends up going
+/// through borrowck as well, using the old `ref` behavior as a fallback, so we get that error too.
+fn borrowck_errors_in_old_editions() {
+ let [ref mut x] = &[0];
+ //~^ ERROR: cannot borrow data in a `&` reference as mutable
+ //[classic2024,structural2024]~| ERROR: this pattern relies on behavior which may change in edition 2024
+ //[classic2024,structural2024]~| cannot override to bind by-reference when that is the implicit default
+}
+
+/// The remaining tests are purely for testing `ref` bindings in the presence of an inherited
+/// reference. These should always fail on edition 2024 and succeed on edition 2021.
+pub fn main() {
+ let [ref x] = &[0];
+ //[classic2024,structural2024]~^ ERROR: this pattern relies on behavior which may change in edition 2024
+ //[classic2024,structural2024]~| cannot override to bind by-reference when that is the implicit default
+ #[cfg(stable2021)] let _: &u32 = x;
+
+ let [ref x] = &mut [0];
+ //[classic2024,structural2024]~^ ERROR: this pattern relies on behavior which may change in edition 2024
+ //[classic2024,structural2024]~| cannot override to bind by-reference when that is the implicit default
+ #[cfg(stable2021)] let _: &u32 = x;
+
+ let [ref mut x] = &mut [0];
+ //[classic2024,structural2024]~^ ERROR: this pattern relies on behavior which may change in edition 2024
+ //[classic2024,structural2024]~| cannot override to bind by-reference when that is the implicit default
+ #[cfg(stable2021)] let _: &mut u32 = x;
+}
diff --git a/tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/ref-binding-on-inh-ref-errors.stable2021.stderr b/tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/ref-binding-on-inh-ref-errors.stable2021.stderr
new file mode 100644
index 00000000000..a21e4bb5b8f
--- /dev/null
+++ b/tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/ref-binding-on-inh-ref-errors.stable2021.stderr
@@ -0,0 +1,42 @@
+error[E0308]: mismatched types
+ --> $DIR/ref-binding-on-inh-ref-errors.rs:43:10
+ |
+LL | let [&ref x] = &[&mut 0];
+ | ^^^^^^ --------- this expression has type `&[&mut {integer}; 1]`
+ | |
+ | types differ in mutability
+ |
+ = note: expected mutable reference `&mut {integer}`
+ found reference `&_`
+help: consider removing `&` from the pattern
+ |
+LL - let [&ref x] = &[&mut 0];
+LL + let [ref x] = &[&mut 0];
+ |
+
+error[E0308]: mismatched types
+ --> $DIR/ref-binding-on-inh-ref-errors.rs:50:10
+ |
+LL | let [&ref x] = &mut [&mut 0];
+ | ^^^^^^ ------------- this expression has type `&mut [&mut {integer}; 1]`
+ | |
+ | types differ in mutability
+ |
+ = note: expected mutable reference `&mut {integer}`
+ found reference `&_`
+help: consider removing `&` from the pattern
+ |
+LL - let [&ref x] = &mut [&mut 0];
+LL + let [ref x] = &mut [&mut 0];
+ |
+
+error[E0596]: cannot borrow data in a `&` reference as mutable
+ --> $DIR/ref-binding-on-inh-ref-errors.rs:74:10
+ |
+LL | let [ref mut x] = &[0];
+ | ^^^^^^^^^ cannot borrow as mutable
+
+error: aborting due to 3 previous errors
+
+Some errors have detailed explanations: E0308, E0596.
+For more information about an error, try `rustc --explain E0308`.
diff --git a/tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/ref-binding-on-inh-ref-errors.structural2024.stderr b/tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/ref-binding-on-inh-ref-errors.structural2024.stderr
new file mode 100644
index 00000000000..ee2c831bfcc
--- /dev/null
+++ b/tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/ref-binding-on-inh-ref-errors.structural2024.stderr
@@ -0,0 +1,141 @@
+error: this pattern relies on behavior which may change in edition 2024
+ --> $DIR/ref-binding-on-inh-ref-errors.rs:15:11
+ |
+LL | let [&ref x] = &[&0];
+ | ^^^ cannot override to bind by-reference when that is the implicit default
+ |
+ = note: for more information, see
+help: make the implied reference pattern explicit
+ |
+LL | let &[&ref x] = &[&0];
+ | +
+
+error: this pattern relies on behavior which may change in edition 2024
+ --> $DIR/ref-binding-on-inh-ref-errors.rs:21:11
+ |
+LL | let [&ref x] = &mut [&0];
+ | ^^^ cannot override to bind by-reference when that is the implicit default
+ |
+ = note: for more information, see
+help: make the implied reference pattern explicit
+ |
+LL | let &mut [&ref x] = &mut [&0];
+ | ++++
+
+error: this pattern relies on behavior which may change in edition 2024
+ --> $DIR/ref-binding-on-inh-ref-errors.rs:27:15
+ |
+LL | let [&mut ref x] = &mut [&mut 0];
+ | ^^^ cannot override to bind by-reference when that is the implicit default
+ |
+ = note: for more information, see
+help: make the implied reference pattern explicit
+ |
+LL | let &mut [&mut ref x] = &mut [&mut 0];
+ | ++++
+
+error: this pattern relies on behavior which may change in edition 2024
+ --> $DIR/ref-binding-on-inh-ref-errors.rs:33:15
+ |
+LL | let [&mut ref mut x] = &mut [&mut 0];
+ | ^^^^^^^ cannot override to bind by-reference when that is the implicit default
+ |
+ = note: for more information, see
+help: make the implied reference pattern explicit
+ |
+LL | let &mut [&mut ref mut x] = &mut [&mut 0];
+ | ++++
+
+error: this pattern relies on behavior which may change in edition 2024
+ --> $DIR/ref-binding-on-inh-ref-errors.rs:43:11
+ |
+LL | let [&ref x] = &[&mut 0];
+ | ^^^ cannot override to bind by-reference when that is the implicit default
+ |
+ = note: for more information, see
+help: make the implied reference pattern explicit
+ |
+LL | let &[&ref x] = &[&mut 0];
+ | +
+
+error: this pattern relies on behavior which may change in edition 2024
+ --> $DIR/ref-binding-on-inh-ref-errors.rs:50:11
+ |
+LL | let [&ref x] = &mut [&mut 0];
+ | ^^^ cannot override to bind by-reference when that is the implicit default
+ |
+ = note: for more information, see
+help: make the implied reference pattern explicit
+ |
+LL | let &mut [&ref x] = &mut [&mut 0];
+ | ++++
+
+error: this pattern relies on behavior which may change in edition 2024
+ --> $DIR/ref-binding-on-inh-ref-errors.rs:60:15
+ |
+LL | let [&mut ref x] = &[&mut 0];
+ | ^^^ cannot override to bind by-reference when that is the implicit default
+ |
+ = note: for more information, see
+help: make the implied reference pattern explicit
+ |
+LL | let &[&mut ref x] = &[&mut 0];
+ | +
+
+error: this pattern relies on behavior which may change in edition 2024
+ --> $DIR/ref-binding-on-inh-ref-errors.rs:74:10
+ |
+LL | let [ref mut x] = &[0];
+ | ^^^^^^^ cannot override to bind by-reference when that is the implicit default
+ |
+ = note: for more information, see
+help: make the implied reference pattern explicit
+ |
+LL | let &[ref mut x] = &[0];
+ | +
+
+error[E0596]: cannot borrow data in a `&` reference as mutable
+ --> $DIR/ref-binding-on-inh-ref-errors.rs:74:10
+ |
+LL | let [ref mut x] = &[0];
+ | ^^^^^^^^^ cannot borrow as mutable
+
+error: this pattern relies on behavior which may change in edition 2024
+ --> $DIR/ref-binding-on-inh-ref-errors.rs:83:10
+ |
+LL | let [ref x] = &[0];
+ | ^^^ cannot override to bind by-reference when that is the implicit default
+ |
+ = note: for more information, see
+help: make the implied reference pattern explicit
+ |
+LL | let &[ref x] = &[0];
+ | +
+
+error: this pattern relies on behavior which may change in edition 2024
+ --> $DIR/ref-binding-on-inh-ref-errors.rs:88:10
+ |
+LL | let [ref x] = &mut [0];
+ | ^^^ cannot override to bind by-reference when that is the implicit default
+ |
+ = note: for more information, see
+help: make the implied reference pattern explicit
+ |
+LL | let &mut [ref x] = &mut [0];
+ | ++++
+
+error: this pattern relies on behavior which may change in edition 2024
+ --> $DIR/ref-binding-on-inh-ref-errors.rs:93:10
+ |
+LL | let [ref mut x] = &mut [0];
+ | ^^^^^^^ cannot override to bind by-reference when that is the implicit default
+ |
+ = note: for more information, see
+help: make the implied reference pattern explicit
+ |
+LL | let &mut [ref mut x] = &mut [0];
+ | ++++
+
+error: aborting due to 12 previous errors
+
+For more information about this error, try `rustc --explain E0596`.
diff --git a/tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/ref-mut-inside-shared-ref-pat.classic.fixed b/tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/ref-mut-inside-shared-ref-pat.classic.fixed
deleted file mode 100644
index 4f4941975d8..00000000000
--- a/tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/ref-mut-inside-shared-ref-pat.classic.fixed
+++ /dev/null
@@ -1,33 +0,0 @@
-//@ edition: 2024
-//@ run-rustfix
-//@ revisions: classic structural
-//! Tests for `&` patterns matched against `&mut` reference types where the inner pattern attempts
-//! to bind by mutable reference.
-#![allow(incomplete_features)]
-#![cfg_attr(classic, feature(ref_pat_eat_one_layer_2024))]
-#![cfg_attr(structural, feature(ref_pat_eat_one_layer_2024_structural))]
-
-pub fn main() {
- if let Some(&mut Some(ref mut x)) = &mut Some(Some(0)) {
- //~^ ERROR: cannot borrow as mutable inside an `&` pattern
- let _: &mut u8 = x;
- }
-
- if let &mut Some(Some(ref mut x)) = &mut Some(Some(0)) {
- //~^ ERROR: cannot borrow as mutable inside an `&` pattern
- let _: &mut u8 = x;
- }
-
- macro_rules! pat {
- ($var:ident) => { ref mut $var };
- }
- let &mut pat!(x) = &mut 0;
- //~^ ERROR: cannot borrow as mutable inside an `&` pattern
- let _: &mut u8 = x;
-
- let &mut (ref mut a, ref mut b) = &mut (true, false);
- //~^ ERROR: cannot borrow as mutable inside an `&` pattern
- //~| ERROR: cannot borrow as mutable inside an `&` pattern
- let _: &mut bool = a;
- let _: &mut bool = b;
-}
diff --git a/tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/ref-mut-inside-shared-ref-pat.classic2024.fixed b/tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/ref-mut-inside-shared-ref-pat.classic2024.fixed
new file mode 100644
index 00000000000..c01784d5076
--- /dev/null
+++ b/tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/ref-mut-inside-shared-ref-pat.classic2024.fixed
@@ -0,0 +1,45 @@
+//@ revisions: stable2021 classic2024 structural2024
+//@[stable2021] edition: 2021
+//@[classic2024] edition: 2024
+//@[structural2024] edition: 2024
+//@[classic2024] run-rustfix
+//@[structural2024] run-rustfix
+//! Tests for `&` patterns matched against `&mut` reference types where the inner pattern attempts
+//! to bind by mutable reference.
+#![allow(incomplete_features)]
+#![cfg_attr(classic2024, feature(ref_pat_eat_one_layer_2024))]
+#![cfg_attr(structural2024, feature(ref_pat_eat_one_layer_2024_structural))]
+
+pub fn main() {
+ if let Some(&mut Some(ref mut x)) = &mut Some(Some(0)) {
+ //[stable2021]~^ ERROR: mismatched types
+ //[classic2024,structural2024]~^^ ERROR: cannot borrow as mutable inside an `&` pattern
+ let _: &mut u8 = x;
+ }
+
+ if let &mut Some(Some(ref mut x)) = &mut Some(Some(0)) {
+ //[stable2021]~^ ERROR: mismatched types
+ //[classic2024,structural2024]~^^ ERROR: cannot borrow as mutable inside an `&` pattern
+ let _: &mut u8 = x;
+ }
+
+ macro_rules! pat {
+ ($var:ident) => { ref mut $var };
+ }
+ let &mut pat!(x) = &mut 0;
+ //[stable2021]~^ ERROR: mismatched types
+ //[classic2024,structural2024]~^^ ERROR: cannot borrow as mutable inside an `&` pattern
+ let _: &mut u8 = x;
+
+ let &mut (ref mut a, ref mut b) = &mut (true, false);
+ //[stable2021]~^ ERROR: mismatched types
+ //[classic2024,structural2024]~^^ ERROR: cannot borrow as mutable inside an `&` pattern
+ //[classic2024,structural2024]~| ERROR: cannot borrow as mutable inside an `&` pattern
+ let _: &mut bool = a;
+ let _: &mut bool = b;
+
+ let &mut [x] = &mut &mut [0];
+ //[stable2021]~^ ERROR: mismatched types
+ //[classic2024]~^^ ERROR: cannot borrow as mutable inside an `&` pattern
+ let _: &u32 = x;
+}
diff --git a/tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/ref-mut-inside-shared-ref-pat.structural.stderr b/tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/ref-mut-inside-shared-ref-pat.classic2024.stderr
similarity index 69%
rename from tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/ref-mut-inside-shared-ref-pat.structural.stderr
rename to tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/ref-mut-inside-shared-ref-pat.classic2024.stderr
index 6c384a51fac..5e98b77be40 100644
--- a/tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/ref-mut-inside-shared-ref-pat.structural.stderr
+++ b/tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/ref-mut-inside-shared-ref-pat.classic2024.stderr
@@ -1,5 +1,5 @@
error[E0596]: cannot borrow as mutable inside an `&` pattern
- --> $DIR/ref-mut-inside-shared-ref-pat.rs:11:31
+ --> $DIR/ref-mut-inside-shared-ref-pat.rs:14:31
|
LL | if let Some(&Some(ref mut x)) = &mut Some(Some(0)) {
| - ^
@@ -7,7 +7,7 @@ LL | if let Some(&Some(ref mut x)) = &mut Some(Some(0)) {
| help: replace this `&` with `&mut`: `&mut`
error[E0596]: cannot borrow as mutable inside an `&` pattern
- --> $DIR/ref-mut-inside-shared-ref-pat.rs:16:31
+ --> $DIR/ref-mut-inside-shared-ref-pat.rs:20:31
|
LL | if let &Some(Some(ref mut x)) = &mut Some(Some(0)) {
| - ^
@@ -15,7 +15,7 @@ LL | if let &Some(Some(ref mut x)) = &mut Some(Some(0)) {
| help: replace this `&` with `&mut`: `&mut`
error[E0596]: cannot borrow as mutable inside an `&` pattern
- --> $DIR/ref-mut-inside-shared-ref-pat.rs:24:15
+ --> $DIR/ref-mut-inside-shared-ref-pat.rs:29:15
|
LL | let &pat!(x) = &mut 0;
| - ^
@@ -23,7 +23,7 @@ LL | let &pat!(x) = &mut 0;
| help: replace this `&` with `&mut`: `&mut`
error[E0596]: cannot borrow as mutable inside an `&` pattern
- --> $DIR/ref-mut-inside-shared-ref-pat.rs:28:19
+ --> $DIR/ref-mut-inside-shared-ref-pat.rs:34:19
|
LL | let &(ref mut a, ref mut b) = &mut (true, false);
| - ^
@@ -31,13 +31,21 @@ LL | let &(ref mut a, ref mut b) = &mut (true, false);
| help: replace this `&` with `&mut`: `&mut`
error[E0596]: cannot borrow as mutable inside an `&` pattern
- --> $DIR/ref-mut-inside-shared-ref-pat.rs:28:30
+ --> $DIR/ref-mut-inside-shared-ref-pat.rs:34:30
|
LL | let &(ref mut a, ref mut b) = &mut (true, false);
| - ^
| |
| help: replace this `&` with `&mut`: `&mut`
-error: aborting due to 5 previous errors
+error[E0596]: cannot borrow as mutable inside an `&` pattern
+ --> $DIR/ref-mut-inside-shared-ref-pat.rs:41:11
+ |
+LL | let &[x] = &mut &mut [0];
+ | - ^
+ | |
+ | help: replace this `&` with `&mut`: `&mut`
+
+error: aborting due to 6 previous errors
For more information about this error, try `rustc --explain E0596`.
diff --git a/tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/ref-mut-inside-shared-ref-pat.rs b/tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/ref-mut-inside-shared-ref-pat.rs
index b29bff7603f..fe40dabb553 100644
--- a/tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/ref-mut-inside-shared-ref-pat.rs
+++ b/tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/ref-mut-inside-shared-ref-pat.rs
@@ -1,20 +1,25 @@
-//@ edition: 2024
-//@ run-rustfix
-//@ revisions: classic structural
+//@ revisions: stable2021 classic2024 structural2024
+//@[stable2021] edition: 2021
+//@[classic2024] edition: 2024
+//@[structural2024] edition: 2024
+//@[classic2024] run-rustfix
+//@[structural2024] run-rustfix
//! Tests for `&` patterns matched against `&mut` reference types where the inner pattern attempts
//! to bind by mutable reference.
#![allow(incomplete_features)]
-#![cfg_attr(classic, feature(ref_pat_eat_one_layer_2024))]
-#![cfg_attr(structural, feature(ref_pat_eat_one_layer_2024_structural))]
+#![cfg_attr(classic2024, feature(ref_pat_eat_one_layer_2024))]
+#![cfg_attr(structural2024, feature(ref_pat_eat_one_layer_2024_structural))]
pub fn main() {
if let Some(&Some(ref mut x)) = &mut Some(Some(0)) {
- //~^ ERROR: cannot borrow as mutable inside an `&` pattern
+ //[stable2021]~^ ERROR: mismatched types
+ //[classic2024,structural2024]~^^ ERROR: cannot borrow as mutable inside an `&` pattern
let _: &mut u8 = x;
}
if let &Some(Some(ref mut x)) = &mut Some(Some(0)) {
- //~^ ERROR: cannot borrow as mutable inside an `&` pattern
+ //[stable2021]~^ ERROR: mismatched types
+ //[classic2024,structural2024]~^^ ERROR: cannot borrow as mutable inside an `&` pattern
let _: &mut u8 = x;
}
@@ -22,12 +27,19 @@ pub fn main() {
($var:ident) => { ref mut $var };
}
let &pat!(x) = &mut 0;
- //~^ ERROR: cannot borrow as mutable inside an `&` pattern
+ //[stable2021]~^ ERROR: mismatched types
+ //[classic2024,structural2024]~^^ ERROR: cannot borrow as mutable inside an `&` pattern
let _: &mut u8 = x;
let &(ref mut a, ref mut b) = &mut (true, false);
- //~^ ERROR: cannot borrow as mutable inside an `&` pattern
- //~| ERROR: cannot borrow as mutable inside an `&` pattern
+ //[stable2021]~^ ERROR: mismatched types
+ //[classic2024,structural2024]~^^ ERROR: cannot borrow as mutable inside an `&` pattern
+ //[classic2024,structural2024]~| ERROR: cannot borrow as mutable inside an `&` pattern
let _: &mut bool = a;
let _: &mut bool = b;
+
+ let &[x] = &mut &mut [0];
+ //[stable2021]~^ ERROR: mismatched types
+ //[classic2024]~^^ ERROR: cannot borrow as mutable inside an `&` pattern
+ let _: &u32 = x;
}
diff --git a/tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/ref-mut-inside-shared-ref-pat.stable2021.stderr b/tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/ref-mut-inside-shared-ref-pat.stable2021.stderr
new file mode 100644
index 00000000000..72c6c05e184
--- /dev/null
+++ b/tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/ref-mut-inside-shared-ref-pat.stable2021.stderr
@@ -0,0 +1,58 @@
+error[E0308]: mismatched types
+ --> $DIR/ref-mut-inside-shared-ref-pat.rs:14:17
+ |
+LL | if let Some(&Some(ref mut x)) = &mut Some(Some(0)) {
+ | ^^^^^^^^^^^^^^^^ ------------------ this expression has type `&mut Option>`
+ | |
+ | expected `Option<{integer}>`, found `&_`
+ |
+ = note: expected enum `Option<{integer}>`
+ found reference `&_`
+
+error[E0308]: mismatched types
+ --> $DIR/ref-mut-inside-shared-ref-pat.rs:20:12
+ |
+LL | if let &Some(Some(ref mut x)) = &mut Some(Some(0)) {
+ | ^^^^^^^^^^^^^^^^^^^^^^ ------------------ this expression has type `&mut Option>`
+ | |
+ | types differ in mutability
+ |
+ = note: expected mutable reference `&mut Option>`
+ found reference `&_`
+
+error[E0308]: mismatched types
+ --> $DIR/ref-mut-inside-shared-ref-pat.rs:29:9
+ |
+LL | let &pat!(x) = &mut 0;
+ | ^^^^^^^^ ------ this expression has type `&mut {integer}`
+ | |
+ | types differ in mutability
+ |
+ = note: expected mutable reference `&mut {integer}`
+ found reference `&_`
+
+error[E0308]: mismatched types
+ --> $DIR/ref-mut-inside-shared-ref-pat.rs:34:9
+ |
+LL | let &(ref mut a, ref mut b) = &mut (true, false);
+ | ^^^^^^^^^^^^^^^^^^^^^^^ ------------------ this expression has type `&mut (bool, bool)`
+ | |
+ | types differ in mutability
+ |
+ = note: expected mutable reference `&mut (bool, bool)`
+ found reference `&_`
+
+error[E0308]: mismatched types
+ --> $DIR/ref-mut-inside-shared-ref-pat.rs:41:9
+ |
+LL | let &[x] = &mut &mut [0];
+ | ^^^^ ------------- this expression has type `&mut &mut [{integer}; 1]`
+ | |
+ | types differ in mutability
+ |
+ = note: expected mutable reference `&mut &mut [{integer}; 1]`
+ found reference `&_`
+
+error: aborting due to 5 previous errors
+
+For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/ref-mut-inside-shared-ref-pat.structural.fixed b/tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/ref-mut-inside-shared-ref-pat.structural.fixed
deleted file mode 100644
index 4f4941975d8..00000000000
--- a/tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/ref-mut-inside-shared-ref-pat.structural.fixed
+++ /dev/null
@@ -1,33 +0,0 @@
-//@ edition: 2024
-//@ run-rustfix
-//@ revisions: classic structural
-//! Tests for `&` patterns matched against `&mut` reference types where the inner pattern attempts
-//! to bind by mutable reference.
-#![allow(incomplete_features)]
-#![cfg_attr(classic, feature(ref_pat_eat_one_layer_2024))]
-#![cfg_attr(structural, feature(ref_pat_eat_one_layer_2024_structural))]
-
-pub fn main() {
- if let Some(&mut Some(ref mut x)) = &mut Some(Some(0)) {
- //~^ ERROR: cannot borrow as mutable inside an `&` pattern
- let _: &mut u8 = x;
- }
-
- if let &mut Some(Some(ref mut x)) = &mut Some(Some(0)) {
- //~^ ERROR: cannot borrow as mutable inside an `&` pattern
- let _: &mut u8 = x;
- }
-
- macro_rules! pat {
- ($var:ident) => { ref mut $var };
- }
- let &mut pat!(x) = &mut 0;
- //~^ ERROR: cannot borrow as mutable inside an `&` pattern
- let _: &mut u8 = x;
-
- let &mut (ref mut a, ref mut b) = &mut (true, false);
- //~^ ERROR: cannot borrow as mutable inside an `&` pattern
- //~| ERROR: cannot borrow as mutable inside an `&` pattern
- let _: &mut bool = a;
- let _: &mut bool = b;
-}
diff --git a/tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/ref-mut-inside-shared-ref-pat.structural2024.fixed b/tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/ref-mut-inside-shared-ref-pat.structural2024.fixed
new file mode 100644
index 00000000000..4ee849b38c5
--- /dev/null
+++ b/tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/ref-mut-inside-shared-ref-pat.structural2024.fixed
@@ -0,0 +1,45 @@
+//@ revisions: stable2021 classic2024 structural2024
+//@[stable2021] edition: 2021
+//@[classic2024] edition: 2024
+//@[structural2024] edition: 2024
+//@[classic2024] run-rustfix
+//@[structural2024] run-rustfix
+//! Tests for `&` patterns matched against `&mut` reference types where the inner pattern attempts
+//! to bind by mutable reference.
+#![allow(incomplete_features)]
+#![cfg_attr(classic2024, feature(ref_pat_eat_one_layer_2024))]
+#![cfg_attr(structural2024, feature(ref_pat_eat_one_layer_2024_structural))]
+
+pub fn main() {
+ if let Some(&mut Some(ref mut x)) = &mut Some(Some(0)) {
+ //[stable2021]~^ ERROR: mismatched types
+ //[classic2024,structural2024]~^^ ERROR: cannot borrow as mutable inside an `&` pattern
+ let _: &mut u8 = x;
+ }
+
+ if let &mut Some(Some(ref mut x)) = &mut Some(Some(0)) {
+ //[stable2021]~^ ERROR: mismatched types
+ //[classic2024,structural2024]~^^ ERROR: cannot borrow as mutable inside an `&` pattern
+ let _: &mut u8 = x;
+ }
+
+ macro_rules! pat {
+ ($var:ident) => { ref mut $var };
+ }
+ let &mut pat!(x) = &mut 0;
+ //[stable2021]~^ ERROR: mismatched types
+ //[classic2024,structural2024]~^^ ERROR: cannot borrow as mutable inside an `&` pattern
+ let _: &mut u8 = x;
+
+ let &mut (ref mut a, ref mut b) = &mut (true, false);
+ //[stable2021]~^ ERROR: mismatched types
+ //[classic2024,structural2024]~^^ ERROR: cannot borrow as mutable inside an `&` pattern
+ //[classic2024,structural2024]~| ERROR: cannot borrow as mutable inside an `&` pattern
+ let _: &mut bool = a;
+ let _: &mut bool = b;
+
+ let &[x] = &mut &mut [0];
+ //[stable2021]~^ ERROR: mismatched types
+ //[classic2024]~^^ ERROR: cannot borrow as mutable inside an `&` pattern
+ let _: &u32 = x;
+}
diff --git a/tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/ref-mut-inside-shared-ref-pat.classic.stderr b/tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/ref-mut-inside-shared-ref-pat.structural2024.stderr
similarity index 83%
rename from tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/ref-mut-inside-shared-ref-pat.classic.stderr
rename to tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/ref-mut-inside-shared-ref-pat.structural2024.stderr
index 6c384a51fac..69cb6c438b6 100644
--- a/tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/ref-mut-inside-shared-ref-pat.classic.stderr
+++ b/tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/ref-mut-inside-shared-ref-pat.structural2024.stderr
@@ -1,5 +1,5 @@
error[E0596]: cannot borrow as mutable inside an `&` pattern
- --> $DIR/ref-mut-inside-shared-ref-pat.rs:11:31
+ --> $DIR/ref-mut-inside-shared-ref-pat.rs:14:31
|
LL | if let Some(&Some(ref mut x)) = &mut Some(Some(0)) {
| - ^
@@ -7,7 +7,7 @@ LL | if let Some(&Some(ref mut x)) = &mut Some(Some(0)) {
| help: replace this `&` with `&mut`: `&mut`
error[E0596]: cannot borrow as mutable inside an `&` pattern
- --> $DIR/ref-mut-inside-shared-ref-pat.rs:16:31
+ --> $DIR/ref-mut-inside-shared-ref-pat.rs:20:31
|
LL | if let &Some(Some(ref mut x)) = &mut Some(Some(0)) {
| - ^
@@ -15,7 +15,7 @@ LL | if let &Some(Some(ref mut x)) = &mut Some(Some(0)) {
| help: replace this `&` with `&mut`: `&mut`
error[E0596]: cannot borrow as mutable inside an `&` pattern
- --> $DIR/ref-mut-inside-shared-ref-pat.rs:24:15
+ --> $DIR/ref-mut-inside-shared-ref-pat.rs:29:15
|
LL | let &pat!(x) = &mut 0;
| - ^
@@ -23,7 +23,7 @@ LL | let &pat!(x) = &mut 0;
| help: replace this `&` with `&mut`: `&mut`
error[E0596]: cannot borrow as mutable inside an `&` pattern
- --> $DIR/ref-mut-inside-shared-ref-pat.rs:28:19
+ --> $DIR/ref-mut-inside-shared-ref-pat.rs:34:19
|
LL | let &(ref mut a, ref mut b) = &mut (true, false);
| - ^
@@ -31,7 +31,7 @@ LL | let &(ref mut a, ref mut b) = &mut (true, false);
| help: replace this `&` with `&mut`: `&mut`
error[E0596]: cannot borrow as mutable inside an `&` pattern
- --> $DIR/ref-mut-inside-shared-ref-pat.rs:28:30
+ --> $DIR/ref-mut-inside-shared-ref-pat.rs:34:30
|
LL | let &(ref mut a, ref mut b) = &mut (true, false);
| - ^
diff --git a/tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/ref_pat_eat_one_layer_2021.rs b/tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/ref_pat_eat_one_layer_2021.rs
index 9372049a2b2..ab3264704ac 100644
--- a/tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/ref_pat_eat_one_layer_2021.rs
+++ b/tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/ref_pat_eat_one_layer_2021.rs
@@ -6,9 +6,11 @@
#![cfg_attr(structural, feature(ref_pat_eat_one_layer_2024_structural))]
pub fn main() {
+ #[cfg(structural)]
if let &Some(Some(x)) = &Some(&mut Some(0)) {
let _: &u32 = x;
}
+
if let Some(&x) = Some(&mut 0) {
let _: u32 = x;
}
diff --git a/tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/well-typed-edition-2024.rs b/tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/well-typed-edition-2024.rs
index 077b52d8f27..3114b9d3bf8 100644
--- a/tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/well-typed-edition-2024.rs
+++ b/tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/well-typed-edition-2024.rs
@@ -1,59 +1,127 @@
-//@ edition: 2024
-//@ revisions: classic structural
-//@ run-pass
+//@ revisions: stable2021 classic2024 structural2024
+//@[stable2021] edition: 2021
+//@[classic2024] edition: 2024
+//@[structural2024] edition: 2024
+//@[classic2024] run-pass
+//@[structural2024] run-pass
//! Test cases for well-typed patterns in edition 2024. These are in their own file to ensure we
//! pass both HIR typeck and MIR borrowck, as we may skip the latter if grouped with failing tests.
-#![allow(incomplete_features)]
-#![cfg_attr(classic, feature(ref_pat_eat_one_layer_2024))]
-#![cfg_attr(structural, feature(ref_pat_eat_one_layer_2024_structural))]
+#![allow(incomplete_features, unused_mut)]
+#![cfg_attr(classic2024, feature(ref_pat_eat_one_layer_2024))]
+#![cfg_attr(structural2024, feature(ref_pat_eat_one_layer_2024_structural))]
pub fn main() {
- if let Some(Some(&x)) = &Some(&Some(0)) {
- let _: u32 = x;
- }
- if let Some(Some(&x)) = &Some(Some(&0)) {
- let _: &u32 = x;
- }
- if let Some(Some(&&x)) = &Some(Some(&0)) {
- let _: u32 = x;
- }
- if let Some(&Some(x)) = &Some(Some(0)) {
- let _: u32 = x;
- }
- if let Some(Some(&mut x)) = &mut Some(&mut Some(0)) {
- let _: u32 = x;
- }
- if let Some(Some(&x)) = &Some(&Some(0)) {
- let _: u32 = x;
- }
- if let Some(&Some(&x)) = &mut Some(&Some(0)) {
- let _: u32 = x;
- }
- if let Some(&Some(x)) = &mut Some(&Some(0)) {
- let _: &u32 = x;
- }
+ // Tests not using match ergonomics. These should always succeed with the same bindings.
if let Some(&Some(&mut ref x)) = Some(&Some(&mut 0)) {
let _: &u32 = x;
}
- if let &Some(Some(x)) = &Some(&mut Some(0)) {
- let _: &u32 = x;
+
+ // Tests for differences in how many layers of reference are eaten by reference patterns
+ if let Some(Some(&x)) = &Some(Some(&0)) {
+ #[cfg(stable2021)] let _: u32 = x;
+ #[cfg(any(classic2024, structural2024))] let _: &u32 = x;
}
- if let Some(&Some(&x)) = &Some(&mut Some(0)) {
+ if let Some(&Some(x)) = &mut Some(&Some(0)) {
+ // This additionally tests that `&` patterns can eat inherited `&mut` refs.
+ // This is possible on stable when the real reference being eaten is of a `&` type.
+ #[cfg(stable2021)] let _: u32 = x;
+ #[cfg(any(classic2024, structural2024))] let _: &u32 = x;
+ }
+ if let Some(Some(&&x)) = &Some(Some(&0)) {
+ //[stable2021]~^ mismatched types
+ //[stable2021]~| expected integer, found `&_`
let _: u32 = x;
}
- if let Some(&Some(&x)) = &Some(&Some(0)) {
+
+ // Tests for eating a lone inherited reference
+ if let Some(Some(&x)) = &Some(&Some(0)) {
+ //[stable2021]~^ mismatched types
+ //[stable2021]~| expected integer, found `&_`
let _: u32 = x;
}
- if let Some(&Some(&x)) = &Some(&mut Some(0)) {
+ if let Some(&Some(x)) = &Some(Some(0)) {
+ //[stable2021]~^ mismatched types
+ //[stable2021]~| expected `Option<{integer}>`, found `&_`
let _: u32 = x;
}
- if let Some(&Some(Some(&x))) = &Some(Some(&mut Some(0))) {
+ if let Some(Some(&mut x)) = &mut Some(&mut Some(0)) {
+ //[stable2021]~^ mismatched types
+ //[stable2021]~| expected integer, found `&mut _`
let _: u32 = x;
}
+
+ // Tests for `&` patterns matching real `&mut` reference types
if let Some(&Some(&x)) = Some(&Some(&mut 0)) {
+ //[stable2021]~^ mismatched types
+ //[stable2021]~| types differ in mutability
+ let _: u32 = x;
+ }
+
+ // Tests for eating only one layer and also eating a lone inherited reference
+ if let Some(&Some(&x)) = &Some(&Some(0)) {
+ //[stable2021]~^ mismatched types
+ //[stable2021]~| expected integer, found `&_`
+ let _: u32 = x;
+ }
+
+ // Tests for `&` matching a lone inherited possibly-`&mut` reference
+ if let Some(&Some(Some(&x))) = &Some(Some(&mut Some(0))) {
+ //[stable2021]~^ mismatched types
+ //[stable2021]~| expected `Option<&mut Option<{integer}>>`, found `&_`
let _: u32 = x;
}
if let Some(&Some(x)) = &mut Some(Some(0)) {
+ //[stable2021]~^ mismatched types
+ //[stable2021]~| expected `Option<{integer}>`, found `&_`
let _: u32 = x;
}
+
+ // Tests eating one layer, eating a lone inherited ref, and `&` eating `&mut` (realness varies)
+ if let Some(&Some(&x)) = &Some(&mut Some(0)) {
+ //[stable2021]~^ mismatched types
+ //[stable2021]~| types differ in mutability
+ let _: u32 = x;
+ }
+ if let Some(&Some(&x)) = &mut Some(&Some(0)) {
+ //[stable2021]~^ mismatched types
+ //[stable2021]~| expected integer, found `&_`
+ let _: u32 = x;
+ }
+
+ // Tests for eat-inner rulesets matching on the outer reference if matching on the inner
+ // reference causes a mutability mismatch, i.e. `Deref(EatInner, FallbackToOuter)`:
+ let [&mut x] = &mut [&0];
+ //[stable2021]~^ mismatched types
+ //[stable2021]~| types differ in mutability
+ let _: &u32 = x;
+
+ let [&mut ref x] = &mut [&0];
+ //[stable2021]~^ mismatched types
+ //[stable2021]~| types differ in mutability
+ let _: &&u32 = x;
+
+ let [&mut ref mut x] = &mut [&0];
+ //[stable2021]~^ mismatched types
+ //[stable2021]~| types differ in mutability
+ let _: &mut &u32 = x;
+
+ let [&mut mut x] = &mut [&0];
+ //[stable2021]~^ mismatched types
+ //[stable2021]~| types differ in mutability
+ let _: &u32 = x;
+
+ let [&mut &x] = &mut [&0];
+ //[stable2021]~^ mismatched types
+ //[stable2021]~| types differ in mutability
+ let _: u32 = x;
+
+ let [&mut &ref x] = &mut [&0];
+ //[stable2021]~^ mismatched types
+ //[stable2021]~| types differ in mutability
+ let _: &u32 = x;
+
+ let [&mut &(mut x)] = &mut [&0];
+ //[stable2021]~^ mismatched types
+ //[stable2021]~| types differ in mutability
+ let _: u32 = x;
}
diff --git a/tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/well-typed-edition-2024.stable2021.stderr b/tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/well-typed-edition-2024.stable2021.stderr
new file mode 100644
index 00000000000..e9c338de243
--- /dev/null
+++ b/tests/ui/pattern/rfc-3627-match-ergonomics-2024/experimental/well-typed-edition-2024.stable2021.stderr
@@ -0,0 +1,260 @@
+error[E0308]: mismatched types
+ --> $DIR/well-typed-edition-2024.rs:30:23
+ |
+LL | if let Some(Some(&&x)) = &Some(Some(&0)) {
+ | ^^ --------------- this expression has type `&Option>`
+ | |
+ | expected integer, found `&_`
+ |
+ = note: expected type `{integer}`
+ found reference `&_`
+help: consider removing `&` from the pattern
+ |
+LL - if let Some(Some(&&x)) = &Some(Some(&0)) {
+LL + if let Some(Some(&x)) = &Some(Some(&0)) {
+ |
+
+error[E0308]: mismatched types
+ --> $DIR/well-typed-edition-2024.rs:37:22
+ |
+LL | if let Some(Some(&x)) = &Some(&Some(0)) {
+ | ^^ --------------- this expression has type `&Option<&Option<{integer}>>`
+ | |
+ | expected integer, found `&_`
+ |
+ = note: expected type `{integer}`
+ found reference `&_`
+help: consider removing `&` from the pattern
+ |
+LL | if let Some(Some(x)) = &Some(&Some(0)) {
+ | ~
+
+error[E0308]: mismatched types
+ --> $DIR/well-typed-edition-2024.rs:42:17
+ |
+LL | if let Some(&Some(x)) = &Some(Some(0)) {
+ | ^^^^^^^^ -------------- this expression has type `&Option>`
+ | |
+ | expected `Option<{integer}>`, found `&_`
+ |
+ = note: expected enum `Option<{integer}>`
+ found reference `&_`
+
+error[E0308]: mismatched types
+ --> $DIR/well-typed-edition-2024.rs:47:22
+ |
+LL | if let Some(Some(&mut x)) = &mut Some(&mut Some(0)) {
+ | ^^^^^^ ----------------------- this expression has type `&mut Option<&mut Option<{integer}>>`
+ | |
+ | expected integer, found `&mut _`
+ |
+ = note: expected type `{integer}`
+ found mutable reference `&mut _`
+note: to declare a mutable binding use: `mut x`
+ --> $DIR/well-typed-edition-2024.rs:47:22
+ |
+LL | if let Some(Some(&mut x)) = &mut Some(&mut Some(0)) {
+ | ^^^^^^
+help: consider removing `&mut` from the pattern
+ |
+LL | if let Some(Some(x)) = &mut Some(&mut Some(0)) {
+ | ~
+
+error[E0308]: mismatched types
+ --> $DIR/well-typed-edition-2024.rs:54:23
+ |
+LL | if let Some(&Some(&x)) = Some(&Some(&mut 0)) {
+ | ^^ ------------------- this expression has type `Option<&Option<&mut {integer}>>`
+ | |
+ | types differ in mutability
+ |
+ = note: expected mutable reference `&mut {integer}`
+ found reference `&_`
+help: consider removing `&` from the pattern
+ |
+LL | if let Some(&Some(x)) = Some(&Some(&mut 0)) {
+ | ~
+
+error[E0308]: mismatched types
+ --> $DIR/well-typed-edition-2024.rs:61:23
+ |
+LL | if let Some(&Some(&x)) = &Some(&Some(0)) {
+ | ^^ --------------- this expression has type `&Option<&Option<{integer}>>`
+ | |
+ | expected integer, found `&_`
+ |
+ = note: expected type `{integer}`
+ found reference `&_`
+help: consider removing `&` from the pattern
+ |
+LL | if let Some(&Some(x)) = &Some(&Some(0)) {
+ | ~
+
+error[E0308]: mismatched types
+ --> $DIR/well-typed-edition-2024.rs:68:17
+ |
+LL | if let Some(&Some(Some(&x))) = &Some(Some(&mut Some(0))) {
+ | ^^^^^^^^^^^^^^^ ------------------------- this expression has type `&Option>>`
+ | |
+ | expected `Option<&mut Option<{integer}>>`, found `&_`
+ |
+ = note: expected enum `Option<&mut Option<{integer}>>`
+ found reference `&_`
+
+error[E0308]: mismatched types
+ --> $DIR/well-typed-edition-2024.rs:73:17
+ |
+LL | if let Some(&Some(x)) = &mut Some(Some(0)) {
+ | ^^^^^^^^ ------------------ this expression has type `&mut Option>`
+ | |
+ | expected `Option<{integer}>`, found `&_`
+ |
+ = note: expected enum `Option<{integer}>`
+ found reference `&_`
+
+error[E0308]: mismatched types
+ --> $DIR/well-typed-edition-2024.rs:80:17
+ |
+LL | if let Some(&Some(&x)) = &Some(&mut Some(0)) {
+ | ^^^^^^^^^ ------------------- this expression has type `&Option<&mut Option<{integer}>>`
+ | |
+ | types differ in mutability
+ |
+ = note: expected mutable reference `&mut Option<{integer}>`
+ found reference `&_`
+
+error[E0308]: mismatched types
+ --> $DIR/well-typed-edition-2024.rs:85:23
+ |
+LL | if let Some(&Some(&x)) = &mut Some(&Some(0)) {
+ | ^^ ------------------- this expression has type `&mut Option<&Option<{integer}>>`
+ | |
+ | expected integer, found `&_`
+ |
+ = note: expected type `{integer}`
+ found reference `&_`
+help: consider removing `&` from the pattern
+ |
+LL | if let Some(&Some(x)) = &mut Some(&Some(0)) {
+ | ~
+
+error[E0308]: mismatched types
+ --> $DIR/well-typed-edition-2024.rs:93:10
+ |
+LL | let [&mut x] = &mut [&0];
+ | ^^^^^^ --------- this expression has type `&mut [&{integer}; 1]`
+ | |
+ | types differ in mutability
+ |
+ = note: expected reference `&{integer}`
+ found mutable reference `&mut _`
+note: to declare a mutable binding use: `mut x`
+ --> $DIR/well-typed-edition-2024.rs:93:10
+ |
+LL | let [&mut x] = &mut [&0];
+ | ^^^^^^
+help: consider removing `&mut` from the pattern
+ |
+LL - let [&mut x] = &mut [&0];
+LL + let [x] = &mut [&0];
+ |
+
+error[E0308]: mismatched types
+ --> $DIR/well-typed-edition-2024.rs:98:10
+ |
+LL | let [&mut ref x] = &mut [&0];
+ | ^^^^^^^^^^ --------- this expression has type `&mut [&{integer}; 1]`
+ | |
+ | types differ in mutability
+ |
+ = note: expected reference `&{integer}`
+ found mutable reference `&mut _`
+note: to declare a mutable binding use: `mut x`
+ --> $DIR/well-typed-edition-2024.rs:98:10
+ |
+LL | let [&mut ref x] = &mut [&0];
+ | ^^^^^^^^^^
+help: consider removing `&mut` from the pattern
+ |
+LL - let [&mut ref x] = &mut [&0];
+LL + let [ref x] = &mut [&0];
+ |
+
+error[E0308]: mismatched types
+ --> $DIR/well-typed-edition-2024.rs:103:10
+ |
+LL | let [&mut ref mut x] = &mut [&0];
+ | ^^^^^^^^^^^^^^ --------- this expression has type `&mut [&{integer}; 1]`
+ | |
+ | types differ in mutability
+ |
+ = note: expected reference `&{integer}`
+ found mutable reference `&mut _`
+note: to declare a mutable binding use: `mut x`
+ --> $DIR/well-typed-edition-2024.rs:103:10
+ |
+LL | let [&mut ref mut x] = &mut [&0];
+ | ^^^^^^^^^^^^^^
+help: consider removing `&mut` from the pattern
+ |
+LL - let [&mut ref mut x] = &mut [&0];
+LL + let [ref mut x] = &mut [&0];
+ |
+
+error[E0308]: mismatched types
+ --> $DIR/well-typed-edition-2024.rs:108:10
+ |
+LL | let [&mut mut x] = &mut [&0];
+ | ^^^^^^^^^^ --------- this expression has type `&mut [&{integer}; 1]`
+ | |
+ | types differ in mutability
+ |
+ = note: expected reference `&{integer}`
+ found mutable reference `&mut _`
+note: to declare a mutable binding use: `mut x`
+ --> $DIR/well-typed-edition-2024.rs:108:10
+ |
+LL | let [&mut mut x] = &mut [&0];
+ | ^^^^^^^^^^
+help: consider removing `&mut` from the pattern
+ |
+LL - let [&mut mut x] = &mut [&0];
+LL + let [mut x] = &mut [&0];
+ |
+
+error[E0308]: mismatched types
+ --> $DIR/well-typed-edition-2024.rs:113:10
+ |
+LL | let [&mut &x] = &mut [&0];
+ | ^^^^^^^ --------- this expression has type `&mut [&{integer}; 1]`
+ | |
+ | types differ in mutability
+ |
+ = note: expected reference `&{integer}`
+ found mutable reference `&mut _`
+
+error[E0308]: mismatched types
+ --> $DIR/well-typed-edition-2024.rs:118:10
+ |
+LL | let [&mut &ref x] = &mut [&0];
+ | ^^^^^^^^^^^ --------- this expression has type `&mut [&{integer}; 1]`
+ | |
+ | types differ in mutability
+ |
+ = note: expected reference `&{integer}`
+ found mutable reference `&mut _`
+
+error[E0308]: mismatched types
+ --> $DIR/well-typed-edition-2024.rs:123:10
+ |
+LL | let [&mut &(mut x)] = &mut [&0];
+ | ^^^^^^^^^^^^^ --------- this expression has type `&mut [&{integer}; 1]`
+ | |
+ | types differ in mutability
+ |
+ = note: expected reference `&{integer}`
+ found mutable reference `&mut _`
+
+error: aborting due to 17 previous errors
+
+For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/privacy/sysroot-private.default.stderr b/tests/ui/privacy/sysroot-private.default.stderr
index 845d4558d13..fef88d107e6 100644
--- a/tests/ui/privacy/sysroot-private.default.stderr
+++ b/tests/ui/privacy/sysroot-private.default.stderr
@@ -1,11 +1,11 @@
error[E0405]: cannot find trait `Equivalent` in this scope
- --> $DIR/sysroot-private.rs:26:18
+ --> $DIR/sysroot-private.rs:27:18
|
LL | trait Trait2: Equivalent {}
| ^^^^^^^^^^ not found in this scope
error[E0412]: cannot find type `K` in this scope
- --> $DIR/sysroot-private.rs:31:35
+ --> $DIR/sysroot-private.rs:32:35
|
LL | fn trait_member(val: &T, key: &K) -> bool {
| - ^
@@ -22,13 +22,13 @@ LL | fn trait_member(val: &T, key: &K) -> bool {
| +++
error[E0220]: associated type `ExpressionStack` not found for `Trait`
- --> $DIR/sysroot-private.rs:21:31
+ --> $DIR/sysroot-private.rs:22:31
|
LL | type AssociatedTy = dyn Trait;
| ^^^^^^^^^^^^^^^ help: `Trait` has the following associated type: `Bar`
error[E0425]: cannot find function `memchr2` in this scope
- --> $DIR/sysroot-private.rs:39:5
+ --> $DIR/sysroot-private.rs:40:5
|
LL | memchr2(b'a', b'b', buf)
| ^^^^^^^ not found in this scope
diff --git a/tests/ui/privacy/sysroot-private.rs b/tests/ui/privacy/sysroot-private.rs
index 67ab67c7f5c..86818574592 100644
--- a/tests/ui/privacy/sysroot-private.rs
+++ b/tests/ui/privacy/sysroot-private.rs
@@ -7,6 +7,7 @@
//! of `std`'s dependencies, but may not be robust against dependency upgrades/changes.
//@ only-unix Windows sysroots seem to not expose this dependency
+//@ ignore-emscripten neither does Emscripten
//@ revisions: default rustc_private_enabled
// Enabling `rustc_private` should `std`'s dependencies accessible, so they should show up
diff --git a/tests/ui/privacy/sysroot-private.rustc_private_enabled.stderr b/tests/ui/privacy/sysroot-private.rustc_private_enabled.stderr
index 98e6922428a..4b54b59714a 100644
--- a/tests/ui/privacy/sysroot-private.rustc_private_enabled.stderr
+++ b/tests/ui/privacy/sysroot-private.rustc_private_enabled.stderr
@@ -1,11 +1,11 @@
error[E0405]: cannot find trait `Equivalent` in this scope
- --> $DIR/sysroot-private.rs:26:18
+ --> $DIR/sysroot-private.rs:27:18
|
LL | trait Trait2: Equivalent {}
| ^^^^^^^^^^ not found in this scope
error[E0412]: cannot find type `K` in this scope
- --> $DIR/sysroot-private.rs:31:35
+ --> $DIR/sysroot-private.rs:32:35
|
LL | fn trait_member(val: &T, key: &K) -> bool {
| - ^
@@ -22,13 +22,13 @@ LL | fn trait_member(val: &T, key: &K) -> bool {
| +++
error[E0220]: associated type `ExpressionStack` not found for `Trait`
- --> $DIR/sysroot-private.rs:21:31
+ --> $DIR/sysroot-private.rs:22:31
|
LL | type AssociatedTy = dyn Trait;
| ^^^^^^^^^^^^^^^ there is an associated type `ExpressionStack` in the trait `gimli::read::op::EvaluationStorage`
error[E0425]: cannot find function `memchr2` in this scope
- --> $DIR/sysroot-private.rs:39:5
+ --> $DIR/sysroot-private.rs:40:5
|
LL | memchr2(b'a', b'b', buf)
| ^^^^^^^ not found in this scope
diff --git a/tests/ui/type/pattern_types/transmute.rs b/tests/ui/type/pattern_types/transmute.rs
new file mode 100644
index 00000000000..cb76b2b938d
--- /dev/null
+++ b/tests/ui/type/pattern_types/transmute.rs
@@ -0,0 +1,32 @@
+#![feature(pattern_types)]
+#![feature(pattern_type_macro)]
+
+use std::pat::pattern_type;
+
+// ok
+fn create(x: u32) -> pattern_type!(u32 is S..=E) {
+ unsafe { std::mem::transmute(x) }
+}
+
+// ok
+fn unwrap(x: pattern_type!(u32 is S..=E)) -> u32 {
+ unsafe { std::mem::transmute(x) }
+}
+
+// bad, only when S != u32::MIN or E != u32::MAX will this ok
+fn non_base_ty_transmute(
+ x: Option,
+) -> u32 {
+ unsafe { std::mem::transmute(x) }
+ //~^ ERROR types of different sizes
+}
+
+// bad, only when S = u32::MIN and E = u32::MAX will this ok
+fn wrapped_transmute(
+ x: Option,
+) -> Option {
+ unsafe { std::mem::transmute(x) }
+ //~^ ERROR types of different sizes
+}
+
+fn main() {}
diff --git a/tests/ui/type/pattern_types/transmute.stderr b/tests/ui/type/pattern_types/transmute.stderr
new file mode 100644
index 00000000000..578549b515c
--- /dev/null
+++ b/tests/ui/type/pattern_types/transmute.stderr
@@ -0,0 +1,21 @@
+error[E0512]: cannot transmute between types of different sizes, or dependently-sized types
+ --> $DIR/transmute.rs:20:14
+ |
+LL | unsafe { std::mem::transmute(x) }
+ | ^^^^^^^^^^^^^^^^^^^
+ |
+ = note: source type: `Option<(u32) is S..=E>` (size can vary because of u32)
+ = note: target type: `u32` (32 bits)
+
+error[E0512]: cannot transmute between types of different sizes, or dependently-sized types
+ --> $DIR/transmute.rs:28:14
+ |
+LL | unsafe { std::mem::transmute(x) }
+ | ^^^^^^^^^^^^^^^^^^^
+ |
+ = note: source type: `Option<(u32) is S..=E>` (size can vary because of u32)
+ = note: target type: `Option` (64 bits)
+
+error: aborting due to 2 previous errors
+
+For more information about this error, try `rustc --explain E0512`.
diff --git a/triagebot.toml b/triagebot.toml
index d09d5eceeb8..29c84e19c56 100644
--- a/triagebot.toml
+++ b/triagebot.toml
@@ -1023,7 +1023,6 @@ contributing_url = "https://rustc-dev-guide.rust-lang.org/getting-started.html"
users_on_vacation = [
"jyn514",
"nnethercote",
- "spastorino",
"workingjubilee",
"kobzol",
"jieyouxu",