rust-lang/rust
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity

Reduce P<T> to a typedef of Box<T>.

Browse Source 
Keep the `P` constructor function for now, to minimize immediate churn.

All the `into_inner` calls are removed, which is nice.
This commit is contained in:
Nicholas Nethercote
2025-05-27 02:32:22 +10:00
parent c42d1fc2c6
commit 991c91fdaa
15 changed files with 48 additions and 131 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
compiler/rustc_parse/src/parser/diagnostics.rs
View File

@@ -2273,9 +2273,9 @@ impl<'a> Parser<'a> {
),
// Also catches `fn foo(&a)`.
PatKind::Ref(ref inner_pat, mutab)
if matches!(inner_pat.clone().into_inner().kind, PatKind::Ident(..)) =>
if matches!(inner_pat.clone().kind, PatKind::Ident(..)) =>
{
match inner_pat.clone().into_inner().kind {
match inner_pat.clone().kind {
PatKind::Ident(_, ident, _) => {
let mutab = mutab.prefix_str();
(

6
compiler/rustc_parse/src/parser/expr.rs
View File

@@ -3450,10 +3450,8 @@ impl<'a> Parser<'a> {
// Detect and recover from `($pat if $cond) => $arm`.
// FIXME(guard_patterns): convert this to a normal guard instead
let span = pat.span;
let ast::PatKind::Paren(subpat) = pat.into_inner().kind else { unreachable!() };
let ast::PatKind::Guard(_, mut cond) = subpat.into_inner().kind else {
unreachable!()
};
let ast::PatKind::Paren(subpat) = pat.kind else { unreachable!() };
let ast::PatKind::Guard(_, mut cond) = subpat.kind else { unreachable!() };
self.psess.gated_spans.ungate_last(sym::guard_patterns, cond.span);
CondChecker::new(self, LetChainsPolicy::AlwaysAllowed).visit_expr(&mut cond);
let right = self.prev_token.span;

4
compiler/rustc_parse/src/parser/item.rs
View File

@@ -145,7 +145,7 @@ impl<'a> Parser<'a> {
{
let mut item = item.expect("an actual item");
attrs.prepend_to_nt_inner(&mut item.attrs);
return Ok(Some(item.into_inner()));
return Ok(Some(*item));
}
self.collect_tokens(None, attrs, force_collect, |this, mut attrs| {
@@ -637,7 +637,7 @@ impl<'a> Parser<'a> {
self.dcx().emit_err(errors::MissingForInTraitImpl { span: missing_for_span });
}
let ty_first = ty_first.into_inner();
let ty_first = *ty_first;
let path = match ty_first.kind {
// This notably includes paths passed through `ty` macro fragments (#46438).
TyKind::Path(None, path) => path,

2
compiler/rustc_parse/src/parser/pat.rs
View File

@@ -1086,7 +1086,7 @@ impl<'a> Parser<'a> {
if matches!(pat.kind, PatKind::Ident(BindingMode(ByRef::Yes(_), Mutability::Mut), ..)) {
self.psess.gated_spans.gate(sym::mut_ref, pat.span);
}
Ok(pat.into_inner().kind)
Ok(pat.kind)
}
/// Turn all by-value immutable bindings in a pattern into mutable bindings.

6
compiler/rustc_parse/src/parser/ty.rs
View File

@@ -404,7 +404,7 @@ impl<'a> Parser<'a> {
})?;
if ts.len() == 1 && matches!(trailing, Trailing::No) {
let ty = ts.into_iter().next().unwrap().into_inner();
let ty = ts.into_iter().next().unwrap();
let maybe_bounds = allow_plus == AllowPlus::Yes && self.token.is_like_plus();
match ty.kind {
// `(TY_BOUND_NOPAREN) + BOUND + ...`.
@@ -420,7 +420,7 @@ impl<'a> Parser<'a> {
self.parse_remaining_bounds(bounds, true)
}
// `(TYPE)`
_ => Ok(TyKind::Paren(P(ty))),
_ => Ok(TyKind::Paren(ty)),
}
} else {
Ok(TyKind::Tup(ts))
@@ -1295,7 +1295,7 @@ impl<'a> Parser<'a> {
) -> PResult<'a, ()> {
let fn_path_segment = fn_path.segments.last_mut().unwrap();
let generic_args = if let Some(p_args) = &fn_path_segment.args {
p_args.clone().into_inner()
*p_args.clone()
} else {
// Normally it wouldn't come here because the upstream should have parsed
// generic parameters (otherwise it's impossible to call this function).