Rollup merge of #139105 - ShE3py:BackendRepr-is_signed, r=compiler-errors
`BackendRepr::is_signed`: comment why this may panics
Was wondering why this method could panics while the others couldn't, so quote PR #70189.
diff --git a/compiler/rustc_builtin_macros/src/edition_panic.rs b/compiler/rustc_builtin_macros/src/edition_panic.rs
index b39c986..ccfcc30 100644
--- a/compiler/rustc_builtin_macros/src/edition_panic.rs
+++ b/compiler/rustc_builtin_macros/src/edition_panic.rs
@@ -74,11 +74,11 @@ pub(crate) fn use_panic_2021(mut span: Span) -> bool {
// (To avoid using the edition of e.g. the assert!() or debug_assert!() definition.)
loop {
let expn = span.ctxt().outer_expn_data();
- if let Some(features) = expn.allow_internal_unstable {
- if features.iter().any(|&f| f == sym::edition_panic) {
- span = expn.call_site;
- continue;
- }
+ if let Some(features) = expn.allow_internal_unstable
+ && features.contains(&sym::edition_panic)
+ {
+ span = expn.call_site;
+ continue;
}
break expn.edition >= Edition::Edition2021;
}
diff --git a/compiler/rustc_codegen_ssa/src/back/write.rs b/compiler/rustc_codegen_ssa/src/back/write.rs
index 216a18e..ccc0273 100644
--- a/compiler/rustc_codegen_ssa/src/back/write.rs
+++ b/compiler/rustc_codegen_ssa/src/back/write.rs
@@ -2186,7 +2186,7 @@ fn msvc_imps_needed(tcx: TyCtxt<'_>) -> bool {
// indirectly from ThinLTO. In theory these are not needed as ThinLTO could resolve
// these, but it currently does not do so.
let can_have_static_objects =
- tcx.sess.lto() == Lto::Thin || tcx.crate_types().iter().any(|ct| *ct == CrateType::Rlib);
+ tcx.sess.lto() == Lto::Thin || tcx.crate_types().contains(&CrateType::Rlib);
tcx.sess.target.is_like_windows &&
can_have_static_objects &&
diff --git a/compiler/rustc_codegen_ssa/src/codegen_attrs.rs b/compiler/rustc_codegen_ssa/src/codegen_attrs.rs
index d16d4ed..a85d032 100644
--- a/compiler/rustc_codegen_ssa/src/codegen_attrs.rs
+++ b/compiler/rustc_codegen_ssa/src/codegen_attrs.rs
@@ -604,7 +604,7 @@ fn codegen_fn_attrs(tcx: TyCtxt<'_>, did: LocalDefId) -> CodegenFnAttrs {
if let Some((name, _)) = lang_items::extract(attrs)
&& let Some(lang_item) = LangItem::from_name(name)
{
- if WEAK_LANG_ITEMS.iter().any(|&l| l == lang_item) {
+ if WEAK_LANG_ITEMS.contains(&lang_item) {
codegen_fn_attrs.flags |= CodegenFnAttrFlags::RUSTC_STD_INTERNAL_SYMBOL;
}
if let Some(link_name) = lang_item.link_name() {
diff --git a/compiler/rustc_hir_analysis/src/check/region.rs b/compiler/rustc_hir_analysis/src/check/region.rs
index 2528adb..cf66ab7 100644
--- a/compiler/rustc_hir_analysis/src/check/region.rs
+++ b/compiler/rustc_hir_analysis/src/check/region.rs
@@ -8,7 +8,6 @@
use std::mem;
-use rustc_data_structures::fx::FxHashSet;
use rustc_hir as hir;
use rustc_hir::def_id::DefId;
use rustc_hir::intravisit::{self, Visitor};
@@ -45,28 +44,6 @@ struct ScopeResolutionVisitor<'tcx> {
scope_tree: ScopeTree,
cx: Context,
-
- /// `terminating_scopes` is a set containing the ids of each
- /// statement, or conditional/repeating expression. These scopes
- /// are calling "terminating scopes" because, when attempting to
- /// find the scope of a temporary, by default we search up the
- /// enclosing scopes until we encounter the terminating scope. A
- /// conditional/repeating expression is one which is not
- /// guaranteed to execute exactly once upon entering the parent
- /// scope. This could be because the expression only executes
- /// conditionally, such as the expression `b` in `a && b`, or
- /// because the expression may execute many times, such as a loop
- /// body. The reason that we distinguish such expressions is that,
- /// upon exiting the parent scope, we cannot statically know how
- /// many times the expression executed, and thus if the expression
- /// creates temporaries we cannot know statically how many such
- /// temporaries we would have to cleanup. Therefore, we ensure that
- /// the temporaries never outlast the conditional/repeating
- /// expression, preventing the need for dynamic checks and/or
- /// arbitrary amounts of stack space. Terminating scopes end
- /// up being contained in a DestructionScope that contains the
- /// destructor's execution.
- terminating_scopes: FxHashSet<hir::ItemLocalId>,
}
/// Records the lifetime of a local variable as `cx.var_parent`
@@ -81,7 +58,11 @@ fn record_var_lifetime(visitor: &mut ScopeResolutionVisitor<'_>, var_id: hir::It
}
}
-fn resolve_block<'tcx>(visitor: &mut ScopeResolutionVisitor<'tcx>, blk: &'tcx hir::Block<'tcx>) {
+fn resolve_block<'tcx>(
+ visitor: &mut ScopeResolutionVisitor<'tcx>,
+ blk: &'tcx hir::Block<'tcx>,
+ terminating: bool,
+) {
debug!("resolve_block(blk.hir_id={:?})", blk.hir_id);
let prev_cx = visitor.cx;
@@ -111,7 +92,7 @@ fn resolve_block<'tcx>(visitor: &mut ScopeResolutionVisitor<'tcx>, blk: &'tcx hi
// `other_argument()` has run and also the call to `quux(..)`
// itself has returned.
- visitor.enter_node_scope_with_dtor(blk.hir_id.local_id);
+ visitor.enter_node_scope_with_dtor(blk.hir_id.local_id, terminating);
visitor.cx.var_parent = visitor.cx.parent;
{
@@ -140,8 +121,7 @@ fn resolve_block<'tcx>(visitor: &mut ScopeResolutionVisitor<'tcx>, blk: &'tcx hi
// the sequence of visits agree with the order in the default
// `hir::intravisit` visitor.
mem::swap(&mut prev_cx, &mut visitor.cx);
- visitor.terminating_scopes.insert(els.hir_id.local_id);
- visitor.visit_block(els);
+ resolve_block(visitor, els, true);
// From now on, we continue normally.
visitor.cx = prev_cx;
}
@@ -169,12 +149,12 @@ fn resolve_block<'tcx>(visitor: &mut ScopeResolutionVisitor<'tcx>, blk: &'tcx hi
if let Some(tail_expr) = blk.expr {
let local_id = tail_expr.hir_id.local_id;
let edition = blk.span.edition();
- if edition.at_least_rust_2024() {
- visitor.terminating_scopes.insert(local_id);
- } else if !visitor
- .tcx
- .lints_that_dont_need_to_run(())
- .contains(&lint::LintId::of(lint::builtin::TAIL_EXPR_DROP_ORDER))
+ let terminating = edition.at_least_rust_2024();
+ if !terminating
+ && !visitor
+ .tcx
+ .lints_that_dont_need_to_run(())
+ .contains(&lint::LintId::of(lint::builtin::TAIL_EXPR_DROP_ORDER))
{
// If this temporary scope will be changing once the codebase adopts Rust 2024,
// and we are linting about possible semantic changes that would result,
@@ -185,7 +165,7 @@ fn resolve_block<'tcx>(visitor: &mut ScopeResolutionVisitor<'tcx>, blk: &'tcx hi
.backwards_incompatible_scope
.insert(local_id, Scope { local_id, data: ScopeData::Node });
}
- visitor.visit_expr(tail_expr);
+ resolve_expr(visitor, tail_expr, terminating);
}
}
@@ -203,18 +183,14 @@ fn has_let_expr(expr: &Expr<'_>) -> bool {
let prev_cx = visitor.cx;
- visitor.terminating_scopes.insert(arm.hir_id.local_id);
-
- visitor.enter_node_scope_with_dtor(arm.hir_id.local_id);
+ visitor.enter_node_scope_with_dtor(arm.hir_id.local_id, true);
visitor.cx.var_parent = visitor.cx.parent;
- if let Some(expr) = arm.guard
- && !has_let_expr(expr)
- {
- visitor.terminating_scopes.insert(expr.hir_id.local_id);
+ resolve_pat(visitor, arm.pat);
+ if let Some(guard) = arm.guard {
+ resolve_expr(visitor, guard, !has_let_expr(guard));
}
-
- intravisit::walk_arm(visitor, arm);
+ resolve_expr(visitor, arm.body, false);
visitor.cx = prev_cx;
}
@@ -243,126 +219,24 @@ fn resolve_stmt<'tcx>(visitor: &mut ScopeResolutionVisitor<'tcx>, stmt: &'tcx hi
// associated destruction scope that represents the scope of the
// statement plus its destructors, and thus the scope for which
// regions referenced by the destructors need to survive.
- visitor.terminating_scopes.insert(stmt_id);
let prev_parent = visitor.cx.parent;
- visitor.enter_node_scope_with_dtor(stmt_id);
+ visitor.enter_node_scope_with_dtor(stmt_id, true);
intravisit::walk_stmt(visitor, stmt);
visitor.cx.parent = prev_parent;
}
-fn resolve_expr<'tcx>(visitor: &mut ScopeResolutionVisitor<'tcx>, expr: &'tcx hir::Expr<'tcx>) {
+fn resolve_expr<'tcx>(
+ visitor: &mut ScopeResolutionVisitor<'tcx>,
+ expr: &'tcx hir::Expr<'tcx>,
+ terminating: bool,
+) {
debug!("resolve_expr - pre-increment {} expr = {:?}", visitor.expr_and_pat_count, expr);
let prev_cx = visitor.cx;
- visitor.enter_node_scope_with_dtor(expr.hir_id.local_id);
-
- {
- let terminating_scopes = &mut visitor.terminating_scopes;
- let mut terminating = |id: hir::ItemLocalId| {
- terminating_scopes.insert(id);
- };
- match expr.kind {
- // Conditional or repeating scopes are always terminating
- // scopes, meaning that temporaries cannot outlive them.
- // This ensures fixed size stacks.
- hir::ExprKind::Binary(
- source_map::Spanned { node: hir::BinOpKind::And | hir::BinOpKind::Or, .. },
- l,
- r,
- ) => {
- // expr is a short circuiting operator (|| or &&). As its
- // functionality can't be overridden by traits, it always
- // processes bool sub-expressions. bools are Copy and thus we
- // can drop any temporaries in evaluation (read) order
- // (with the exception of potentially failing let expressions).
- // We achieve this by enclosing the operands in a terminating
- // scope, both the LHS and the RHS.
-
- // We optimize this a little in the presence of chains.
- // Chains like a && b && c get lowered to AND(AND(a, b), c).
- // In here, b and c are RHS, while a is the only LHS operand in
- // that chain. This holds true for longer chains as well: the
- // leading operand is always the only LHS operand that is not a
- // binop itself. Putting a binop like AND(a, b) into a
- // terminating scope is not useful, thus we only put the LHS
- // into a terminating scope if it is not a binop.
-
- let terminate_lhs = match l.kind {
- // let expressions can create temporaries that live on
- hir::ExprKind::Let(_) => false,
- // binops already drop their temporaries, so there is no
- // need to put them into a terminating scope.
- // This is purely an optimization to reduce the number of
- // terminating scopes.
- hir::ExprKind::Binary(
- source_map::Spanned {
- node: hir::BinOpKind::And | hir::BinOpKind::Or, ..
- },
- ..,
- ) => false,
- // otherwise: mark it as terminating
- _ => true,
- };
- if terminate_lhs {
- terminating(l.hir_id.local_id);
- }
-
- // `Let` expressions (in a let-chain) shouldn't be terminating, as their temporaries
- // should live beyond the immediate expression
- if !matches!(r.kind, hir::ExprKind::Let(_)) {
- terminating(r.hir_id.local_id);
- }
- }
- hir::ExprKind::If(_, then, Some(otherwise)) => {
- terminating(then.hir_id.local_id);
- terminating(otherwise.hir_id.local_id);
- }
-
- hir::ExprKind::If(_, then, None) => {
- terminating(then.hir_id.local_id);
- }
-
- hir::ExprKind::Loop(body, _, _, _) => {
- terminating(body.hir_id.local_id);
- }
-
- hir::ExprKind::DropTemps(expr) => {
- // `DropTemps(expr)` does not denote a conditional scope.
- // Rather, we want to achieve the same behavior as `{ let _t = expr; _t }`.
- terminating(expr.hir_id.local_id);
- }
-
- hir::ExprKind::AssignOp(..)
- | hir::ExprKind::Index(..)
- | hir::ExprKind::Unary(..)
- | hir::ExprKind::Call(..)
- | hir::ExprKind::MethodCall(..) => {
- // FIXME(https://github.com/rust-lang/rfcs/issues/811) Nested method calls
- //
- // The lifetimes for a call or method call look as follows:
- //
- // call.id
- // - arg0.id
- // - ...
- // - argN.id
- // - call.callee_id
- //
- // The idea is that call.callee_id represents *the time when
- // the invoked function is actually running* and call.id
- // represents *the time to prepare the arguments and make the
- // call*. See the section "Borrows in Calls" borrowck/README.md
- // for an extended explanation of why this distinction is
- // important.
- //
- // record_superlifetime(new_cx, expr.callee_id);
- }
-
- _ => {}
- }
- }
+ visitor.enter_node_scope_with_dtor(expr.hir_id.local_id, terminating);
let prev_pessimistic = visitor.pessimistic_yield;
@@ -417,6 +291,53 @@ fn resolve_expr<'tcx>(visitor: &mut ScopeResolutionVisitor<'tcx>, expr: &'tcx hi
// properly, we can't miss any types.
match expr.kind {
+ // Conditional or repeating scopes are always terminating
+ // scopes, meaning that temporaries cannot outlive them.
+ // This ensures fixed size stacks.
+ hir::ExprKind::Binary(
+ source_map::Spanned { node: hir::BinOpKind::And | hir::BinOpKind::Or, .. },
+ left,
+ right,
+ ) => {
+ // expr is a short circuiting operator (|| or &&). As its
+ // functionality can't be overridden by traits, it always
+ // processes bool sub-expressions. bools are Copy and thus we
+ // can drop any temporaries in evaluation (read) order
+ // (with the exception of potentially failing let expressions).
+ // We achieve this by enclosing the operands in a terminating
+ // scope, both the LHS and the RHS.
+
+ // We optimize this a little in the presence of chains.
+ // Chains like a && b && c get lowered to AND(AND(a, b), c).
+ // In here, b and c are RHS, while a is the only LHS operand in
+ // that chain. This holds true for longer chains as well: the
+ // leading operand is always the only LHS operand that is not a
+ // binop itself. Putting a binop like AND(a, b) into a
+ // terminating scope is not useful, thus we only put the LHS
+ // into a terminating scope if it is not a binop.
+
+ let terminate_lhs = match left.kind {
+ // let expressions can create temporaries that live on
+ hir::ExprKind::Let(_) => false,
+ // binops already drop their temporaries, so there is no
+ // need to put them into a terminating scope.
+ // This is purely an optimization to reduce the number of
+ // terminating scopes.
+ hir::ExprKind::Binary(
+ source_map::Spanned { node: hir::BinOpKind::And | hir::BinOpKind::Or, .. },
+ ..,
+ ) => false,
+ // otherwise: mark it as terminating
+ _ => true,
+ };
+
+ // `Let` expressions (in a let-chain) shouldn't be terminating, as their temporaries
+ // should live beyond the immediate expression
+ let terminate_rhs = !matches!(right.kind, hir::ExprKind::Let(_));
+
+ resolve_expr(visitor, left, terminate_lhs);
+ resolve_expr(visitor, right, terminate_rhs);
+ }
// Manually recurse over closures, because they are nested bodies
// that share the parent environment. We handle const blocks in
// `visit_inline_const`.
@@ -485,9 +406,9 @@ fn resolve_expr<'tcx>(visitor: &mut ScopeResolutionVisitor<'tcx>, expr: &'tcx hi
visitor.enter_scope(Scope { local_id: then.hir_id.local_id, data });
visitor.cx.var_parent = visitor.cx.parent;
visitor.visit_expr(cond);
- visitor.visit_expr(then);
+ resolve_expr(visitor, then, true);
visitor.cx = expr_cx;
- visitor.visit_expr(otherwise);
+ resolve_expr(visitor, otherwise, true);
}
hir::ExprKind::If(cond, then, None) => {
@@ -500,10 +421,20 @@ fn resolve_expr<'tcx>(visitor: &mut ScopeResolutionVisitor<'tcx>, expr: &'tcx hi
visitor.enter_scope(Scope { local_id: then.hir_id.local_id, data });
visitor.cx.var_parent = visitor.cx.parent;
visitor.visit_expr(cond);
- visitor.visit_expr(then);
+ resolve_expr(visitor, then, true);
visitor.cx = expr_cx;
}
+ hir::ExprKind::Loop(body, _, _, _) => {
+ resolve_block(visitor, body, true);
+ }
+
+ hir::ExprKind::DropTemps(expr) => {
+ // `DropTemps(expr)` does not denote a conditional scope.
+ // Rather, we want to achieve the same behavior as `{ let _t = expr; _t }`.
+ resolve_expr(visitor, expr, true);
+ }
+
_ => intravisit::walk_expr(visitor, expr),
}
@@ -786,12 +717,12 @@ fn enter_scope(&mut self, child_scope: Scope) {
self.cx.parent = Some(child_scope);
}
- fn enter_node_scope_with_dtor(&mut self, id: hir::ItemLocalId) {
+ fn enter_node_scope_with_dtor(&mut self, id: hir::ItemLocalId, terminating: bool) {
// If node was previously marked as a terminating scope during the
// recursive visit of its parent node in the HIR, then we need to
// account for the destruction scope representing the scope of
// the destructors that run immediately after it completes.
- if self.terminating_scopes.contains(&id) {
+ if terminating {
self.enter_scope(Scope { local_id: id, data: ScopeData::Destruction });
}
self.enter_scope(Scope { local_id: id, data: ScopeData::Node });
@@ -803,13 +734,11 @@ fn enter_body(&mut self, hir_id: hir::HirId, f: impl FnOnce(&mut Self)) {
// visited the body.
let outer_ec = mem::replace(&mut self.expr_and_pat_count, 0);
let outer_cx = self.cx;
- let outer_ts = mem::take(&mut self.terminating_scopes);
// The 'pessimistic yield' flag is set to true when we are
// processing a `+=` statement and have to make pessimistic
// control flow assumptions. This doesn't apply to nested
// bodies within the `+=` statements. See #69307.
let outer_pessimistic_yield = mem::replace(&mut self.pessimistic_yield, false);
- self.terminating_scopes.insert(hir_id.local_id);
self.enter_scope(Scope { local_id: hir_id.local_id, data: ScopeData::CallSite });
self.enter_scope(Scope { local_id: hir_id.local_id, data: ScopeData::Arguments });
@@ -819,14 +748,13 @@ fn enter_body(&mut self, hir_id: hir::HirId, f: impl FnOnce(&mut Self)) {
// Restore context we had at the start.
self.expr_and_pat_count = outer_ec;
self.cx = outer_cx;
- self.terminating_scopes = outer_ts;
self.pessimistic_yield = outer_pessimistic_yield;
}
}
impl<'tcx> Visitor<'tcx> for ScopeResolutionVisitor<'tcx> {
fn visit_block(&mut self, b: &'tcx Block<'tcx>) {
- resolve_block(self, b);
+ resolve_block(self, b, false);
}
fn visit_body(&mut self, body: &hir::Body<'tcx>) {
@@ -850,7 +778,7 @@ fn visit_body(&mut self, body: &hir::Body<'tcx>) {
}
// The body of the every fn is a root scope.
- this.visit_expr(body.value)
+ resolve_expr(this, body.value, true);
} else {
// Only functions have an outer terminating (drop) scope, while
// temporaries in constant initializers may be 'static, but only
@@ -871,6 +799,10 @@ fn visit_body(&mut self, body: &hir::Body<'tcx>) {
// (i.e., `'static`), which means that after `g` returns, it drops,
// and all the associated destruction scope rules apply.
this.cx.var_parent = None;
+ this.enter_scope(Scope {
+ local_id: body.value.hir_id.local_id,
+ data: ScopeData::Destruction,
+ });
resolve_local(this, None, Some(body.value));
}
})
@@ -886,7 +818,7 @@ fn visit_stmt(&mut self, s: &'tcx Stmt<'tcx>) {
resolve_stmt(self, s);
}
fn visit_expr(&mut self, ex: &'tcx Expr<'tcx>) {
- resolve_expr(self, ex);
+ resolve_expr(self, ex, false);
}
fn visit_local(&mut self, l: &'tcx LetStmt<'tcx>) {
resolve_local(self, Some(l.pat), l.init)
@@ -916,7 +848,6 @@ pub(crate) fn region_scope_tree(tcx: TyCtxt<'_>, def_id: DefId) -> &ScopeTree {
scope_tree: ScopeTree::default(),
expr_and_pat_count: 0,
cx: Context { parent: None, var_parent: None },
- terminating_scopes: Default::default(),
pessimistic_yield: false,
fixup_scopes: vec![],
};
diff --git a/compiler/rustc_hir_typeck/src/expr_use_visitor.rs b/compiler/rustc_hir_typeck/src/expr_use_visitor.rs
index c71a5ea..6fb2892 100644
--- a/compiler/rustc_hir_typeck/src/expr_use_visitor.rs
+++ b/compiler/rustc_hir_typeck/src/expr_use_visitor.rs
@@ -1,6 +1,9 @@
//! A different sort of visitor for walking fn bodies. Unlike the
//! normal visitor, which just walks the entire body in one shot, the
//! `ExprUseVisitor` determines how expressions are being used.
+//!
+//! In the compiler, this is only used for upvar inference, but there
+//! are many uses within clippy.
use std::cell::{Ref, RefCell};
use std::ops::Deref;
@@ -25,7 +28,7 @@
use rustc_middle::{bug, span_bug};
use rustc_span::{ErrorGuaranteed, Span};
use rustc_trait_selection::infer::InferCtxtExt;
-use tracing::{debug, trace};
+use tracing::{debug, instrument, trace};
use crate::fn_ctxt::FnCtxt;
@@ -35,11 +38,8 @@ pub trait Delegate<'tcx> {
/// The value found at `place` is moved, depending
/// on `mode`. Where `diag_expr_id` is the id used for diagnostics for `place`.
///
- /// Use of a `Copy` type in a ByValue context is considered a use
- /// by `ImmBorrow` and `borrow` is called instead. This is because
- /// a shared borrow is the "minimum access" that would be needed
- /// to perform a copy.
- ///
+ /// If the value is `Copy`, [`copy`][Self::copy] is called instead, which
+ /// by default falls back to [`borrow`][Self::borrow].
///
/// The parameter `diag_expr_id` indicates the HIR id that ought to be used for
/// diagnostics. Around pattern matching such as `let pat = expr`, the diagnostic
@@ -73,6 +73,10 @@ fn borrow(
/// The value found at `place` is being copied.
/// `diag_expr_id` is the id used for diagnostics (see `consume` for more details).
+ ///
+ /// If an implementation is not provided, use of a `Copy` type in a ByValue context is instead
+ /// considered a use by `ImmBorrow` and `borrow` is called instead. This is because a shared
+ /// borrow is the "minimum access" that would be needed to perform a copy.
fn copy(&mut self, place_with_id: &PlaceWithHirId<'tcx>, diag_expr_id: HirId) {
// In most cases, copying data from `x` is equivalent to doing `*&x`, so by default
// we treat a copy of `x` as a borrow of `x`.
@@ -141,6 +145,8 @@ fn fake_read(
}
}
+/// This trait makes `ExprUseVisitor` usable with both [`FnCtxt`]
+/// and [`LateContext`], depending on where in the compiler it is used.
pub trait TypeInformationCtxt<'tcx> {
type TypeckResults<'a>: Deref<Target = ty::TypeckResults<'tcx>>
where
@@ -154,7 +160,7 @@ pub trait TypeInformationCtxt<'tcx> {
fn try_structurally_resolve_type(&self, span: Span, ty: Ty<'tcx>) -> Ty<'tcx>;
- fn report_error(&self, span: Span, msg: impl ToString) -> Self::Error;
+ fn report_bug(&self, span: Span, msg: impl ToString) -> Self::Error;
fn error_reported_in_ty(&self, ty: Ty<'tcx>) -> Result<(), Self::Error>;
@@ -189,7 +195,7 @@ fn try_structurally_resolve_type(&self, sp: Span, ty: Ty<'tcx>) -> Ty<'tcx> {
(**self).try_structurally_resolve_type(sp, ty)
}
- fn report_error(&self, span: Span, msg: impl ToString) -> Self::Error {
+ fn report_bug(&self, span: Span, msg: impl ToString) -> Self::Error {
self.dcx().span_delayed_bug(span, msg.to_string())
}
@@ -239,7 +245,7 @@ fn resolve_vars_if_possible<T: TypeFoldable<TyCtxt<'tcx>>>(&self, t: T) -> T {
t
}
- fn report_error(&self, span: Span, msg: impl ToString) -> ! {
+ fn report_bug(&self, span: Span, msg: impl ToString) -> ! {
span_bug!(span, "{}", msg.to_string())
}
@@ -268,9 +274,9 @@ fn tcx(&self) -> TyCtxt<'tcx> {
}
}
-/// The ExprUseVisitor type
+/// A visitor that reports how each expression is being used.
///
-/// This is the code that actually walks the tree.
+/// See [module-level docs][self] and [`Delegate`] for details.
pub struct ExprUseVisitor<'tcx, Cx: TypeInformationCtxt<'tcx>, D: Delegate<'tcx>> {
cx: Cx,
/// We use a `RefCell` here so that delegates can mutate themselves, but we can
@@ -314,9 +320,8 @@ pub fn consume_body(&self, body: &hir::Body<'_>) -> Result<(), Cx::Error> {
Ok(())
}
+ #[instrument(skip(self), level = "debug")]
fn consume_or_copy(&self, place_with_id: &PlaceWithHirId<'tcx>, diag_expr_id: HirId) {
- debug!("delegate_consume(place_with_id={:?})", place_with_id);
-
if self.cx.type_is_copy_modulo_regions(place_with_id.place.ty()) {
self.delegate.borrow_mut().copy(place_with_id, diag_expr_id);
} else {
@@ -324,9 +329,8 @@ fn consume_or_copy(&self, place_with_id: &PlaceWithHirId<'tcx>, diag_expr_id: Hi
}
}
+ #[instrument(skip(self), level = "debug")]
pub fn consume_clone_or_copy(&self, place_with_id: &PlaceWithHirId<'tcx>, diag_expr_id: HirId) {
- debug!("delegate_consume_or_clone(place_with_id={:?})", place_with_id);
-
// `x.use` will do one of the following
// * if it implements `Copy`, it will be a copy
// * if it implements `UseCloned`, it will be a call to `clone`
@@ -351,18 +355,16 @@ fn consume_exprs(&self, exprs: &[hir::Expr<'_>]) -> Result<(), Cx::Error> {
}
// FIXME: It's suspicious that this is public; clippy should probably use `walk_expr`.
+ #[instrument(skip(self), level = "debug")]
pub fn consume_expr(&self, expr: &hir::Expr<'_>) -> Result<(), Cx::Error> {
- debug!("consume_expr(expr={:?})", expr);
-
let place_with_id = self.cat_expr(expr)?;
self.consume_or_copy(&place_with_id, place_with_id.hir_id);
self.walk_expr(expr)?;
Ok(())
}
+ #[instrument(skip(self), level = "debug")]
pub fn consume_or_clone_expr(&self, expr: &hir::Expr<'_>) -> Result<(), Cx::Error> {
- debug!("consume_or_clone_expr(expr={:?})", expr);
-
let place_with_id = self.cat_expr(expr)?;
self.consume_clone_or_copy(&place_with_id, place_with_id.hir_id);
self.walk_expr(expr)?;
@@ -376,17 +378,15 @@ fn mutate_expr(&self, expr: &hir::Expr<'_>) -> Result<(), Cx::Error> {
Ok(())
}
+ #[instrument(skip(self), level = "debug")]
fn borrow_expr(&self, expr: &hir::Expr<'_>, bk: ty::BorrowKind) -> Result<(), Cx::Error> {
- debug!("borrow_expr(expr={:?}, bk={:?})", expr, bk);
-
let place_with_id = self.cat_expr(expr)?;
self.delegate.borrow_mut().borrow(&place_with_id, place_with_id.hir_id, bk);
self.walk_expr(expr)
}
+ #[instrument(skip(self), level = "debug")]
pub fn walk_expr(&self, expr: &hir::Expr<'_>) -> Result<(), Cx::Error> {
- debug!("walk_expr(expr={:?})", expr);
-
self.walk_adjustment(expr)?;
match expr.kind {
@@ -733,9 +733,8 @@ fn walk_local<F>(
/// Indicates that the value of `blk` will be consumed, meaning either copied or moved
/// depending on its type.
+ #[instrument(skip(self), level = "debug")]
fn walk_block(&self, blk: &hir::Block<'_>) -> Result<(), Cx::Error> {
- debug!("walk_block(blk.hir_id={})", blk.hir_id);
-
for stmt in blk.stmts {
self.walk_stmt(stmt)?;
}
@@ -861,7 +860,7 @@ fn walk_adjustment(&self, expr: &hir::Expr<'_>) -> Result<(), Cx::Error> {
}
/// Walks the autoref `autoref` applied to the autoderef'd
- /// `expr`. `base_place` is the mem-categorized form of `expr`
+ /// `expr`. `base_place` is `expr` represented as a place,
/// after all relevant autoderefs have occurred.
fn walk_autoref(
&self,
@@ -942,14 +941,13 @@ fn walk_irrefutable_pat(
}
/// The core driver for walking a pattern
+ #[instrument(skip(self), level = "debug")]
fn walk_pat(
&self,
discr_place: &PlaceWithHirId<'tcx>,
pat: &hir::Pat<'_>,
has_guard: bool,
) -> Result<(), Cx::Error> {
- debug!("walk_pat(discr_place={:?}, pat={:?}, has_guard={:?})", discr_place, pat, has_guard);
-
let tcx = self.cx.tcx();
self.cat_pattern(discr_place.clone(), pat, &mut |place, pat| {
match pat.kind {
@@ -1042,6 +1040,7 @@ fn walk_pat(
///
/// - When reporting the Place back to the Delegate, ensure that the UpvarId uses the enclosing
/// closure as the DefId.
+ #[instrument(skip(self), level = "debug")]
fn walk_captures(&self, closure_expr: &hir::Closure<'_>) -> Result<(), Cx::Error> {
fn upvar_is_local_variable(
upvars: Option<&FxIndexMap<HirId, hir::Upvar>>,
@@ -1051,8 +1050,6 @@ fn upvar_is_local_variable(
upvars.map(|upvars| !upvars.contains_key(&upvar_id)).unwrap_or(body_owner_is_closure)
}
- debug!("walk_captures({:?})", closure_expr);
-
let tcx = self.cx.tcx();
let closure_def_id = closure_expr.def_id;
// For purposes of this function, coroutine and closures are equivalent.
@@ -1164,55 +1161,17 @@ fn upvar_is_local_variable(
}
}
-/// The job of the categorization methods is to analyze an expression to
-/// determine what kind of memory is used in evaluating it (for example,
-/// where dereferences occur and what kind of pointer is dereferenced;
-/// whether the memory is mutable, etc.).
+/// The job of the methods whose name starts with `cat_` is to analyze
+/// expressions and construct the corresponding [`Place`]s. The `cat`
+/// stands for "categorize", this is a leftover from long ago when
+/// places were called "categorizations".
///
-/// Categorization effectively transforms all of our expressions into
-/// expressions of the following forms (the actual enum has many more
-/// possibilities, naturally, but they are all variants of these base
-/// forms):
-/// ```ignore (not-rust)
-/// E = rvalue // some computed rvalue
-/// | x // address of a local variable or argument
-/// | *E // deref of a ptr
-/// | E.comp // access to an interior component
-/// ```
-/// Imagine a routine ToAddr(Expr) that evaluates an expression and returns an
-/// address where the result is to be found. If Expr is a place, then this
-/// is the address of the place. If `Expr` is an rvalue, this is the address of
-/// some temporary spot in memory where the result is stored.
-///
-/// Now, `cat_expr()` classifies the expression `Expr` and the address `A = ToAddr(Expr)`
-/// as follows:
-///
-/// - `cat`: what kind of expression was this? This is a subset of the
-/// full expression forms which only includes those that we care about
-/// for the purpose of the analysis.
-/// - `mutbl`: mutability of the address `A`.
-/// - `ty`: the type of data found at the address `A`.
-///
-/// The resulting categorization tree differs somewhat from the expressions
-/// themselves. For example, auto-derefs are explicit. Also, an index `a[b]` is
-/// decomposed into two operations: a dereference to reach the array data and
-/// then an index to jump forward to the relevant item.
-///
-/// ## By-reference upvars
-///
-/// One part of the codegen which may be non-obvious is that we translate
-/// closure upvars into the dereference of a borrowed pointer; this more closely
-/// resembles the runtime codegen. So, for example, if we had:
-///
-/// let mut x = 3;
-/// let y = 5;
-/// let inc = || x += y;
-///
-/// Then when we categorize `x` (*within* the closure) we would yield a
-/// result of `*x'`, effectively, where `x'` is a `Categorization::Upvar` reference
-/// tied to `x`. The type of `x'` will be a borrowed pointer.
+/// Note that a [`Place`] differs somewhat from the expression itself. For
+/// example, auto-derefs are explicit. Also, an index `a[b]` is decomposed into
+/// two operations: a dereference to reach the array data and then an index to
+/// jump forward to the relevant item.
impl<'tcx, Cx: TypeInformationCtxt<'tcx>, D: Delegate<'tcx>> ExprUseVisitor<'tcx, Cx, D> {
- fn resolve_type_vars_or_error(
+ fn resolve_type_vars_or_bug(
&self,
id: HirId,
ty: Option<Ty<'tcx>>,
@@ -1222,10 +1181,10 @@ fn resolve_type_vars_or_error(
let ty = self.cx.resolve_vars_if_possible(ty);
self.cx.error_reported_in_ty(ty)?;
if ty.is_ty_var() {
- debug!("resolve_type_vars_or_error: infer var from {:?}", ty);
+ debug!("resolve_type_vars_or_bug: infer var from {:?}", ty);
Err(self
.cx
- .report_error(self.cx.tcx().hir().span(id), "encountered type variable"))
+ .report_bug(self.cx.tcx().hir().span(id), "encountered type variable"))
} else {
Ok(ty)
}
@@ -1233,24 +1192,21 @@ fn resolve_type_vars_or_error(
None => {
// FIXME: We shouldn't be relying on the infcx being tainted.
self.cx.tainted_by_errors()?;
- bug!(
- "no type for node {} in mem_categorization",
- self.cx.tcx().hir_id_to_string(id)
- );
+ bug!("no type for node {} in ExprUseVisitor", self.cx.tcx().hir_id_to_string(id));
}
}
}
fn node_ty(&self, hir_id: HirId) -> Result<Ty<'tcx>, Cx::Error> {
- self.resolve_type_vars_or_error(hir_id, self.cx.typeck_results().node_type_opt(hir_id))
+ self.resolve_type_vars_or_bug(hir_id, self.cx.typeck_results().node_type_opt(hir_id))
}
fn expr_ty(&self, expr: &hir::Expr<'_>) -> Result<Ty<'tcx>, Cx::Error> {
- self.resolve_type_vars_or_error(expr.hir_id, self.cx.typeck_results().expr_ty_opt(expr))
+ self.resolve_type_vars_or_bug(expr.hir_id, self.cx.typeck_results().expr_ty_opt(expr))
}
fn expr_ty_adjusted(&self, expr: &hir::Expr<'_>) -> Result<Ty<'tcx>, Cx::Error> {
- self.resolve_type_vars_or_error(
+ self.resolve_type_vars_or_bug(
expr.hir_id,
self.cx.typeck_results().expr_ty_adjusted_opt(expr),
)
@@ -1285,7 +1241,7 @@ fn pat_ty_adjusted(&self, pat: &hir::Pat<'_>) -> Result<Ty<'tcx>, Cx::Error> {
self.pat_ty_unadjusted(pat)
}
- /// Like `TypeckResults::pat_ty`, but ignores implicit `&` patterns.
+ /// Like [`Self::pat_ty_adjusted`], but ignores implicit `&` patterns.
fn pat_ty_unadjusted(&self, pat: &hir::Pat<'_>) -> Result<Ty<'tcx>, Cx::Error> {
let base_ty = self.node_ty(pat.hir_id)?;
trace!(?base_ty);
@@ -1315,7 +1271,7 @@ fn pat_ty_unadjusted(&self, pat: &hir::Pat<'_>) -> Result<Ty<'tcx>, Cx::Error> {
debug!("By-ref binding of non-derefable type");
Err(self
.cx
- .report_error(pat.span, "by-ref binding of non-derefable type"))
+ .report_bug(pat.span, "by-ref binding of non-derefable type"))
}
}
} else {
@@ -1511,7 +1467,7 @@ fn cat_res(
}
}
- def => span_bug!(span, "unexpected definition in memory categorization: {:?}", def),
+ def => span_bug!(span, "unexpected definition in ExprUseVisitor: {:?}", def),
}
}
@@ -1604,7 +1560,7 @@ fn cat_deref(
Some(ty) => ty,
None => {
debug!("explicit deref of non-derefable type: {:?}", base_curr_ty);
- return Err(self.cx.report_error(
+ return Err(self.cx.report_bug(
self.cx.tcx().hir().span(node),
"explicit deref of non-derefable type",
));
@@ -1629,7 +1585,7 @@ fn variant_index_for_adt(
let ty::Adt(adt_def, _) = self.cx.try_structurally_resolve_type(span, ty).kind() else {
return Err(self
.cx
- .report_error(span, "struct or tuple struct pattern not applied to an ADT"));
+ .report_bug(span, "struct or tuple struct pattern not applied to an ADT"));
};
match res {
@@ -1675,7 +1631,7 @@ fn total_fields_in_tuple(&self, pat_hir_id: HirId, span: Span) -> Result<usize,
let ty = self.cx.typeck_results().node_type(pat_hir_id);
match self.cx.try_structurally_resolve_type(span, ty).kind() {
ty::Tuple(args) => Ok(args.len()),
- _ => Err(self.cx.report_error(span, "tuple pattern not applied to a tuple")),
+ _ => Err(self.cx.report_bug(span, "tuple pattern not applied to a tuple")),
}
}
@@ -1854,7 +1810,7 @@ fn cat_pattern<F>(
debug!("explicit index of non-indexable type {:?}", place_with_id);
return Err(self
.cx
- .report_error(pat.span, "explicit index of non-indexable type"));
+ .report_bug(pat.span, "explicit index of non-indexable type"));
};
let elt_place = self.cat_projection(
pat.hir_id,
diff --git a/compiler/rustc_hir_typeck/src/upvar.rs b/compiler/rustc_hir_typeck/src/upvar.rs
index fc98a60..d07bfad 100644
--- a/compiler/rustc_hir_typeck/src/upvar.rs
+++ b/compiler/rustc_hir_typeck/src/upvar.rs
@@ -18,12 +18,12 @@
//! from there).
//!
//! The fact that we are inferring borrow kinds as we go results in a
-//! semi-hacky interaction with mem-categorization. In particular,
-//! mem-categorization will query the current borrow kind as it
-//! categorizes, and we'll return the *current* value, but this may get
+//! semi-hacky interaction with the way `ExprUseVisitor` is computing
+//! `Place`s. In particular, it will query the current borrow kind as it
+//! goes, and we'll return the *current* value, but this may get
//! adjusted later. Therefore, in this module, we generally ignore the
-//! borrow kind (and derived mutabilities) that are returned from
-//! mem-categorization, since they may be inaccurate. (Another option
+//! borrow kind (and derived mutabilities) that `ExprUseVisitor` returns
+//! within `Place`s, since they may be inaccurate. (Another option
//! would be to use a unification scheme, where instead of returning a
//! concrete borrow kind like `ty::ImmBorrow`, we return a
//! `ty::InferBorrow(upvar_id)` or something like that, but this would
diff --git a/compiler/rustc_metadata/src/rmeta/mod.rs b/compiler/rustc_metadata/src/rmeta/mod.rs
index dc453b1..34e4f2f 100644
--- a/compiler/rustc_metadata/src/rmeta/mod.rs
+++ b/compiler/rustc_metadata/src/rmeta/mod.rs
@@ -36,7 +36,7 @@
use rustc_session::config::{SymbolManglingVersion, TargetModifier};
use rustc_session::cstore::{CrateDepKind, ForeignModule, LinkagePreference, NativeLib};
use rustc_span::edition::Edition;
-use rustc_span::hygiene::{ExpnIndex, MacroKind, SyntaxContextData};
+use rustc_span::hygiene::{ExpnIndex, MacroKind, SyntaxContextKey};
use rustc_span::{self, ExpnData, ExpnHash, ExpnId, Ident, Span, Symbol};
use rustc_target::spec::{PanicStrategy, TargetTuple};
use table::TableBuilder;
@@ -193,7 +193,7 @@ enum LazyState {
Previous(NonZero<usize>),
}
-type SyntaxContextTable = LazyTable<u32, Option<LazyValue<SyntaxContextData>>>;
+type SyntaxContextTable = LazyTable<u32, Option<LazyValue<SyntaxContextKey>>>;
type ExpnDataTable = LazyTable<ExpnIndex, Option<LazyValue<ExpnData>>>;
type ExpnHashTable = LazyTable<ExpnIndex, Option<LazyValue<ExpnHash>>>;
diff --git a/compiler/rustc_middle/src/hir/place.rs b/compiler/rustc_middle/src/hir/place.rs
index 316ad80..60ce854 100644
--- a/compiler/rustc_middle/src/hir/place.rs
+++ b/compiler/rustc_middle/src/hir/place.rs
@@ -53,7 +53,10 @@ pub struct Projection<'tcx> {
pub kind: ProjectionKind,
}
-/// A `Place` represents how a value is located in memory.
+/// A `Place` represents how a value is located in memory. This does not
+/// always correspond to a syntactic place expression. For example, when
+/// processing a pattern, a `Place` can be used to refer to the sub-value
+/// currently being inspected.
///
/// This is an HIR version of [`rustc_middle::mir::Place`].
#[derive(Clone, Debug, PartialEq, Eq, Hash, TyEncodable, TyDecodable, HashStable)]
@@ -67,7 +70,10 @@ pub struct Place<'tcx> {
pub projections: Vec<Projection<'tcx>>,
}
-/// A `PlaceWithHirId` represents how a value is located in memory.
+/// A `PlaceWithHirId` represents how a value is located in memory. This does not
+/// always correspond to a syntactic place expression. For example, when
+/// processing a pattern, a `Place` can be used to refer to the sub-value
+/// currently being inspected.
///
/// This is an HIR version of [`rustc_middle::mir::Place`].
#[derive(Clone, Debug, PartialEq, Eq, Hash, TyEncodable, TyDecodable, HashStable)]
diff --git a/compiler/rustc_middle/src/query/on_disk_cache.rs b/compiler/rustc_middle/src/query/on_disk_cache.rs
index 14e3ce8..ce6219c 100644
--- a/compiler/rustc_middle/src/query/on_disk_cache.rs
+++ b/compiler/rustc_middle/src/query/on_disk_cache.rs
@@ -16,7 +16,7 @@
use rustc_serialize::{Decodable, Decoder, Encodable, Encoder};
use rustc_session::Session;
use rustc_span::hygiene::{
- ExpnId, HygieneDecodeContext, HygieneEncodeContext, SyntaxContext, SyntaxContextData,
+ ExpnId, HygieneDecodeContext, HygieneEncodeContext, SyntaxContext, SyntaxContextKey,
};
use rustc_span::source_map::Spanned;
use rustc_span::{
@@ -75,9 +75,9 @@ pub struct OnDiskCache {
alloc_decoding_state: AllocDecodingState,
// A map from syntax context ids to the position of their associated
- // `SyntaxContextData`. We use a `u32` instead of a `SyntaxContext`
+ // `SyntaxContextKey`. We use a `u32` instead of a `SyntaxContext`
// to represent the fact that we are storing *encoded* ids. When we decode
- // a `SyntaxContext`, a new id will be allocated from the global `HygieneData`,
+ // a `SyntaxContextKey`, a new id will be allocated from the global `HygieneData`,
// which will almost certainly be different than the serialized id.
syntax_contexts: FxHashMap<u32, AbsoluteBytePos>,
// A map from the `DefPathHash` of an `ExpnId` to the position
@@ -305,7 +305,7 @@ pub fn serialize(&self, tcx: TyCtxt<'_>, encoder: FileEncoder) -> FileEncodeResu
let mut expn_data = UnhashMap::default();
let mut foreign_expn_data = UnhashMap::default();
- // Encode all hygiene data (`SyntaxContextData` and `ExpnData`) from the current
+ // Encode all hygiene data (`SyntaxContextKey` and `ExpnData`) from the current
// session.
hygiene_encode_context.encode(
@@ -566,7 +566,7 @@ fn decode_syntax_context(&mut self) -> SyntaxContext {
// We look up the position of the associated `SyntaxData` and decode it.
let pos = syntax_contexts.get(&id).unwrap();
this.with_position(pos.to_usize(), |decoder| {
- let data: SyntaxContextData = decode_tagged(decoder, TAG_SYNTAX_CONTEXT);
+ let data: SyntaxContextKey = decode_tagged(decoder, TAG_SYNTAX_CONTEXT);
data
})
})
diff --git a/compiler/rustc_middle/src/ty/parameterized.rs b/compiler/rustc_middle/src/ty/parameterized.rs
index 19e2b57..134f76d 100644
--- a/compiler/rustc_middle/src/ty/parameterized.rs
+++ b/compiler/rustc_middle/src/ty/parameterized.rs
@@ -111,7 +111,7 @@ impl $crate::ty::ParameterizedOverTcx for $ty {
rustc_span::Span,
rustc_span::Symbol,
rustc_span::def_id::DefPathHash,
- rustc_span::hygiene::SyntaxContextData,
+ rustc_span::hygiene::SyntaxContextKey,
rustc_span::Ident,
rustc_type_ir::Variance,
rustc_hir::Attribute,
diff --git a/compiler/rustc_mir_build/src/builder/scope.rs b/compiler/rustc_mir_build/src/builder/scope.rs
index e56c0ae..e42336a 100644
--- a/compiler/rustc_mir_build/src/builder/scope.rs
+++ b/compiler/rustc_mir_build/src/builder/scope.rs
@@ -1496,7 +1496,7 @@ fn build_scope_drops<'tcx>(
// path, then don't generate the drop. (We only take this into
// account for non-unwind paths so as not to disturb the
// caching mechanism.)
- if scope.moved_locals.iter().any(|&o| o == local) {
+ if scope.moved_locals.contains(&local) {
continue;
}
diff --git a/compiler/rustc_passes/src/entry.rs b/compiler/rustc_passes/src/entry.rs
index d272987..2a435c4 100644
--- a/compiler/rustc_passes/src/entry.rs
+++ b/compiler/rustc_passes/src/entry.rs
@@ -24,7 +24,7 @@ struct EntryContext<'tcx> {
}
fn entry_fn(tcx: TyCtxt<'_>, (): ()) -> Option<(DefId, EntryFnType)> {
- let any_exe = tcx.crate_types().iter().any(|ty| *ty == CrateType::Executable);
+ let any_exe = tcx.crate_types().contains(&CrateType::Executable);
if !any_exe {
// No need to find a main function.
return None;
diff --git a/compiler/rustc_session/src/utils.rs b/compiler/rustc_session/src/utils.rs
index fcede37..2243e83 100644
--- a/compiler/rustc_session/src/utils.rs
+++ b/compiler/rustc_session/src/utils.rs
@@ -149,14 +149,15 @@ pub fn extra_compiler_flags() -> Option<(Vec<String>, bool)> {
arg[a.len()..].to_string()
};
let option = content.split_once('=').map(|s| s.0).unwrap_or(&content);
- if ICE_REPORT_COMPILER_FLAGS_EXCLUDE.iter().any(|exc| option == *exc) {
+ if ICE_REPORT_COMPILER_FLAGS_EXCLUDE.contains(&option) {
excluded_cargo_defaults = true;
} else {
result.push(a.to_string());
- match ICE_REPORT_COMPILER_FLAGS_STRIP_VALUE.iter().find(|s| option == **s) {
- Some(s) => result.push(format!("{s}=[REDACTED]")),
- None => result.push(content),
- }
+ result.push(if ICE_REPORT_COMPILER_FLAGS_STRIP_VALUE.contains(&option) {
+ format!("{option}=[REDACTED]")
+ } else {
+ content
+ });
}
}
}
diff --git a/compiler/rustc_span/src/hygiene.rs b/compiler/rustc_span/src/hygiene.rs
index 4390085..f948588 100644
--- a/compiler/rustc_span/src/hygiene.rs
+++ b/compiler/rustc_span/src/hygiene.rs
@@ -24,9 +24,6 @@
// because getting it wrong can lead to nested `HygieneData::with` calls that
// trigger runtime aborts. (Fortunately these are obvious and easy to fix.)
-use std::cell::RefCell;
-use std::collections::hash_map::Entry;
-use std::collections::hash_set::Entry as SetEntry;
use std::hash::Hash;
use std::sync::Arc;
use std::{fmt, iter, mem};
@@ -34,7 +31,7 @@
use rustc_data_structures::fingerprint::Fingerprint;
use rustc_data_structures::fx::{FxHashMap, FxHashSet};
use rustc_data_structures::stable_hasher::{HashStable, HashingControls, StableHasher};
-use rustc_data_structures::sync::{Lock, WorkerLocal};
+use rustc_data_structures::sync::Lock;
use rustc_data_structures::unhash::UnhashMap;
use rustc_hashes::Hash64;
use rustc_index::IndexVec;
@@ -59,10 +56,10 @@ impl !PartialOrd for SyntaxContext {}
/// If this part of two syntax contexts is equal, then the whole syntax contexts should be equal.
/// The other fields are only for caching.
-type SyntaxContextKey = (SyntaxContext, ExpnId, Transparency);
+pub type SyntaxContextKey = (SyntaxContext, ExpnId, Transparency);
#[derive(Clone, Copy, PartialEq, Debug, Encodable, Decodable)]
-pub struct SyntaxContextData {
+struct SyntaxContextData {
outer_expn: ExpnId,
outer_transparency: Transparency,
parent: SyntaxContext,
@@ -94,6 +91,21 @@ fn is_decode_placeholder(&self) -> bool {
self.dollar_crate_name == kw::Empty
}
+ fn new(
+ (parent, outer_expn, outer_transparency): SyntaxContextKey,
+ opaque: SyntaxContext,
+ opaque_and_semitransparent: SyntaxContext,
+ ) -> Self {
+ SyntaxContextData {
+ parent,
+ outer_expn,
+ outer_transparency,
+ opaque,
+ opaque_and_semitransparent,
+ dollar_crate_name: kw::DollarCrate,
+ }
+ }
+
fn key(&self) -> SyntaxContextKey {
(self.parent, self.outer_expn, self.outer_transparency)
}
@@ -574,67 +586,49 @@ fn apply_mark(
fn apply_mark_internal(
&mut self,
- ctxt: SyntaxContext,
+ parent: SyntaxContext,
expn_id: ExpnId,
transparency: Transparency,
) -> SyntaxContext {
- let syntax_context_data = &mut self.syntax_context_data;
- debug_assert!(!syntax_context_data[ctxt.0 as usize].is_decode_placeholder());
- let mut opaque = syntax_context_data[ctxt.0 as usize].opaque;
- let mut opaque_and_semitransparent =
- syntax_context_data[ctxt.0 as usize].opaque_and_semitransparent;
-
- if transparency >= Transparency::Opaque {
- let parent = opaque;
- opaque = *self
- .syntax_context_map
- .entry((parent, expn_id, transparency))
- .or_insert_with(|| {
- let new_opaque = SyntaxContext::from_usize(syntax_context_data.len());
- syntax_context_data.push(SyntaxContextData {
- outer_expn: expn_id,
- outer_transparency: transparency,
- parent,
- opaque: new_opaque,
- opaque_and_semitransparent: new_opaque,
- dollar_crate_name: kw::DollarCrate,
- });
- new_opaque
- });
+ debug_assert!(!self.syntax_context_data[parent.0 as usize].is_decode_placeholder());
+ // Look into the cache first.
+ let key = (parent, expn_id, transparency);
+ if let Some(ctxt) = self.syntax_context_map.get(&key) {
+ return *ctxt;
}
+ // Reserve a new syntax context.
+ let ctxt = SyntaxContext::from_usize(self.syntax_context_data.len());
+ self.syntax_context_data.push(SyntaxContextData::decode_placeholder());
+ self.syntax_context_map.insert(key, ctxt);
- if transparency >= Transparency::SemiTransparent {
- let parent = opaque_and_semitransparent;
- opaque_and_semitransparent = *self
- .syntax_context_map
- .entry((parent, expn_id, transparency))
- .or_insert_with(|| {
- let new_opaque_and_semitransparent =
- SyntaxContext::from_usize(syntax_context_data.len());
- syntax_context_data.push(SyntaxContextData {
- outer_expn: expn_id,
- outer_transparency: transparency,
- parent,
- opaque,
- opaque_and_semitransparent: new_opaque_and_semitransparent,
- dollar_crate_name: kw::DollarCrate,
- });
- new_opaque_and_semitransparent
- });
- }
+ // Opaque and semi-transparent versions of the parent. Note that they may be equal to the
+ // parent itself. E.g. `parent_opaque` == `parent` if the expn chain contains only opaques,
+ // and `parent_opaque_and_semitransparent` == `parent` if the expn contains only opaques
+ // and semi-transparents.
+ let parent_opaque = self.syntax_context_data[parent.0 as usize].opaque;
+ let parent_opaque_and_semitransparent =
+ self.syntax_context_data[parent.0 as usize].opaque_and_semitransparent;
- let parent = ctxt;
- *self.syntax_context_map.entry((parent, expn_id, transparency)).or_insert_with(|| {
- syntax_context_data.push(SyntaxContextData {
- outer_expn: expn_id,
- outer_transparency: transparency,
- parent,
- opaque,
- opaque_and_semitransparent,
- dollar_crate_name: kw::DollarCrate,
- });
- SyntaxContext::from_usize(syntax_context_data.len() - 1)
- })
+ // Evaluate opaque and semi-transparent versions of the new syntax context.
+ let (opaque, opaque_and_semitransparent) = match transparency {
+ Transparency::Transparent => (parent_opaque, parent_opaque_and_semitransparent),
+ Transparency::SemiTransparent => (
+ parent_opaque,
+ // Will be the same as `ctxt` if the expn chain contains only opaques and semi-transparents.
+ self.apply_mark_internal(parent_opaque_and_semitransparent, expn_id, transparency),
+ ),
+ Transparency::Opaque => (
+ // Will be the same as `ctxt` if the expn chain contains only opaques.
+ self.apply_mark_internal(parent_opaque, expn_id, transparency),
+ // Will be the same as `ctxt` if the expn chain contains only opaques and semi-transparents.
+ self.apply_mark_internal(parent_opaque_and_semitransparent, expn_id, transparency),
+ ),
+ };
+
+ // Fill the full data, now that we have it.
+ self.syntax_context_data[ctxt.as_u32() as usize] =
+ SyntaxContextData::new(key, opaque, opaque_and_semitransparent);
+ ctxt
}
}
@@ -1265,7 +1259,7 @@ pub fn schedule_expn_data_for_encoding(&self, expn: ExpnId) {
pub fn encode<T>(
&self,
encoder: &mut T,
- mut encode_ctxt: impl FnMut(&mut T, u32, &SyntaxContextData),
+ mut encode_ctxt: impl FnMut(&mut T, u32, &SyntaxContextKey),
mut encode_expn: impl FnMut(&mut T, ExpnId, &ExpnData, ExpnHash),
) {
// When we serialize a `SyntaxContextData`, we may end up serializing
@@ -1323,9 +1317,6 @@ struct HygieneDecodeContextInner {
/// Additional information used to assist in decoding hygiene data
pub struct HygieneDecodeContext {
inner: Lock<HygieneDecodeContextInner>,
-
- /// A set of serialized `SyntaxContext` ids that are currently being decoded on each thread.
- local_in_progress: WorkerLocal<RefCell<FxHashSet<u32>>>,
}
/// Register an expansion which has been decoded from the on-disk-cache for the local crate.
@@ -1396,10 +1387,10 @@ pub fn decode_expn_id(
// to track which `SyntaxContext`s we have already decoded.
// The provided closure will be invoked to deserialize a `SyntaxContextData`
// if we haven't already seen the id of the `SyntaxContext` we are deserializing.
-pub fn decode_syntax_context<D: Decoder, F: FnOnce(&mut D, u32) -> SyntaxContextData>(
+pub fn decode_syntax_context<D: Decoder, F: FnOnce(&mut D, u32) -> SyntaxContextKey>(
d: &mut D,
context: &HygieneDecodeContext,
- decode_data: F,
+ decode_ctxt_key: F,
) -> SyntaxContext {
let raw_id: u32 = Decodable::decode(d);
if raw_id == 0 {
@@ -1408,58 +1399,9 @@ pub fn decode_syntax_context<D: Decoder, F: FnOnce(&mut D, u32) -> SyntaxContext
return SyntaxContext::root();
}
- let pending_ctxt = {
- let mut inner = context.inner.lock();
-
- // Reminder: `HygieneDecodeContext` is per-crate, so there are no collisions between
- // raw ids from different crate metadatas.
- if let Some(ctxt) = inner.remapped_ctxts.get(raw_id as usize).copied().flatten() {
- // This has already been decoded.
- return ctxt;
- }
-
- match inner.decoding.entry(raw_id) {
- Entry::Occupied(ctxt_entry) => {
- let pending_ctxt = *ctxt_entry.get();
- match context.local_in_progress.borrow_mut().entry(raw_id) {
- // We're decoding this already on the current thread. Return here and let the
- // function higher up the stack finish decoding to handle recursive cases.
- // Hopefully having a `SyntaxContext` that refers to an incorrect data is ok
- // during reminder of the decoding process, it's certainly not ok after the
- // top level decoding function returns.
- SetEntry::Occupied(..) => return pending_ctxt,
- // Some other thread is currently decoding this.
- // Race with it (alternatively we could wait here).
- // We cannot return this value, unlike in the recursive case above, because it
- // may expose a `SyntaxContext` pointing to incorrect data to arbitrary code.
- SetEntry::Vacant(entry) => {
- entry.insert();
- pending_ctxt
- }
- }
- }
- Entry::Vacant(entry) => {
- // We are the first thread to start decoding. Mark the current thread as being progress.
- context.local_in_progress.borrow_mut().insert(raw_id);
-
- // Allocate and store SyntaxContext id *before* calling the decoder function,
- // as the SyntaxContextData may reference itself.
- let new_ctxt = HygieneData::with(|hygiene_data| {
- // Push a dummy SyntaxContextData to ensure that nobody else can get the
- // same ID as us. This will be overwritten after call `decode_data`.
- hygiene_data.syntax_context_data.push(SyntaxContextData::decode_placeholder());
- SyntaxContext::from_usize(hygiene_data.syntax_context_data.len() - 1)
- });
- entry.insert(new_ctxt);
- new_ctxt
- }
- }
- };
-
// Don't try to decode data while holding the lock, since we need to
// be able to recursively decode a SyntaxContext
- let ctxt_data = decode_data(d, raw_id);
- let ctxt_key = ctxt_data.key();
+ let ctxt_key = decode_ctxt_key(d, raw_id);
let ctxt = HygieneData::with(|hygiene_data| {
match hygiene_data.syntax_context_map.get(&ctxt_key) {
@@ -1473,29 +1415,10 @@ pub fn decode_syntax_context<D: Decoder, F: FnOnce(&mut D, u32) -> SyntaxContext
Some(&ctxt) => ctxt,
// This is a completely new context.
// Overwrite its placeholder data with our decoded data.
- None => {
- let ctxt_data_ref =
- &mut hygiene_data.syntax_context_data[pending_ctxt.as_u32() as usize];
- let prev_ctxt_data = mem::replace(ctxt_data_ref, ctxt_data);
- // Reset `dollar_crate_name` so that it will be updated by `update_dollar_crate_names`.
- // We don't care what the encoding crate set this to - we want to resolve it
- // from the perspective of the current compilation session.
- ctxt_data_ref.dollar_crate_name = kw::DollarCrate;
- // Make sure nothing weird happened while `decode_data` was running.
- if !prev_ctxt_data.is_decode_placeholder() {
- // Another thread may have already inserted the decoded data,
- // but the decoded data should match.
- assert_eq!(prev_ctxt_data, *ctxt_data_ref);
- }
- hygiene_data.syntax_context_map.insert(ctxt_key, pending_ctxt);
- pending_ctxt
- }
+ None => hygiene_data.apply_mark_internal(ctxt_key.0, ctxt_key.1, ctxt_key.2),
}
});
- // Mark the context as completed
- context.local_in_progress.borrow_mut().remove(&raw_id);
-
let mut inner = context.inner.lock();
let new_len = raw_id as usize + 1;
if inner.remapped_ctxts.len() < new_len {
@@ -1507,7 +1430,7 @@ pub fn decode_syntax_context<D: Decoder, F: FnOnce(&mut D, u32) -> SyntaxContext
ctxt
}
-fn for_all_ctxts_in<F: FnMut(u32, SyntaxContext, &SyntaxContextData)>(
+fn for_all_ctxts_in<F: FnMut(u32, SyntaxContext, &SyntaxContextKey)>(
ctxts: impl Iterator<Item = SyntaxContext>,
mut f: F,
) {
@@ -1515,7 +1438,7 @@ fn for_all_ctxts_in<F: FnMut(u32, SyntaxContext, &SyntaxContextData)>(
ctxts.map(|ctxt| (ctxt, data.syntax_context_data[ctxt.0 as usize].clone())).collect()
});
for (ctxt, data) in all_data.into_iter() {
- f(ctxt.0, ctxt, &data);
+ f(ctxt.0, ctxt, &data.key());
}
}
diff --git a/compiler/rustc_span/src/lib.rs b/compiler/rustc_span/src/lib.rs
index f19d4d9..9e6ba2e 100644
--- a/compiler/rustc_span/src/lib.rs
+++ b/compiler/rustc_span/src/lib.rs
@@ -876,7 +876,7 @@ pub fn allows_unstable(self, feature: Symbol) -> bool {
self.ctxt()
.outer_expn_data()
.allow_internal_unstable
- .is_some_and(|features| features.iter().any(|&f| f == feature))
+ .is_some_and(|features| features.contains(&feature))
}
/// Checks if this span arises from a compiler desugaring of kind `kind`.
diff --git a/compiler/rustc_target/src/spec/targets/armv5te_unknown_linux_uclibceabi.rs b/compiler/rustc_target/src/spec/targets/armv5te_unknown_linux_uclibceabi.rs
index dbe1540..860629b 100644
--- a/compiler/rustc_target/src/spec/targets/armv5te_unknown_linux_uclibceabi.rs
+++ b/compiler/rustc_target/src/spec/targets/armv5te_unknown_linux_uclibceabi.rs
@@ -2,7 +2,7 @@
pub(crate) fn target() -> Target {
Target {
- llvm_target: "armv5te-unknown-linux-uclibcgnueabi".into(),
+ llvm_target: "armv5te-unknown-linux-gnueabi".into(),
metadata: TargetMetadata {
description: Some("Armv5TE Linux with uClibc".into()),
tier: Some(3),
diff --git a/compiler/rustc_target/src/spec/targets/mips_unknown_linux_uclibc.rs b/compiler/rustc_target/src/spec/targets/mips_unknown_linux_uclibc.rs
index 0955b3d..c14bfbf 100644
--- a/compiler/rustc_target/src/spec/targets/mips_unknown_linux_uclibc.rs
+++ b/compiler/rustc_target/src/spec/targets/mips_unknown_linux_uclibc.rs
@@ -4,7 +4,7 @@
pub(crate) fn target() -> Target {
Target {
- llvm_target: "mips-unknown-linux-uclibc".into(),
+ llvm_target: "mips-unknown-linux-gnu".into(),
metadata: TargetMetadata {
description: Some("MIPS Linux with uClibc".into()),
tier: Some(3),
diff --git a/compiler/rustc_target/src/spec/targets/mipsel_unknown_linux_uclibc.rs b/compiler/rustc_target/src/spec/targets/mipsel_unknown_linux_uclibc.rs
index 08c4347..f005679 100644
--- a/compiler/rustc_target/src/spec/targets/mipsel_unknown_linux_uclibc.rs
+++ b/compiler/rustc_target/src/spec/targets/mipsel_unknown_linux_uclibc.rs
@@ -2,7 +2,7 @@
pub(crate) fn target() -> Target {
Target {
- llvm_target: "mipsel-unknown-linux-uclibc".into(),
+ llvm_target: "mipsel-unknown-linux-gnu".into(),
metadata: TargetMetadata {
description: Some("MIPS (LE) Linux with uClibc".into()),
tier: Some(3),
diff --git a/compiler/rustc_target/src/spec/targets/x86_64_unknown_l4re_uclibc.rs b/compiler/rustc_target/src/spec/targets/x86_64_unknown_l4re_uclibc.rs
index a034a9f..4107249 100644
--- a/compiler/rustc_target/src/spec/targets/x86_64_unknown_l4re_uclibc.rs
+++ b/compiler/rustc_target/src/spec/targets/x86_64_unknown_l4re_uclibc.rs
@@ -8,7 +8,7 @@ pub(crate) fn target() -> Target {
base.panic_strategy = PanicStrategy::Abort;
Target {
- llvm_target: "x86_64-unknown-l4re-uclibc".into(),
+ llvm_target: "x86_64-unknown-l4re-gnu".into(),
metadata: TargetMetadata {
description: None,
tier: Some(3),
diff --git a/compiler/stable_mir/src/mir/body.rs b/compiler/stable_mir/src/mir/body.rs
index b1bf7bc..2a1c163 100644
--- a/compiler/stable_mir/src/mir/body.rs
+++ b/compiler/stable_mir/src/mir/body.rs
@@ -1057,8 +1057,7 @@ impl Place {
/// In order to retrieve the correct type, the `locals` argument must match the list of all
/// locals from the function body where this place originates from.
pub fn ty(&self, locals: &[LocalDecl]) -> Result<Ty, Error> {
- let start_ty = locals[self.local].ty;
- self.projection.iter().fold(Ok(start_ty), |place_ty, elem| elem.ty(place_ty?))
+ self.projection.iter().try_fold(locals[self.local].ty, |place_ty, elem| elem.ty(place_ty))
}
}
diff --git a/compiler/stable_mir/src/mir/visit.rs b/compiler/stable_mir/src/mir/visit.rs
index 09447e7..9d2368b 100644
--- a/compiler/stable_mir/src/mir/visit.rs
+++ b/compiler/stable_mir/src/mir/visit.rs
@@ -563,7 +563,7 @@ pub struct PlaceRef<'a> {
impl PlaceRef<'_> {
/// Get the type of this place.
pub fn ty(&self, locals: &[LocalDecl]) -> Result<Ty, Error> {
- self.projection.iter().fold(Ok(locals[self.local].ty), |place_ty, elem| elem.ty(place_ty?))
+ self.projection.iter().try_fold(locals[self.local].ty, |place_ty, elem| elem.ty(place_ty))
}
}
diff --git a/library/core/src/cell.rs b/library/core/src/cell.rs
index 1a320b3..e789601 100644
--- a/library/core/src/cell.rs
+++ b/library/core/src/cell.rs
@@ -495,7 +495,7 @@ fn is_nonoverlapping<T>(src: *const T, dst: *const T) -> bool {
/// ```
#[inline]
#[stable(feature = "move_cell", since = "1.17.0")]
- #[rustc_const_unstable(feature = "const_cell", issue = "131283")]
+ #[rustc_const_stable(feature = "const_cell", since = "CURRENT_RUSTC_VERSION")]
#[rustc_confusables("swap")]
pub const fn replace(&self, val: T) -> T {
// SAFETY: This can cause data races if called from a separate thread,
@@ -537,7 +537,7 @@ impl<T: Copy> Cell<T> {
/// ```
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
- #[rustc_const_unstable(feature = "const_cell", issue = "131283")]
+ #[rustc_const_stable(feature = "const_cell", since = "CURRENT_RUSTC_VERSION")]
pub const fn get(&self) -> T {
// SAFETY: This can cause data races if called from a separate thread,
// but `Cell` is `!Sync` so this won't happen.
@@ -617,7 +617,7 @@ pub const fn as_ptr(&self) -> *mut T {
/// ```
#[inline]
#[stable(feature = "cell_get_mut", since = "1.11.0")]
- #[rustc_const_unstable(feature = "const_cell", issue = "131283")]
+ #[rustc_const_stable(feature = "const_cell", since = "CURRENT_RUSTC_VERSION")]
pub const fn get_mut(&mut self) -> &mut T {
self.value.get_mut()
}
@@ -637,7 +637,7 @@ pub const fn get_mut(&mut self) -> &mut T {
/// ```
#[inline]
#[stable(feature = "as_cell", since = "1.37.0")]
- #[rustc_const_unstable(feature = "const_cell", issue = "131283")]
+ #[rustc_const_stable(feature = "const_cell", since = "CURRENT_RUSTC_VERSION")]
pub const fn from_mut(t: &mut T) -> &Cell<T> {
// SAFETY: `&mut` ensures unique access.
unsafe { &*(t as *mut T as *const Cell<T>) }
@@ -695,7 +695,7 @@ impl<T> Cell<[T]> {
/// assert_eq!(slice_cell.len(), 3);
/// ```
#[stable(feature = "as_cell", since = "1.37.0")]
- #[rustc_const_unstable(feature = "const_cell", issue = "131283")]
+ #[rustc_const_stable(feature = "const_cell", since = "CURRENT_RUSTC_VERSION")]
pub const fn as_slice_of_cells(&self) -> &[Cell<T>] {
// SAFETY: `Cell<T>` has the same memory layout as `T`.
unsafe { &*(self as *const Cell<[T]> as *const [Cell<T>]) }
diff --git a/library/coretests/tests/pin_macro.rs b/library/coretests/tests/pin_macro.rs
index 639eab7..3174c91 100644
--- a/library/coretests/tests/pin_macro.rs
+++ b/library/coretests/tests/pin_macro.rs
@@ -47,3 +47,14 @@ fn temp_lifetime() {
}
async fn foo(_: &mut usize) {}
}
+
+#[test]
+fn transitive_extension() {
+ async fn temporary() {}
+
+ // `pin!` witnessed in the wild being used like this, even if it yields
+ // a `Pin<&mut &mut impl Unpin>`; it does work because `pin!`
+ // happens to transitively extend the lifespan of `temporary()`.
+ let p = pin!(&mut temporary());
+ let _use = p;
+}
diff --git a/library/std/src/fs.rs b/library/std/src/fs.rs
index fa98db6..801baf3 100644
--- a/library/std/src/fs.rs
+++ b/library/std/src/fs.rs
@@ -2370,7 +2370,7 @@ fn as_inner(&self) -> &fs_imp::DirEntry {
#[doc(alias = "rm", alias = "unlink", alias = "DeleteFile")]
#[stable(feature = "rust1", since = "1.0.0")]
pub fn remove_file<P: AsRef<Path>>(path: P) -> io::Result<()> {
- fs_imp::unlink(path.as_ref())
+ fs_imp::remove_file(path.as_ref())
}
/// Given a path, queries the file system to get information about a file,
@@ -2409,7 +2409,7 @@ pub fn remove_file<P: AsRef<Path>>(path: P) -> io::Result<()> {
#[doc(alias = "stat")]
#[stable(feature = "rust1", since = "1.0.0")]
pub fn metadata<P: AsRef<Path>>(path: P) -> io::Result<Metadata> {
- fs_imp::stat(path.as_ref()).map(Metadata)
+ fs_imp::metadata(path.as_ref()).map(Metadata)
}
/// Queries the metadata about a file without following symlinks.
@@ -2444,7 +2444,7 @@ pub fn metadata<P: AsRef<Path>>(path: P) -> io::Result<Metadata> {
#[doc(alias = "lstat")]
#[stable(feature = "symlink_metadata", since = "1.1.0")]
pub fn symlink_metadata<P: AsRef<Path>>(path: P) -> io::Result<Metadata> {
- fs_imp::lstat(path.as_ref()).map(Metadata)
+ fs_imp::symlink_metadata(path.as_ref()).map(Metadata)
}
/// Renames a file or directory to a new name, replacing the original file if
@@ -2598,7 +2598,7 @@ pub fn copy<P: AsRef<Path>, Q: AsRef<Path>>(from: P, to: Q) -> io::Result<u64> {
#[doc(alias = "CreateHardLink", alias = "linkat")]
#[stable(feature = "rust1", since = "1.0.0")]
pub fn hard_link<P: AsRef<Path>, Q: AsRef<Path>>(original: P, link: Q) -> io::Result<()> {
- fs_imp::link(original.as_ref(), link.as_ref())
+ fs_imp::hard_link(original.as_ref(), link.as_ref())
}
/// Creates a new symbolic link on the filesystem.
@@ -2664,7 +2664,7 @@ pub fn soft_link<P: AsRef<Path>, Q: AsRef<Path>>(original: P, link: Q) -> io::Re
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
pub fn read_link<P: AsRef<Path>>(path: P) -> io::Result<PathBuf> {
- fs_imp::readlink(path.as_ref())
+ fs_imp::read_link(path.as_ref())
}
/// Returns the canonical, absolute form of a path with all intermediate
@@ -2840,7 +2840,7 @@ pub fn create_dir_all<P: AsRef<Path>>(path: P) -> io::Result<()> {
#[doc(alias = "rmdir", alias = "RemoveDirectory")]
#[stable(feature = "rust1", since = "1.0.0")]
pub fn remove_dir<P: AsRef<Path>>(path: P) -> io::Result<()> {
- fs_imp::rmdir(path.as_ref())
+ fs_imp::remove_dir(path.as_ref())
}
/// Removes a directory at this path, after removing all its contents. Use
@@ -2967,7 +2967,7 @@ pub fn remove_dir_all<P: AsRef<Path>>(path: P) -> io::Result<()> {
#[doc(alias = "ls", alias = "opendir", alias = "FindFirstFile", alias = "FindNextFile")]
#[stable(feature = "rust1", since = "1.0.0")]
pub fn read_dir<P: AsRef<Path>>(path: P) -> io::Result<ReadDir> {
- fs_imp::readdir(path.as_ref()).map(ReadDir)
+ fs_imp::read_dir(path.as_ref()).map(ReadDir)
}
/// Changes the permissions found on a file or a directory.
@@ -3003,7 +3003,7 @@ pub fn read_dir<P: AsRef<Path>>(path: P) -> io::Result<ReadDir> {
#[doc(alias = "chmod", alias = "SetFileAttributes")]
#[stable(feature = "set_permissions", since = "1.1.0")]
pub fn set_permissions<P: AsRef<Path>>(path: P, perm: Permissions) -> io::Result<()> {
- fs_imp::set_perm(path.as_ref(), perm.0)
+ fs_imp::set_permissions(path.as_ref(), perm.0)
}
impl DirBuilder {
diff --git a/library/std/src/lib.rs b/library/std/src/lib.rs
index ad00583..9dcedaa 100644
--- a/library/std/src/lib.rs
+++ b/library/std/src/lib.rs
@@ -297,6 +297,7 @@
#![feature(extended_varargs_abi_support)]
#![feature(f128)]
#![feature(f16)]
+#![feature(ffi_const)]
#![feature(formatting_options)]
#![feature(if_let_guard)]
#![feature(intra_doc_pointers)]
diff --git a/library/std/src/sys/fs/mod.rs b/library/std/src/sys/fs/mod.rs
index c2e19eb..3b176d0 100644
--- a/library/std/src/sys/fs/mod.rs
+++ b/library/std/src/sys/fs/mod.rs
@@ -1,28 +1,115 @@
#![deny(unsafe_op_in_unsafe_fn)]
+use crate::io;
+use crate::path::{Path, PathBuf};
+
pub mod common;
cfg_if::cfg_if! {
if #[cfg(target_family = "unix")] {
mod unix;
- pub use unix::*;
+ use unix as imp;
+ pub use unix::{chown, fchown, lchown};
+ #[cfg(not(target_os = "fuchsia"))]
+ pub use unix::chroot;
+ pub(crate) use unix::debug_assert_fd_is_open;
+ #[cfg(any(target_os = "linux", target_os = "android"))]
+ pub(crate) use unix::CachedFileMetadata;
+ use crate::sys::common::small_c_string::run_path_with_cstr as with_native_path;
} else if #[cfg(target_os = "windows")] {
mod windows;
- pub use windows::*;
+ use windows as imp;
+ pub use windows::{symlink_inner, junction_point};
} else if #[cfg(target_os = "hermit")] {
mod hermit;
- pub use hermit::*;
+ use hermit as imp;
} else if #[cfg(target_os = "solid_asp3")] {
mod solid;
- pub use solid::*;
+ use solid as imp;
} else if #[cfg(target_os = "uefi")] {
mod uefi;
- pub use uefi::*;
+ use uefi as imp;
} else if #[cfg(target_os = "wasi")] {
mod wasi;
- pub use wasi::*;
+ use wasi as imp;
} else {
mod unsupported;
- pub use unsupported::*;
+ use unsupported as imp;
}
}
+
+// FIXME: Replace this with platform-specific path conversion functions.
+#[cfg(not(target_family = "unix"))]
+#[inline]
+pub fn with_native_path<T>(path: &Path, f: &dyn Fn(&Path) -> io::Result<T>) -> io::Result<T> {
+ f(path)
+}
+
+pub use imp::{
+ DirBuilder, DirEntry, File, FileAttr, FilePermissions, FileTimes, FileType, OpenOptions,
+ ReadDir,
+};
+
+pub fn read_dir(path: &Path) -> io::Result<ReadDir> {
+ // FIXME: use with_native_path
+ imp::readdir(path)
+}
+
+pub fn remove_file(path: &Path) -> io::Result<()> {
+ with_native_path(path, &imp::unlink)
+}
+
+pub fn rename(old: &Path, new: &Path) -> io::Result<()> {
+ with_native_path(old, &|old| with_native_path(new, &|new| imp::rename(old, new)))
+}
+
+pub fn remove_dir(path: &Path) -> io::Result<()> {
+ with_native_path(path, &imp::rmdir)
+}
+
+pub fn remove_dir_all(path: &Path) -> io::Result<()> {
+ // FIXME: use with_native_path
+ imp::remove_dir_all(path)
+}
+
+pub fn read_link(path: &Path) -> io::Result<PathBuf> {
+ with_native_path(path, &imp::readlink)
+}
+
+pub fn symlink(original: &Path, link: &Path) -> io::Result<()> {
+ with_native_path(original, &|original| {
+ with_native_path(link, &|link| imp::symlink(original, link))
+ })
+}
+
+pub fn hard_link(original: &Path, link: &Path) -> io::Result<()> {
+ with_native_path(original, &|original| {
+ with_native_path(link, &|link| imp::link(original, link))
+ })
+}
+
+pub fn metadata(path: &Path) -> io::Result<FileAttr> {
+ with_native_path(path, &imp::stat)
+}
+
+pub fn symlink_metadata(path: &Path) -> io::Result<FileAttr> {
+ with_native_path(path, &imp::lstat)
+}
+
+pub fn set_permissions(path: &Path, perm: FilePermissions) -> io::Result<()> {
+ with_native_path(path, &|path| imp::set_perm(path, perm.clone()))
+}
+
+pub fn canonicalize(path: &Path) -> io::Result<PathBuf> {
+ with_native_path(path, &imp::canonicalize)
+}
+
+pub fn copy(from: &Path, to: &Path) -> io::Result<u64> {
+ // FIXME: use with_native_path
+ imp::copy(from, to)
+}
+
+pub fn exists(path: &Path) -> io::Result<bool> {
+ // FIXME: use with_native_path
+ imp::exists(path)
+}
diff --git a/library/std/src/sys/fs/unix.rs b/library/std/src/sys/fs/unix.rs
index 7c3ed80..87865be 100644
--- a/library/std/src/sys/fs/unix.rs
+++ b/library/std/src/sys/fs/unix.rs
@@ -155,15 +155,15 @@ unsafe fn try_statx(
enum STATX_STATE{ Unknown = 0, Present, Unavailable }
static STATX_SAVED_STATE: AtomicU8 = AtomicU8::new(STATX_STATE::Unknown as u8);
- syscall! {
+ syscall!(
fn statx(
fd: c_int,
pathname: *const c_char,
flags: c_int,
mask: libc::c_uint,
- statxbuf: *mut libc::statx
- ) -> c_int
- }
+ statxbuf: *mut libc::statx,
+ ) -> c_int;
+ );
let statx_availability = STATX_SAVED_STATE.load(Ordering::Relaxed);
if statx_availability == STATX_STATE::Unavailable as u8 {
@@ -926,7 +926,7 @@ pub fn metadata(&self) -> io::Result<FileAttr> {
miri
))]
pub fn metadata(&self) -> io::Result<FileAttr> {
- lstat(&self.path())
+ run_path_with_cstr(&self.path(), &lstat)
}
#[cfg(any(
@@ -1540,7 +1540,9 @@ pub fn set_times(&self, times: FileTimes) -> io::Result<()> {
let times = [to_timespec(times.accessed)?, to_timespec(times.modified)?];
// futimens requires Android API level 19
cvt(unsafe {
- weak!(fn futimens(c_int, *const libc::timespec) -> c_int);
+ weak!(
+ fn futimens(fd: c_int, times: *const libc::timespec) -> c_int;
+ );
match futimens.get() {
Some(futimens) => futimens(self.as_raw_fd(), times.as_ptr()),
None => return Err(io::const_error!(
@@ -1556,7 +1558,9 @@ pub fn set_times(&self, times: FileTimes) -> io::Result<()> {
use crate::sys::{time::__timespec64, weak::weak};
// Added in glibc 2.34
- weak!(fn __futimens64(libc::c_int, *const __timespec64) -> libc::c_int);
+ weak!(
+ fn __futimens64(fd: c_int, times: *const __timespec64) -> c_int;
+ );
if let Some(futimens64) = __futimens64.get() {
let to_timespec = |time: Option<SystemTime>| time.map(|time| time.t.to_timespec64())
@@ -1653,7 +1657,7 @@ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
fn get_path(fd: c_int) -> Option<PathBuf> {
let mut p = PathBuf::from("/proc/self/fd");
p.push(&fd.to_string());
- readlink(&p).ok()
+ run_path_with_cstr(&p, &readlink).ok()
}
#[cfg(any(target_vendor = "apple", target_os = "netbsd"))]
@@ -1671,7 +1675,7 @@ fn get_path(fd: c_int) -> Option<PathBuf> {
// fallback to procfs as last resort
let mut p = PathBuf::from("/proc/self/fd");
p.push(&fd.to_string());
- return readlink(&p).ok();
+ return run_path_with_cstr(&p, &readlink).ok()
} else {
return None;
}
@@ -1826,127 +1830,106 @@ pub fn readdir(path: &Path) -> io::Result<ReadDir> {
}
}
-pub fn unlink(p: &Path) -> io::Result<()> {
- run_path_with_cstr(p, &|p| cvt(unsafe { libc::unlink(p.as_ptr()) }).map(|_| ()))
+pub fn unlink(p: &CStr) -> io::Result<()> {
+ cvt(unsafe { libc::unlink(p.as_ptr()) }).map(|_| ())
}
-pub fn rename(old: &Path, new: &Path) -> io::Result<()> {
- run_path_with_cstr(old, &|old| {
- run_path_with_cstr(new, &|new| {
- cvt(unsafe { libc::rename(old.as_ptr(), new.as_ptr()) }).map(|_| ())
- })
- })
+pub fn rename(old: &CStr, new: &CStr) -> io::Result<()> {
+ cvt(unsafe { libc::rename(old.as_ptr(), new.as_ptr()) }).map(|_| ())
}
-pub fn set_perm(p: &Path, perm: FilePermissions) -> io::Result<()> {
- run_path_with_cstr(p, &|p| cvt_r(|| unsafe { libc::chmod(p.as_ptr(), perm.mode) }).map(|_| ()))
+pub fn set_perm(p: &CStr, perm: FilePermissions) -> io::Result<()> {
+ cvt_r(|| unsafe { libc::chmod(p.as_ptr(), perm.mode) }).map(|_| ())
}
-pub fn rmdir(p: &Path) -> io::Result<()> {
- run_path_with_cstr(p, &|p| cvt(unsafe { libc::rmdir(p.as_ptr()) }).map(|_| ()))
+pub fn rmdir(p: &CStr) -> io::Result<()> {
+ cvt(unsafe { libc::rmdir(p.as_ptr()) }).map(|_| ())
}
-pub fn readlink(p: &Path) -> io::Result<PathBuf> {
- run_path_with_cstr(p, &|c_path| {
- let p = c_path.as_ptr();
+pub fn readlink(c_path: &CStr) -> io::Result<PathBuf> {
+ let p = c_path.as_ptr();
- let mut buf = Vec::with_capacity(256);
+ let mut buf = Vec::with_capacity(256);
- loop {
- let buf_read =
- cvt(unsafe { libc::readlink(p, buf.as_mut_ptr() as *mut _, buf.capacity()) })?
- as usize;
+ loop {
+ let buf_read =
+ cvt(unsafe { libc::readlink(p, buf.as_mut_ptr() as *mut _, buf.capacity()) })? as usize;
- unsafe {
- buf.set_len(buf_read);
- }
-
- if buf_read != buf.capacity() {
- buf.shrink_to_fit();
-
- return Ok(PathBuf::from(OsString::from_vec(buf)));
- }
-
- // Trigger the internal buffer resizing logic of `Vec` by requiring
- // more space than the current capacity. The length is guaranteed to be
- // the same as the capacity due to the if statement above.
- buf.reserve(1);
- }
- })
-}
-
-pub fn symlink(original: &Path, link: &Path) -> io::Result<()> {
- run_path_with_cstr(original, &|original| {
- run_path_with_cstr(link, &|link| {
- cvt(unsafe { libc::symlink(original.as_ptr(), link.as_ptr()) }).map(|_| ())
- })
- })
-}
-
-pub fn link(original: &Path, link: &Path) -> io::Result<()> {
- run_path_with_cstr(original, &|original| {
- run_path_with_cstr(link, &|link| {
- cfg_if::cfg_if! {
- if #[cfg(any(target_os = "vxworks", target_os = "redox", target_os = "android", target_os = "espidf", target_os = "horizon", target_os = "vita", target_env = "nto70"))] {
- // VxWorks, Redox and ESP-IDF lack `linkat`, so use `link` instead. POSIX leaves
- // it implementation-defined whether `link` follows symlinks, so rely on the
- // `symlink_hard_link` test in library/std/src/fs/tests.rs to check the behavior.
- // Android has `linkat` on newer versions, but we happen to know `link`
- // always has the correct behavior, so it's here as well.
- cvt(unsafe { libc::link(original.as_ptr(), link.as_ptr()) })?;
- } else {
- // Where we can, use `linkat` instead of `link`; see the comment above
- // this one for details on why.
- cvt(unsafe { libc::linkat(libc::AT_FDCWD, original.as_ptr(), libc::AT_FDCWD, link.as_ptr(), 0) })?;
- }
- }
- Ok(())
- })
- })
-}
-
-pub fn stat(p: &Path) -> io::Result<FileAttr> {
- run_path_with_cstr(p, &|p| {
- cfg_has_statx! {
- if let Some(ret) = unsafe { try_statx(
- libc::AT_FDCWD,
- p.as_ptr(),
- libc::AT_STATX_SYNC_AS_STAT,
- libc::STATX_BASIC_STATS | libc::STATX_BTIME,
- ) } {
- return ret;
- }
+ unsafe {
+ buf.set_len(buf_read);
}
- let mut stat: stat64 = unsafe { mem::zeroed() };
- cvt(unsafe { stat64(p.as_ptr(), &mut stat) })?;
- Ok(FileAttr::from_stat64(stat))
- })
-}
+ if buf_read != buf.capacity() {
+ buf.shrink_to_fit();
-pub fn lstat(p: &Path) -> io::Result<FileAttr> {
- run_path_with_cstr(p, &|p| {
- cfg_has_statx! {
- if let Some(ret) = unsafe { try_statx(
- libc::AT_FDCWD,
- p.as_ptr(),
- libc::AT_SYMLINK_NOFOLLOW | libc::AT_STATX_SYNC_AS_STAT,
- libc::STATX_BASIC_STATS | libc::STATX_BTIME,
- ) } {
- return ret;
- }
+ return Ok(PathBuf::from(OsString::from_vec(buf)));
}
- let mut stat: stat64 = unsafe { mem::zeroed() };
- cvt(unsafe { lstat64(p.as_ptr(), &mut stat) })?;
- Ok(FileAttr::from_stat64(stat))
- })
+ // Trigger the internal buffer resizing logic of `Vec` by requiring
+ // more space than the current capacity. The length is guaranteed to be
+ // the same as the capacity due to the if statement above.
+ buf.reserve(1);
+ }
}
-pub fn canonicalize(p: &Path) -> io::Result<PathBuf> {
- let r = run_path_with_cstr(p, &|path| unsafe {
- Ok(libc::realpath(path.as_ptr(), ptr::null_mut()))
- })?;
+pub fn symlink(original: &CStr, link: &CStr) -> io::Result<()> {
+ cvt(unsafe { libc::symlink(original.as_ptr(), link.as_ptr()) }).map(|_| ())
+}
+
+pub fn link(original: &CStr, link: &CStr) -> io::Result<()> {
+ cfg_if::cfg_if! {
+ if #[cfg(any(target_os = "vxworks", target_os = "redox", target_os = "android", target_os = "espidf", target_os = "horizon", target_os = "vita", target_env = "nto70"))] {
+ // VxWorks, Redox and ESP-IDF lack `linkat`, so use `link` instead. POSIX leaves
+ // it implementation-defined whether `link` follows symlinks, so rely on the
+ // `symlink_hard_link` test in library/std/src/fs/tests.rs to check the behavior.
+ // Android has `linkat` on newer versions, but we happen to know `link`
+ // always has the correct behavior, so it's here as well.
+ cvt(unsafe { libc::link(original.as_ptr(), link.as_ptr()) })?;
+ } else {
+ // Where we can, use `linkat` instead of `link`; see the comment above
+ // this one for details on why.
+ cvt(unsafe { libc::linkat(libc::AT_FDCWD, original.as_ptr(), libc::AT_FDCWD, link.as_ptr(), 0) })?;
+ }
+ }
+ Ok(())
+}
+
+pub fn stat(p: &CStr) -> io::Result<FileAttr> {
+ cfg_has_statx! {
+ if let Some(ret) = unsafe { try_statx(
+ libc::AT_FDCWD,
+ p.as_ptr(),
+ libc::AT_STATX_SYNC_AS_STAT,
+ libc::STATX_BASIC_STATS | libc::STATX_BTIME,
+ ) } {
+ return ret;
+ }
+ }
+
+ let mut stat: stat64 = unsafe { mem::zeroed() };
+ cvt(unsafe { stat64(p.as_ptr(), &mut stat) })?;
+ Ok(FileAttr::from_stat64(stat))
+}
+
+pub fn lstat(p: &CStr) -> io::Result<FileAttr> {
+ cfg_has_statx! {
+ if let Some(ret) = unsafe { try_statx(
+ libc::AT_FDCWD,
+ p.as_ptr(),
+ libc::AT_SYMLINK_NOFOLLOW | libc::AT_STATX_SYNC_AS_STAT,
+ libc::STATX_BASIC_STATS | libc::STATX_BTIME,
+ ) } {
+ return ret;
+ }
+ }
+
+ let mut stat: stat64 = unsafe { mem::zeroed() };
+ cvt(unsafe { lstat64(p.as_ptr(), &mut stat) })?;
+ Ok(FileAttr::from_stat64(stat))
+}
+
+pub fn canonicalize(path: &CStr) -> io::Result<PathBuf> {
+ let r = unsafe { libc::realpath(path.as_ptr(), ptr::null_mut()) };
if r.is_null() {
return Err(io::Error::last_os_error());
}
@@ -2324,19 +2307,19 @@ fn remove_dir_all_recursive(parent_fd: Option<RawFd>, path: &CStr) -> io::Result
Ok(())
}
- fn remove_dir_all_modern(p: &Path) -> io::Result<()> {
+ fn remove_dir_all_modern(p: &CStr) -> io::Result<()> {
// We cannot just call remove_dir_all_recursive() here because that would not delete a passed
// symlink. No need to worry about races, because remove_dir_all_recursive() does not recurse
// into symlinks.
let attr = lstat(p)?;
if attr.file_type().is_symlink() {
- crate::fs::remove_file(p)
+ super::unlink(p)
} else {
- run_path_with_cstr(p, &|p| remove_dir_all_recursive(None, &p))
+ remove_dir_all_recursive(None, &p)
}
}
pub fn remove_dir_all(p: &Path) -> io::Result<()> {
- remove_dir_all_modern(p)
+ run_path_with_cstr(p, &remove_dir_all_modern)
}
}
diff --git a/library/std/src/sys/pal/unix/fd.rs b/library/std/src/sys/pal/unix/fd.rs
index f03c440..2ec8d01 100644
--- a/library/std/src/sys/pal/unix/fd.rs
+++ b/library/std/src/sys/pal/unix/fd.rs
@@ -232,14 +232,14 @@ pub fn read_vectored_at(&self, bufs: &mut [IoSliceMut<'_>], offset: u64) -> io::
// implementation if `preadv` is not available.
#[cfg(all(target_os = "android", target_pointer_width = "64"))]
pub fn read_vectored_at(&self, bufs: &mut [IoSliceMut<'_>], offset: u64) -> io::Result<usize> {
- super::weak::syscall! {
+ super::weak::syscall!(
fn preadv(
fd: libc::c_int,
iovec: *const libc::iovec,
n_iovec: libc::c_int,
- offset: off64_t
- ) -> isize
- }
+ offset: off64_t,
+ ) -> isize;
+ );
let ret = cvt(unsafe {
preadv(
@@ -257,7 +257,14 @@ fn preadv(
// and its metadata from LLVM IR.
#[no_sanitize(cfi)]
pub fn read_vectored_at(&self, bufs: &mut [IoSliceMut<'_>], offset: u64) -> io::Result<usize> {
- super::weak::weak!(fn preadv64(libc::c_int, *const libc::iovec, libc::c_int, off64_t) -> isize);
+ super::weak::weak!(
+ fn preadv64(
+ fd: libc::c_int,
+ iovec: *const libc::iovec,
+ n_iovec: libc::c_int,
+ offset: off64_t,
+ ) -> isize;
+ );
match preadv64.get() {
Some(preadv) => {
@@ -286,7 +293,14 @@ pub fn read_vectored_at(&self, bufs: &mut [IoSliceMut<'_>], offset: u64) -> io::
// use "weak" linking.
#[cfg(target_vendor = "apple")]
pub fn read_vectored_at(&self, bufs: &mut [IoSliceMut<'_>], offset: u64) -> io::Result<usize> {
- super::weak::weak!(fn preadv(libc::c_int, *const libc::iovec, libc::c_int, off64_t) -> isize);
+ super::weak::weak!(
+ fn preadv(
+ fd: libc::c_int,
+ iovec: *const libc::iovec,
+ n_iovec: libc::c_int,
+ offset: off64_t,
+ ) -> isize;
+ );
match preadv.get() {
Some(preadv) => {
@@ -428,14 +442,14 @@ pub fn write_vectored_at(&self, bufs: &[IoSlice<'_>], offset: u64) -> io::Result
// implementation if `pwritev` is not available.
#[cfg(all(target_os = "android", target_pointer_width = "64"))]
pub fn write_vectored_at(&self, bufs: &[IoSlice<'_>], offset: u64) -> io::Result<usize> {
- super::weak::syscall! {
+ super::weak::syscall!(
fn pwritev(
fd: libc::c_int,
iovec: *const libc::iovec,
n_iovec: libc::c_int,
- offset: off64_t
- ) -> isize
- }
+ offset: off64_t,
+ ) -> isize;
+ );
let ret = cvt(unsafe {
pwritev(
@@ -450,7 +464,14 @@ fn pwritev(
#[cfg(all(target_os = "android", target_pointer_width = "32"))]
pub fn write_vectored_at(&self, bufs: &[IoSlice<'_>], offset: u64) -> io::Result<usize> {
- super::weak::weak!(fn pwritev64(libc::c_int, *const libc::iovec, libc::c_int, off64_t) -> isize);
+ super::weak::weak!(
+ fn pwritev64(
+ fd: libc::c_int,
+ iovec: *const libc::iovec,
+ n_iovec: libc::c_int,
+ offset: off64_t,
+ ) -> isize;
+ );
match pwritev64.get() {
Some(pwritev) => {
@@ -479,7 +500,14 @@ pub fn write_vectored_at(&self, bufs: &[IoSlice<'_>], offset: u64) -> io::Result
// use "weak" linking.
#[cfg(target_vendor = "apple")]
pub fn write_vectored_at(&self, bufs: &[IoSlice<'_>], offset: u64) -> io::Result<usize> {
- super::weak::weak!(fn pwritev(libc::c_int, *const libc::iovec, libc::c_int, off64_t) -> isize);
+ super::weak::weak!(
+ fn pwritev(
+ fd: libc::c_int,
+ iovec: *const libc::iovec,
+ n_iovec: libc::c_int,
+ offset: off64_t,
+ ) -> isize;
+ );
match pwritev.get() {
Some(pwritev) => {
diff --git a/library/std/src/sys/pal/unix/kernel_copy.rs b/library/std/src/sys/pal/unix/kernel_copy.rs
index bbf29f3..d42a7e2a 100644
--- a/library/std/src/sys/pal/unix/kernel_copy.rs
+++ b/library/std/src/sys/pal/unix/kernel_copy.rs
@@ -604,16 +604,16 @@ pub(super) fn copy_regular_files(reader: RawFd, writer: RawFd, max_len: u64) ->
_ => true,
};
- syscall! {
+ syscall!(
fn copy_file_range(
fd_in: libc::c_int,
off_in: *mut libc::loff_t,
fd_out: libc::c_int,
off_out: *mut libc::loff_t,
len: libc::size_t,
- flags: libc::c_uint
- ) -> libc::ssize_t
- }
+ flags: libc::c_uint,
+ ) -> libc::ssize_t;
+ );
fn probe_copy_file_range_support() -> u8 {
// In some cases, we cannot determine availability from the first
@@ -727,16 +727,16 @@ fn sendfile_splice(mode: SpliceMode, reader: RawFd, writer: RawFd, len: u64) ->
// Android builds use feature level 14, but the libc wrapper for splice is
// gated on feature level 21+, so we have to invoke the syscall directly.
#[cfg(target_os = "android")]
- syscall! {
+ syscall!(
fn splice(
srcfd: libc::c_int,
src_offset: *const i64,
dstfd: libc::c_int,
dst_offset: *const i64,
len: libc::size_t,
- flags: libc::c_int
- ) -> libc::ssize_t
- }
+ flags: libc::c_int,
+ ) -> libc::ssize_t;
+ );
#[cfg(target_os = "linux")]
use libc::splice;
diff --git a/library/std/src/sys/pal/unix/os.rs b/library/std/src/sys/pal/unix/os.rs
index 30282fb..f47421c 100644
--- a/library/std/src/sys/pal/unix/os.rs
+++ b/library/std/src/sys/pal/unix/os.rs
@@ -59,11 +59,14 @@
#[cfg_attr(any(target_os = "freebsd", target_vendor = "apple"), link_name = "__error")]
#[cfg_attr(target_os = "haiku", link_name = "_errnop")]
#[cfg_attr(target_os = "aix", link_name = "_Errno")]
+ // SAFETY: this will always return the same pointer on a given thread.
+ #[unsafe(ffi_const)]
fn errno_location() -> *mut c_int;
}
/// Returns the platform-specific value of errno
#[cfg(not(any(target_os = "dragonfly", target_os = "vxworks", target_os = "rtems")))]
+#[inline]
pub fn errno() -> i32 {
unsafe { (*errno_location()) as i32 }
}
@@ -72,16 +75,19 @@ pub fn errno() -> i32 {
// needed for readdir and syscall!
#[cfg(all(not(target_os = "dragonfly"), not(target_os = "vxworks"), not(target_os = "rtems")))]
#[allow(dead_code)] // but not all target cfgs actually end up using it
+#[inline]
pub fn set_errno(e: i32) {
unsafe { *errno_location() = e as c_int }
}
#[cfg(target_os = "vxworks")]
+#[inline]
pub fn errno() -> i32 {
unsafe { libc::errnoGet() }
}
#[cfg(target_os = "rtems")]
+#[inline]
pub fn errno() -> i32 {
unsafe extern "C" {
#[thread_local]
@@ -92,6 +98,7 @@ pub fn errno() -> i32 {
}
#[cfg(target_os = "dragonfly")]
+#[inline]
pub fn errno() -> i32 {
unsafe extern "C" {
#[thread_local]
@@ -103,6 +110,7 @@ pub fn errno() -> i32 {
#[cfg(target_os = "dragonfly")]
#[allow(dead_code)]
+#[inline]
pub fn set_errno(e: i32) {
unsafe extern "C" {
#[thread_local]
diff --git a/library/std/src/sys/pal/unix/stack_overflow.rs b/library/std/src/sys/pal/unix/stack_overflow.rs
index 4bd0ced..34b3948 100644
--- a/library/std/src/sys/pal/unix/stack_overflow.rs
+++ b/library/std/src/sys/pal/unix/stack_overflow.rs
@@ -424,18 +424,32 @@ unsafe fn install_main_guard_freebsd(page_size: usize) -> Option<Range<usize>> {
let pages = PAGES.get_or_init(|| {
use crate::sys::weak::dlsym;
- dlsym!(fn sysctlbyname(*const libc::c_char, *mut libc::c_void, *mut libc::size_t, *const libc::c_void, libc::size_t) -> libc::c_int);
+ dlsym!(
+ fn sysctlbyname(
+ name: *const libc::c_char,
+ oldp: *mut libc::c_void,
+ oldlenp: *mut libc::size_t,
+ newp: *const libc::c_void,
+ newlen: libc::size_t,
+ ) -> libc::c_int;
+ );
let mut guard: usize = 0;
let mut size = size_of_val(&guard);
let oid = c"security.bsd.stack_guard_page";
match sysctlbyname.get() {
- Some(fcn) if unsafe {
- fcn(oid.as_ptr(),
- (&raw mut guard).cast(),
- &raw mut size,
- ptr::null_mut(),
- 0) == 0
- } => guard,
+ Some(fcn)
+ if unsafe {
+ fcn(
+ oid.as_ptr(),
+ (&raw mut guard).cast(),
+ &raw mut size,
+ ptr::null_mut(),
+ 0,
+ ) == 0
+ } =>
+ {
+ guard
+ }
_ => 1,
}
});
diff --git a/library/std/src/sys/pal/unix/thread.rs b/library/std/src/sys/pal/unix/thread.rs
index bb34c2f..9078dd1 100644
--- a/library/std/src/sys/pal/unix/thread.rs
+++ b/library/std/src/sys/pal/unix/thread.rs
@@ -193,11 +193,12 @@ pub fn set_name(name: &CStr) {
// and its metadata from LLVM IR.
#[no_sanitize(cfi)]
pub fn set_name(name: &CStr) {
- weak! {
+ weak!(
fn pthread_setname_np(
- libc::pthread_t, *const libc::c_char
- ) -> libc::c_int
- }
+ thread: libc::pthread_t,
+ name: *const libc::c_char,
+ ) -> libc::c_int;
+ );
if let Some(f) = pthread_setname_np.get() {
#[cfg(target_os = "nto")]
@@ -762,7 +763,9 @@ unsafe fn min_stack_size(attr: *const libc::pthread_attr_t) -> usize {
// We use dlsym to avoid an ELF version dependency on GLIBC_PRIVATE. (#23628)
// We shouldn't really be using such an internal symbol, but there's currently
// no other way to account for the TLS size.
- dlsym!(fn __pthread_get_minstack(*const libc::pthread_attr_t) -> libc::size_t);
+ dlsym!(
+ fn __pthread_get_minstack(attr: *const libc::pthread_attr_t) -> libc::size_t;
+ );
match __pthread_get_minstack.get() {
None => libc::PTHREAD_STACK_MIN,
diff --git a/library/std/src/sys/pal/unix/time.rs b/library/std/src/sys/pal/unix/time.rs
index c0a3044..b8469b1 100644
--- a/library/std/src/sys/pal/unix/time.rs
+++ b/library/std/src/sys/pal/unix/time.rs
@@ -123,7 +123,12 @@ pub fn now(clock: libc::clockid_t) -> Timespec {
// __clock_gettime64 was added to 32-bit arches in glibc 2.34,
// and it handles both vDSO calls and ENOSYS fallbacks itself.
- weak!(fn __clock_gettime64(libc::clockid_t, *mut __timespec64) -> libc::c_int);
+ weak!(
+ fn __clock_gettime64(
+ clockid: libc::clockid_t,
+ tp: *mut __timespec64,
+ ) -> libc::c_int;
+ );
if let Some(clock_gettime64) = __clock_gettime64.get() {
let mut t = MaybeUninit::uninit();
diff --git a/library/std/src/sys/pal/unix/weak.rs b/library/std/src/sys/pal/unix/weak.rs
index ce3f66a..e7f4e00 100644
--- a/library/std/src/sys/pal/unix/weak.rs
+++ b/library/std/src/sys/pal/unix/weak.rs
@@ -29,7 +29,7 @@
// We can use true weak linkage on ELF targets.
#[cfg(all(unix, not(target_vendor = "apple")))]
pub(crate) macro weak {
- (fn $name:ident($($t:ty),*) -> $ret:ty) => (
+ (fn $name:ident($($param:ident : $t:ty),* $(,)?) -> $ret:ty;) => (
let ref $name: ExternWeak<unsafe extern "C" fn($($t),*) -> $ret> = {
unsafe extern "C" {
#[linkage = "extern_weak"]
@@ -62,10 +62,16 @@ pub(crate) fn get(&self) -> Option<F> {
}
pub(crate) macro dlsym {
- (fn $name:ident($($t:ty),*) -> $ret:ty) => (
- dlsym!(fn $name($($t),*) -> $ret, stringify!($name));
+ (fn $name:ident($($param:ident : $t:ty),* $(,)?) -> $ret:ty;) => (
+ dlsym!(
+ #[link_name = stringify!($name)]
+ fn $name($($param : $t),*) -> $ret;
+ );
),
- (fn $name:ident($($t:ty),*) -> $ret:ty, $sym:expr) => (
+ (
+ #[link_name = $sym:expr]
+ fn $name:ident($($param:ident : $t:ty),* $(,)?) -> $ret:ty;
+ ) => (
static DLSYM: DlsymWeak<unsafe extern "C" fn($($t),*) -> $ret> =
DlsymWeak::new(concat!($sym, '\0'));
let $name = &DLSYM;
@@ -143,15 +149,15 @@ unsafe fn fetch(name: &str) -> *mut libc::c_void {
#[cfg(not(any(target_os = "linux", target_os = "android")))]
pub(crate) macro syscall {
- (fn $name:ident($($arg_name:ident: $t:ty),*) -> $ret:ty) => (
+ (fn $name:ident($($param:ident : $t:ty),* $(,)?) -> $ret:ty;) => (
// FIXME(#115199): Rust currently omits weak function definitions
// and its metadata from LLVM IR.
#[no_sanitize(cfi)]
- unsafe fn $name($($arg_name: $t),*) -> $ret {
- weak! { fn $name($($t),*) -> $ret }
+ unsafe fn $name($($param: $t),*) -> $ret {
+ weak!(fn $name($($param: $t),*) -> $ret;);
if let Some(fun) = $name.get() {
- fun($($arg_name),*)
+ fun($($param),*)
} else {
super::os::set_errno(libc::ENOSYS);
-1
@@ -162,16 +168,18 @@ unsafe fn $name($($arg_name: $t),*) -> $ret {
#[cfg(any(target_os = "linux", target_os = "android"))]
pub(crate) macro syscall {
- (fn $name:ident($($arg_name:ident: $t:ty),*) -> $ret:ty) => (
- unsafe fn $name($($arg_name:$t),*) -> $ret {
- weak! { fn $name($($t),*) -> $ret }
+ (
+ fn $name:ident($($param:ident : $t:ty),* $(,)?) -> $ret:ty;
+ ) => (
+ unsafe fn $name($($param: $t),*) -> $ret {
+ weak!(fn $name($($param: $t),*) -> $ret;);
// Use a weak symbol from libc when possible, allowing `LD_PRELOAD`
// interposition, but if it's not found just use a raw syscall.
if let Some(fun) = $name.get() {
- fun($($arg_name),*)
+ fun($($param),*)
} else {
- libc::syscall(libc::${concat(SYS_, $name)}, $($arg_name),*) as $ret
+ libc::syscall(libc::${concat(SYS_, $name)}, $($param),*) as $ret
}
}
)
@@ -179,9 +187,9 @@ unsafe fn $name($($arg_name:$t),*) -> $ret {
#[cfg(any(target_os = "linux", target_os = "android"))]
pub(crate) macro raw_syscall {
- (fn $name:ident($($arg_name:ident: $t:ty),*) -> $ret:ty) => (
- unsafe fn $name($($arg_name:$t),*) -> $ret {
- libc::syscall(libc::${concat(SYS_, $name)}, $($arg_name),*) as $ret
+ (fn $name:ident($($param:ident : $t:ty),* $(,)?) -> $ret:ty;) => (
+ unsafe fn $name($($param: $t),*) -> $ret {
+ libc::syscall(libc::${concat(SYS_, $name)}, $($param),*) as $ret
}
)
}
diff --git a/library/std/src/sys/pal/wasi/thread.rs b/library/std/src/sys/pal/wasi/thread.rs
index c85b03d..cc569bb 100644
--- a/library/std/src/sys/pal/wasi/thread.rs
+++ b/library/std/src/sys/pal/wasi/thread.rs
@@ -67,7 +67,7 @@ fn drop(&mut self) {
}
}
-pub const DEFAULT_MIN_STACK_SIZE: usize = 64 * 1024;
+pub const DEFAULT_MIN_STACK_SIZE: usize = 1024 * 1024;
impl Thread {
// unsafe: see thread::Builder::spawn_unchecked for safety requirements
diff --git a/library/std/src/sys/pal/wasm/atomics/thread.rs b/library/std/src/sys/pal/wasm/atomics/thread.rs
index afdb159..dd5aff3 100644
--- a/library/std/src/sys/pal/wasm/atomics/thread.rs
+++ b/library/std/src/sys/pal/wasm/atomics/thread.rs
@@ -6,7 +6,7 @@
pub struct Thread(!);
-pub const DEFAULT_MIN_STACK_SIZE: usize = 64 * 1024;
+pub const DEFAULT_MIN_STACK_SIZE: usize = 1024 * 1024;
impl Thread {
// unsafe: see thread::Builder::spawn_unchecked for safety requirements
diff --git a/library/std/src/sys/process/unix/unix.rs b/library/std/src/sys/process/unix/unix.rs
index 42542f8..191a09c 100644
--- a/library/std/src/sys/process/unix/unix.rs
+++ b/library/std/src/sys/process/unix/unix.rs
@@ -461,18 +461,20 @@ fn posix_spawn(
if #[cfg(target_os = "linux")] {
use crate::sys::weak::weak;
- weak! {
+ weak!(
fn pidfd_spawnp(
- *mut libc::c_int,
- *const libc::c_char,
- *const libc::posix_spawn_file_actions_t,
- *const libc::posix_spawnattr_t,
- *const *mut libc::c_char,
- *const *mut libc::c_char
- ) -> libc::c_int
- }
+ pidfd: *mut libc::c_int,
+ path: *const libc::c_char,
+ file_actions: *const libc::posix_spawn_file_actions_t,
+ attrp: *const libc::posix_spawnattr_t,
+ argv: *const *mut libc::c_char,
+ envp: *const *mut libc::c_char,
+ ) -> libc::c_int;
+ );
- weak! { fn pidfd_getpid(libc::c_int) -> libc::c_int }
+ weak!(
+ fn pidfd_getpid(pidfd: libc::c_int) -> libc::c_int;
+ );
static PIDFD_SUPPORTED: AtomicU8 = AtomicU8::new(0);
const UNKNOWN: u8 = 0;
@@ -593,19 +595,19 @@ fn get_posix_spawn_addchdir() -> Option<PosixSpawnAddChdirFn> {
// https://pubs.opengroup.org/onlinepubs/9799919799/functions/posix_spawn_file_actions_addchdir.html.
// The _np version is more widely available, though, so try that first.
- weak! {
+ weak!(
fn posix_spawn_file_actions_addchdir_np(
- *mut libc::posix_spawn_file_actions_t,
- *const libc::c_char
- ) -> libc::c_int
- }
+ file_actions: *mut libc::posix_spawn_file_actions_t,
+ path: *const libc::c_char,
+ ) -> libc::c_int;
+ );
- weak! {
+ weak!(
fn posix_spawn_file_actions_addchdir(
- *mut libc::posix_spawn_file_actions_t,
- *const libc::c_char
- ) -> libc::c_int
- }
+ file_actions: *mut libc::posix_spawn_file_actions_t,
+ path: *const libc::c_char,
+ ) -> libc::c_int;
+ );
posix_spawn_file_actions_addchdir_np
.get()
diff --git a/library/std/src/sys/random/linux.rs b/library/std/src/sys/random/linux.rs
index e3cb792..c0591ec 100644
--- a/library/std/src/sys/random/linux.rs
+++ b/library/std/src/sys/random/linux.rs
@@ -73,13 +73,13 @@ fn getrandom(mut bytes: &mut [u8], insecure: bool) {
// A weak symbol allows interposition, e.g. for perf measurements that want to
// disable randomness for consistency. Otherwise, we'll try a raw syscall.
// (`getrandom` was added in glibc 2.25, musl 1.1.20, android API level 28)
- syscall! {
+ syscall!(
fn getrandom(
buffer: *mut libc::c_void,
length: libc::size_t,
- flags: libc::c_uint
- ) -> libc::ssize_t
- }
+ flags: libc::c_uint,
+ ) -> libc::ssize_t;
+ );
static GETRANDOM_AVAILABLE: AtomicBool = AtomicBool::new(true);
static GRND_INSECURE_AVAILABLE: AtomicBool = AtomicBool::new(true);
diff --git a/src/doc/rustc-dev-guide/src/tests/ui.md b/src/doc/rustc-dev-guide/src/tests/ui.md
index 98bb9de..1190c26 100644
--- a/src/doc/rustc-dev-guide/src/tests/ui.md
+++ b/src/doc/rustc-dev-guide/src/tests/ui.md
@@ -202,6 +202,9 @@
* `~|`: Associates the error level and message with the *same* line as the
*previous comment*. This is more convenient than using multiple carets when
there are multiple messages associated with the same line.
+* `~v`: Associates the error level and message with the *next* error
+ annotation line. Each symbol (`v`) that you add adds a line to this, so `~vvv`
+ is three lines below the error annotation line.
* `~?`: Used to match error levels and messages with errors not having line
information. These can be placed on any line in the test file, but are
conventionally placed at the end.
@@ -273,6 +276,18 @@
//~| ERROR this pattern has 1 field, but the corresponding tuple struct has 3 fields [E0023]
```
+#### Positioned above error line
+
+Use the `//~v` idiom with number of v's in the string to indicate the number
+of lines below. This is typically used in lexer or parser tests matching on errors like unclosed
+delimiter or unclosed literal happening at the end of file.
+
+```rust,ignore
+// ignore-tidy-trailing-newlines
+//~v ERROR this file contains an unclosed delimiter
+fn main((ؼ
+```
+
#### Error without line information
Use `//~?` to match an error without line information.
diff --git a/src/tools/compiletest/src/errors.rs b/src/tools/compiletest/src/errors.rs
index c0566ef..b68f817 100644
--- a/src/tools/compiletest/src/errors.rs
+++ b/src/tools/compiletest/src/errors.rs
@@ -122,13 +122,17 @@ fn parse_expected(
// //~|
// //~^
// //~^^^^^
+ // //~v
+ // //~vvvvv
// //~?
// //[rev1]~
// //[rev1,rev2]~^^
static RE: OnceLock<Regex> = OnceLock::new();
let captures = RE
- .get_or_init(|| Regex::new(r"//(?:\[(?P<revs>[\w\-,]+)])?~(?P<adjust>\?|\||\^*)").unwrap())
+ .get_or_init(|| {
+ Regex::new(r"//(?:\[(?P<revs>[\w\-,]+)])?~(?P<adjust>\?|\||[v\^]*)").unwrap()
+ })
.captures(line)?;
match (test_revision, captures.name("revs")) {
@@ -164,6 +168,8 @@ fn parse_expected(
(true, Some(last_nonfollow_error.expect("encountered //~| without preceding //~^ line")))
} else if line_num_adjust == "?" {
(false, None)
+ } else if line_num_adjust.starts_with('v') {
+ (false, Some(line_num + line_num_adjust.len()))
} else {
(false, Some(line_num - line_num_adjust.len()))
};
diff --git a/src/tools/compiletest/src/header.rs b/src/tools/compiletest/src/header.rs
index d7a5f30..f654bd9 100644
--- a/src/tools/compiletest/src/header.rs
+++ b/src/tools/compiletest/src/header.rs
@@ -924,7 +924,14 @@ fn iter_header(
impl Config {
fn parse_and_update_revisions(&self, testfile: &Path, line: &str, existing: &mut Vec<String>) {
- const FORBIDDEN_REVISION_NAMES: [&str; 9] =
+ const FORBIDDEN_REVISION_NAMES: [&str; 2] = [
+ // `//@ revisions: true false` Implying `--cfg=true` and `--cfg=false` makes it very
+ // weird for the test, since if the test writer wants a cfg of the same revision name
+ // they'd have to use `cfg(r#true)` and `cfg(r#false)`.
+ "true", "false",
+ ];
+
+ const FILECHECK_FORBIDDEN_REVISION_NAMES: [&str; 9] =
["CHECK", "COM", "NEXT", "SAME", "EMPTY", "NOT", "COUNT", "DAG", "LABEL"];
if let Some(raw) = self.parse_name_value_directive(line, "revisions") {
@@ -933,25 +940,38 @@ fn parse_and_update_revisions(&self, testfile: &Path, line: &str, existing: &mut
}
let mut duplicates: HashSet<_> = existing.iter().cloned().collect();
- for revision in raw.split_whitespace().map(|r| r.to_string()) {
- if !duplicates.insert(revision.clone()) {
+ for revision in raw.split_whitespace() {
+ if !duplicates.insert(revision.to_string()) {
panic!(
"duplicate revision: `{}` in line `{}`: {}",
revision,
raw,
testfile.display()
);
- } else if matches!(self.mode, Mode::Assembly | Mode::Codegen | Mode::MirOpt)
- && FORBIDDEN_REVISION_NAMES.contains(&revision.as_str())
- {
+ }
+
+ if FORBIDDEN_REVISION_NAMES.contains(&revision) {
panic!(
- "revision name `{revision}` is not permitted in a test suite that uses `FileCheck` annotations\n\
- as it is confusing when used as custom `FileCheck` prefix: `{revision}` in line `{}`: {}",
+ "revision name `{revision}` is not permitted: `{}` in line `{}`: {}",
+ revision,
raw,
testfile.display()
);
}
- existing.push(revision);
+
+ if matches!(self.mode, Mode::Assembly | Mode::Codegen | Mode::MirOpt)
+ && FILECHECK_FORBIDDEN_REVISION_NAMES.contains(&revision)
+ {
+ panic!(
+ "revision name `{revision}` is not permitted in a test suite that uses \
+ `FileCheck` annotations as it is confusing when used as custom `FileCheck` \
+ prefix: `{revision}` in line `{}`: {}",
+ raw,
+ testfile.display()
+ );
+ }
+
+ existing.push(revision.to_string());
}
}
}
diff --git a/src/tools/compiletest/src/header/tests.rs b/src/tools/compiletest/src/header/tests.rs
index 007318b..4d90f15 100644
--- a/src/tools/compiletest/src/header/tests.rs
+++ b/src/tools/compiletest/src/header/tests.rs
@@ -568,6 +568,13 @@ fn test_assembly_mode_forbidden_revisions() {
}
#[test]
+#[should_panic(expected = "revision name `true` is not permitted")]
+fn test_forbidden_revisions() {
+ let config = cfg().mode("ui").build();
+ parse_rs(&config, "//@ revisions: true");
+}
+
+#[test]
#[should_panic(
expected = "revision name `CHECK` is not permitted in a test suite that uses `FileCheck` annotations"
)]
diff --git a/tests/ui/parser/issues/issue-103451.rs b/tests/ui/parser/issues/issue-103451.rs
index 6b09282..687dbc6 100644
--- a/tests/ui/parser/issues/issue-103451.rs
+++ b/tests/ui/parser/issues/issue-103451.rs
@@ -1,4 +1,4 @@
-//@ error-pattern: this file contains an unclosed delimiter
struct R { }
+//~vv ERROR this file contains an unclosed delimiter
struct S {
x: [u8; R
diff --git a/tests/ui/parser/issues/issue-10636-2.rs b/tests/ui/parser/issues/issue-10636-2.rs
index 7200ea1..dcc03fe 100644
--- a/tests/ui/parser/issues/issue-10636-2.rs
+++ b/tests/ui/parser/issues/issue-10636-2.rs
@@ -1,7 +1,7 @@
-//@ error-pattern: mismatched closing delimiter: `}`
// FIXME(31528) we emit a bunch of silly errors here due to continuing past the
// first one. This would be easy-ish to address by better recovery in tokenisation.
+//~vvvvv ERROR mismatched closing delimiter: `}`
pub fn trace_option(option: Option<isize>) {
option.map(|some| 42;
diff --git a/tests/ui/parser/issues/issue-58094-missing-right-square-bracket.rs b/tests/ui/parser/issues/issue-58094-missing-right-square-bracket.rs
index 7952d29..0c0fbd7 100644
--- a/tests/ui/parser/issues/issue-58094-missing-right-square-bracket.rs
+++ b/tests/ui/parser/issues/issue-58094-missing-right-square-bracket.rs
@@ -1,5 +1,4 @@
// Fixed in #66054.
// ignore-tidy-trailing-newlines
-//@ error-pattern: this file contains an unclosed delimiter
-//@ error-pattern: aborting due to 1 previous error
+//~v ERROR this file contains an unclosed delimiter
#[Ѕ
\ No newline at end of file
diff --git a/tests/ui/parser/issues/issue-58094-missing-right-square-bracket.stderr b/tests/ui/parser/issues/issue-58094-missing-right-square-bracket.stderr
index 14f5469..28fd78d 100644
--- a/tests/ui/parser/issues/issue-58094-missing-right-square-bracket.stderr
+++ b/tests/ui/parser/issues/issue-58094-missing-right-square-bracket.stderr
@@ -1,5 +1,5 @@
error: this file contains an unclosed delimiter
- --> $DIR/issue-58094-missing-right-square-bracket.rs:5:4
+ --> $DIR/issue-58094-missing-right-square-bracket.rs:4:4
|
LL | #[Ѕ
| - ^
diff --git a/tests/ui/parser/issues/issue-62524.rs b/tests/ui/parser/issues/issue-62524.rs
index a219f66..a8c7d6e 100644
--- a/tests/ui/parser/issues/issue-62524.rs
+++ b/tests/ui/parser/issues/issue-62524.rs
@@ -1,6 +1,7 @@
// ignore-tidy-trailing-newlines
-//@ error-pattern: aborting due to 1 previous error
+
#![allow(uncommon_codepoints)]
+//~vv ERROR this file contains an unclosed delimiter
y![
Ϥ,
\ No newline at end of file
diff --git a/tests/ui/parser/issues/issue-62524.stderr b/tests/ui/parser/issues/issue-62524.stderr
index d83a49a..c1ff6e7 100644
--- a/tests/ui/parser/issues/issue-62524.stderr
+++ b/tests/ui/parser/issues/issue-62524.stderr
@@ -1,5 +1,5 @@
error: this file contains an unclosed delimiter
- --> $DIR/issue-62524.rs:6:3
+ --> $DIR/issue-62524.rs:7:3
|
LL | y![
| - unclosed delimiter
diff --git a/tests/ui/parser/issues/issue-62554.rs b/tests/ui/parser/issues/issue-62554.rs
index 9f196e4..4a8a168 100644
--- a/tests/ui/parser/issues/issue-62554.rs
+++ b/tests/ui/parser/issues/issue-62554.rs
@@ -1,5 +1,4 @@
-//@ error-pattern:this file contains an unclosed delimiter
-
fn main() {}
+//~v ERROR this file contains an unclosed delimiter
fn foo(u: u8) { if u8 macro_rules! u8 { (u6) => { fn uuuuuuuuuuu() { use s loo mod u8 {
diff --git a/tests/ui/parser/issues/issue-62554.stderr b/tests/ui/parser/issues/issue-62554.stderr
index d4aaef1..50515c4 100644
--- a/tests/ui/parser/issues/issue-62554.stderr
+++ b/tests/ui/parser/issues/issue-62554.stderr
@@ -1,5 +1,5 @@
error: this file contains an unclosed delimiter
- --> $DIR/issue-62554.rs:5:89
+ --> $DIR/issue-62554.rs:4:89
|
LL | fn foo(u: u8) { if u8 macro_rules! u8 { (u6) => { fn uuuuuuuuuuu() { use s loo mod u8 {
| - - - - -^
diff --git a/tests/ui/parser/issues/issue-62894.rs b/tests/ui/parser/issues/issue-62894.rs
index 5b1627a..c49cbe4 100644
--- a/tests/ui/parser/issues/issue-62894.rs
+++ b/tests/ui/parser/issues/issue-62894.rs
@@ -1,6 +1,6 @@
// Regression test for #62894, shouldn't crash.
-//@ error-pattern: this file contains an unclosed delimiter
+//~vvv ERROR this file contains an unclosed delimiter
fn f() { assert_eq!(f(), (), assert_eq!(assert_eq!
fn main() {}
diff --git a/tests/ui/parser/issues/issue-62973.rs b/tests/ui/parser/issues/issue-62973.rs
index 5c666d8..a091e4e 100644
--- a/tests/ui/parser/issues/issue-62973.rs
+++ b/tests/ui/parser/issues/issue-62973.rs
@@ -1,8 +1,10 @@
// ignore-tidy-trailing-newlines
-//@ error-pattern: aborting due to 3 previous errors
fn main() {}
+//~vvv ERROR mismatched closing delimiter: `)`
+//~vv ERROR mismatched closing delimiter: `)`
+//~vvv ERROR this file contains an unclosed delimiter
fn p() { match s { v, E { [) {) }
diff --git a/tests/ui/parser/issues/issue-62973.stderr b/tests/ui/parser/issues/issue-62973.stderr
index 4931839..ea3e2be 100644
--- a/tests/ui/parser/issues/issue-62973.stderr
+++ b/tests/ui/parser/issues/issue-62973.stderr
@@ -1,5 +1,5 @@
error: mismatched closing delimiter: `)`
- --> $DIR/issue-62973.rs:6:27
+ --> $DIR/issue-62973.rs:8:27
|
LL | fn p() { match s { v, E { [) {) }
| ^^ mismatched closing delimiter
@@ -7,7 +7,7 @@
| unclosed delimiter
error: mismatched closing delimiter: `)`
- --> $DIR/issue-62973.rs:6:30
+ --> $DIR/issue-62973.rs:8:30
|
LL | fn p() { match s { v, E { [) {) }
| ^^ mismatched closing delimiter
@@ -15,7 +15,7 @@
| unclosed delimiter
error: this file contains an unclosed delimiter
- --> $DIR/issue-62973.rs:8:2
+ --> $DIR/issue-62973.rs:10:2
|
LL | fn p() { match s { v, E { [) {) }
| - - - - missing open `(` for this delimiter
diff --git a/tests/ui/parser/issues/issue-63116.rs b/tests/ui/parser/issues/issue-63116.rs
index 3be9606..48abe63 100644
--- a/tests/ui/parser/issues/issue-63116.rs
+++ b/tests/ui/parser/issues/issue-63116.rs
@@ -1,3 +1,4 @@
// fixed by #66361
-//@ error-pattern: aborting due to 2 previous errors
+//~vv ERROR mismatched closing delimiter: `]`
+//~v ERROR this file contains an unclosed delimiter
impl W <s(f;Y(;]
diff --git a/tests/ui/parser/issues/issue-63116.stderr b/tests/ui/parser/issues/issue-63116.stderr
index e0f7dd1..e5bad84 100644
--- a/tests/ui/parser/issues/issue-63116.stderr
+++ b/tests/ui/parser/issues/issue-63116.stderr
@@ -1,5 +1,5 @@
error: mismatched closing delimiter: `]`
- --> $DIR/issue-63116.rs:3:14
+ --> $DIR/issue-63116.rs:4:14
|
LL | impl W <s(f;Y(;]
| ^ ^ mismatched closing delimiter
@@ -7,7 +7,7 @@
| unclosed delimiter
error: this file contains an unclosed delimiter
- --> $DIR/issue-63116.rs:3:18
+ --> $DIR/issue-63116.rs:4:18
|
LL | impl W <s(f;Y(;]
| - -^
diff --git a/tests/ui/parser/issues/issue-63135.rs b/tests/ui/parser/issues/issue-63135.rs
index 112dd4c..63eca5b 100644
--- a/tests/ui/parser/issues/issue-63135.rs
+++ b/tests/ui/parser/issues/issue-63135.rs
@@ -1,3 +1,2 @@
-//@ error-pattern: this file contains an unclosed delimiter
-//@ error-pattern: aborting due to 1 previous error
+//~v ERROR this file contains an unclosed delimiter
fn i(n{...,f #
diff --git a/tests/ui/parser/issues/issue-63135.stderr b/tests/ui/parser/issues/issue-63135.stderr
index d627590..061ec17 100644
--- a/tests/ui/parser/issues/issue-63135.stderr
+++ b/tests/ui/parser/issues/issue-63135.stderr
@@ -1,5 +1,5 @@
error: this file contains an unclosed delimiter
- --> $DIR/issue-63135.rs:3:16
+ --> $DIR/issue-63135.rs:2:16
|
LL | fn i(n{...,f #
| - - ^
diff --git a/tests/ui/parser/issues/issue-81804.rs b/tests/ui/parser/issues/issue-81804.rs
index 7c9e6e9..57951ca 100644
--- a/tests/ui/parser/issues/issue-81804.rs
+++ b/tests/ui/parser/issues/issue-81804.rs
@@ -1,6 +1,5 @@
-//@ error-pattern: this file contains an unclosed delimiter
-//@ error-pattern: this file contains an unclosed delimiter
-
fn main() {}
+//~vv ERROR mismatched closing delimiter: `}`
+//~v ERROR this file contains an unclosed delimiter
fn p([=(}
diff --git a/tests/ui/parser/issues/issue-81804.stderr b/tests/ui/parser/issues/issue-81804.stderr
index 6caaaa7..f12c6a6 100644
--- a/tests/ui/parser/issues/issue-81804.stderr
+++ b/tests/ui/parser/issues/issue-81804.stderr
@@ -1,5 +1,5 @@
error: mismatched closing delimiter: `}`
- --> $DIR/issue-81804.rs:6:8
+ --> $DIR/issue-81804.rs:5:8
|
LL | fn p([=(}
| ^^ mismatched closing delimiter
@@ -7,7 +7,7 @@
| unclosed delimiter
error: this file contains an unclosed delimiter
- --> $DIR/issue-81804.rs:6:11
+ --> $DIR/issue-81804.rs:5:11
|
LL | fn p([=(}
| -- ^
diff --git a/tests/ui/parser/issues/issue-81827.rs b/tests/ui/parser/issues/issue-81827.rs
index a2bd345..7dfeec1 100644
--- a/tests/ui/parser/issues/issue-81827.rs
+++ b/tests/ui/parser/issues/issue-81827.rs
@@ -1,10 +1,7 @@
-//@ error-pattern: this file contains an unclosed delimiter
-//@ error-pattern: mismatched closing delimiter: `]`
-
#![crate_name="0"]
-
-
fn main() {}
+//~vv ERROR mismatched closing delimiter: `]`
+//~v ERROR this file contains an unclosed delimiter
fn r()->i{0|{#[cfg(r(0{]0
diff --git a/tests/ui/parser/issues/issue-81827.stderr b/tests/ui/parser/issues/issue-81827.stderr
index d12c74b..986ed6b 100644
--- a/tests/ui/parser/issues/issue-81827.stderr
+++ b/tests/ui/parser/issues/issue-81827.stderr
@@ -1,5 +1,5 @@
error: mismatched closing delimiter: `]`
- --> $DIR/issue-81827.rs:10:23
+ --> $DIR/issue-81827.rs:7:23
|
LL | fn r()->i{0|{#[cfg(r(0{]0
| - ^^ mismatched closing delimiter
@@ -8,7 +8,7 @@
| closing delimiter possibly meant for this
error: this file contains an unclosed delimiter
- --> $DIR/issue-81827.rs:10:27
+ --> $DIR/issue-81827.rs:7:27
|
LL | fn r()->i{0|{#[cfg(r(0{]0
| - - - ^
diff --git a/tests/ui/parser/issues/issue-84104.rs b/tests/ui/parser/issues/issue-84104.rs
index bced05e..6baf882 100644
--- a/tests/ui/parser/issues/issue-84104.rs
+++ b/tests/ui/parser/issues/issue-84104.rs
@@ -1,2 +1,2 @@
-//@ error-pattern: this file contains an unclosed delimiter
+//~v ERROR this file contains an unclosed delimiter
#[i=i::<ښܖ<
diff --git a/tests/ui/parser/issues/issue-84148-2.rs b/tests/ui/parser/issues/issue-84148-2.rs
index 560475b..4522790 100644
--- a/tests/ui/parser/issues/issue-84148-2.rs
+++ b/tests/ui/parser/issues/issue-84148-2.rs
@@ -1,2 +1,2 @@
-//@ error-pattern: this file contains an unclosed delimiter
+//~v ERROR this file contains an unclosed delimiter
fn f(t:for<>t?
diff --git a/tests/ui/parser/issues/issue-88770.rs b/tests/ui/parser/issues/issue-88770.rs
index ecc5048..0dd1843 100644
--- a/tests/ui/parser/issues/issue-88770.rs
+++ b/tests/ui/parser/issues/issue-88770.rs
@@ -1,7 +1,6 @@
// Regression test for the ICE described in #88770.
-//@ error-pattern:this file contains an unclosed delimiter
-
+//~vvvv ERROR this file contains an unclosed delimiter
fn m(){print!("",(c for&g
u
e
diff --git a/tests/ui/parser/issues/issue-88770.stderr b/tests/ui/parser/issues/issue-88770.stderr
index 5b54072..137cfea 100644
--- a/tests/ui/parser/issues/issue-88770.stderr
+++ b/tests/ui/parser/issues/issue-88770.stderr
@@ -1,5 +1,5 @@
error: this file contains an unclosed delimiter
- --> $DIR/issue-88770.rs:8:3
+ --> $DIR/issue-88770.rs:7:3
|
LL | fn m(){print!("",(c for&g
| - - - unclosed delimiter
diff --git a/tests/ui/parser/mbe_missing_right_paren.rs b/tests/ui/parser/mbe_missing_right_paren.rs
index 9c57b0e..8519193 100644
--- a/tests/ui/parser/mbe_missing_right_paren.rs
+++ b/tests/ui/parser/mbe_missing_right_paren.rs
@@ -1,3 +1,3 @@
// ignore-tidy-trailing-newlines
-//@ error-pattern: this file contains an unclosed delimiter
+//~v ERROR this file contains an unclosed delimiter
macro_rules! abc(ؼ
\ No newline at end of file
diff --git a/tests/ui/parser/missing_right_paren.rs b/tests/ui/parser/missing_right_paren.rs
index bbf4519..311a16c 100644
--- a/tests/ui/parser/missing_right_paren.rs
+++ b/tests/ui/parser/missing_right_paren.rs
@@ -1,4 +1,3 @@
// ignore-tidy-trailing-newlines
-//@ error-pattern: this file contains an unclosed delimiter
-//@ error-pattern: aborting due to 1 previous error
+//~v ERROR this file contains an unclosed delimiter
fn main((ؼ
\ No newline at end of file
diff --git a/tests/ui/parser/missing_right_paren.stderr b/tests/ui/parser/missing_right_paren.stderr
index 4815f04..97ccb40 100644
--- a/tests/ui/parser/missing_right_paren.stderr
+++ b/tests/ui/parser/missing_right_paren.stderr
@@ -1,5 +1,5 @@
error: this file contains an unclosed delimiter
- --> $DIR/missing_right_paren.rs:4:11
+ --> $DIR/missing_right_paren.rs:3:11
|
LL | fn main((ؼ
| -- ^
diff --git a/tests/ui/parser/unbalanced-doublequote.rs b/tests/ui/parser/unbalanced-doublequote.rs
index d9c9361..43e23a7 100644
--- a/tests/ui/parser/unbalanced-doublequote.rs
+++ b/tests/ui/parser/unbalanced-doublequote.rs
@@ -1,6 +1,4 @@
-//@ error-pattern: unterminated double quote string
-
-
+//~vv ERROR unterminated double quote string
fn main() {
"
}
diff --git a/tests/ui/parser/unbalanced-doublequote.stderr b/tests/ui/parser/unbalanced-doublequote.stderr
index d40b982..60057edd 100644
--- a/tests/ui/parser/unbalanced-doublequote.stderr
+++ b/tests/ui/parser/unbalanced-doublequote.stderr
@@ -1,5 +1,5 @@
error[E0765]: unterminated double quote string
- --> $DIR/unbalanced-doublequote.rs:5:5
+ --> $DIR/unbalanced-doublequote.rs:3:5
|
LL | / "
LL | | }
diff --git a/tests/ui/parser/use-unclosed-brace.rs b/tests/ui/parser/use-unclosed-brace.rs
index 6679651..aa52fe9 100644
--- a/tests/ui/parser/use-unclosed-brace.rs
+++ b/tests/ui/parser/use-unclosed-brace.rs
@@ -1,4 +1,3 @@
-//@ error-pattern: this file contains an unclosed delimiter
use foo::{bar, baz;
use std::fmt::Display;
@@ -7,4 +6,5 @@ mod bar { }
mod baz { }
+//~v ERROR this file contains an unclosed delimiter
fn main() {}
diff --git a/tests/ui/pin-macro/pin_move.rs b/tests/ui/pin-macro/pin_move.rs
new file mode 100644
index 0000000..0f6d34f
--- /dev/null
+++ b/tests/ui/pin-macro/pin_move.rs
@@ -0,0 +1,26 @@
+//@ edition:2024
+
+use core::marker::PhantomPinned;
+use core::pin::pin;
+
+fn a() {
+ struct NotCopy<T>(T);
+ #[allow(unused_mut)]
+ let mut pointee = NotCopy(PhantomPinned);
+ pin!(pointee);
+ let _moved = pointee;
+ //~^ ERROR use of moved value
+}
+
+fn b() {
+ struct NotCopy<T>(T);
+ let mut pointee = NotCopy(PhantomPinned);
+ pin!(*&mut pointee);
+ //~^ ERROR cannot move
+ let _moved = pointee;
+}
+
+fn main() {
+ a();
+ b();
+}
diff --git a/tests/ui/pin-macro/pin_move.stderr b/tests/ui/pin-macro/pin_move.stderr
new file mode 100644
index 0000000..c9b8ad9
--- /dev/null
+++ b/tests/ui/pin-macro/pin_move.stderr
@@ -0,0 +1,38 @@
+error[E0382]: use of moved value: `pointee`
+ --> $DIR/pin_move.rs:11:18
+ |
+LL | let mut pointee = NotCopy(PhantomPinned);
+ | ----------- move occurs because `pointee` has type `a::NotCopy<PhantomPinned>`, which does not implement the `Copy` trait
+LL | pin!(pointee);
+ | ------- value moved here
+LL | let _moved = pointee;
+ | ^^^^^^^ value used here after move
+ |
+note: if `a::NotCopy<PhantomPinned>` implemented `Clone`, you could clone the value
+ --> $DIR/pin_move.rs:7:5
+ |
+LL | struct NotCopy<T>(T);
+ | ^^^^^^^^^^^^^^^^^ consider implementing `Clone` for this type
+...
+LL | pin!(pointee);
+ | ------- you could clone this value
+
+error[E0507]: cannot move out of a mutable reference
+ --> $DIR/pin_move.rs:18:10
+ |
+LL | pin!(*&mut pointee);
+ | ^^^^^^^^^^^^^ move occurs because value has type `b::NotCopy<PhantomPinned>`, which does not implement the `Copy` trait
+ |
+note: if `b::NotCopy<PhantomPinned>` implemented `Clone`, you could clone the value
+ --> $DIR/pin_move.rs:16:5
+ |
+LL | struct NotCopy<T>(T);
+ | ^^^^^^^^^^^^^^^^^ consider implementing `Clone` for this type
+LL | let mut pointee = NotCopy(PhantomPinned);
+LL | pin!(*&mut pointee);
+ | ------------- you could clone this value
+
+error: aborting due to 2 previous errors
+
+Some errors have detailed explanations: E0382, E0507.
+For more information about an error, try `rustc --explain E0382`.
diff --git a/tests/ui/proc-macro/nonterminal-token-hygiene.stdout b/tests/ui/proc-macro/nonterminal-token-hygiene.stdout
index c80a332..6fd6cb4 100644
--- a/tests/ui/proc-macro/nonterminal-token-hygiene.stdout
+++ b/tests/ui/proc-macro/nonterminal-token-hygiene.stdout
@@ -5,19 +5,19 @@
stream: TokenStream [
Ident {
ident: "struct",
- span: $DIR/nonterminal-token-hygiene.rs:32:5: 32:11 (#4),
+ span: $DIR/nonterminal-token-hygiene.rs:32:5: 32:11 (#5),
},
Ident {
ident: "S",
- span: $DIR/nonterminal-token-hygiene.rs:32:12: 32:13 (#4),
+ span: $DIR/nonterminal-token-hygiene.rs:32:12: 32:13 (#5),
},
Punct {
ch: ';',
spacing: Alone,
- span: $DIR/nonterminal-token-hygiene.rs:32:13: 32:14 (#4),
+ span: $DIR/nonterminal-token-hygiene.rs:32:13: 32:14 (#5),
},
],
- span: $DIR/nonterminal-token-hygiene.rs:22:27: 22:32 (#5),
+ span: $DIR/nonterminal-token-hygiene.rs:22:27: 22:32 (#4),
},
]
#![feature /* 0#0 */(prelude_import)]
@@ -59,7 +59,7 @@
struct S /* 0#0 */;
macro inner /* 0#3 */ { () => { print_bang! { struct S; } } }
-struct S /* 0#4 */;
+struct S /* 0#5 */;
// OK, not a duplicate definition of `S`
fn main /* 0#0 */() {}
@@ -70,7 +70,7 @@
crate0::{{expn1}}: parent: crate0::{{expn0}}, call_site_ctxt: #0, def_site_ctxt: #0, kind: AstPass(StdImports)
crate0::{{expn2}}: parent: crate0::{{expn0}}, call_site_ctxt: #0, def_site_ctxt: #0, kind: Macro(Bang, "outer")
crate0::{{expn3}}: parent: crate0::{{expn2}}, call_site_ctxt: #3, def_site_ctxt: #3, kind: Macro(Bang, "inner")
-crate0::{{expn4}}: parent: crate0::{{expn3}}, call_site_ctxt: #5, def_site_ctxt: #0, kind: Macro(Bang, "print_bang")
+crate0::{{expn4}}: parent: crate0::{{expn3}}, call_site_ctxt: #4, def_site_ctxt: #0, kind: Macro(Bang, "print_bang")
crate1::{{expnNNN}}: parent: crate0::{{expn0}}, call_site_ctxt: #0, def_site_ctxt: #0, kind: Macro(Attr, "diagnostic::on_unimplemented")
crate1::{{expnNNN}}: parent: crate0::{{expn0}}, call_site_ctxt: #0, def_site_ctxt: #0, kind: Macro(Attr, "diagnostic::on_unimplemented")
crate1::{{expnNNN}}: parent: crate0::{{expn0}}, call_site_ctxt: #0, def_site_ctxt: #0, kind: Macro(Attr, "diagnostic::on_unimplemented")
@@ -83,9 +83,9 @@
#1: parent: #0, outer_mark: (crate0::{{expn1}}, Opaque)
#2: parent: #0, outer_mark: (crate0::{{expn1}}, Transparent)
#3: parent: #0, outer_mark: (crate0::{{expn2}}, SemiTransparent)
-#4: parent: #0, outer_mark: (crate0::{{expn3}}, Opaque)
-#5: parent: #3, outer_mark: (crate0::{{expn3}}, Opaque)
+#4: parent: #3, outer_mark: (crate0::{{expn3}}, Opaque)
+#5: parent: #0, outer_mark: (crate0::{{expn3}}, Opaque)
#6: parent: #0, outer_mark: (crate0::{{expn4}}, Opaque)
-#7: parent: #5, outer_mark: (crate0::{{expn4}}, Transparent)
-#8: parent: #4, outer_mark: (crate0::{{expn4}}, SemiTransparent)
+#7: parent: #4, outer_mark: (crate0::{{expn4}}, Transparent)
+#8: parent: #5, outer_mark: (crate0::{{expn4}}, SemiTransparent)
*/
