user0/rust
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Auto merge of #140608 - matthiaskrgr:rollup-twv6muy, r=matthiaskrgr

Browse source 
Rollup of 8 pull requests

Successful merges:

 - #139343 (Change signature of File::try_lock and File::try_lock_shared)
 - #140505 (linker: Quote symbol names in .def files)
 - #140534 (PassWrapper: adapt for llvm/llvm-project@f137c3d592e96330e450a8fd63ef…)
 - #140546 (Remove backtrace dep from anyhow in features status dump tool)
 - #140548 (Emit user type annotations for free consts in pattern position)
 - #140564 (Use present indicative tense in std::io::pipe() API docs)
 - #140568 (Add regression test for #140545)
 - #140606 (Improve hir pretty printing)

r? `@ghost`
`@rustbot` modify labels: rollup
This commit is contained in:
bors 2025-05-03 07:20:33 +00:00
commit 5fe04cbebd
35 changed files with 316 additions and 167 deletions
Download patch file Download diff file Expand all files Collapse all files

3
Cargo.lock
View file

@ -161,9 +161,6 @@ name = "anyhow"
version = "1.0.97"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "dcfed56ad506cb2c684a14971b8861fdc3baaaae314b9e5f9bb532cbe3ba7a4f"
dependencies = [
"backtrace",
]
[[package]]
name = "ar_archive_writer"

6
compiler/rustc_ast_pretty/src/pp.rs
View file

@ -244,9 +244,6 @@ struct BufEntry {
// forgotten will trigger a panic in `drop`. (Closing a box more than once
// isn't possible because `BoxMarker` doesn't implement `Copy` or `Clone`.)
//
// FIXME(nnethercote): the panic in `drop` is currently disabled because a few
// places fail to close their boxes. It can be enabled once they are fixed.
//
// Note: it would be better to make open/close mismatching impossible and avoid
// the need for this marker type altogether by having functions like
// `with_ibox` that open a box, call a closure, and then close the box. That
@ -261,8 +258,7 @@ impl !Copy for BoxMarker {}
impl Drop for BoxMarker {
fn drop(&mut self) {
// FIXME(nnethercote): enable once the bad cases are fixed
//panic!("BoxMarker not ended with `Printer::end()`");
panic!("BoxMarker not ended with `Printer::end()`");
}
}

15
compiler/rustc_ast_pretty/src/pprust/state/expr.rs
View file

@ -13,7 +13,7 @@ use rustc_ast::{
use crate::pp::Breaks::Inconsistent;
use crate::pprust::state::fixup::FixupContext;
use crate::pprust::state::{AnnNode, BoxMarker, INDENT_UNIT, PrintState, State};
use crate::pprust::state::{AnnNode, INDENT_UNIT, PrintState, State};
impl<'a> State<'a> {
fn print_else(&mut self, els: Option<&ast::Expr>) {
@ -485,12 +485,12 @@ impl<'a> State<'a> {
self.print_block_with_attrs(body, attrs, cb, ib);
}
ast::ExprKind::Loop(blk, opt_label, _) => {
let cb = self.cbox(0);
let ib = self.ibox(0);
if let Some(label) = opt_label {
self.print_ident(label.ident);
self.word_space(":");
}
let cb = self.cbox(0);
let ib = self.ibox(0);
self.word_nbsp("loop");
self.print_block_with_attrs(blk, attrs, cb, ib);
}
@ -542,15 +542,6 @@ impl<'a> State<'a> {
self.print_fn_params_and_ret(fn_decl, true);
self.space();
self.print_expr(body, FixupContext::default());
// FIXME(nnethercote): Bogus. Reduce visibility of `ended` once it's fixed.
let fake_ib = BoxMarker;
self.end(fake_ib);
// A box will be closed by print_expr, but we didn't want an overall
// wrapper so we closed the corresponding opening. so create an
// empty box to satisfy the close.
// FIXME(nnethercote): Bogus.
let _ib = self.ibox(0);
}
ast::ExprKind::Block(blk, opt_label) => {
if let Some(label) = opt_label {

4
compiler/rustc_codegen_ssa/src/back/linker.rs
View file

@ -816,7 +816,9 @@ impl<'a> Linker for GccLinker<'a> {
writeln!(f, "EXPORTS")?;
for symbol in symbols {
debug!(" _{symbol}");
writeln!(f, " {symbol}")?;
// Quote the name in case it's reserved by linker in some way
// (this accounts for names with dots in particular).
writeln!(f, " \"{symbol}\"")?;
}
};
if let Err(error) = res {

37
compiler/rustc_hir_pretty/src/lib.rs
View file

@ -110,6 +110,7 @@ impl<'a> State<'a> {
}
self.print_attr_item(&unparsed, unparsed.span);
self.word("]");
self.hardbreak()
}
hir::Attribute::Parsed(AttributeKind::DocComment { style, kind, comment, .. }) => {
self.word(rustc_ast_pretty::pprust::state::doc_comment_to_string(
@ -183,7 +184,7 @@ impl<'a> State<'a> {
Node::Ty(a) => self.print_type(a),
Node::AssocItemConstraint(a) => self.print_assoc_item_constraint(a),
Node::TraitRef(a) => self.print_trait_ref(a),
Node::OpaqueTy(o) => self.print_opaque_ty(o),
Node::OpaqueTy(_) => panic!("cannot print Node::OpaqueTy"),
Node::Pat(a) => self.print_pat(a),
Node::TyPat(a) => self.print_ty_pat(a),
Node::PatField(a) => self.print_patfield(a),
@ -654,10 +655,11 @@ impl<'a> State<'a> {
self.bclose(item.span, cb);
}
hir::ItemKind::GlobalAsm { asm, .. } => {
// FIXME(nnethercote): `ib` is unclosed
let (cb, _ib) = self.head("global_asm!");
let (cb, ib) = self.head("global_asm!");
self.print_inline_asm(asm);
self.end(cb)
self.word(";");
self.end(cb);
self.end(ib);
}
hir::ItemKind::TyAlias(ident, ty, generics) => {
let (cb, ib) = self.head("type");
@ -764,14 +766,6 @@ impl<'a> State<'a> {
self.print_path(t.path, false);
}
fn print_opaque_ty(&mut self, o: &hir::OpaqueTy<'_>) {
// FIXME(nnethercote): `cb` and `ib` are unclosed
let (_cb, _ib) = self.head("opaque");
self.word("{");
self.print_bounds("impl", o.bounds);
self.word("}");
}
fn print_formal_generic_params(&mut self, generic_params: &[hir::GenericParam<'_>]) {
if !generic_params.is_empty() {
self.word("for");
@ -1509,7 +1503,7 @@ impl<'a> State<'a> {
}
hir::ExprKind::DropTemps(init) => {
// Print `{`:
let cb = self.cbox(INDENT_UNIT);
let cb = self.cbox(0);
let ib = self.ibox(0);
self.bopen(ib);
@ -1532,16 +1526,18 @@ impl<'a> State<'a> {
self.print_if(test, blk, elseopt);
}
hir::ExprKind::Loop(blk, opt_label, _, _) => {
let cb = self.cbox(0);
let ib = self.ibox(0);
if let Some(label) = opt_label {
self.print_ident(label.ident);
self.word_space(":");
}
let (cb, ib) = self.head("loop");
self.word_nbsp("loop");
self.print_block(blk, cb, ib);
}
hir::ExprKind::Match(expr, arms, _) => {
let cb = self.cbox(INDENT_UNIT);
let ib = self.ibox(INDENT_UNIT);
let cb = self.cbox(0);
let ib = self.ibox(0);
self.word_nbsp("match");
self.print_expr_as_cond(expr);
self.space();
@ -1572,15 +1568,6 @@ impl<'a> State<'a> {
// This is a bare expression.
self.ann.nested(self, Nested::Body(body));
// FIXME(nnethercote): this is bogus
let fake_ib = BoxMarker;
self.end(fake_ib);
// A box will be closed by `print_expr`, but we didn't want an overall
// wrapper so we closed the corresponding opening. so create an
// empty box to satisfy the close.
// FIXME(nnethercote): this is bogus, and `print_expr` is missing
let _ib = self.ibox(0);
}
hir::ExprKind::Block(blk, opt_label) => {
if let Some(label) = opt_label {

5
compiler/rustc_llvm/llvm-wrapper/PassWrapper.cpp
View file

@ -512,8 +512,13 @@ extern "C" LLVMTargetMachineRef LLVMRustCreateTargetMachine(
#endif
}
#if LLVM_VERSION_GE(21, 0)
TargetMachine *TM = TheTarget->createTargetMachine(Trip, CPU, Feature,
Options, RM, CM, OptLevel);
#else
TargetMachine *TM = TheTarget->createTargetMachine(
Trip.getTriple(), CPU, Feature, Options, RM, CM, OptLevel);
#endif
return wrap(TM);
}

3
compiler/rustc_mir_build/src/thir/pattern/mod.rs
View file

@ -553,8 +553,7 @@ impl<'a, 'tcx> PatCtxt<'a, 'tcx> {
let res = self.typeck_results.qpath_res(qpath, id);
let (def_id, user_ty) = match res {
Res::Def(DefKind::Const, def_id) => (def_id, None),
Res::Def(DefKind::AssocConst, def_id) => {
Res::Def(DefKind::Const, def_id) | Res::Def(DefKind::AssocConst, def_id) => {
(def_id, self.typeck_results.user_provided_types().get(id))
}

71
library/std/src/fs.rs
View file

@ -21,7 +21,6 @@
mod tests;
use crate::ffi::OsString;
use crate::fmt;
use crate::io::{self, BorrowedCursor, IoSlice, IoSliceMut, Read, Seek, SeekFrom, Write};
use crate::path::{Path, PathBuf};
use crate::sealed::Sealed;
@ -29,6 +28,7 @@ use crate::sync::Arc;
use crate::sys::fs as fs_imp;
use crate::sys_common::{AsInner, AsInnerMut, FromInner, IntoInner};
use crate::time::SystemTime;
use crate::{error, fmt};
/// An object providing access to an open file on the filesystem.
///
@ -116,6 +116,22 @@ pub struct File {
inner: fs_imp::File,
}
/// An enumeration of possible errors which can occur while trying to acquire a lock
/// from the [`try_lock`] method and [`try_lock_shared`] method on a [`File`].
///
/// [`try_lock`]: File::try_lock
/// [`try_lock_shared`]: File::try_lock_shared
#[unstable(feature = "file_lock", issue = "130994")]
pub enum TryLockError {
/// The lock could not be acquired due to an I/O error on the file. The standard library will
/// not return an [`ErrorKind::WouldBlock`] error inside [`TryLockError::Error`]
///
/// [`ErrorKind::WouldBlock`]: io::ErrorKind::WouldBlock
Error(io::Error),
/// The lock could not be acquired at this time because it is held by another handle/process.
WouldBlock,
}
/// Metadata information about a file.
///
/// This structure is returned from the [`metadata`] or
@ -352,6 +368,30 @@ pub fn write<P: AsRef<Path>, C: AsRef<[u8]>>(path: P, contents: C) -> io::Result
inner(path.as_ref(), contents.as_ref())
}
#[unstable(feature = "file_lock", issue = "130994")]
impl error::Error for TryLockError {}
#[unstable(feature = "file_lock", issue = "130994")]
impl fmt::Debug for TryLockError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
TryLockError::Error(err) => err.fmt(f),
TryLockError::WouldBlock => "WouldBlock".fmt(f),
}
}
}
#[unstable(feature = "file_lock", issue = "130994")]
impl fmt::Display for TryLockError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
TryLockError::Error(_) => "lock acquisition failed due to I/O error",
TryLockError::WouldBlock => "lock acquisition failed because the operation would block",
}
.fmt(f)
}
}
impl File {
/// Attempts to open a file in read-only mode.
///
@ -734,8 +774,8 @@ impl File {
/// Try to acquire an exclusive lock on the file.
///
/// Returns `Ok(false)` if a different lock is already held on this file (via another
/// handle/descriptor).
/// Returns `Err(TryLockError::WouldBlock)` if a different lock is already held on this file
/// (via another handle/descriptor).
///
/// This acquires an exclusive lock; no other file handle to this file may acquire another lock.
///
@ -777,23 +817,27 @@ impl File {
///
/// ```no_run
/// #![feature(file_lock)]
/// use std::fs::File;
/// use std::fs::{File, TryLockError};
///
/// fn main() -> std::io::Result<()> {
/// let f = File::create("foo.txt")?;
/// f.try_lock()?;
/// match f.try_lock() {
/// Ok(_) => (),
/// Err(TryLockError::WouldBlock) => (), // Lock not acquired
/// Err(TryLockError::Error(err)) => return Err(err),
/// }
/// Ok(())
/// }
/// ```
#[unstable(feature = "file_lock", issue = "130994")]
pub fn try_lock(&self) -> io::Result<bool> {
pub fn try_lock(&self) -> Result<(), TryLockError> {
self.inner.try_lock()
}
/// Try to acquire a shared (non-exclusive) lock on the file.
///
/// Returns `Ok(false)` if an exclusive lock is already held on this file (via another
/// handle/descriptor).
/// Returns `Err(TryLockError::WouldBlock)` if a different lock is already held on this file
/// (via another handle/descriptor).
///
/// This acquires a shared lock; more than one file handle may hold a shared lock, but none may
/// hold an exclusive lock at the same time.
@ -834,16 +878,21 @@ impl File {
///
/// ```no_run
/// #![feature(file_lock)]
/// use std::fs::File;
/// use std::fs::{File, TryLockError};
///
/// fn main() -> std::io::Result<()> {
/// let f = File::open("foo.txt")?;
/// f.try_lock_shared()?;
/// match f.try_lock_shared() {
/// Ok(_) => (),
/// Err(TryLockError::WouldBlock) => (), // Lock not acquired
/// Err(TryLockError::Error(err)) => return Err(err),
/// }
///
/// Ok(())
/// }
/// ```
#[unstable(feature = "file_lock", issue = "130994")]
pub fn try_lock_shared(&self) -> io::Result<bool> {
pub fn try_lock_shared(&self) -> Result<(), TryLockError> {
self.inner.try_lock_shared()
}

36
library/std/src/fs/tests.rs
View file

@ -1,6 +1,22 @@
use rand::RngCore;
#[cfg(any(
windows,
target_os = "freebsd",
target_os = "linux",
target_os = "netbsd",
target_vendor = "apple",
))]
use crate::assert_matches::assert_matches;
use crate::char::MAX_LEN_UTF8;
#[cfg(any(
windows,
target_os = "freebsd",
target_os = "linux",
target_os = "netbsd",
target_vendor = "apple",
))]
use crate::fs::TryLockError;
use crate::fs::{self, File, FileTimes, OpenOptions};
use crate::io::prelude::*;
use crate::io::{BorrowedBuf, ErrorKind, SeekFrom};
@ -223,8 +239,8 @@ fn file_lock_multiple_shared() {
check!(f2.lock_shared());
check!(f1.unlock());
check!(f2.unlock());
assert!(check!(f1.try_lock_shared()));
assert!(check!(f2.try_lock_shared()));
check!(f1.try_lock_shared());
check!(f2.try_lock_shared());
}
#[test]
@ -243,12 +259,12 @@ fn file_lock_blocking() {
// Check that shared locks block exclusive locks
check!(f1.lock_shared());
assert!(!check!(f2.try_lock()));
assert_matches!(f2.try_lock(), Err(TryLockError::WouldBlock));
check!(f1.unlock());
// Check that exclusive locks block shared locks
check!(f1.lock());
assert!(!check!(f2.try_lock_shared()));
assert_matches!(f2.try_lock_shared(), Err(TryLockError::WouldBlock));
}
#[test]
@ -267,9 +283,9 @@ fn file_lock_drop() {
// Check that locks are released when the File is dropped
check!(f1.lock_shared());
assert!(!check!(f2.try_lock()));
assert_matches!(f2.try_lock(), Err(TryLockError::WouldBlock));
drop(f1);
assert!(check!(f2.try_lock()));
check!(f2.try_lock());
}
#[test]
@ -288,10 +304,10 @@ fn file_lock_dup() {
// Check that locks are not dropped if the File has been cloned
check!(f1.lock_shared());
assert!(!check!(f2.try_lock()));
assert_matches!(f2.try_lock(), Err(TryLockError::WouldBlock));
let cloned = check!(f1.try_clone());
drop(f1);
assert!(!check!(f2.try_lock()));
assert_matches!(f2.try_lock(), Err(TryLockError::WouldBlock));
drop(cloned)
}
@ -307,9 +323,9 @@ fn file_lock_double_unlock() {
// Check that both are released by unlock()
check!(f1.lock());
check!(f1.lock_shared());
assert!(!check!(f2.try_lock()));
assert_matches!(f2.try_lock(), Err(TryLockError::WouldBlock));
check!(f1.unlock());
assert!(check!(f2.try_lock()));
check!(f2.try_lock());
}
#[test]

6
library/std/src/io/pipe.rs
View file

@ -2,7 +2,7 @@ use crate::io;
use crate::sys::anonymous_pipe::{AnonPipe, pipe as pipe_inner};
use crate::sys_common::{FromInner, IntoInner};
/// Create an anonymous pipe.
/// Creates an anonymous pipe.
///
/// # Behavior
///
@ -108,7 +108,7 @@ impl IntoInner<AnonPipe> for PipeWriter {
}
impl PipeReader {
/// Create a new [`PipeReader`] instance that shares the same underlying file description.
/// Creates a new [`PipeReader`] instance that shares the same underlying file description.
///
/// # Examples
///
@ -167,7 +167,7 @@ impl PipeReader {
}
impl PipeWriter {
/// Create a new [`PipeWriter`] instance that shares the same underlying file description.
/// Creates a new [`PipeWriter`] instance that shares the same underlying file description.
///
/// # Examples
///

11
library/std/src/sys/fs/hermit.rs
View file

@ -1,4 +1,5 @@
use crate::ffi::{CStr, OsStr, OsString, c_char};
use crate::fs::TryLockError;
use crate::io::{self, BorrowedCursor, Error, ErrorKind, IoSlice, IoSliceMut, SeekFrom};
use crate::os::hermit::ffi::OsStringExt;
use crate::os::hermit::hermit_abi::{
@ -12,7 +13,7 @@ use crate::sys::common::small_c_string::run_path_with_cstr;
use crate::sys::fd::FileDesc;
pub use crate::sys::fs::common::{copy, exists};
use crate::sys::time::SystemTime;
use crate::sys::{cvt, unsupported};
use crate::sys::{cvt, unsupported, unsupported_err};
use crate::sys_common::{AsInner, AsInnerMut, FromInner, IntoInner};
use crate::{fmt, mem};
@ -366,12 +367,12 @@ impl File {
unsupported()
}
pub fn try_lock(&self) -> io::Result<bool> {
unsupported()
pub fn try_lock(&self) -> Result<(), TryLockError> {
Err(TryLockError::Error(unsupported_err()))
}
pub fn try_lock_shared(&self) -> io::Result<bool> {
unsupported()
pub fn try_lock_shared(&self) -> Result<(), TryLockError> {
Err(TryLockError::Error(unsupported_err()))
}
pub fn unlock(&self) -> io::Result<()> {

11
library/std/src/sys/fs/solid.rs
View file

@ -2,6 +2,7 @@
use crate::ffi::{CStr, CString, OsStr, OsString};
use crate::fmt;
use crate::fs::TryLockError;
use crate::io::{self, BorrowedCursor, IoSlice, IoSliceMut, SeekFrom};
use crate::mem::MaybeUninit;
use crate::os::raw::{c_int, c_short};
@ -11,7 +12,7 @@ use crate::sync::Arc;
pub use crate::sys::fs::common::exists;
use crate::sys::pal::{abi, error};
use crate::sys::time::SystemTime;
use crate::sys::unsupported;
use crate::sys::{unsupported, unsupported_err};
use crate::sys_common::ignore_notfound;
type CIntNotMinusOne = core::num::niche_types::NotAllOnes<c_int>;
@ -352,12 +353,12 @@ impl File {
unsupported()
}
pub fn try_lock(&self) -> io::Result<bool> {
unsupported()
pub fn try_lock(&self) -> Result<(), TryLockError> {
Err(TryLockError::Error(unsupported_err()))
}
pub fn try_lock_shared(&self) -> io::Result<bool> {
unsupported()
pub fn try_lock_shared(&self) -> Result<(), TryLockError> {
Err(TryLockError::Error(unsupported_err()))
}
pub fn unlock(&self) -> io::Result<()> {

5
library/std/src/sys/fs/uefi.rs
View file

@ -2,6 +2,7 @@ use r_efi::protocols::file;
use crate::ffi::OsString;
use crate::fmt;
use crate::fs::TryLockError;
use crate::hash::Hash;
use crate::io::{self, BorrowedCursor, IoSlice, IoSliceMut, SeekFrom};
use crate::path::{Path, PathBuf};
@ -227,11 +228,11 @@ impl File {
self.0
}
pub fn try_lock(&self) -> io::Result<bool> {
pub fn try_lock(&self) -> Result<(), TryLockError> {
self.0
}
pub fn try_lock_shared(&self) -> io::Result<bool> {
pub fn try_lock_shared(&self) -> Result<(), TryLockError> {
self.0
}

39
library/std/src/sys/fs/unix.rs
View file

@ -75,6 +75,7 @@ use libc::{dirent64, fstat64, ftruncate64, lseek64, lstat64, off64_t, open64, st
use crate::ffi::{CStr, OsStr, OsString};
use crate::fmt::{self, Write as _};
use crate::fs::TryLockError;
use crate::io::{self, BorrowedCursor, Error, IoSlice, IoSliceMut, SeekFrom};
use crate::os::unix::io::{AsFd, AsRawFd, BorrowedFd, FromRawFd, IntoRawFd};
use crate::os::unix::prelude::*;
@ -1310,15 +1311,17 @@ impl File {
target_os = "netbsd",
target_vendor = "apple",
))]
pub fn try_lock(&self) -> io::Result<bool> {
pub fn try_lock(&self) -> Result<(), TryLockError> {
let result = cvt(unsafe { libc::flock(self.as_raw_fd(), libc::LOCK_EX | libc::LOCK_NB) });
if let Err(ref err) = result {
if let Err(err) = result {
if err.kind() == io::ErrorKind::WouldBlock {
return Ok(false);
Err(TryLockError::WouldBlock)
} else {
Err(TryLockError::Error(err))
}
} else {
Ok(())
}
result?;
return Ok(true);
}
#[cfg(not(any(
@ -1328,8 +1331,11 @@ impl File {
target_os = "netbsd",
target_vendor = "apple",
)))]
pub fn try_lock(&self) -> io::Result<bool> {
Err(io::const_error!(io::ErrorKind::Unsupported, "try_lock() not supported"))
pub fn try_lock(&self) -> Result<(), TryLockError> {
Err(TryLockError::Error(io::const_error!(
io::ErrorKind::Unsupported,
"try_lock() not supported"
)))
}
#[cfg(any(
@ -1339,15 +1345,17 @@ impl File {
target_os = "netbsd",
target_vendor = "apple",
))]
pub fn try_lock_shared(&self) -> io::Result<bool> {
pub fn try_lock_shared(&self) -> Result<(), TryLockError> {
let result = cvt(unsafe { libc::flock(self.as_raw_fd(), libc::LOCK_SH | libc::LOCK_NB) });
if let Err(ref err) = result {
if let Err(err) = result {
if err.kind() == io::ErrorKind::WouldBlock {
return Ok(false);
Err(TryLockError::WouldBlock)
} else {
Err(TryLockError::Error(err))
}
} else {
Ok(())
}
result?;
return Ok(true);
}
#[cfg(not(any(
@ -1357,8 +1365,11 @@ impl File {
target_os = "netbsd",
target_vendor = "apple",
)))]
pub fn try_lock_shared(&self) -> io::Result<bool> {
Err(io::const_error!(io::ErrorKind::Unsupported, "try_lock_shared() not supported"))
pub fn try_lock_shared(&self) -> Result<(), TryLockError> {
Err(TryLockError::Error(io::const_error!(
io::ErrorKind::Unsupported,
"try_lock_shared() not supported"
)))
}
#[cfg(any(

5
library/std/src/sys/fs/unsupported.rs
View file

@ -1,5 +1,6 @@
use crate::ffi::OsString;
use crate::fmt;
use crate::fs::TryLockError;
use crate::hash::{Hash, Hasher};
use crate::io::{self, BorrowedCursor, IoSlice, IoSliceMut, SeekFrom};
use crate::path::{Path, PathBuf};
@ -206,11 +207,11 @@ impl File {
self.0
}
pub fn try_lock(&self) -> io::Result<bool> {
pub fn try_lock(&self) -> Result<(), TryLockError> {
self.0
}
pub fn try_lock_shared(&self) -> io::Result<bool> {
pub fn try_lock_shared(&self) -> Result<(), TryLockError> {
self.0
}

11
library/std/src/sys/fs/wasi.rs
View file

@ -1,4 +1,5 @@
use crate::ffi::{CStr, OsStr, OsString};
use crate::fs::TryLockError;
use crate::io::{self, BorrowedCursor, IoSlice, IoSliceMut, SeekFrom};
use crate::mem::{self, ManuallyDrop};
use crate::os::raw::c_int;
@ -10,7 +11,7 @@ use crate::sys::common::small_c_string::run_path_with_cstr;
use crate::sys::fd::WasiFd;
pub use crate::sys::fs::common::exists;
use crate::sys::time::SystemTime;
use crate::sys::unsupported;
use crate::sys::{unsupported, unsupported_err};
use crate::sys_common::{AsInner, FromInner, IntoInner, ignore_notfound};
use crate::{fmt, iter, ptr};
@ -461,12 +462,12 @@ impl File {
unsupported()
}
pub fn try_lock(&self) -> io::Result<bool> {
unsupported()
pub fn try_lock(&self) -> Result<(), TryLockError> {
Err(TryLockError::Error(unsupported_err()))
}
pub fn try_lock_shared(&self) -> io::Result<bool> {
unsupported()
pub fn try_lock_shared(&self) -> Result<(), TryLockError> {
Err(TryLockError::Error(unsupported_err()))
}
pub fn unlock(&self) -> io::Result<()> {

17
library/std/src/sys/fs/windows.rs
View file

@ -3,6 +3,7 @@
use crate::alloc::{Layout, alloc, dealloc};
use crate::borrow::Cow;
use crate::ffi::{OsStr, OsString, c_void};
use crate::fs::TryLockError;
use crate::io::{self, BorrowedCursor, Error, IoSlice, IoSliceMut, SeekFrom};
use crate::mem::{self, MaybeUninit, offset_of};
use crate::os::windows::io::{AsHandle, BorrowedHandle};
@ -399,7 +400,7 @@ impl File {
self.acquire_lock(0)
}
pub fn try_lock(&self) -> io::Result<bool> {
pub fn try_lock(&self) -> Result<(), TryLockError> {
let result = cvt(unsafe {
let mut overlapped = mem::zeroed();
c::LockFileEx(
@ -413,18 +414,18 @@ impl File {
});
match result {
Ok(_) => Ok(true),
Ok(_) => Ok(()),
Err(err)
if err.raw_os_error() == Some(c::ERROR_IO_PENDING as i32)
|| err.raw_os_error() == Some(c::ERROR_LOCK_VIOLATION as i32) =>
{
Ok(false)
Err(TryLockError::WouldBlock)
}
Err(err) => Err(err),
Err(err) => Err(TryLockError::Error(err)),
}
}
pub fn try_lock_shared(&self) -> io::Result<bool> {
pub fn try_lock_shared(&self) -> Result<(), TryLockError> {
let result = cvt(unsafe {
let mut overlapped = mem::zeroed();
c::LockFileEx(
@ -438,14 +439,14 @@ impl File {
});
match result {
Ok(_) => Ok(true),
Ok(_) => Ok(()),
Err(err)
if err.raw_os_error() == Some(c::ERROR_IO_PENDING as i32)
|| err.raw_os_error() == Some(c::ERROR_LOCK_VIOLATION as i32) =>
{
Ok(false)
Err(TryLockError::WouldBlock)
}
Err(err) => Err(err),
Err(err) => Err(TryLockError::Error(err)),
}
}

2
src/tools/features-status-dump/Cargo.toml
View file

@ -5,7 +5,7 @@ license = "MIT OR Apache-2.0"
edition = "2021"
[dependencies]
anyhow = { version = "1", features = ["backtrace"] }
anyhow = { version = "1" }
clap = { version = "4", features = ["derive"] }
serde = { version = "1.0.125", features = [ "derive" ] }
serde_json = "1.0.59"

3
tests/pretty/hir-delegation.pp
View file

@ -2,7 +2,8 @@
//@ pretty-mode:hir
//@ pp-exact:hir-delegation.pp
#![allow(incomplete_features)]#![feature(fn_delegation)]
#![allow(incomplete_features)]
#![feature(fn_delegation)]
#[prelude_import]
use ::std::prelude::rust_2015::*;
#[macro_use]

2
tests/rustdoc-json/attrs/automatically_derived.rs
View file

@ -9,5 +9,5 @@ impl Default for Manual {
}
}
//@ is '$.index[?(@.inner.impl.for.resolved_path.path == "Derive" && @.inner.impl.trait.path == "Default")].attrs' '["#[automatically_derived]"]'
//@ is '$.index[?(@.inner.impl.for.resolved_path.path == "Derive" && @.inner.impl.trait.path == "Default")].attrs' '["#[automatically_derived]\n"]'
//@ is '$.index[?(@.inner.impl.for.resolved_path.path == "Manual" && @.inner.impl.trait.path == "Default")].attrs' '[]'

2
tests/rustdoc-json/attrs/export_name_2021.rs
View file

@ -1,6 +1,6 @@
//@ edition: 2021
#![no_std]
//@ is "$.index[?(@.name=='example')].attrs" '["#[export_name = \"altered\"]"]'
//@ is "$.index[?(@.name=='example')].attrs" '["#[export_name = \"altered\"]\n"]'
#[export_name = "altered"]
pub extern "C" fn example() {}

2
tests/rustdoc-json/attrs/export_name_2024.rs
View file

@ -4,6 +4,6 @@
// The representation of `#[unsafe(export_name = ..)]` in rustdoc in edition 2024
// is still `#[export_name = ..]` without the `unsafe` attribute wrapper.
//@ is "$.index[?(@.name=='example')].attrs" '["#[export_name = \"altered\"]"]'
//@ is "$.index[?(@.name=='example')].attrs" '["#[export_name = \"altered\"]\n"]'
#[unsafe(export_name = "altered")]
pub extern "C" fn example() {}

4
tests/rustdoc-json/attrs/must_use.rs
View file

@ -1,9 +1,9 @@
#![no_std]
//@ is "$.index[?(@.name=='example')].attrs" '["#[must_use]"]'
//@ is "$.index[?(@.name=='example')].attrs" '["#[must_use]\n"]'
#[must_use]
pub fn example() -> impl Iterator<Item = i64> {}
//@ is "$.index[?(@.name=='explicit_message')].attrs" '["#[must_use = \"does nothing if you do not use it\"]"]'
//@ is "$.index[?(@.name=='explicit_message')].attrs" '["#[must_use = \"does nothing if you do not use it\"]\n"]'
#[must_use = "does nothing if you do not use it"]
pub fn explicit_message() -> impl Iterator<Item = i64> {}

2
tests/rustdoc-json/attrs/no_mangle_2021.rs
View file

@ -1,6 +1,6 @@
//@ edition: 2021
#![no_std]
//@ is "$.index[?(@.name=='example')].attrs" '["#[no_mangle]"]'
//@ is "$.index[?(@.name=='example')].attrs" '["#[no_mangle]\n"]'
#[no_mangle]
pub extern "C" fn example() {}

2
tests/rustdoc-json/attrs/no_mangle_2024.rs
View file

@ -4,6 +4,6 @@
// The representation of `#[unsafe(no_mangle)]` in rustdoc in edition 2024
// is still `#[no_mangle]` without the `unsafe` attribute wrapper.
//@ is "$.index[?(@.name=='example')].attrs" '["#[no_mangle]"]'
//@ is "$.index[?(@.name=='example')].attrs" '["#[no_mangle]\n"]'
#[unsafe(no_mangle)]
pub extern "C" fn example() {}

6
tests/rustdoc-json/attrs/non_exhaustive.rs
View file

@ -1,18 +1,18 @@
#![no_std]
//@ is "$.index[?(@.name=='MyEnum')].attrs" '["#[non_exhaustive]"]'
//@ is "$.index[?(@.name=='MyEnum')].attrs" '["#[non_exhaustive]\n"]'
#[non_exhaustive]
pub enum MyEnum {
First,
}
pub enum NonExhaustiveVariant {
//@ is "$.index[?(@.name=='Variant')].attrs" '["#[non_exhaustive]"]'
//@ is "$.index[?(@.name=='Variant')].attrs" '["#[non_exhaustive]\n"]'
#[non_exhaustive]
Variant(i64),
}
//@ is "$.index[?(@.name=='MyStruct')].attrs" '["#[non_exhaustive]"]'
//@ is "$.index[?(@.name=='MyStruct')].attrs" '["#[non_exhaustive]\n"]'
#[non_exhaustive]
pub struct MyStruct {
pub x: i64,

4
tests/rustdoc-json/keyword_private.rs
View file

@ -5,7 +5,7 @@
//@ !has "$.index[?(@.name=='match')]"
//@ has "$.index[?(@.name=='foo')]"
//@ is "$.index[?(@.name=='foo')].attrs" '["#[doc(keyword = \"match\")]"]'
//@ is "$.index[?(@.name=='foo')].attrs" '["#[doc(keyword = \"match\")]\n"]'
//@ is "$.index[?(@.name=='foo')].docs" '"this is a test!"'
#[doc(keyword = "match")]
/// this is a test!
@ -13,7 +13,7 @@ pub mod foo {}
//@ !has "$.index[?(@.name=='break')]"
//@ has "$.index[?(@.name=='bar')]"
//@ is "$.index[?(@.name=='bar')].attrs" '["#[doc(keyword = \"break\")]"]'
//@ is "$.index[?(@.name=='bar')].attrs" '["#[doc(keyword = \"break\")]\n"]'
//@ is "$.index[?(@.name=='bar')].docs" '"hello"'
#[doc(keyword = "break")]
/// hello

4
tests/ui-fulldeps/stable-mir/check_attribute.rs
View file

@ -35,12 +35,12 @@ fn test_stable_mir() -> ControlFlow<()> {
fn test_tool(items: &CrateItems) {
let rustfmt_fn = *get_item(&items, "do_not_format").unwrap();
let rustfmt_attrs = rustfmt_fn.tool_attrs(&["rustfmt".to_string(), "skip".to_string()]);
assert_eq!(rustfmt_attrs[0].as_str(), "#[rustfmt::skip]");
assert_eq!(rustfmt_attrs[0].as_str(), "#[rustfmt::skip]\n");
let clippy_fn = *get_item(&items, "complex_fn").unwrap();
let clippy_attrs = clippy_fn.tool_attrs(&["clippy".to_string(),
"cyclomatic_complexity".to_string()]);
assert_eq!(clippy_attrs[0].as_str(), "#[clippy::cyclomatic_complexity = \"100\"]");
assert_eq!(clippy_attrs[0].as_str(), "#[clippy::cyclomatic_complexity = \"100\"]\n");
}
fn get_item<'a>(

14
tests/ui/generic-const-items/user_type_annotations_pattern.rs Normal file
View file

@ -0,0 +1,14 @@
#![feature(generic_const_items)]
#![expect(incomplete_features)]
const FOO<'a: 'static>: usize = 10;
fn bar<'a>() {
match 10_usize {
FOO::<'a> => todo!(),
//~^ ERROR: lifetime may not live long enough
_ => todo!(),
}
}
fn main() {}

11
tests/ui/generic-const-items/user_type_annotations_pattern.stderr Normal file
View file

@ -0,0 +1,11 @@
error: lifetime may not live long enough
--> $DIR/user_type_annotations_pattern.rs:8:9
|
LL | fn bar<'a>() {
| -- lifetime `'a` defined here
LL | match 10_usize {
LL | FOO::<'a> => todo!(),
| ^^^^^^^^^ requires that `'a` must outlive `'static`
error: aborting due to 1 previous error

12
tests/ui/impl-trait/non-defining-uses/double-wrap-with-defining-use.rs Normal file
View file

@ -0,0 +1,12 @@
// Regression test for ICE from issue #140545
// The error message is confusing and wrong, but that's a different problem (#139350)
//@ edition:2018
trait Foo {}
fn a(x: impl Foo) -> impl Foo {
if true { x } else { a(a(x)) }
//~^ ERROR: expected generic type parameter, found `impl Foo` [E0792]
//~| ERROR: type parameter `impl Foo` is part of concrete type but not used in parameter list for the `impl Trait` type alias
}
fn main(){}

17
tests/ui/impl-trait/non-defining-uses/double-wrap-with-defining-use.stderr Normal file
View file

@ -0,0 +1,17 @@
error[E0792]: expected generic type parameter, found `impl Foo`
--> $DIR/double-wrap-with-defining-use.rs:7:26
|
LL | fn a(x: impl Foo) -> impl Foo {
| -------- this generic parameter must be used with a generic type parameter
LL | if true { x } else { a(a(x)) }
| ^^^^^^^
error: type parameter `impl Foo` is part of concrete type but not used in parameter list for the `impl Trait` type alias
--> $DIR/double-wrap-with-defining-use.rs:7:26
|
LL | if true { x } else { a(a(x)) }
| ^^^^^^^
error: aborting due to 2 previous errors
For more information about this error, try `rustc --explain E0792`.

10
tests/ui/linking/weird-export-names.rs Normal file
View file

@ -0,0 +1,10 @@
//@ build-pass
//@ needs-crate-type: cdylib
#![crate_type = "cdylib"]
#[export_name = "foo.0123"]
pub extern "C" fn foo() {}
#[export_name = "EXPORTS"]
pub extern "C" fn bar() {}

3
tests/ui/unpretty/exhaustive-asm.hir.stdout
View file

@ -27,5 +27,6 @@ mod expressions {
mod items {
/// ItemKind::GlobalAsm
mod item_global_asm {/// ItemKind::GlobalAsm
global_asm! (".globl my_asm_func") }
global_asm! (".globl my_asm_func");
}
}

98
tests/ui/unpretty/exhaustive.hir.stdout
View file

@ -8,7 +8,28 @@
// Note: the HIR revision includes a `.stderr` file because there are some
// errors that only occur once we get past the AST.
#![feature(auto_traits)]#![feature(box_patterns)]#![feature(builtin_syntax)]#![feature(concat_idents)]#![feature(const_trait_impl)]#![feature(decl_macro)]#![feature(deref_patterns)]#![feature(dyn_star)]#![feature(explicit_tail_calls)]#![feature(gen_blocks)]#![feature(more_qualified_paths)]#![feature(never_patterns)]#![feature(never_type)]#![feature(pattern_types)]#![feature(pattern_type_macro)]#![feature(prelude_import)]#![feature(specialization)]#![feature(trace_macros)]#![feature(trait_alias)]#![feature(try_blocks)]#![feature(yeet_expr)]#![allow(incomplete_features)]
#![feature(auto_traits)]
#![feature(box_patterns)]
#![feature(builtin_syntax)]
#![feature(concat_idents)]
#![feature(const_trait_impl)]
#![feature(decl_macro)]
#![feature(deref_patterns)]
#![feature(dyn_star)]
#![feature(explicit_tail_calls)]
#![feature(gen_blocks)]
#![feature(more_qualified_paths)]
#![feature(never_patterns)]
#![feature(never_type)]
#![feature(pattern_types)]
#![feature(pattern_type_macro)]
#![feature(prelude_import)]
#![feature(specialization)]
#![feature(trace_macros)]
#![feature(trait_alias)]
#![feature(try_blocks)]
#![feature(yeet_expr)]
#![allow(incomplete_features)]
#[prelude_import]
use std::prelude::rust_2024::*;
#[macro_use]
@ -33,20 +54,25 @@ mod prelude {
/*!
* inner multi-line doc comment
*/
#[doc = "inner doc attribute"]#[allow(dead_code, unused_variables)]#[no_std]
#[doc = "inner doc attribute"]
#[allow(dead_code, unused_variables)]
#[no_std]
mod attributes {//! inner single-line doc comment
/*!
* inner multi-line doc comment
*/
#![doc =
"inner doc attribute"]#![allow(dead_code, unused_variables)]#![no_std]
#![doc = "inner doc attribute"]
#![allow(dead_code, unused_variables)]
#![no_std]
/// outer single-line doc comment
/**
* outer multi-line doc comment
*/
#[doc =
"outer doc attribute"]#[doc = "macro"]#[allow()]#[attr = Repr([ReprC])]
#[doc = "outer doc attribute"]
#[doc = "macro"]
#[allow()]
#[attr = Repr([ReprC])]
struct Struct;
}
@ -147,32 +173,31 @@ mod expressions {
fn expr_for_loop() {
let x;
{
let _t =
match #[lang = "into_iter"](x) {
mut iter =>
loop {
match #[lang = "next"](&mut iter) {
#[lang = "None"] {} => break,
#[lang = "Some"] { 0: _ } => { }
}
},
};
_t
};
let _t =
match #[lang = "into_iter"](x) {
mut iter =>
loop {
match #[lang = "next"](&mut iter) {
#[lang = "None"] {} => break,
#[lang = "Some"] { 0: _ } => { }
}
},
};
_t
};
{
let _t =
match #[lang = "into_iter"](x) {
mut iter =>
'a:
loop {
match #[lang = "next"](&mut iter) {
#[lang = "None"] {} => break,
#[lang = "Some"] { 0: _ } => { }
}
},
};
_t
}
let _t =
match #[lang = "into_iter"](x) {
mut iter =>
'a: loop {
match #[lang = "next"](&mut iter) {
#[lang = "None"] {} => break,
#[lang = "Some"] { 0: _ } => { }
}
},
};
_t
}
}
/// ExprKind::Loop
@ -357,12 +382,11 @@ mod expressions {
fn expr_try() {
let expr;
match #[lang = "branch"](expr) {
#[lang = "Break"] { 0: residual } =>
#[allow(unreachable_code)]
return #[lang = "from_residual"](residual),
#[lang = "Continue"] { 0: val } => #[allow(unreachable_code)]
val,
};
#[lang = "Break"] { 0: residual } => #[allow(unreachable_code)]
return #[lang = "from_residual"](residual),
#[lang = "Continue"] { 0: val } => #[allow(unreachable_code)]
val,
};
}
/// ExprKind::Yield
fn expr_yield() { yield (); yield true; }